@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
448 lines (420 loc) • 20.4 kB
text/typescript
// Registry model renames do not reach a saved provider config on their own.
//
// `reconcileOAuthProviders` refuses to touch a row whose `authMode` is not
// `oauth` (src/oauth/index.ts), and `enrichProviderFromRegistry` is fill-only by
// design: it backfills a MISSING field and never rewrites a present one, so a
// user's hand-edited model list survives an upgrade. Both postures are correct.
// Their gap is the case where the registry did not ADD a model but RENAMED one:
// the saved row keeps a retired id forever, the supported id never appears, and
// the capability metadata stays keyed to an id the vendor is taking offline
// (issue #1610 — `qwen3.8-max-preview` persisted through the `qwen3.8-max`
// rename in six separate fields, including a reasoning ladder that had since
// diverged from the registry's).
//
// This migration is deliberately NOT general reconciliation. It rewrites exactly
// one thing: an id this file declares retired, on a provider that still carries
// the registry's transport, and only when the registry currently seeds the
// replacement — and it skips a field where the retired entry is registry residue
// with nothing left to carry forward (see `isRegistryResidue`, issue #5066).
// Everything else in the row is left alone.
import { PROVIDER_REGISTRY, normalizedProviderEndpoint } from "./registry";
import { KIMI_API_K31_REASONING_EFFORT_MAP, MINIMAX_M31_FLASH, MINIMAX_M31_FLASH_PREVIEW_RETIRED } from "./registry/model-seeds";
import { MODEL_KEYED_RECORDS, MODEL_ID_LISTS, MODEL_ID_SCALARS, MODEL_NESTED_RECORDS } from "./model-rename-fields";
import { providerConfigSeed } from "./derive";
import type { OcxConfig, OcxProviderConfig } from "../types";
export interface ModelRename {
/** Registry provider id whose saved rows may carry the retired model id. */
provider: string;
from: string;
to: string;
/** Why the vendor retired it, for the startup warning and future readers. */
reason: string;
/**
* Drop the retired key from `modelReasoningEffortMap` instead of renaming it.
*
* Renaming preserves the VALUE, which is right for records whose values describe the
* model — a context window or an effort ladder survives a rename — and wrong for the
* one record whose values are themselves wire ids. An effort map saved as
* `high -> gemini-3.6-flash-high` would keep naming a dead wire id under the new key,
* and the adapter maps effort BEFORE resolving CCA routing, so that value arrives as
* an unrecognised effort and silently degrades to the default tier.
*
* Only that one record is dropped. Emptying the others would be worse than the bug:
* catalog enrichment treats an existing `{}` as "already populated" and will not
* restore the registry's records, so the migrated user would keep routing correctly
* but lose the reasoning picker entirely.
*/
dropReasoningEffortMap?: boolean;
/**
* Remove both the retired id and its replacement from `noReasoningModels`.
*
* Use this only when the rename also marks a capability change: carrying the old
* no-reasoning classification onto a newly adjustable alias would keep the picker
* disabled after the model id itself was repaired.
*/
dropNoReasoningModels?: boolean;
/** Refresh exact registry defaults already saved under the replacement id. */
targetSeedRefresh?: {
/**
* Refresh only values carried over from the retired id. Set this when the registry never
* seeded the replacement id with the stale values, so anything already saved under it is a
* user override even when it happens to equal the old seed.
*/
onlyTransferred?: boolean;
contextWindow?: { from: number; to: number };
reasoning?: {
fromEfforts: readonly string[];
toEfforts: readonly string[];
defaultEffort: string;
effortMap: Readonly<Record<string, string>>;
};
};
}
const KIMI_K28_ALIAS = "kimi-for-coding";
const KIMI_RETIRED_CODING_IDS = [
"kimi-k2.7-code",
"kimi-k2.7-code-highspeed",
"kimi-k2.6",
"kimi-k2.5",
] as const;
const KIMI_K28_TARGET_SEED_REFRESH: NonNullable<ModelRename["targetSeedRefresh"]> = {
contextWindow: { from: 262_144, to: 1_048_576 },
reasoning: {
fromEfforts: [],
toEfforts: ["low", "high", "max"],
defaultEffort: "max",
effortMap: { none: "none", low: "low", medium: "high", high: "high", xhigh: "max", max: "max" },
},
};
function kimiCodingRenames(provider: "kimi" | "kimi-code", endpoint: string): ModelRename[] {
return KIMI_RETIRED_CODING_IDS.map(from => ({
provider,
from,
to: KIMI_K28_ALIAS,
reason: `Moonshot retired the k2.x coding ids from the ${endpoint}; kimi-for-coding is the stable alias the endpoint still serves`,
dropNoReasoningModels: true,
targetSeedRefresh: KIMI_K28_TARGET_SEED_REFRESH,
}));
}
/**
* Renames already applied to `PROVIDER_REGISTRY`. An entry stays here after the
* registry moves on: it is what repairs configs saved before that move. Removing
* one strands every config that has not started since the rename shipped.
*/
export const MODEL_RENAMES: readonly ModelRename[] = [
{
provider: "alibaba-token-plan",
from: "qwen3.8-max-preview",
to: "qwen3.8-max",
reason: "Alibaba shipped Qwen3.8-Max as stable and documents the preview endpoint as liable to be taken offline once preview concludes",
},
{
provider: "alibaba-token-plan-intl",
from: "qwen3.8-max-preview",
to: "qwen3.8-max",
reason: "Alibaba shipped Qwen3.8-Max as stable and documents the preview endpoint as liable to be taken offline once preview concludes",
},
// Kimi coding renames. Moonshot retired the k2.x ids from the subscription/coding
// endpoint when K2.8 Preview shipped (live /coding/v1/models lists only
// kimi-for-coding[-highspeed], k3, k3-256k); kimi-for-coding is the stable alias the
// endpoint still serves and currently routes to K2.8 Preview. The registry picker no
// longer seeds the retired ids, so a saved defaultModel naming one is a dead selection
// rather than a merely outdated one.
...kimiCodingRenames("kimi", "subscription endpoint after K2.8 Preview shipped"),
...kimiCodingRenames("kimi-code", "coding endpoint after K2.8 Preview shipped"),
{
provider: "moonshot",
from: "kimi-k2.5",
to: "kimi-k3.1-pro",
// Verified 2026-10-28: https://platform.kimi.ai/docs/models.md
reason: "Moonshot discontinued K2.5 on 2026-08-31 and recommends K3.1 Pro for API users",
dropNoReasoningModels: true,
targetSeedRefresh: {
onlyTransferred: true,
contextWindow: { from: 262_144, to: 1_048_576 },
reasoning: {
fromEfforts: [],
toEfforts: ["low", "high", "max"],
defaultEffort: "max",
effortMap: KIMI_API_K31_REASONING_EFFORT_MAP,
},
},
},
// Antigravity Flash generations. Google takes the previous Flash model off Cloud Code
// Assist almost immediately when the next ships, so a saved 3.6 (or older 3.5) id is a
// dead selection rather than a merely outdated one. Routing already redirects these ids
// at request time; this migration repairs the saved config so the picker, the allowlist
// and the capability maps stop naming a model the backend no longer serves. The target is
// the live 3.8 base: 3.7 left the static lineup on 2026-10-14 (CCA 404s its wire id), and
// registrySeedsTarget refuses to write an id the registry no longer seeds.
...(["gemini-3.6-flash", "gemini-3.6-flash-low", "gemini-3.6-flash-medium", "gemini-3.6-flash-high",
"gemini-3.5-flash-extra-low", "gemini-3.5-flash-low", "gemini-3.5-flash-mid", "gemini-3.5-flash-high",
"gemini-3-flash-agent"] as const).map(from => ({
provider: "google-antigravity",
from,
to: "gemini-3.8-flash",
reason: "Google retires the previous Antigravity Flash generation from Cloud Code Assist when its successor ships, so the saved id no longer resolves to a live model",
// The retired Flash tiers were wire ids, so any saved per-model record keyed by one
// may also hold one as a value. 3.8 resolves tiers from its own suffix ladder instead.
dropReasoningEffortMap: true,
})),
// MiniMax shipped M3.1-Flash as generally available on 2026-10-19 and retired the preview
// id, so a saved MiniMax-M3.1-Flash-Preview selection would answer model-not-found. The
// stale-roster refresh only matches exact old seeds; this repairs the preview id itself.
...(["minimax", "minimax-cn"] as const).map(provider => ({
provider,
from: MINIMAX_M31_FLASH_PREVIEW_RETIRED,
to: MINIMAX_M31_FLASH,
reason: "MiniMax shipped M3.1-Flash as generally available and retired the preview id",
})),
];
function renameInList(value: unknown, from: string, to: string): string[] | null {
if (!Array.isArray(value) || !value.includes(from)) return null;
const seen = new Set<string>();
const next: string[] = [];
// Rename in place to preserve ordering, and collapse a duplicate if the target
// id was already present alongside the retired one.
for (const entry of value) {
if (typeof entry !== "string") continue;
const mapped = entry === from ? to : entry;
if (seen.has(mapped)) continue;
seen.add(mapped);
next.push(mapped);
}
return next;
}
function dropRenamedIdsFromList(
value: unknown,
from: string,
to: string,
dropStaleTarget: boolean,
keepTarget = false,
): string[] | null {
if (!Array.isArray(value)) return null;
const hasRetired = value.includes(from);
if (!hasRetired && !(dropStaleTarget && !keepTarget && value.includes(to))) return null;
return value.filter(entry => typeof entry === "string" && entry !== from && (keepTarget || entry !== to));
}
function renameInRecord(value: unknown, from: string, to: string): Record<string, unknown> | null {
if (!value || typeof value !== "object" || Array.isArray(value)) return null;
const record = value as Record<string, unknown>;
if (!(from in record)) return null;
const next: Record<string, unknown> = {};
for (const [key, entry] of Object.entries(record)) {
const mapped = key === from ? to : key;
if (mapped in next) continue;
// An explicit entry already saved under the new id is the newer intent.
next[mapped] = key === from && to in record ? record[to] : entry;
}
return next;
}
/** Drop the retired key entirely, leaving any entry already saved under the new id. */
function dropFromRecord(value: unknown, from: string): Record<string, unknown> | null {
if (!value || typeof value !== "object" || Array.isArray(value)) return null;
const record = value as Record<string, unknown>;
if (!(from in record)) return null;
const next: Record<string, unknown> = {};
for (const [key, entry] of Object.entries(record)) {
if (key === from) continue;
next[key] = entry;
}
return next;
}
function sameStringArray(value: unknown, expected: readonly string[]): boolean {
return Array.isArray(value)
&& value.length === expected.length
&& value.every((entry, index) => entry === expected[index]);
}
function targetReasoningMatchesStaleSeed(row: Record<string, unknown>, rename: ModelRename): boolean {
const reasoning = rename.targetSeedRefresh?.reasoning;
const efforts = row.modelReasoningEfforts as Record<string, unknown> | undefined;
return !!reasoning && !!efforts && sameStringArray(efforts[rename.to], reasoning.fromEfforts);
}
/** Refresh only exact defaults emitted by the previous registry; preserve user overrides. */
function refreshTargetSeed(
row: Record<string, unknown>, rename: ModelRename, savedBefore: { window: boolean; efforts: boolean },
): boolean {
const refresh = rename.targetSeedRefresh;
if (!refresh) return false;
let changed = false;
const windows = row.modelContextWindows as Record<string, unknown> | undefined;
if (windows && refresh.contextWindow && windows[rename.to] === refresh.contextWindow.from
&& !(refresh.onlyTransferred && savedBefore.window)) {
windows[rename.to] = refresh.contextWindow.to;
changed = true;
}
const reasoning = refresh.reasoning;
if (refresh.onlyTransferred && savedBefore.efforts) return changed;
const efforts = row.modelReasoningEfforts as Record<string, unknown> | undefined;
if (!reasoning || !efforts || !sameStringArray(efforts[rename.to], reasoning.fromEfforts)) return changed;
efforts[rename.to] = [...reasoning.toEfforts];
const defaults = (row.modelDefaultReasoningEfforts ??= {}) as Record<string, unknown>;
if (!(rename.to in defaults)) defaults[rename.to] = reasoning.defaultEffort;
const maps = (row.modelReasoningEffortMap ??= {}) as Record<string, unknown>;
if (!(rename.to in maps)) maps[rename.to] = { ...reasoning.effortMap };
return true;
}
/**
* `provider/model` rows in the top-level `disabledModels` list.
*
* The retired row is DROPPED rather than renamed: carrying its disabled state to
* the new id would hide the supported model behind a toggle the user set for a
* different model. An existing row for the new id is left untouched.
*/
function renameDisabledModels(config: OcxConfig, rename: ModelRename): boolean {
const list = config.disabledModels;
if (!Array.isArray(list)) return false;
const retired = `${rename.provider}/${rename.from}`;
if (!list.includes(retired)) return false;
config.disabledModels = list.filter(entry => entry !== retired);
return true;
}
/**
* Only migrate a row that still points at the registry's own endpoint. A user who
* repointed `baseUrl` at a different vendor owns their model ids.
*/
function providerStillMatchesRegistry(name: string, prov: OcxProviderConfig): boolean {
const entry = PROVIDER_REGISTRY.find(row => row.id === name);
if (!entry) return false;
if (!prov.baseUrl || !entry.baseUrl) return true;
const choices = entry.baseUrlChoices?.map(choice => choice.baseUrl) ?? [];
const known = [entry.baseUrl, ...choices]
.filter((url): url is string => typeof url === "string")
.map(normalizedProviderEndpoint);
return known.includes(normalizedProviderEndpoint(prov.baseUrl));
}
/** Guard against a stale rename: only apply when the registry actually seeds `to`. */
function registrySeedsTarget(rename: ModelRename): boolean {
const entry = PROVIDER_REGISTRY.find(row => row.id === rename.provider);
return !!entry?.models?.includes(rename.to);
}
/** The row the registry contributes to a saved config, or `undefined` when it dropped the id. */
function registrySeed(provider: string): Record<string, unknown> | undefined {
const entry = PROVIDER_REGISTRY.find(row => row.id === provider);
return entry ? (providerConfigSeed(entry) as unknown as Record<string, unknown>) : undefined;
}
/** Whether a saved list or model-keyed record names this id at all. */
function publishes(container: unknown, id: string): boolean {
if (Array.isArray(container)) return container.includes(id);
if (!container || typeof container !== "object") return false;
return id in (container as Record<string, unknown>);
}
/**
* Whether this field’s retired entry is registry residue rather than something to repair.
*
* Two things have to be true. The registry’s own seed — `providerConfigSeed`, the row both the
* OAuth preset (`deriveOAuthProviderConfig`) and `enrichProviderFromRegistry` contribute — must
* still publish the retired id in this field, so the entry arrives in the config on its own. And
* the saved field must already carry the supported id, so the rename would only DELETE a key,
* with nothing to carry forward.
*
* Under those two conditions the rewrite is worse than a no-op, because it never converges.
* `startServer` runs this migration and then `reconcileOAuthProviders`, and
* `applyOAuthPresetCatalog` fills missing preset keys into the saved metadata maps.
* The deletion is undone inside the same boot, the config is written twice, and the user
* is told about a rename that never sticks on every single start. Issue #5066 is exactly that:
* `ANTIGRAVITY_MODEL_CONTEXT_WINDOWS` derives a window for every compatibility alias, so
* `modelContextWindows` holds a key for all nine retired Flash ids beside the live ones — the
* nine `[model-rename-migration]` lines the reporter saw at every `ocx start`, none of which
* required them to have selected any of those nine models.
*
* Those registry entries are deliberate and stay: a request that still names `gemini-3.6-flash`
* routes to 3.7 and needs a context window under the id it asked for. The second condition is
* what keeps this narrow. A row that saved `{ "gemini-3.6-flash": 1048576 }` and nothing else
* still gets the value carried onto the supported id, because dropping it there would blank the
* record instead of moving it (`tests/adapters/google/gemini-37-flash-migration.test.ts`).
*/
function isRegistryResidue(
seed: Record<string, unknown> | undefined,
field: string,
saved: unknown,
rename: ModelRename,
): boolean {
if (!seed) return false;
return publishes(seed[field], rename.from) && publishes(saved, rename.to);
}
export interface ModelRenameProjection {
config: OcxConfig;
changed: boolean;
warnings: string[];
}
/**
* Pure projection: apply every applicable rename and report what changed. The
* caller decides whether to persist.
*/
export function projectModelRenames(
config: OcxConfig,
renames: readonly ModelRename[] = MODEL_RENAMES,
): ModelRenameProjection {
const warnings: string[] = [];
let changed = false;
for (const rename of renames) {
const prov = config.providers?.[rename.provider];
if (!prov) continue;
if (!registrySeedsTarget(rename)) {
warnings.push(
`registry no longer seeds "${rename.to}" for "${rename.provider}"; skipping the `
+ `"${rename.from}" rename rather than writing an id the registry does not know.`,
);
continue;
}
if (!providerStillMatchesRegistry(rename.provider, prov)) continue;
// Provider config is a closed interface, so index through one unknown-cast
// view rather than casting at each assignment.
const row = prov as unknown as Record<string, unknown>;
const seed = registrySeed(rename.provider);
const savedBefore = {
window: publishes(row.modelContextWindows, rename.to),
efforts: publishes(row.modelReasoningEfforts, rename.to),
};
let touched = false;
for (const field of MODEL_ID_LISTS) {
if (isRegistryResidue(seed, field, row[field], rename)) continue;
const next = rename.dropNoReasoningModels && field === "noReasoningModels"
? dropRenamedIdsFromList(
row[field],
rename.from,
rename.to,
targetReasoningMatchesStaleSeed(row, rename),
// A successor classification saved before the migration is the user's, not registry residue.
rename.targetSeedRefresh?.onlyTransferred === true,
)
: renameInList(row[field], rename.from, rename.to);
if (!next) continue;
row[field] = next;
touched = true;
}
for (const field of MODEL_KEYED_RECORDS) {
if (isRegistryResidue(seed, field, row[field], rename)) continue;
const next = rename.dropReasoningEffortMap && field === "modelReasoningEffortMap"
? dropFromRecord(row[field], rename.from)
: renameInRecord(row[field], rename.from, rename.to);
if (!next) continue;
row[field] = next;
touched = true;
}
for (const field of MODEL_NESTED_RECORDS) {
const container = row[field];
if (!container || typeof container !== "object" || Array.isArray(container)) continue;
const nested = container as Record<string, unknown>;
const next = renameInRecord(nested.models, rename.from, rename.to);
if (!next) continue;
row[field] = { ...nested, models: next };
touched = true;
}
for (const field of MODEL_ID_SCALARS) {
if (row[field] !== rename.from) continue;
row[field] = rename.to;
touched = true;
}
if (renameDisabledModels(config, rename)) touched = true;
if (touched && refreshTargetSeed(row, rename, savedBefore)) touched = true;
if (touched) {
changed = true;
warnings.push(
`renamed "${rename.provider}/${rename.from}" to "${rename.to}" in the saved config: ${rename.reason}.`,
);
}
}
return { config, changed, warnings };
}