@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
236 lines (226 loc) • 10.7 kB
text/typescript
import type { OcxConfig } from "../types";
import { routedSlug, slugEquals } from "./slug-codec";
import {
antigravityEffortFamilyIds, antigravityFamilyDisabled,
type AntigravityEffortFamilyRow,
} from "./antigravity-effort-families";
export const MODEL_REMOVAL_GRACE_FETCHES = 3;
export const MAX_KNOWN_MODELS_PER_PROVIDER = 2_000;
export const MAX_RECENT_ARRIVALS_PER_PROVIDER = 50;
export type KnownModelBaseline = NonNullable<NonNullable<OcxConfig["modelDiscovery"]>["knownModels"]>[string];
/**
* `on` keeps arrivals visible, `off` disables them, and `admit` (#8236) appends them to a
* provider's custom `selectedModels` so a curated picker gains new releases. `admit` touches
* only custom selections: a preset owns which flagships arrive, and a provider without a
* selection already shows every arrival.
*/
export type NewModelPolicy = "on" | "off" | "admit";
/**
* Which side of the reconciliation is running.
*
* `converge` (the default) is the catalog convergence cycle: it advances the removal grace and
* retires ids missing for {@link MODEL_REMOVAL_GRACE_FETCHES} cycles. `discovery` is the HTTP read
* side (GET /v1/models), which is polled far more often than convergence runs; it absorbs genuine
* arrivals and reappearances but never advances removal accounting, so a transiently absent id
* cannot be retired by repeated polls.
*/
export type NewModelPolicyMode = "converge" | "discovery";
export interface NewModelPolicyResult {
newIds: string[];
nextBaseline: KnownModelBaseline;
slugsToDisable: string[];
/** New ids to append to a custom selection; only under `admit`. */
idsToAdmit: string[];
arrivals: Array<{ id: string; at: string }>;
overflow: boolean;
}
/**
* Whether a transition actually changes persisted state.
*
* `updatedAt` moves on every successful fetch, so comparing whole baselines would report a
* change every time and rewrite config.json on every catalog convergence — a write amplification
* that also churns the config generation other writers revalidate against. Only the fields that
* carry meaning are compared.
*/
function baselineDiffers(prior: KnownModelBaseline | undefined, next: KnownModelBaseline): boolean {
if (!prior) return true;
const sameList = (a: readonly string[], b: readonly string[]) =>
a.length === b.length && a.every((value, index) => value === b[index]);
if (!sameList(prior.ids, next.ids) || !sameList(prior.removed, next.removed)) return true;
const priorMissing = prior.missing ?? {};
const nextMissing = next.missing ?? {};
const keys = new Set([...Object.keys(priorMissing), ...Object.keys(nextMissing)]);
for (const key of keys) if (priorMissing[key] !== nextMissing[key]) return true;
return false;
}
/** Pure successful-discovery transition. An absent baseline bootstraps without hiding anything. */
export function applyNewModelPolicy(options: {
provider: string;
discoveredIds: Iterable<string>;
baseline?: KnownModelBaseline;
policy: NewModelPolicy;
hasSelectedModels?: boolean;
/** A non-empty selection that is not preset-derived; the only kind `admit` widens. */
customSelection?: boolean;
now: string;
/** See {@link NewModelPolicyMode}; defaults to `converge`. */
mode?: NewModelPolicyMode;
}): NewModelPolicyResult {
const discovered = [...new Set(options.discoveredIds)].sort();
const prior = options.baseline;
if (!prior) {
return {
newIds: [],
nextBaseline: { ids: discovered, removed: [], updatedAt: options.now },
slugsToDisable: [], idsToAdmit: [], arrivals: [],
overflow: discovered.length > MAX_KNOWN_MODELS_PER_PROVIDER,
};
}
const active = new Set(prior.ids);
const removed = new Set(prior.removed);
const seen = new Set(discovered);
const newIds = discovered.filter(id => !active.has(id) && !removed.has(id));
const missing: Record<string, number> = {};
// Read-side discovery must not advance the removal grace: a per-poll increment would retire a
// transiently absent id after three polls. Absence keeps its recorded count (and a reappearance
// clears it) instead of moving toward `removed`.
const discovery = options.mode === "discovery";
for (const id of active) {
if (seen.has(id)) continue;
if (discovery) {
const priorCount = prior.missing?.[id];
if (priorCount !== undefined) missing[id] = priorCount;
continue;
}
const count = (prior.missing?.[id] ?? 0) + 1;
if (count >= MODEL_REMOVAL_GRACE_FETCHES) {
active.delete(id);
removed.add(id);
} else missing[id] = count;
}
for (const id of discovered) active.add(id);
const unionSize = active.size + removed.size;
const overflow = unionSize > MAX_KNOWN_MODELS_PER_PROVIDER;
const arrivals = newIds.map(id => ({ id, at: options.now }));
return {
newIds,
nextBaseline: {
ids: [...active].sort(), removed: [...removed].sort(), updatedAt: options.now,
...(Object.keys(missing).length ? { missing } : {}),
},
// A non-empty preset/custom allowlist already excludes arrivals. This explicit no-op is
// deliberate: preset mode owns which matching flagships arrive on.
slugsToDisable: !overflow && options.policy === "off" && !options.hasSelectedModels
? newIds.map(id => routedSlug(options.provider, id)) : [],
idsToAdmit: !overflow && options.policy === "admit" && options.customSelection === true ? newIds : [],
arrivals,
overflow,
};
}
export function effectiveNewModelPolicy(config: OcxConfig, provider: string): NewModelPolicy {
const local = config.providers[provider]?.newModelPolicy;
if (local === "on" || local === "off" || local === "admit") return local;
return config.modelDiscovery?.newModelPolicy ?? "on";
}
/** Normalize policy identities only; the original rows and saved wire selections stay intact. */
function normalizeEffortFamilies(config: OcxConfig, provider: string, rows: AntigravityEffortFamilyRow[]) {
const aliases = new Map<string, string>();
const inheritedDisables: string[] = [];
const bases = new Set(rows.filter(row => antigravityEffortFamilyIds(row)).map(row => row.id));
for (const row of rows) {
const ids = antigravityEffortFamilyIds(row);
if (!ids) continue;
for (const id of ids) if (!bases.has(id)) aliases.set(id, row.id);
if (antigravityFamilyDisabled(config, row, rows)
&& !config.disabledModels?.some(slug => slugEquals(slug, provider, row.id))) {
inheritedDisables.push(routedSlug(provider, row.id));
}
}
const normalize = (id: string) => aliases.get(id) ?? id;
const normalizeIds = (ids: string[]) => [...new Set(ids.map(normalize))].sort();
const prior = config.modelDiscovery?.knownModels?.[provider];
let baseline = prior;
if (prior && aliases.size) {
const missing: Record<string, number> = {};
for (const [id, count] of Object.entries(prior.missing ?? {})) {
const key = normalize(id);
// A family cannot disappear sooner than its least-missing known tier.
missing[key] = Math.min(missing[key] ?? count, count);
}
baseline = { ...prior, ids: normalizeIds(prior.ids), removed: normalizeIds(prior.removed),
...(Object.keys(missing).length ? { missing } : {}) };
}
return { discoveredIds: normalizeIds(rows.map(row => row.id)), baseline, inheritedDisables };
}
/** Apply authoritative provider rows to a mutable convergence copy; degraded providers are omitted. */
export function reconcileSuccessfulModelDiscoveries(options: {
config: OcxConfig;
models: Iterable<AntigravityEffortFamilyRow>;
authoritativeProviders: Iterable<string>;
now: string;
/** See {@link NewModelPolicyMode}; defaults to `converge`. */
mode?: NewModelPolicyMode;
}): boolean {
const byProvider = new Map<string, AntigravityEffortFamilyRow[]>();
for (const model of options.models) {
if (model.custom || model.catalogKind === "custom-model-v1") continue;
const rows = byProvider.get(model.provider) ?? [];
rows.push(model); byProvider.set(model.provider, rows);
}
let changed = false;
for (const provider of options.authoritativeProviders) {
const configured = options.config.providers[provider];
if (!configured || configured.liveModels === false) continue;
const { discoveredIds, baseline, inheritedDisables } = normalizeEffortFamilies(
options.config, provider, byProvider.get(provider) ?? [],
);
const discovery = options.config.modelDiscovery ??= {};
const known = discovery.knownModels ??= {};
const result = applyNewModelPolicy({
provider, discoveredIds, baseline,
policy: effectiveNewModelPolicy(options.config, provider),
hasSelectedModels: (configured.selectedModels?.length ?? 0) > 0,
customSelection: (configured.selectedModels?.length ?? 0) > 0 && configured.modelPreset?.mode !== "preset",
now: options.now,
mode: options.mode,
});
if (result.overflow) continue;
const priorBaseline = known[provider];
const baselineChanged = baselineDiffers(priorBaseline, result.nextBaseline);
known[provider] = result.nextBaseline;
// Keep the previous timestamp when nothing else moved, so a steady-state roster does not
// make the baseline look dirty on the next comparison either.
if (!baselineChanged && priorBaseline) known[provider] = priorBaseline;
const slugsToDisable = [...result.slugsToDisable, ...inheritedDisables];
if (slugsToDisable.length) {
const disabled = options.config.disabledModels ??= [];
for (const slug of slugsToDisable) {
if (disabled.includes(slug)) continue;
disabled.push(slug);
changed = true;
}
}
if (result.idsToAdmit.length) {
const selected = configured.selectedModels ??= [];
for (const id of result.idsToAdmit) if (!selected.includes(id)) selected.push(id);
changed = true;
}
if (result.arrivals.length) {
const recent = discovery.recentArrivals ??= {};
// Recorded so the status can tell a policy disable from the user's own (#8236); rows from
// before these fields keep reading as auto-disabled.
const policyDisabled = new Set(result.slugsToDisable);
const admitted = new Set(result.idsToAdmit);
const rows = result.arrivals.map(row => ({
...row,
...(admitted.has(row.id) ? { admitted: true } : {}),
disabledByPolicy: policyDisabled.has(routedSlug(provider, row.id)),
}));
recent[provider] = [...(recent[provider] ?? []), ...rows]
.slice(-MAX_RECENT_ARRIVALS_PER_PROVIDER);
changed = true;
}
if (baselineChanged) changed = true;
}
return changed;
}