@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
text/typescript
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];
}