UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

196 lines (180 loc) • 8.53 kB
import { PROVIDER_REGISTRY } from "./registry"; export function effectiveProviderAlias( providerName: string, provider?: Pick<OcxProviderConfig, "alias">, config?: Pick<OcxConfig, "providers">, ): string | undefined { if (provider && provider.alias !== undefined) { const trimmed = provider.alias.trim(); return trimmed.length > 0 ? trimmed : undefined; } const regAlias = PROVIDER_REGISTRY.find(e => e.id === providerName)?.alias; if (!regAlias) return undefined; if (config?.providers) { const lower = regAlias.toLowerCase(); const claimedByOther = Object.entries(config.providers).some(([name, p]) => name !== providerName && ( name.toLowerCase() === lower || (typeof p.alias === "string" && p.alias.trim().toLowerCase() === lower) ) ); if (claimedByOther) return undefined; } return regAlias; } export function effectiveProviderAliasDecision( providerName: string, provider?: Pick<OcxProviderConfig, "alias">, config?: Pick<OcxConfig, "providers">, ): string | null | undefined { const active = effectiveProviderAlias(providerName, provider, config); if (active !== undefined) return active; const hasRegistryAlias = Boolean(PROVIDER_REGISTRY.find(e => e.id === providerName)?.alias); const hasConfiguredAlias = provider?.alias !== undefined; if (hasRegistryAlias || hasConfiguredAlias) { return null; } return undefined; } import type { OcxConfig, OcxProviderConfig } from "../types"; import { expandAliasTemplate, MODEL_ALIAS_PATTERN, type AliasTemplateSkip } from "./alias-template"; export { MODEL_ALIAS_PATTERN }; /** Ordered, most-specific-first built-in aliases. Updated with the provider registry. */ export const DEFAULT_MODEL_ALIASES: ReadonlyArray<{ match: RegExp; alias: string }> = [ { match: /^claude-opus-5/, alias: "opus" }, { match: /^claude-sonnet-5/, alias: "sonnet" }, { match: /^claude-haiku/, alias: "haiku" }, { match: /^gemini-3(?:\.\d+)?-pro/, alias: "g3p" }, { match: /^gemini-3(?:\.\d+)?-flash/, alias: "g3f" }, // Ordered before the V4 rule on purpose: `builtinRule` takes the first match, and // `/^deepseek-v4/` also matches `deepseek-v4.1-flash`. { match: /^deepseek-v4\.1/, alias: "ds41" }, { match: /^deepseek-v4/, alias: "ds4" }, { match: /^deepseek-flash/, alias: "dsf" }, { match: /^grok-4/, alias: "grok" }, ]; export interface EffectiveModelAlias { alias: string; source: "user" | "builtin" | "template" } function builtinRule(id: string): { match: RegExp; alias: string } | undefined { const tail = id.slice(id.lastIndexOf("/") + 1); return DEFAULT_MODEL_ALIASES.find(rule => rule.match.test(id) || rule.match.test(tail)); } export function defaultAliasesEnabled(config: Pick<OcxConfig, "defaultModelAliases">, provider: Pick<OcxProviderConfig, "defaultAliases">): boolean { return provider.defaultAliases ?? config.defaultModelAliases ?? false; } /** The parts of the config an alias view reads; `providers` and `combos` only matter to templates. */ export type AliasViewConfig = Pick<OcxConfig, "defaultModelAliases"> & Partial<Pick<OcxConfig, "providers" | "combos">>; type AliasViewProvider = Pick<OcxProviderConfig, "defaultAliases" | "modelAliases" | "aliasTemplate" | "alias">; /** * Manual aliases, then built-in ones (when enabled), then the provider's opt-in template (#7705). * The template applies only when `providerName` is given, so a caller that does not pass it sees * exactly the view it always did. */ export function effectiveModelAliases( config: AliasViewConfig, provider: AliasViewProvider, knownIds: Iterable<string>, providerName?: string, ): Map<string, EffectiveModelAlias> { const known = [...knownIds]; const result = new Map<string, EffectiveModelAlias>(); for (const [id, alias] of Object.entries(provider.modelAliases ?? {})) { if (typeof alias === "string" && MODEL_ALIAS_PATTERN.test(alias)) result.set(id, { alias, source: "user" }); } if (defaultAliasesEnabled(config, provider)) { const claims = new Map<string, string[]>(); for (const id of known) { if (result.has(id)) continue; const rule = builtinRule(id); if (!rule) continue; const key = rule.alias.toLowerCase(); const ids = claims.get(key); if (ids) ids.push(id); else claims.set(key, [id]); } for (const [alias, ids] of claims) { if (ids.length !== 1) continue; const id = ids[0]!; // Catalog drift must skip, never shadow, a native id or explicit user alias. if (known.some(candidate => candidate.toLowerCase() === alias)) continue; if ([...result.values()].some(value => value.alias.toLowerCase() === alias)) continue; result.set(id, { alias: builtinRule(id)!.alias, source: "builtin" }); } } if (providerName !== undefined && provider.aliasTemplate) { for (const [id, alias] of templateAliasPlan(config, provider, providerName, known, result).accepted) { result.set(id, { alias, source: "template" }); } } return result; } export interface TemplateAliasPlan { accepted: Map<string, string>; skipped: Array<{ id: string; candidate?: string; reason: AliasTemplateSkip | "collision" | "reserved" }>; } /** * Template candidates for ids that have no manual or built-in alias. Every name already claimed is * reserved first: this provider's native ids and aliases, every built-in alias name, every * provider name and provider alias, other providers' manual aliases, and combo ids and aliases. * Two candidates that collide are both skipped, so the result does not depend on roster order; * nothing is ever renamed to make it fit. */ export function templateAliasPlan( config: AliasViewConfig, provider: Pick<AliasViewProvider, "aliasTemplate" | "alias">, providerName: string, knownIds: readonly string[], existing: ReadonlyMap<string, EffectiveModelAlias>, ): TemplateAliasPlan { const plan: TemplateAliasPlan = { accepted: new Map(), skipped: [] }; const template = provider.aliasTemplate; if (!template) return plan; const providerAlias = config.providers ? effectiveProviderAlias(providerName, provider, config as Pick<OcxConfig, "providers">) : (provider.alias?.trim() || undefined); const reserved = new Set<string>(); const reserve = (value: unknown) => { if (typeof value === "string" && value.trim()) reserved.add(value.trim().toLowerCase()); }; for (const id of knownIds) reserve(id); for (const value of existing.values()) reserve(value.alias); for (const rule of DEFAULT_MODEL_ALIASES) reserve(rule.alias); for (const [name, other] of Object.entries(config.providers ?? {})) { reserve(name); reserve(other.alias); // A registry alias (`agy` for google-antigravity) names the provider even when it sets none. if (config.providers) reserve(effectiveProviderAlias(name, other, config as Pick<OcxConfig, "providers">)); if (name !== providerName) for (const alias of Object.values(other.modelAliases ?? {})) reserve(alias); } for (const [id, combo] of Object.entries(config.combos ?? {})) { reserve(id); reserve((combo as { alias?: unknown }).alias); } const candidates = new Map<string, Array<{ id: string; alias: string }>>(); for (const id of [...new Set(knownIds)].sort()) { if (existing.has(id)) continue; const expanded = expandAliasTemplate(template, providerAlias, id); if ("skip" in expanded) { plan.skipped.push({ id, reason: expanded.skip }); continue; } const key = expanded.alias.toLowerCase(); const rows = candidates.get(key); const row = { id, alias: expanded.alias }; if (rows) rows.push(row); else candidates.set(key, [row]); } for (const [key, rows] of candidates) { if (rows.length > 1) { for (const row of rows) plan.skipped.push({ id: row.id, candidate: row.alias, reason: "collision" }); } else if (reserved.has(key)) { plan.skipped.push({ id: rows[0]!.id, candidate: rows[0]!.alias, reason: "reserved" }); } else { plan.accepted.set(rows[0]!.id, rows[0]!.alias); } } plan.skipped.sort((a, b) => a.id.localeCompare(b.id)); return plan; } export function resolveModelAlias( config: AliasViewConfig, provider: OcxProviderConfig, knownIds: Iterable<string>, requested: string, providerName?: string, ): string | undefined { const needle = requested.toLowerCase(); return [...effectiveModelAliases(config, provider, knownIds, providerName)] .find(([, value]) => value.alias.toLowerCase() === needle)?.[0]; }