UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

830 lines (823 loc) • 44.2 kB
import { effectiveProviderAlias, effectiveProviderAliasDecision } from "../../providers/default-aliases"; import { initialModelSelectionPending } from "../../providers/initial-model-selection"; import { execFileSync } from "node:child_process"; import { createHash, createHmac, randomBytes } from "node:crypto"; import { copyFileSync, existsSync, mkdirSync, readFileSync, realpathSync } from "node:fs"; import { delimiter, dirname, join, resolve } from "node:path"; import { atomicWriteFile, expandUserPath, getConfigDir, websocketsEnabled } from "../../config"; import { resolveProviderApiKey } from "../../providers/key-store"; import { captureOAuthAccountSelection, credentialGeneration, getAccountCredentialWithStatus, getAccountSet } from "../../oauth/store"; import { readKiroAccountModels, kiroObservedContextWindow } from "../../providers/kiro-model-catalog"; import { CODEX_CONFIG_PATH, CODEX_MODELS_CACHE_PATH, DEFAULT_CATALOG_PATH, readRootTomlString, resolveCodexConfigPath } from "../paths"; import { clearModelCache, clearProviderDiscoveryStatus, captureModelCacheGeneration, observeModelCacheRevision, DEFAULT_MODEL_CACHE_TTL_MS, getFreshCached, getStaleCached, isModelsFetchCoolingDown, isModelCacheGenerationCurrent, markModelsFetchFailure, markProviderDiscoveryFailed, markProviderDiscoveryOk, shouldLogDiscoveryFailure, setCached, type ProviderModelDiscoveryFailure, } from "../model-cache"; import { buildModelsRequest, getValidAccessTokenSnapshot, observeActiveOAuthAccessToken, resolveModelsAuthToken, type OAuthActiveTokenObservation, } from "../../oauth"; import type { OcxConfig, OcxProviderConfig } from "../../types"; import { modelInList } from "../../types"; import { CODEX_REASONING_LEVELS, codexEffortRank, configuredReasoningEfforts, modelRecordValue, sanitizeCodexReasoningEfforts } from "../../reasoning-effort"; import { isModelVisionSidecarConsumer } from "../../vision/eligibility"; import { getModelMetadata, getModelMetadataCaseInsensitive, listModelMetadata, resolveMetadataProvider, type ModelMetadata } from "../../generated/model-metadata"; import { enrichProviderFromRegistry, shouldCaseFoldMetadataModelId } from "../../providers/derive"; import { captureFastPolicyAuthority, fastPolicyForModel, serviceTierSupportFromPolicy, } from "../../providers/service-tier"; import type { FastPolicyAuthority } from "../../providers/fastwire"; import { effectiveGoogleMode, getProviderRegistryEntry, providerMatchesRegistryTransport, registryEntryForProviderDestination } from "../../providers/registry"; import { parseAntigravityAvailableModels, registerAntigravityDiscoveredWireModels } from "../../providers/antigravity-models"; import { applyProviderContextCap, providerContextCap, resolveUnknownRoutedContextWindow } from "../../providers/context-cap"; import { clampAutoCompactTokenLimit } from "../../providers/auto-compact-budget"; import { effectiveModelAliases } from "../../providers/default-aliases"; import { routedSlug, slugEquals, slugEquivalenceKey, slugsEquivalent } from "../../providers/slug-codec"; import { CODEX_GPT5_IDENTITY_LINE } from "../../adapters/identity"; import { filterCursorConfiguredModelsByLiveDiscovery } from "../../adapters/cursor/discovery"; import { fetchCursorUsableModels } from "../../adapters/cursor/live-models"; import { cursorLiveRosterScope, recordLiveCursorClaudeModels, recordLiveCursorMaxModeModels } from "../../adapters/cursor/catalog"; import { fetchQoderModels } from "../../adapters/qoder/live-models"; import { resolveQoderProfile } from "../../adapters/qoder/profiles"; import { CODEBUDDY_PROFILES, type CodeBuddyProfile } from "../../adapters/codebuddy/profiles"; import { fetchCodeBuddyModels } from "../../adapters/codebuddy/live-models"; import { resolveProfileByBaseUrl } from "../../adapters/coding-agent/profile"; import { fetchDevinUsableModels } from "../../adapters/devin/live-models"; import { resolveDevinApiBaseUrl } from "../../oauth/devin/api-base"; import { isCanonicalOpenAiForwardProvider, OPENAI_API_PROVIDER_ID, OPENAI_CODEX_PROVIDER_ID } from "../../providers/openai-tiers"; import { COMBO_NAMESPACE, comboModelId, getCombo, listComboIds, quotaInactiveReason, targetKey, } from "../../combos"; import type { NormalizedComboConfig } from "../../combos/types"; import { ProviderOutboundPolicyError, ProviderOutboundSendCancelledError, providerOutboundGet, providerOutboundPost, providerRedirectError, } from "../../lib/provider-outbound"; import { redactSecretString } from "../../lib/redact"; import { extractProviderModelItems, isRegistryModelDiscoveryUrl, readBoundedDiscoveryJson, resolveProviderModelDiscovery, type ModelDiscoveryResponseFailure, type ProviderModelsApiItem, type ResolvedProviderModelDiscovery, } from "../../providers/model-discovery"; import { extractGoogleAiStudioModelItems } from "../../providers/google-ai-studio-model-discovery"; import { applyConfiguredHeadersLast, fetchOllamaShowEnrichment, ollamaShowEnrichable } from "../../providers/ollama-show"; import upstreamModelsSnapshot from "../data/upstream-models.json"; import { createAdmissionGate, ResourceAdmissionError, type AdmissionMetrics } from "../../lib/admission"; import { CODEX_CUSTOM_MODEL_CATALOG_KIND, JAWCODE_CATALOG_AUGMENT_PROVIDERS, catalogModelSlug, shouldExposeRoutedModel } from "./parsing"; import type { CatalogModel } from "./parsing"; import { disabledNativeSlugs, hasComboTargets, hasNativeOpenAiCapabilityMetadata, NATIVE_GPT56_MAX_INPUT_TOKENS, nativeContextLimits, nativeOpenAiCapabilityDisplayName, nativeDefaultReasoningEffort, nativeInputModalities, nativeOpenAiAutoCompactTokenLimit, nativeOpenAiContextWindow, nativeOpenAiMaxInputTokens, nativeOpenAiMaxOutputTokens, nativeOpenAiSlugs, nativeParallelToolCalls, nativeReasoningEfforts } from "./metadata"; import { deriveComboCatalogModel, normalizedOpenAiApiSignature, openAiApiCollisionWarnings, replaceLastComboCatalogOmissions, warnUncataloguedComboOnce } from "./aggregation"; import type { ComboCatalogOmission } from "./aggregation"; import type { CatalogGatherProviderAuthEvidence } from "./filesystem-evidence"; import type { CatalogAdmissionSnapshot, CatalogDiscoveryPolicyField, CatalogGatherAuthorityIdentity, CatalogProviderDiscoveryPolicySnapshot, CatalogProcessLocalEvidence, CatalogSourceEvidence, CatalogTrustedOpenAiApiPolicySnapshot, } from "../convergence-types"; import type { CapturedProviderGather, CatalogGatherProviderAuthOutcome, CatalogGatherProviderModelOutcome, ModelsAuthResolution, ModelsAuthResolver } from "./gather-capture"; import { QUIET_AUTHORITATIVE_CATALOG_PROVIDERS, applyConfigHintsToCachedModels, applyProviderConfigHints, boundedOwnedBy, catalogHintsFromModelsApiItem, catalogHintsFromProviderConfig } from "./model-hints"; import { mergeConfiguredModelsIntoLiveCatalog, shouldExposeProviderModel, warnDroppedConfiguredIdsOnce } from "./model-visibility"; import { captureModelsRequest, captureProviderGather, materializeCapturedHeaders } from "./gather-capture"; /** Observed Kiro ids advertised in the public catalog: plain ids that need no router decoding. */ const KIRO_PUBLISHABLE_MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/; /** Upper bound on observed Kiro ids added to the catalog across the whole roster. */ const KIRO_OBSERVED_CATALOG_MAX = 64; export interface ProviderModelsResult { readonly models: CatalogModel[]; readonly outcome: CatalogGatherProviderModelOutcome; /** * The provider's cache content revision as it stood when these rows were chosen. * * Sampled here rather than by the caller because only this point is synchronous with the * choice. A caller reading it after its own await can observe a revision another flight * published in between, and would then record these rows under that flight's identity. */ readonly contentRevision: string; } export const refreshingModelsAuthResolver: ModelsAuthResolver = { kind: "refreshing" }; export function observedModelsAuthResolver( authStoreBuffer: Uint8Array | null, outcomes: CatalogGatherProviderAuthOutcome[], ): ModelsAuthResolver { return { kind: "observed", resolve(name, provider) { if (provider.authMode === "forward") return { apiKey: undefined, observed: true }; if (provider.authMode !== "oauth") { return { apiKey: resolveProviderApiKey(provider.apiKey), observed: true }; } const observation = observeActiveOAuthAccessToken(name, authStoreBuffer); outcomes.push({ provider: name, state: observation.kind }); if (observation.kind !== "available") return { apiKey: undefined, observed: true }; return { apiKey: observation.snapshot.accessToken, observed: true, oauthAccountId: observation.snapshot.accountId, oauthGeneration: observation.snapshot.generation, ...(observation.snapshot.apiBaseUrl ? { oauthApiBaseUrl: observation.snapshot.apiBaseUrl } : {}), ...(observation.snapshot.projectId ? { oauthProjectId: observation.snapshot.projectId } : {}), }; }, }; } export async function fetchProviderModelsWithAuth( captured: CapturedProviderGather, ttlMs: number, contextCap: number | undefined, resolveAuth: ModelsAuthResolver, ): Promise<ProviderModelsResult> { const { name, provider: prov, discovery, metadataModelIdCaseFold } = captured; const observed = ( models: CatalogModel[], state: CatalogGatherProviderModelOutcome["state"], ): ProviderModelsResult => ({ models, outcome: { provider: name, state }, contentRevision: observeModelCacheRevision(name), }); // Capture before any credential refresh or outbound await. OAuth account changes clear this // generation, so a request started with the former account cannot later publish its result. const cacheGeneration = captureModelCacheGeneration(name); const isCurrentCacheGeneration = () => isModelCacheGenerationCurrent(name, cacheGeneration); const anthropicSelection = name === "anthropic" && prov.authMode === "oauth" ? captureOAuthAccountSelection(name) : null; if (prov.authMode === "forward") return observed([], "authoritative"); // ChatGPT backend has no /models const seedVertexDefault = prov.adapter === "google" && prov.googleMode === "vertex" && (prov.models?.length ?? 0) === 0 && Boolean(prov.defaultModel); const seedStaticDefault = prov.liveModels === false && (prov.models?.length ?? 0) === 0 && Boolean(prov.defaultModel); // Ordered dedupe union: implicit default seed, then `models`, then `retainModels`. `configured` is the // single seed for the static path, the degraded fallback, drop diagnostics, and provider hints, // so a retain-only id must enter here or it never exists to be retained (#1690). const configuredIds = [...new Set([ ...((seedVertexDefault || seedStaticDefault) && prov.defaultModel ? [prov.defaultModel] : []), ...(prov.models ?? []), ...(prov.retainModels ?? []), ])]; const configured: CatalogModel[] = configuredIds.map(id => ({ id, provider: name, ...catalogHintsFromProviderConfig(name, prov, id, contextCap, metadataModelIdCaseFold, captured.effectiveAlias), })); const withConfiguredRetention = ( models: CatalogModel[], options?: { retainComboTargets?: boolean; warnDrops?: boolean }, ): CatalogModel[] => { const { models: merged, droppedConfiguredIds } = mergeConfiguredModelsIntoLiveCatalog({ name, provider: prov, models, configured, retainConfiguredModelIds: captured.retainConfiguredModelIds, contextCap, seedVertexDefault, retainComboTargets: options?.retainComboTargets, metadataModelIdCaseFold, }); if ( options?.warnDrops === true && droppedConfiguredIds.length > 0 && name !== OPENAI_API_PROVIDER_ID && !QUIET_AUTHORITATIVE_CATALOG_PROVIDERS.has(name) ) { warnDroppedConfiguredIdsOnce(name, droppedConfiguredIds); } return merged; }; // Static catalogs never need an OAuth refresh or an upstream model request. Clear any // discovery failure left by an older live configuration even when the account is logged out. if (prov.liveModels === false) { clearProviderDiscoveryStatus(name); if (name === "kiro") { const ids = [...configuredIds]; // Observed ids are advertised only when they round-trip through catalog encoding (no "/" // or other separators the router would have to decode), and the roster adds at most // KIRO_OBSERVED_CATALOG_MAX of them. Every observed id still informs routing preference. let observedAdded = 0; for (const account of getAccountSet("kiro")?.accounts ?? []) { if (account.needsReauth === true || account.paused === true) continue; for (const row of readKiroAccountModels(account) ?? []) { if (observedAdded >= KIRO_OBSERVED_CATALOG_MAX) break; if (!KIRO_PUBLISHABLE_MODEL_ID.test(row.modelId) || ids.includes(row.modelId)) continue; ids.push(row.modelId); observedAdded += 1; } } return observed(ids.map(id => { const hints = catalogHintsFromProviderConfig(name, prov, id, contextCap, metadataModelIdCaseFold, captured.effectiveAlias); const observedWindow = kiroObservedContextWindow(id); return { id, provider: name, ...hints, ...(observedWindow !== undefined ? { contextWindow: applyProviderContextCap(observedWindow, contextCap) } : {}) }; }), "authoritative"); } return observed(configured, "authoritative"); } const auth: ModelsAuthResolution = captured.observedAuth ?? (resolveAuth.kind === "refreshing" ? prov.authMode === "oauth" ? await getValidAccessTokenSnapshot(name) .then(snapshot => ({ apiKey: snapshot.accessToken, observed: false, oauthAccountId: snapshot.accountId, oauthGeneration: snapshot.generation, ...(snapshot.apiBaseUrl ? { oauthApiBaseUrl: snapshot.apiBaseUrl } : {}), ...(snapshot.projectId ? { oauthProjectId: snapshot.projectId } : {}), })) .catch(() => ({ apiKey: undefined, observed: false })) : { apiKey: await resolveModelsAuthToken(name, prov), observed: false } : resolveAuth.resolve(name, prov)); const apiKey = auth.apiKey; const maySendAnthropicDiscovery = () => { if (name !== "anthropic" || prov.authMode !== "oauth") return true; const selected = captureOAuthAccountSelection(name); const row = auth.oauthAccountId ? getAccountCredentialWithStatus(name, auth.oauthAccountId) : null; return !!anthropicSelection && !!selected && !!row && !row.paused && !row.needsReauth && selected.accountId === anthropicSelection.accountId && selected.revision === anthropicSelection.revision && row.credential.expires > Date.now() && auth.oauthAccountId === selected.accountId && credentialGeneration(row.credential) === auth.oauthGeneration && row.credential.access === apiKey; }; // A configured default is a real callable selector and must remain discoverable when a // compatible provider's live /models request fails (issue #308). Static providers already seed // their default selector above when no explicit model list exists. const failedDiscoveryConfigured = configured.length > 0 || !prov.defaultModel || prov.adapter !== "anthropic" ? configured : [{ id: prov.defaultModel, provider: name, ...catalogHintsFromProviderConfig(name, prov, prov.defaultModel, contextCap, metadataModelIdCaseFold, captured.effectiveAlias), }]; const vertexDefaultSeed = seedVertexDefault ? configured[0] : undefined; const withVertexDefaultSeed = (models: CatalogModel[]): CatalogModel[] => ( vertexDefaultSeed && !models.some(model => model.id === vertexDefaultSeed.id) ? [...models, vertexDefaultSeed] : models ); if (prov.adapter === "codebuddy") { if (!apiKey) return observed(configured, "degraded"); const resolvedProfile = resolveProfileByBaseUrl(CODEBUDDY_PROFILES, prov.baseUrl); if (!resolvedProfile) return observed(configured, "degraded"); const profile = resolvedProfile as CodeBuddyProfile; // Cache reads/writes are provider/key-fingerprint-scoped: an irreversible fingerprint of // the configured key means a key switch never reuses the roster cached for the previous // key. The roster comes from the product configuration endpoint authenticated with that // same key, so the fingerprint scope and the roster's authority are the same identity: the // roster is the key's own account answer, never the CLI login's. const authorityIdentity = createHash("sha256").update(apiKey).digest("hex"); const fresh = getFreshCached(name, ttlMs, Date.now(), authorityIdentity); if (fresh) { return observed(withConfiguredRetention( applyConfigHintsToCachedModels(name, prov, fresh, contextCap, metadataModelIdCaseFold, captured.effectiveAlias), ), "authoritative"); } const scopedStale = getStaleCached(name, authorityIdentity); if (isModelsFetchCoolingDown(name, undefined, undefined, authorityIdentity) && scopedStale) { return observed(withConfiguredRetention( applyConfigHintsToCachedModels(name, prov, scopedStale, contextCap, metadataModelIdCaseFold, captured.effectiveAlias), ), "degraded"); } const live = await fetchCodeBuddyModels(profile, apiKey); if (live.ok) { const discovered = live.models.map(id => ({ id, provider: name, ...catalogHintsFromProviderConfig(name, prov, id, contextCap, metadataModelIdCaseFold, captured.effectiveAlias), })); const forCache = withConfiguredRetention(discovered, { retainComboTargets: false }); if (!setCached(name, forCache, Date.now(), cacheGeneration, authorityIdentity)) { return observed(withConfiguredRetention(configured), "degraded"); } markProviderDiscoveryOk(name, live.models.length); return observed(withConfiguredRetention(forCache, { warnDrops: true }), "authoritative"); } if (isCurrentCacheGeneration()) { markModelsFetchFailure(name, undefined, authorityIdentity); markProviderDiscoveryFailed(name, { reason: "provider" }); console.warn(`[opencodex] CodeBuddy model discovery failed [${live.error}]${live.status === undefined ? "" : ` status=${live.status}`}; using stale/static catalog degradation.`); } const stale = getStaleCached(name, authorityIdentity); return observed(withConfiguredRetention( stale ? applyConfigHintsToCachedModels(name, prov, stale, contextCap, metadataModelIdCaseFold, captured.effectiveAlias) : configured, ), "degraded"); } if (prov.adapter === "qoder") { if (!apiKey) return observed(configured, "degraded"); const profile = resolveQoderProfile(prov.baseUrl); if (!profile) return observed(configured, "degraded"); // Qoder's model list is entitlement-specific. Bind cache reads/writes to an irreversible PAT // fingerprint so an account switch cannot observe another account's roster, even if a caller // bypasses the normal config mutation path that clears provider caches. const authorityIdentity = createHash("sha256").update(apiKey).digest("hex"); const fresh = getFreshCached(name, ttlMs, Date.now(), authorityIdentity); if (fresh) { return observed(withConfiguredRetention( applyConfigHintsToCachedModels(name, prov, fresh, contextCap, metadataModelIdCaseFold, captured.effectiveAlias), ), "authoritative"); } const scopedStale = getStaleCached(name, authorityIdentity); if (isModelsFetchCoolingDown(name) && scopedStale) { return observed(withConfiguredRetention( applyConfigHintsToCachedModels(name, prov, scopedStale, contextCap, metadataModelIdCaseFold, captured.effectiveAlias), ), "degraded"); } const live = await fetchQoderModels(profile, apiKey); if (live.ok) { const discovered = live.models.map(id => ({ id, provider: name, ...catalogHintsFromProviderConfig(name, prov, id, contextCap, metadataModelIdCaseFold, captured.effectiveAlias), })); const forCache = withConfiguredRetention(discovered, { retainComboTargets: false }); if (!setCached(name, forCache, Date.now(), cacheGeneration, authorityIdentity)) { return observed(withConfiguredRetention(configured), "degraded"); } markProviderDiscoveryOk(name, live.models.length); return observed(withConfiguredRetention(forCache, { warnDrops: true }), "authoritative"); } if (isCurrentCacheGeneration()) { markModelsFetchFailure(name); markProviderDiscoveryFailed(name, { reason: "provider" }); console.warn(`[opencodex] Qoder model discovery for "${name}" failed [${live.error}]${live.detail ? `: ${live.detail}` : ""}; using stale/static catalog degradation.`); } const stale = getStaleCached(name, authorityIdentity); return observed(withConfiguredRetention( stale ? applyConfigHintsToCachedModels(name, prov, stale, contextCap, metadataModelIdCaseFold, captured.effectiveAlias) : configured, ), "degraded"); } if (prov.adapter === "devin") { if (!apiKey) return observed(configured, "degraded"); // Both the credential and its validated tenant destination own this roster. // The registered Devin route ignores a saved baseUrl override; discovery must // use that same fixed destination when the stored tenant URL is invalid. const configuredBase = name === "devin" ? getProviderRegistryEntry(name)?.baseUrl ?? prov.baseUrl : prov.baseUrl; const destination = resolveDevinApiBaseUrl(auth.oauthApiBaseUrl ?? configuredBase); const authorityIdentity = createHash("sha256") .update(JSON.stringify([apiKey, destination])).digest("hex"); const cachedDevin = getFreshCached(name, ttlMs, Date.now(), authorityIdentity); if (cachedDevin) { return observed( withConfiguredRetention(applyConfigHintsToCachedModels(name, prov, cachedDevin)), "authoritative", ); } if (isModelsFetchCoolingDown(name, undefined, undefined, authorityIdentity)) { const cooling = getStaleCached(name, authorityIdentity); return observed( withConfiguredRetention( cooling ? applyConfigHintsToCachedModels(name, prov, cooling) : configured, ), "degraded", ); } // The OAuth snapshot owns both values: never combine one account's durable // key with the registry's default host or another account's tenant host. const liveResult = await fetchDevinUsableModels({ apiKey, baseUrl: destination, }); if (liveResult.ok) { // Live catalog is the source of truth — use the discovered base models // directly, not a filtered subset of the static seed. // // That extends to the context window. Cognition publishes no window // anywhere, so the per-account catalog is the only first-party number, // and the shipped static table is a degraded-mode guess that was wrong // for nine of its eleven rows. The live value is applied first and the // config hints run after it, so an explicit per-model override and an // enabled Context cap still win — this only replaces the number nobody // chose. const result = liveResult.models.map((id) => { const liveWindow = liveResult.contextWindows[id]; return { id, provider: name, ...(liveWindow ? { contextWindow: liveWindow } : {}), // The account catalog names the effort variants each base model has, so // its ladder is measured rather than assumed. Without this the entry // inherits the generic routed ladder and offers rungs the model rounds // away, and every client that keys an effort control off this field — // the Pi-shaped exports — renders no control at all. ...(liveResult.efforts[id]?.length ? { reasoningEfforts: liveResult.efforts[id] } : {}), // The family's effective enabled default, matching an unset effort at request time. ...(liveResult.defaultEfforts[id] ? { defaultReasoningEffort: liveResult.defaultEfforts[id] } : {}), // The account catalog's per-base supportsImages vote collapses to one // modalities value. It spreads before the hints so exact // modelCapabilities declarations, the legacy modelInputModalities // record and the vision-sidecar rewrite keep winning — the live // value survives only when none of them applies. ...(liveResult.inputModalities[id]?.length ? { inputModalities: liveResult.inputModalities[id] } : {}), ...catalogHintsFromProviderConfig(name, prov, id, contextCap, metadataModelIdCaseFold, captured.effectiveAlias), } as CatalogModel; }); const forCache = withConfiguredRetention(result, { retainComboTargets: false }); if (!setCached(name, forCache, Date.now(), cacheGeneration, authorityIdentity)) { return observed(withConfiguredRetention(configured), "degraded"); } markProviderDiscoveryOk(name, liveResult.models.length); return observed(withConfiguredRetention(forCache), "authoritative"); } if (isCurrentCacheGeneration()) { markModelsFetchFailure(name, undefined, authorityIdentity); markProviderDiscoveryFailed(name, { reason: liveResult.error === "auth" ? "provider" : "invalid_response" }); } const stale = getStaleCached(name, authorityIdentity); return observed( withConfiguredRetention(stale ? applyConfigHintsToCachedModels(name, prov, stale) : configured), "degraded", ); } if (prov.adapter === "cursor") { if (!apiKey) return observed(configured, "degraded"); // Cursor uses a bespoke GetUsableModels RPC (not /models), returning the full effort-suffixed // variants this PLAN can use. Keep the base-model UX (the request builder appends the effort // suffix) but filter the static seed to the bases the account actually has — so models not on the // plan (e.g. claude-fable-5) drop out instead of failing ERROR_BAD_MODEL_NAME. Fall back to the seed. // The roster is entitlement-specific, so the cache entry is bound to an irreversible // credential fingerprint: a credential switch must not observe the previous account's // plan roster, its stale fallback, or its failure cooldown suppression. const authorityIdentity = createHash("sha256").update(apiKey).digest("hex"); const cachedCursor = getFreshCached(name, ttlMs, Date.now(), authorityIdentity); if (cachedCursor) { return observed( withConfiguredRetention(applyConfigHintsToCachedModels(name, prov, cachedCursor, undefined, metadataModelIdCaseFold, captured.effectiveAlias)), "authoritative", ); } if (isModelsFetchCoolingDown(name, undefined, undefined, authorityIdentity)) { const cooling = getStaleCached(name, authorityIdentity); return observed( withConfiguredRetention( cooling ? applyConfigHintsToCachedModels(name, prov, cooling, undefined, metadataModelIdCaseFold, captured.effectiveAlias) : configured, ), "degraded", ); } const cursorFetch = (prov as OcxProviderConfig & { fetch?: typeof globalThis.fetch }).fetch; const liveResult = await fetchCursorUsableModels({ apiKey, baseUrl: prov.baseUrl, upstreamHttpVersion: prov.upstreamHttpVersion, ...(cursorFetch ? { fetch: cursorFetch } : {}), }); if (liveResult.ok) { const available = filterCursorConfiguredModelsByLiveDiscovery( configured, liveResult.models, liveResult.maxModeModels ?? [], ); const result = available.length > 0 ? available : configured; // Cache the discovery-filtered roster without combo retention so a later // gather can re-apply the current capture's retain set on read. const forCache = withConfiguredRetention(result, { retainComboTargets: false }); if (!setCached(name, forCache, Date.now(), cacheGeneration, authorityIdentity)) { return observed(withConfiguredRetention(configured), "degraded"); } // Publish roster-derived state only for a discovery the cache accepted: a stale // in-flight capture (generation revoked by a credential/config change) must not // overwrite the spelling or Max-Mode evidence of the newer one. const liveRosterScope = { provider: name, key: cursorLiveRosterScope(prov.baseUrl, apiKey) }; recordLiveCursorClaudeModels(liveResult.models, liveRosterScope); // Live Max-Mode evidence feeds the umbrella resolver's ultra gate // (devlog 260828_cursor_umbrella_catalog; union with static evidence). recordLiveCursorMaxModeModels(liveResult.maxModeModels ?? [], liveRosterScope); markProviderDiscoveryOk(name, liveResult.models.length); return observed(withConfiguredRetention(forCache, { warnDrops: true }), "authoritative"); } if (isCurrentCacheGeneration()) { markModelsFetchFailure(name, undefined, authorityIdentity); markProviderDiscoveryFailed(name, { reason: "provider" }); console.warn( `[opencodex] Cursor model discovery for "${name}" failed [${liveResult.error}]${liveResult.detail ? `: ${liveResult.detail}` : ""}; using stale/static catalog degradation.`, ); } const staleCursor = getStaleCached(name, authorityIdentity); return observed( withConfiguredRetention( staleCursor ? applyConfigHintsToCachedModels(name, prov, staleCursor, undefined, metadataModelIdCaseFold, captured.effectiveAlias) : configured, ), "degraded", ); } if (prov.authMode === "oauth" && !apiKey) { // No usable token (logged out, or account marked needsReauth). Still surface the // configured static catalog so the GUI Models tab / rail counts are not empty — // matching Cursor's !apiKey → configured degradation and fetch-failure fallback. return observed(configured, "degraded"); } const cloudCodeAssist = effectiveGoogleMode(name, prov) === "cloud-code-assist"; const project = prov.project ?? auth.oauthProjectId; if (cloudCodeAssist && !project) return observed(configured, "degraded"); const fresh = getFreshCached(name, ttlMs); if (fresh) { return observed( withConfiguredRetention( withVertexDefaultSeed(applyConfigHintsToCachedModels(name, prov, fresh, contextCap, metadataModelIdCaseFold, captured.effectiveAlias)), ), "authoritative", ); // dedups Codex's frequent /v1/models polling within the TTL } if (isModelsFetchCoolingDown(name)) { // A recently-failed provider (unreachable API, missing proxy, bad key) must not re-pay the // fetch timeout on every catalog poll — the dashboard polls this path per page load. const stale = getStaleCached(name); return observed( withConfiguredRetention( stale ? withVertexDefaultSeed(applyConfigHintsToCachedModels(name, prov, stale, contextCap, metadataModelIdCaseFold, captured.effectiveAlias)) : failedDiscoveryConfigured, ), "degraded", ); } // The captured request predates any refresh, so a refreshing gather rebuilds it // from the auth it resolved: the token and its origin, together. const request = resolveAuth.kind === "refreshing" ? captureModelsRequest(name, prov, auth.oauthApiBaseUrl) : captured.request; const url = request.url; let headers = materializeCapturedHeaders(request, apiKey); // One Ollama authority contract: for canonical ollama-cloud/ollama-native rows, discovery // (/v1/models), enrichment (/api/show) and inference (/api/chat) must all materialize the // SAME effective credential/header authority. buildModelsRequest's generic tail writes the // generated Bearer AFTER configured headers, but the native inference adapter applies // provider.headers LAST (configured wins, case-insensitive collapse). Reapply the configured // provider headers here so the whole Ollama request family shares that one authority. if (ollamaShowEnrichable(name, prov)) { headers = applyConfiguredHeadersLast(headers, prov.headers); } const urlClass = new URL(url).hostname.endsWith("aiplatform.googleapis.com") ? "vertex-aiplatform" : "provider-models"; const failedDiscoveryFallback = ( failure: ProviderModelDiscoveryFailure, ): { models: CatalogModel[]; fallback: "stale" | "configured"; shouldLog: boolean } => { if (!isCurrentCacheGeneration()) { return { models: withConfiguredRetention(failedDiscoveryConfigured), fallback: "configured", shouldLog: false, }; } // Decide logging BEFORE recording the new status, so we can compare against the prior one and // suppress an identical repeated failure (#395 log flood). The failure stays observable via the // discovery-status API regardless. const shouldLog = shouldLogDiscoveryFailure(name, failure); markModelsFetchFailure(name); markProviderDiscoveryFailed(name, failure); const stale = getStaleCached(name); return { models: withConfiguredRetention( stale ? withVertexDefaultSeed(applyConfigHintsToCachedModels(name, prov, stale, contextCap, metadataModelIdCaseFold, captured.effectiveAlias)) : failedDiscoveryConfigured, ), fallback: stale ? "stale" : "configured", shouldLog, }; }; try { // Canonical-URL TUN transparency for Clash/Surge/Mihomo fake-IP DNS: // `isRegistryModelDiscoveryUrl` proves the FINAL request URL is the // registry's own fixed discovery URL, so a purely-benchmark DNS answer may // be pin-connected through the intercepting TUN without proxy env. The // proof is on the URL — not the provider name — because an OAuth/forward // name matches any baseUrl by design. Retargeted or renamed custom rows // fetch a different URL and keep the rejection. if (!maySendAnthropicDiscovery()) return observed(withConfiguredRetention(failedDiscoveryConfigured), "degraded"); const outboundDependencies = { isCanonicalUrl: isRegistryModelDiscoveryUrl, beforeSend: maySendAnthropicDiscovery }; const res = request.method === "POST" ? await providerOutboundPost(name, prov, url, { headers, body: JSON.stringify({ project }), signal: AbortSignal.timeout(8000), }, outboundDependencies) : await providerOutboundGet(name, prov, url, { headers, signal: AbortSignal.timeout(8000), }, outboundDependencies); const redirectError = await providerRedirectError(res, url); if (redirectError) { const { models, fallback, shouldLog } = failedDiscoveryFallback({ reason: "http", httpStatus: res.status }); if (shouldLog) { console.warn( `[opencodex] Provider model discovery for "${name}" ${redirectError} [urlClass=${urlClass}, fallback=${fallback}].`, ); } return observed(models, "degraded"); } if (!res.ok) { const { models, fallback, shouldLog } = failedDiscoveryFallback({ reason: "http", httpStatus: res.status }); if (shouldLog) { console.warn( `[opencodex] Provider model discovery for "${name}" failed with HTTP ${res.status} [urlClass=${urlClass}, fallback=${fallback}].`, ); } return observed(models, "degraded"); } const contentType = ( res.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() || "missing" ).slice(0, 80); const bounded = await readBoundedDiscoveryJson(res, discovery.maxResponseBytes); if (!bounded.ok) { const { models, fallback, shouldLog } = failedDiscoveryFallback({ reason: "invalid_response" }); const diagnostic = bounded.reason === "response_too_large" ? `exceeded the ${discovery.maxResponseBytes}-byte response limit` : contentType === "application/json" || contentType.endsWith("+json") ? "returned invalid JSON in a 2xx response" : "returned a non-JSON 2xx response"; if (shouldLog) { console.warn( `[opencodex] Provider model discovery for "${name}" ${diagnostic} [status=${res.status}, contentType=${contentType}, urlClass=${urlClass}, fallback=${fallback}].`, ); } return observed(models, "degraded"); } const antigravity = cloudCodeAssist ? parseAntigravityAvailableModels(bounded.value, discovery.maxModels) : undefined; if (cloudCodeAssist && !antigravity) { const { models, fallback, shouldLog } = failedDiscoveryFallback({ reason: "invalid_response" }); if (shouldLog) { console.warn( `[opencodex] Provider model discovery for "${name}" returned malformed CCA model data [status=${res.status}, contentType=${contentType}, urlClass=${urlClass}, fallback=${fallback}].`, ); } return observed(models, "degraded"); } if (antigravity) { const live = antigravity.map(model => applyProviderConfigHints(name, prov, { id: model.id, provider: name, // CCA only exposes a numeric thinking budget. Until the adapter owns an exact Codex // effort-to-wire mapping for a newly discovered model, do not advertise a false ladder. reasoningEfforts: [], ...(model.contextWindow ? { contextWindow: model.contextWindow } : {}), ...(model.inputModalities ? { inputModalities: model.inputModalities } : {}), }, contextCap, metadataModelIdCaseFold, captured.effectiveAlias)); const forCache = withConfiguredRetention(live, { retainComboTargets: false }); if (!setCached(name, forCache, Date.now(), cacheGeneration)) { return observed(withConfiguredRetention(configured), "degraded"); } registerAntigravityDiscoveredWireModels(prov.baseUrl, antigravity, { provider: name, cacheGeneration, }); markProviderDiscoveryOk(name, live.length); return observed(withConfiguredRetention(forCache, { warnDrops: true }), "authoritative"); } const googleAiStudio = effectiveGoogleMode(name, prov) === "ai-studio" ? extractGoogleAiStudioModelItems(bounded.value, discovery.maxModels) : undefined; // Native /v1beta/models wins; a google row served by an OpenAI-compatible // gateway keeps the generic data[] / top-level-array contract. const extracted = googleAiStudio?.ok ? googleAiStudio : extractProviderModelItems(bounded.value, discovery); if (!extracted.ok) { const { models, fallback, shouldLog } = failedDiscoveryFallback({ reason: "invalid_response" }); const diagnostic: Record<ModelDiscoveryResponseFailure, string> = { response_too_large: "returned an oversized 2xx response", invalid_json: "returned invalid JSON in a 2xx response", invalid_shape: "returned malformed 2xx data", too_many_models: `exceeded the ${discovery.maxModels}-row model limit`, }; if (shouldLog) { console.warn( `[opencodex] Provider model discovery for "${name}" ${diagnostic[extracted.reason]} [status=${res.status}, contentType=${contentType}, urlClass=${urlClass}, fallback=${fallback}].`, ); } return observed(models, "degraded"); } const items = extracted.items; // Ollama Cloud enrichment: /v1/models carries no per-model context or capability metadata, // so a newly announced id would otherwise publish generic defaults. /api/show fills that // per model, fail-soft, bounded, and cached with this gather's result. Explicit configured // metadata keeps its normal precedence (applyProviderConfigHints applies the discovered // window only where exact config is absent, and the provider context cap still caps it). const showEnrichment = ollamaShowEnrichable(name, prov) ? await fetchOllamaShowEnrichment({ headers, discoveryUrl: request.url, modelIds: items.map(m => m.id), provider: prov, }).catch(() => undefined) : undefined; const live = items.map(m => { const ownedBy = boundedOwnedBy(m.owned_by); // Precedence: the authoritative /v1/models row wins; /api/show fills only metadata the // models-API row does not carry. applyProviderConfigHints then applies explicit // configured metadata over both, and the provider context cap still caps the result. const modelsApiHints = catalogHintsFromModelsApiItem(name, m); const show = showEnrichment?.metadata.get(m.id); const discoveredHints = { ...modelsApiHints, ...(modelsApiHints.contextWindow === undefined && show?.contextWindow !== undefined ? { contextWindow: show.contextWindow } : {}), ...(modelsApiHints.inputModalities === undefined && show?.nativeVision === true ? { inputModalities: ["text", "image"] as string[] } : {}), }; return applyProviderConfigHints(name, prov, { id: m.id, provider: name, ...(ownedBy ? { owned_by: ownedBy } : {}), ...discoveredHints, }, contextCap, metadataModelIdCaseFold, captured.effectiveAlias); }) .filter(m => shouldExposeProviderModel(name, m.id)); // Capture the count BEFORE the alias/configured augmentation below pushes extra rows into // `live`; otherwise configured entries would be reported as discovered ones. const liveModelCount = live.length; // Dated-release aliases + configured retention (compat allow-list, combo targets, // Vertex default). Cache without combo retention so a later gather re-applies the // current capture's retain set on read (warm-cache OCX-111 / #1308). const forCache = withConfiguredRetention(live, { retainComboTargets: false }); const returned = withConfiguredRetention(forCache, { warnDrops: true }); const droppedConfiguredIds = configured .map(model => model.id) .filter(id => !returned.some(model => model.id === id)); if (returned.length === 0 && name !== OPENAI_API_PROVIDER_ID) { console.warn( `[opencodex] Provider model discovery for "${name}" returned an authoritative empty catalog; ${droppedConfiguredIds.length > 0 ? `dropping configured model ids: ${droppedConfiguredIds.join(", ")}` : "no models will be exposed"}.`, ); } if (!setCached(name, forCache, Date.now(), cacheGeneration)) { return observed(withConfiguredRetention(configured), "degraded"); } markProviderDiscoveryOk(name, liveModelCount); return observed(returned, "authoritative"); } catch (error) { if (error instanceof ProviderOutboundSendCancelledError) { return observed(withConfiguredRetention(failedDiscoveryConfigured), "degraded"); } if (error instanceof ProviderOutboundPolicyError) { const { models, fallback, shouldLog } = failedDiscoveryFallback({ reason: "blocked" }); if (shouldLog) { console.warn( `[opencodex] Provider model discovery for "${name}" was blocked by destination policy: ${error.message} [urlClass=${urlClass}, fallback=${fallback}].`, ); } return observed(models, "degraded"); } const { models, fallback, shouldLog } = failedDiscoveryFallback({ reason: "network" }); if (shouldLog) { console.warn( `[opencodex] Provider model discovery for "${name}" threw ${error instanceof Error ? error.name : "unknown"} [urlClass=${urlClass}, fallback=${fallback}].`, ); } return observed(models, "degraded"); } } export async function fetchProviderModels( name: string, prov: OcxProviderConfig, ttlMs: number, contextCap?: number, ): Promise<CatalogModel[]> { const captured = captureProviderGather(name, prov, refreshingModelsAuthResolver); return (await fetchProviderModelsWithAuth( captured, ttlMs, contextCap, refreshingModelsAuthResolver, )).models; }