@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
177 lines (157 loc) • 7.04 kB
text/typescript
import { routedSlug, slugEquivalenceKey } from "../providers/slug-codec";
import type { OcxConfig } from "../types";
const MIGRATION_FIELD = "customModelCatalogMigration";
const MIGRATION_VERSION = 1;
type ConfigRecord = Record<string, unknown>;
interface SupportedMigrationState {
readonly record: ConfigRecord;
readonly legacyOwnedSlugs: readonly string[];
}
type ParsedMigrationState =
| { readonly kind: "absent" }
| { readonly kind: "supported"; readonly state: SupportedMigrationState }
| { readonly kind: "unsupported"; readonly value: unknown };
type CustomModelSlugSet =
| { readonly kind: "valid"; readonly byKey: ReadonlyMap<string, string> }
| { readonly kind: "invalid" };
function configRecord(value: unknown): ConfigRecord | null {
return value !== null && typeof value === "object" && !Array.isArray(value)
? value as ConfigRecord
: null;
}
function canonicalRoutedSlug(value: unknown): string | null {
if (typeof value !== "string") return null;
const slug = value.trim();
const slash = slug.indexOf("/");
if (slash <= 0 || slash === slug.length - 1) return null;
const provider = slug.slice(0, slash).trim();
const modelId = slug.slice(slash + 1).trim();
if (!provider || !modelId || provider.includes("/")) return null;
return routedSlug(provider, modelId);
}
function canonicalSlugMap(values: readonly unknown[]): ReadonlyMap<string, string> | null {
const byKey = new Map<string, string>();
for (const value of values) {
const slug = canonicalRoutedSlug(value);
if (slug === null) return null;
byKey.set(slugEquivalenceKey(slug), slug);
}
return byKey;
}
function parseMigrationState(config: unknown): ParsedMigrationState {
const record = configRecord(config);
if (!record || !Object.hasOwn(record, MIGRATION_FIELD)) return { kind: "absent" };
const value = record[MIGRATION_FIELD];
const state = configRecord(value);
if (!state || state.version !== MIGRATION_VERSION || !Array.isArray(state.legacyOwnedSlugs)) {
return { kind: "unsupported", value };
}
const slugs = canonicalSlugMap(state.legacyOwnedSlugs);
if (slugs === null) return { kind: "unsupported", value };
return {
kind: "supported",
state: {
record: state,
legacyOwnedSlugs: [...slugs.values()].sort(),
},
};
}
function customModelSlugs(config: unknown): CustomModelSlugSet {
const record = configRecord(config);
if (!record || record.customModels === undefined) {
return { kind: "valid", byKey: new Map() };
}
if (!Array.isArray(record.customModels)) return { kind: "invalid" };
const byKey = new Map<string, string>();
for (const value of record.customModels) {
const custom = configRecord(value);
if (!custom || typeof custom.provider !== "string" || typeof custom.modelId !== "string") {
return { kind: "invalid" };
}
const provider = custom.provider.trim();
const modelId = custom.modelId.trim();
if (!provider || !modelId || provider.includes("/")) return { kind: "invalid" };
const slug = routedSlug(provider, modelId);
byKey.set(slugEquivalenceKey(slug), slug);
}
return { kind: "valid", byKey };
}
function copyMigrationField(target: OcxConfig, source: OcxConfig): void {
const targetRecord = target as unknown as ConfigRecord;
const sourceRecord = source as unknown as ConfigRecord;
if (Object.hasOwn(sourceRecord, MIGRATION_FIELD)) {
targetRecord[MIGRATION_FIELD] = structuredClone(sourceRecord[MIGRATION_FIELD]);
} else {
delete targetRecord[MIGRATION_FIELD];
}
}
/**
* Project one-time legacy custom-model ownership onto a whole-config write.
*
* The persisted pre-write config is the only authority for pre-marker ownership.
* Unknown future/malformed state is carried forward byte-for-value and grants no
* deletion authority; an older binary must never reinterpret or erase it.
*/
export function projectCustomModelCatalogMigration(
persistedConfig: unknown,
candidateConfig: OcxConfig,
): OcxConfig {
const persistedState = parseMigrationState(persistedConfig);
const candidateState = parseMigrationState(candidateConfig);
const projected = { ...candidateConfig } as OcxConfig;
const projectedRecord = projected as unknown as ConfigRecord;
if (persistedState.kind === "unsupported") {
projectedRecord[MIGRATION_FIELD] = structuredClone(persistedState.value);
return projected;
}
if (persistedState.kind === "absent" && candidateState.kind === "unsupported") {
projectedRecord[MIGRATION_FIELD] = structuredClone(candidateState.value);
return projected;
}
const legacyByKey = new Map<string, string>();
const addLegacy = (slugs: readonly string[]): void => {
for (const slug of slugs) legacyByKey.set(slugEquivalenceKey(slug), slug);
};
if (persistedState.kind === "supported") addLegacy(persistedState.state.legacyOwnedSlugs);
if (candidateState.kind === "supported") addLegacy(candidateState.state.legacyOwnedSlugs);
const persistedCustom = customModelSlugs(persistedConfig);
const candidateCustom = customModelSlugs(candidateConfig);
// Only an absent persisted version means these rows can predate the ownership marker.
// Never add candidate-only or post-version models: those are born with custom-model-v1.
if (persistedState.kind === "absent" && persistedCustom.kind === "valid") {
for (const [key, slug] of persistedCustom.byKey) legacyByKey.set(key, slug);
}
// Establish an empty v1 on the first custom-model add too: the cutover, not list
// non-emptiness, proves that candidate-only models can never be inferred as legacy.
// Unrelated saves for users who never configured custom models remain untouched.
const shouldVersion = persistedState.kind === "supported"
|| candidateState.kind === "supported"
|| (persistedState.kind === "absent"
&& ((persistedCustom.kind === "valid" && persistedCustom.byKey.size > 0)
|| (candidateCustom.kind === "valid" && candidateCustom.byKey.size > 0)));
if (!shouldVersion) {
delete projectedRecord[MIGRATION_FIELD];
return projected;
}
const priorRecord = persistedState.kind === "supported" ? persistedState.state.record : {};
const nextRecord = candidateState.kind === "supported" ? candidateState.state.record : {};
projectedRecord[MIGRATION_FIELD] = {
...structuredClone(priorRecord),
...structuredClone(nextRecord),
version: MIGRATION_VERSION,
legacyOwnedSlugs: [...legacyByKey.values()].sort(),
};
return projected;
}
/** Copy only the internal migration state after the projected write succeeds. */
export function adoptCustomModelCatalogMigration(
target: OcxConfig,
projected: OcxConfig,
): void {
copyMigrationField(target, projected);
}
/** Canonical slugs that may classify old, unmarked OpenCodex custom rows. */
export function legacyCustomModelCatalogSlugs(config: OcxConfig): ReadonlySet<string> {
const state = parseMigrationState(config);
return new Set(state.kind === "supported" ? state.state.legacyOwnedSlugs : []);
}