UNPKG

@bitkyc08/opencodex

Version:

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

376 lines (364 loc) • 19.5 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 { CODEX_CONFIG_PATH, CODEX_MODELS_CACHE_PATH, DEFAULT_CATALOG_PATH, readRootTomlString, resolveCodexConfigPath } from "../paths"; import { clearModelCache, clearProviderDiscoveryStatus, captureModelCacheGeneration, 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 { recordLiveCursorClaudeModels, recordLiveCursorMaxModeModels } from "../../adapters/cursor/catalog"; import { fetchQoderModels } from "../../adapters/qoder/live-models"; import { resolveQoderProfile } from "../../adapters/qoder/profiles"; import { fetchDevinUsableModels } from "../../adapters/devin/live-models"; 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, 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 { applyProviderConfigHints, configuredAutoCompactTokenLimit, positiveSafeInteger } from "./model-hints"; /** Model ids each provider must retain for combo catalog derivation (OCX-111). */ export function configuredComboTargetModelsByProvider( config: Pick<OcxConfig, "combos">, ): Map<string, ReadonlySet<string>> { const byProvider = new Map<string, Set<string>>(); for (const id of listComboIds(config)) { const combo = getCombo(config, id); if (!combo) continue; for (const target of combo.targets) { let models = byProvider.get(target.provider); if (!models) { models = new Set(); byProvider.set(target.provider, models); } models.add(target.model); } } return byProvider; } /** * Last-resort context window for combo member synthesis when discovery, * provider config, and an enabled Context cap all omit one. Matches the * catalog entry default in `normalizeRoutedCatalogEntry` so incomplete live * rows still catalog. An enabled Context cap is the operator-facing window, * not a clamp on this placeholder. */ const COMBO_MEMBER_CONTEXT_FALLBACK = 128_000; interface ComboCatalogMemberFallback { readonly contextWindow?: number; /** Input ceiling when it is lower than the window (native GPT-5.6: 922k under 1.05M). */ readonly maxInputTokens?: number; readonly maxOutputTokens?: number; readonly autoCompactTokenLimit?: number; readonly inputModalities?: readonly string[]; readonly reasoningEfforts?: readonly string[]; } /** * Ladder advertised for a combo member whose vendor metadata says it reasons but * carries no explicit ladder (Claude, Grok). Codex needs a non-empty ladder to show * the effort control; the routed adapters clamp to the real upstream top rung. */ const ROUTED_COMBO_MEMBER_REASONING_EFFORTS: readonly string[] = ["low", "medium", "high", "xhigh", "max"]; /** * Vendor-table lookup tolerant of point releases and date pins. Configured combo * targets often name a variant the table does not carry (`claude-fable-5-1`, * `claude-opus-4-5-20251101`); the base family row still describes its modality * and reasoning capability, so fall back to it before giving up. */ function comboMemberVendorMetadata(provider: string, modelId: string): ModelMetadata | undefined { const exact = getModelMetadataCaseInsensitive(provider, modelId); if (exact) return exact; let candidate = modelId.replace(/\[[^\]]*\]$/, ""); while (true) { const trimmed = candidate.replace(/-\d+$/, ""); if (trimmed === candidate || !trimmed.includes("-")) return undefined; const hit = getModelMetadataCaseInsensitive(provider, trimmed); if (hit) return hit; candidate = trimmed; } } /** * Combo members are usually thin discovery rows (id + context window). Without a * capability source the combo intersection collapses to text-only / no effort ladder, * and the Codex app then refuses image attachments and hides the effort picker for * every Claude combo. The generated vendor table knows both, so use it as the * last-resort fallback when the caller supplied none. * * `ModelMetadata.maxTokens` is the OUTPUT ceiling, so it fills `maxOutputTokens`. * Mapping it onto `maxInputTokens` would be read by the combo intersection * (`aggregation.ts` `Math.min` over member input ceilings) as a 128k input limit and * shrink a 1M Claude combo window to 128k, taking autoCompactTokenLimit down with it. */ function vendorMetadataComboFallback(target: { provider: string; model: string }): ComboCatalogMemberFallback | undefined { const metadataProvider = resolveMetadataProvider(target.provider); // Custom OpenAI-compatible routes commonly retain the canonical OpenAI model id // while using a provider name that has no metadata alias. Reuse only its effort // ladder below; context/modality rows remain provider-owned. const metadata = metadataProvider ? comboMemberVendorMetadata(metadataProvider, target.model) : comboMemberVendorMetadata("openai", target.model); if (!metadata) return undefined; return { ...(metadataProvider && typeof metadata.contextWindow === "number" && metadata.contextWindow > 0 ? { contextWindow: metadata.contextWindow } : {}), ...(metadataProvider && typeof metadata.maxTokens === "number" && metadata.maxTokens > 0 ? { maxOutputTokens: metadata.maxTokens } : {}), ...(metadataProvider && Array.isArray(metadata.input) && metadata.input.length > 0 ? { inputModalities: [...metadata.input] } : {}), ...(metadata.reasoning === true ? { reasoningEfforts: [...ROUTED_COMBO_MEMBER_REASONING_EFFORTS] } : {}), }; } /** * Resolve a combo target to a catalog member for derivation. * Prefer discovery metadata; when the target is missing from the gather map or * lacks a positive contextWindow, synthesize from the (registry-enriched) * provider config so combos remain catalogued when targets are configured but * discovery metadata is incomplete. Disabled providers stay unresolved. * When hints still omit contextWindow, prefer known maxInputTokens, else the * enabled Context cap, else COMBO_MEMBER_CONTEXT_FALLBACK so a live row * without ctx does not drop the whole combo from the public catalog. */ export function resolveComboCatalogMember( target: { provider: string; model: string }, memberByKey: ReadonlyMap<string, CatalogModel>, providers: ReadonlyMap<string, OcxProviderConfig>, contextCap?: number, callerFallback?: ComboCatalogMemberFallback, metadataModelIdCaseFold?: boolean, ): CatalogModel | undefined { const existing = memberByKey.get(targetKey(target)); const prov = providers.get(target.provider); const fallback = callerFallback ?? vendorMetadataComboFallback(target); // Disabled providers never contribute members — even a complete discovery row // is unusable for catalog derivation while the provider is off. if (prov?.disabled === true) return undefined; const withFallbackMetadata = (member: CatalogModel): CatalogModel => { const contextWindow = typeof member.contextWindow === "number" && member.contextWindow > 0 ? member.contextWindow : undefined; const addMaxInput = fallback !== undefined && contextWindow !== undefined && !(typeof member.maxInputTokens === "number" && member.maxInputTokens > 0); const addMaxOutput = fallback !== undefined && typeof fallback.maxOutputTokens === "number" && fallback.maxOutputTokens > 0 && !(typeof member.maxOutputTokens === "number" && member.maxOutputTokens > 0); const effectiveMaxInput = addMaxInput ? Math.min(fallback?.maxInputTokens ?? contextWindow!, contextWindow!) : member.maxInputTokens; const softCandidates = [member.autoCompactTokenLimit, fallback?.autoCompactTokenLimit] .filter((value): value is number => typeof value === "number" && value > 0); const autoCompactTokenLimit = contextWindow !== undefined && softCandidates.length > 0 ? clampAutoCompactTokenLimit(contextWindow, effectiveMaxInput, Math.min(...softCandidates)) : member.autoCompactTokenLimit; const adjustAutoCompact = autoCompactTokenLimit !== member.autoCompactTokenLimit; const addModalities = (!Array.isArray(member.inputModalities) || member.inputModalities.length === 0) && fallback?.inputModalities !== undefined; const addReasoning = member.reasoningEfforts === undefined && fallback?.reasoningEfforts !== undefined; if (!addMaxInput && !addMaxOutput && !adjustAutoCompact && !addModalities && !addReasoning) return member; return { ...member, // Never claim a larger input budget than the window, and prefer the model's own // measured ceiling when the fallback carries one. ...(addMaxInput ? { maxInputTokens: effectiveMaxInput } : {}), ...(addMaxOutput ? { maxOutputTokens: fallback!.maxOutputTokens } : {}), ...(adjustAutoCompact && autoCompactTokenLimit !== undefined ? { autoCompactTokenLimit } : {}), ...(addModalities ? { inputModalities: [...fallback!.inputModalities!] } : {}), ...(addReasoning ? { reasoningEfforts: [...fallback!.reasoningEfforts!] } : {}), }; }; // Complete live/configured rows still honour providerContextCaps so a high // discovery window cannot outrun an operator-configured cap. Native-alias // fallback metadata may fill only capability gaps; it never raises an explicit // discovered/configured context window. if ( existing && typeof existing.contextWindow === "number" && existing.contextWindow > 0 ) { // Live discovery can explicitly say text-only even when configured routing // supplies a vision sidecar. Apply the same provider hints used for thin // rows before deriving a combo from this complete row. const hinted = prov && isModelVisionSidecarConsumer(prov, existing.id) ? applyProviderConfigHints(target.provider, prov, existing, contextCap, metadataModelIdCaseFold) : existing; const capped = applyProviderContextCap(hinted.contextWindow, contextCap); if (capped === undefined || capped === existing.contextWindow) { return withFallbackMetadata(hinted); } const maxInput = typeof hinted.maxInputTokens === "number" && hinted.maxInputTokens > 0 ? Math.min(hinted.maxInputTokens, capped) : Math.min(fallback?.maxInputTokens ?? capped, capped); return withFallbackMetadata({ ...hinted, contextWindow: capped, maxInputTokens: maxInput, contextCap, contextCapped: true as const, }); } const base: CatalogModel = existing ?? { id: target.model, provider: target.provider, }; const hinted = prov ? applyProviderConfigHints(target.provider, prov, base, contextCap, metadataModelIdCaseFold) : base; const hintedContext = typeof hinted.contextWindow === "number" && hinted.contextWindow > 0 ? hinted.contextWindow : undefined; const knownMaxInput = typeof hinted.maxInputTokens === "number" && hinted.maxInputTokens > 0 ? hinted.maxInputTokens : (typeof base.maxInputTokens === "number" && base.maxInputTokens > 0 ? base.maxInputTokens : undefined); // Kept OUT of knownMaxInput on purpose: that value doubles as a context-window fallback // below, and a native alias whose input ceiling (922k) is lower than its window (1.05M) // would otherwise shrink the advertised window to the input limit. const fallbackMaxInput = existing || prov ? fallback?.maxInputTokens : undefined; // Real discovery/config values win. A native alias is the next fallback tier. // The generic 128k/text synthesis from #1305 remains the final fallback. const fallbackContext = existing || prov ? fallback?.contextWindow : undefined; const uncappedContext = hintedContext ?? knownMaxInput ?? fallbackContext ?? (existing || prov ? resolveUnknownRoutedContextWindow(contextCap) : undefined); if (uncappedContext === undefined) return undefined; // 真发现值才压低。resolveUnknownRoutedContextWindow 已经把 cap 当成窗口填进去了,不能再 min 一次。 const usedDiscoveredWindow = hintedContext !== undefined || knownMaxInput !== undefined || fallbackContext !== undefined; const cappedContext = usedDiscoveredWindow ? applyProviderContextCap(uncappedContext, contextCap) : uncappedContext; const contextWindow = cappedContext ?? uncappedContext; const fallbackCapped = usedDiscoveredWindow && contextCap !== undefined && cappedContext !== undefined && cappedContext !== uncappedContext; const inputModalities = hinted.inputModalities ?? base.inputModalities ?? (fallback?.inputModalities ? [...fallback.inputModalities] : undefined) ?? ["text"]; const reasoningEfforts = hinted.reasoningEfforts ?? (prov ? configuredReasoningEfforts(prov, target.model) : undefined) ?? base.reasoningEfforts ?? (fallback?.reasoningEfforts ? [...fallback.reasoningEfforts] : undefined); const maxOutputTokens = positiveSafeInteger(hinted.maxOutputTokens, base.maxOutputTokens) ?? (existing || prov ? positiveSafeInteger(fallback?.maxOutputTokens) : undefined); // The model's own measured input ceiling still applies when discovery gave us nothing: // GPT-5.6 advertises a 1.05M window but refuses input past 922k. const effectiveMaxInput = knownMaxInput ?? fallbackMaxInput; const maxInputTokens = effectiveMaxInput !== undefined ? Math.min(effectiveMaxInput, contextWindow) : contextWindow; const softCandidates = [ hinted.autoCompactTokenLimit, base.autoCompactTokenLimit, fallback?.autoCompactTokenLimit, configuredAutoCompactTokenLimit(prov, target.model), ].filter((value): value is number => typeof value === "number" && value > 0); // A generic 128k synthesis is a catalog compatibility fallback, not evidence // that a configured soft policy has an authoritative window to clamp against. const hasAuthoritativeAutoCompactBasis = hintedContext !== undefined || fallbackContext !== undefined || contextCap !== undefined; const autoCompactTokenLimit = hasAuthoritativeAutoCompactBasis && softCandidates.length > 0 ? clampAutoCompactTokenLimit(contextWindow, maxInputTokens, Math.min(...softCandidates)) : undefined; return { ...hinted, inputModalities, ...(reasoningEfforts !== undefined ? { reasoningEfforts } : {}), contextWindow, maxInputTokens, ...(maxOutputTokens !== undefined ? { maxOutputTokens } : {}), ...(autoCompactTokenLimit !== undefined ? { autoCompactTokenLimit } : {}), ...(fallbackCapped ? { contextCap, contextCapped: true as const } : {}), }; }