@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
313 lines (300 loc) • 15.6 kB
text/typescript
import { effectiveProviderAlias, effectiveProviderAliasDecision } from "../../providers/default-aliases";
import { antigravityFamilyDisabled, collapseAntigravityPublicModels, projectAntigravitySelectedModels } from "../../providers/antigravity-effort-families";
import { XAI_OAUTH_FAST_VARIANT_IDS } from "../../providers/xai-fast-model";
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 { hasRoutedSlug, routedSlug, 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 { CALLABLE_CONFIGURED_COMPATIBILITY_MODELS, applyProviderConfigHints, copyReasoningHintSource } from "./model-hints";
const DATED_VARIANT_YYYYMMDD = /^(\d{4})(\d{2})(\d{2})$/;
const DATED_VARIANT_YYMMDD = /^(2\d)(\d{2})(\d{2})$/;
const DATED_VARIANT_MMDD_OR_YYMM = /^(\d{2})(\d{2})$/;
/** Whether a Gregorian year contains February 29th. */
function isLeapYear(year: number): boolean {
return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
}
/**
* Whether a month/day pair exists in the given year. Without a year, February 29th is
* accepted because it occurs in at least one calendar year.
*/
function isValidCalendarDate(year: number | undefined, month: number, day: number): boolean {
if (year !== undefined && (year < 1 || year > 9999)) return false;
if (month < 1 || month > 12 || day < 1) return false;
const daysInMonth = [
31, year === undefined || isLeapYear(year) ? 29 : 28, 31, 30, 31, 30,
31, 31, 30, 31, 30, 31,
];
return day <= daysInMonth[month - 1]!;
}
/**
* Release-date suffixes providers actually publish: `YYYYMMDD` (`-20251001`), `YYMMDD`
* (`-260806`), `MMDD` (`-0813`) and `YYMM` (`-2512`). A `\d{8}`-only rule matched none of
* the dated ids on a real multi-provider install, so DeepSeek, Kimi, Mistral, Qwen and
* Solar aliases all fell through to `droppedConfiguredIds` (#3024).
*
* Calendar validation rejects impossible month-end and leap-day values as well as ordinary
* numeric suffixes such as `-2048`, `-4096` and `-8192`. `-1024` is the one irreducible
* collision — it is a valid `MMDD` (October 24th) — so it reads as dated. That is a known,
* accepted cost; the test table pins it so it cannot become a surprise later.
*
* Hyphenated ISO suffixes (`-2024-08-06`, `-05-06`) are deliberately out of scope: a
* hyphenated suffix is ambiguous against ordinary name segments and needs its own call.
*/
function isDatedVariantSuffix(suffix: string): boolean {
const yyyyMmDd = DATED_VARIANT_YYYYMMDD.exec(suffix);
if (yyyyMmDd) {
return isValidCalendarDate(
Number(yyyyMmDd[1]), Number(yyyyMmDd[2]), Number(yyyyMmDd[3]),
);
}
const yyMmDd = DATED_VARIANT_YYMMDD.exec(suffix);
if (yyMmDd) {
return isValidCalendarDate(
2000 + Number(yyMmDd[1]), Number(yyMmDd[2]), Number(yyMmDd[3]),
);
}
const mmDdOrYyMm = DATED_VARIANT_MMDD_OR_YYMM.exec(suffix);
if (!mmDdOrYyMm) return false;
const first = Number(mmDdOrYyMm[1]);
const second = Number(mmDdOrYyMm[2]);
return isValidCalendarDate(undefined, first, second)
|| (first >= 20 && first <= 29 && second >= 1 && second <= 12);
}
/** Whether `liveId` is a supported dated release of the configured base id. */
export function isDatedVariantId(liveId: string, configuredId: string): boolean {
if (!liveId.startsWith(`${configuredId}-`)) return false;
return isDatedVariantSuffix(liveId.slice(configuredId.length + 1));
}
export const lastDropWarnSignature = new Map<string, string>();
let lastWarningReconciledGeneration = 0;
export function reconcileProviderFetchWarnings(generation: number): number {
if (generation <= lastWarningReconciledGeneration) return 0;
const removed = lastDropWarnSignature.size;
lastDropWarnSignature.clear();
lastWarningReconciledGeneration = generation;
return removed;
}
export function warnDroppedConfiguredIdsOnce(name: string, droppedConfiguredIds: string[]): void {
const signature = [...droppedConfiguredIds].sort().join(",");
if (lastDropWarnSignature.get(name) === signature) return;
lastDropWarnSignature.set(name, signature);
console.warn(
`[opencodex] Provider model discovery for "${name}" omitted configured model ids; dropping them from the authoritative live catalog: ${droppedConfiguredIds.join(", ")}.`,
);
}
export function shouldExposeProviderModel(providerName: string, modelId: string): boolean {
// xAI /models advertises both the dated deployment and this floating alias.
// Keep only grok-4.20-multi-agent-0309; the alias is the same server-side id.
if (providerName === "xai" && modelId === "grok-4.20-multi-agent-beta-latest") return false;
// grok-4.7-build-fast is grok-4.7 on a faster serving lane; it is reached through grok-4.7's Fast
// selection on OAuth (xai-fast-model.ts), so the lane id is not published as a second model.
if (providerName === "xai" && XAI_OAUTH_FAST_VARIANT_IDS.has(modelId)) return false;
return true;
}
export function shouldRetainConfiguredProviderModel(
providerName: string,
modelId: string,
prov?: OcxProviderConfig,
): boolean {
if (CALLABLE_CONFIGURED_COMPATIBILITY_MODELS[providerName]?.has(modelId)) return true;
if (modelInList(prov?.retainModels, modelId)) return true;
return false;
}
/**
* Fold dated-release aliases and retain configured rows that must survive an
* authoritative live roster (compatibility allow-list, combo targets, Vertex
* default). Used on every discovery return — live, fresh cache, stale, and
* failure fallback — so a warm cache captured before a combo existed still
* surfaces the configured target (OCX-111 / #1308).
*
* Cache writes should pass `retainComboTargets: false` so combo retention is
* re-applied on read against the current capture, not frozen into the TTL entry.
*/
export function mergeConfiguredModelsIntoLiveCatalog(opts: {
name: string;
provider: OcxProviderConfig;
models: readonly CatalogModel[];
configured: readonly CatalogModel[];
retainConfiguredModelIds?: ReadonlySet<string>;
contextCap?: number;
seedVertexDefault?: boolean;
retainComboTargets?: boolean;
metadataModelIdCaseFold?: boolean;
metadataConfigDir?: string;
includeVisionSidecar?: boolean;
}): { models: CatalogModel[]; droppedConfiguredIds: string[] } {
const {
name,
provider: prov,
configured,
retainConfiguredModelIds,
contextCap,
seedVertexDefault,
retainComboTargets = true,
metadataModelIdCaseFold,
metadataConfigDir,
includeVisionSidecar,
} = opts;
const out = [...opts.models];
const present = new Set(out.map(model => model.id));
const droppedConfiguredIds: string[] = [];
for (const candidate of configured) {
if (present.has(candidate.id)) continue;
const dated = out.find(live => isDatedVariantId(live.id, candidate.id));
if (dated) {
const alias = copyReasoningHintSource(dated, { ...dated, id: candidate.id });
out.push(applyProviderConfigHints(name, prov, alias, contextCap, metadataModelIdCaseFold, undefined, metadataConfigDir, includeVisionSidecar));
present.add(candidate.id);
continue;
}
if (
seedVertexDefault === true
|| shouldRetainConfiguredProviderModel(name, candidate.id, prov)
|| (retainComboTargets && retainConfiguredModelIds?.has(candidate.id) === true)
) {
out.push(candidate);
present.add(candidate.id);
continue;
}
droppedConfiguredIds.push(candidate.id);
}
return { models: out, droppedConfiguredIds };
}
export function filterCatalogVisibleModels(
models: CatalogModel[],
config: Pick<OcxConfig, "disabledModels" | "providers" | "modelDiscovery">,
): CatalogModel[] {
const disabled = new Set(config.disabledModels ?? []);
const allowByProvider = new Map<string, Set<string>>();
for (const [name, prov] of Object.entries(config.providers)) {
const sel = prov.selectedModels;
// Keyed the way `sync.ts` keys the same list, so a slash-bearing native id and
// the encoded slug the Codex picker displays are one entry rather than two. A
// bare `Set(sel)` matched only the native form, so an allowlist written from the
// displayed slug — which `ocx models remove` also accepts — hid every model it
// was meant to keep.
//
// The key is deliberately lossy: `p/a/b` and `p/a-b` collapse to one entry, so a
// provider publishing both spellings has them selected together. That is a real
// limitation, pinned by the tests below and tracked as a follow-up; it is NOT
// fixed here. Resolving selections against the current roster instead was tried
// and rejected — the roster is an incomplete dictionary (live discovery can omit
// a published id), so it produces the same over-grant while additionally
// disagreeing with the `slugEquivalenceKey` contract `sync.ts` uses at merge time.
// Two catalog stages with different equivalence relations is the exact bug class
// this change exists to remove.
if (Array.isArray(sel) && sel.length > 0) {
allowByProvider.set(name, new Set(projectAntigravitySelectedModels(name, sel, models)
.map(model => slugEquivalenceKey(routedSlug(name, model)))));
}
}
return collapseAntigravityPublicModels(models).filter(m => {
if (initialModelSelectionPending(config.providers[m.provider])) return false;
if (config.providers[m.provider]?.disabled === true) return false;
if (antigravityFamilyDisabled(config, m, models)) return false;
const nativeAlias = m.provider === COMBO_NAMESPACE && m.nativeAlias === true;
// disabledModels may be stored raw (canonical) or encoded (legacy UI writes).
// Keep both the public combo alias and the canonical combo/<id> exclusion.
if (m.alias !== undefined && !nativeAlias && disabled.has(catalogModelSlug(m))) return false;
if (hasRoutedSlug(disabled, m.provider, m.id)) return false;
const allow = allowByProvider.get(m.provider);
return !allow || allow.has(slugEquivalenceKey(routedSlug(m.provider, m.id)));
});
}