@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
138 lines (132 loc) • 7.69 kB
text/typescript
// Deliberate pure port of gui/src/model-picker-order.ts; test-only conformance guards drift.
export type ModelPickerOrderMode = "default" | "alphabetical" | "provider" | "most-used" | "custom";
export type SavedModelPickerOrderMode = Exclude<ModelPickerOrderMode, "default" | "custom">;
export interface ModelPickerUsage {
provider: string;
model: string;
resolvedModel?: string;
requests: number;
}
export interface PickerModelIdentity { provider: string; id: string; namespaced: string }
export interface PickerOrderSaved {
pickerOrder: string[];
pickerOrderMode: SavedModelPickerOrderMode | null;
}
export interface PickerOrderSettings extends PickerOrderSaved { pickerAvailable: string[]; chosen?: string[] }
function stringList(value: unknown): value is string[] {
return Array.isArray(value) && value.every(id => typeof id === "string" && id.trim().length > 0);
}
function savedMode(value: unknown): value is SavedModelPickerOrderMode | null {
return value === null || value === "alphabetical" || value === "provider" || value === "most-used";
}
export function isPickerOrderSaved(value: unknown): value is PickerOrderSaved {
if (value === null || typeof value !== "object") return false;
const row = value as Record<string, unknown>;
return stringList(row.pickerOrder) && savedMode(row.pickerOrderMode);
}
export function isPickerOrderSettings(value: unknown): value is PickerOrderSettings {
if (!isPickerOrderSaved(value)) return false;
const row = value as PickerOrderSettings;
// Roster writes accept every string, including blanks; picker fields remain nonempty-string lists.
return stringList(row.pickerAvailable) && (!("chosen" in row)
|| (Array.isArray(row.chosen) && row.chosen.every(id => typeof id === "string")));
}
export function isModelPickerUsage(value: unknown): value is ModelPickerUsage[] {
return Array.isArray(value) && value.every(row => row !== null && typeof row === "object"
&& typeof row.provider === "string" && typeof row.model === "string"
&& (row.resolvedModel === undefined || typeof row.resolvedModel === "string")
&& typeof row.requests === "number" && Number.isFinite(row.requests) && row.requests >= 0);
}
function parts(slug: string): [string, string] {
const slash = slug.indexOf("/");
return slash < 0 ? ["", slug] : [slug.slice(0, slash), slug.slice(slash + 1)];
}
// Fixed locale makes snapshots independent of the user's display language/OS locale.
const compare = (a: string, b: string) => a.localeCompare(b, "en");
function byProvider(a: string, b: string): number {
const [ap, am] = parts(a), [bp, bm] = parts(b);
return compare(ap, bp) || compare(am, bm);
}
export function modelPickerOrder(
mode: Exclude<ModelPickerOrderMode, "custom">,
models: readonly string[],
usage: readonly ModelPickerUsage[] = [],
identities: readonly PickerModelIdentity[] = [],
): string[] | null {
if (mode === "default") return null;
const unique = [...new Set(models)];
if (mode === "alphabetical") return unique.sort((a, b) => compare(parts(a)[1], parts(b)[1]) || byProvider(a, b));
if (mode === "provider") return unique.sort(byProvider);
const candidates = new Set(unique);
const raw = new Map<string, Set<string>>();
const owners = new Map<string, Set<string>>();
for (const row of identities) {
if (!candidates.has(row.namespaced)) continue;
const key = JSON.stringify([row.provider, row.id]);
const values = raw.get(key) ?? new Set<string>();
values.add(row.namespaced);
raw.set(key, values);
const sources = owners.get(row.namespaced) ?? new Set<string>();
sources.add(key);
owners.set(row.namespaced, sources);
}
const unambiguous = (slug: string): string | null => (owners.get(slug)?.size ?? 0) > 1 ? null : slug;
const resolve = (provider: string, id: string): string | null | undefined => {
const exact = raw.get(JSON.stringify([provider, id]));
if (exact) return exact.size === 1 ? unambiguous([...exact][0]!) : null;
// A raw upstream slash is not a namespace. Use the observed identity table above;
// only fall back to an exact same-provider catalog id or an ordinary bare model id.
if (id.startsWith(`${provider}/`) && candidates.has(id)) return unambiguous(id);
const slug = `${provider}/${id}`;
return !id.includes("/") && candidates.has(slug) ? unambiguous(slug) : undefined;
};
const counts = new Map<string, number>();
for (const row of usage) {
// Summary buckets are keyed by requested model. resolvedModel is only a
// representative observation, not proof that every request used that target.
const target = resolve(row.provider, row.model);
if (target) counts.set(target, (counts.get(target) ?? 0) + row.requests);
}
return unique.sort((a, b) => (counts.get(b) ?? 0) - (counts.get(a) ?? 0) || byProvider(a, b));
}
/** Resolve exact canonical ids before legacy provider/raw spellings; never guess a bare native id. */
export function normalizePickerIds(ids: readonly string[], available: readonly string[], identities: readonly PickerModelIdentity[]): string[] {
const candidates = new Set(available.filter(id => id.includes("/")));
const resolve = (id: string): string | undefined => {
if (candidates.has(id)) return id;
const matches = new Set(identities.filter(row => candidates.has(row.namespaced)
&& id === `${row.provider}/${row.id}`).map(row => row.namespaced));
return matches.size === 1 ? [...matches][0] : undefined;
};
return [...new Set(ids.map(id => resolve(id.trim())).filter((id): id is string => id !== undefined))];
}
/** Every candidate needs one observed provider/raw identity, with no encoded/raw collisions. */
export function pickerIdentityCoverage(available: readonly string[], identities: readonly PickerModelIdentity[]): boolean {
const candidates = new Set(available.filter(id => id.includes("/")));
const rawBySlug = new Map<string, Set<string>>(), slugsByRaw = new Map<string, Set<string>>();
for (const row of identities) {
if (!candidates.has(row.namespaced)) continue;
const raw = `${row.provider}/${row.id}`;
const raws = rawBySlug.get(row.namespaced) ?? new Set<string>();
const slugs = slugsByRaw.get(raw) ?? new Set<string>();
raws.add(raw); slugs.add(row.namespaced);
rawBySlug.set(row.namespaced, raws); slugsByRaw.set(raw, slugs);
}
return [...candidates].every(slug => {
const raws = rawBySlug.get(slug);
return raws?.size === 1 && slugsByRaw.get([...raws][0]!)?.size === 1;
});
}
export function customPickerRows(settings: PickerOrderSettings, identities: readonly PickerModelIdentity[]): { order: string[]; fixed: string[] } | null {
// Unknown featured state and complete/native orders cannot safely become routed-only drafts.
if (settings.chosen === undefined || settings.pickerOrder.some(id => !id.includes("/"))) return null;
const available = [...new Set(settings.pickerAvailable.filter(id => id.includes("/")))];
if (!pickerIdentityCoverage(available, identities)) return null;
// Roster strings stay verbatim. Map uses the LAST occurrence; each row prefers its exact canonical rank.
const chosenRank = new Map(settings.chosen.map((id, index) => [id, index]));
const rawBySlug = new Map(identities.map(row => [row.namespaced, `${row.provider}/${row.id}`]));
const rankOf = (slug: string) => chosenRank.get(slug) ?? chosenRank.get(rawBySlug.get(slug)!);
const fixed = available.filter(slug => rankOf(slug) !== undefined).sort((a, b) => rankOf(a)! - rankOf(b)!);
const saved = normalizePickerIds(settings.pickerOrder, available, identities);
return { fixed, order: [...new Set([...fixed, ...saved, ...available])] };
}