@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
125 lines (115 loc) • 5.46 kB
text/typescript
import { PROVIDER_REGISTRY } from "./registry";
import { OPENAI_API_PROVIDER_ID } from "./openai-tiers";
import type { OcxParsedRequest } from "../types";
import type { RouteResult } from "../router";
import type { RequestLogContext } from "../server/request-log";
import type { InboundWire } from "./registry/types";
import { providerMatchesRegistryTransportWithStaticGuards } from "./static-model-discovery";
import { resolveModelPolicy } from "./resolved-model-policy";
export interface OpenAiVirtualModelResolution {
selectedModelId: string;
wireModelId: string;
reasoningMode: "pro";
}
export class InvalidOpenAiVirtualModelRegistryError extends Error {
constructor(selectedModelId: string) {
super(`Invalid OpenAI virtual model registry definition: ${selectedModelId}`);
this.name = "InvalidOpenAiVirtualModelRegistryError";
}
}
export function validateOpenAiVirtualModelDefinition(
selectedModelId: string,
definition: unknown,
): OpenAiVirtualModelResolution {
if (!definition || typeof definition !== "object" || Array.isArray(definition)) {
throw new InvalidOpenAiVirtualModelRegistryError(selectedModelId);
}
const raw = definition as { wireModelId?: unknown; reasoningMode?: unknown };
if (
typeof raw.wireModelId !== "string"
|| raw.wireModelId.trim() !== raw.wireModelId
|| raw.wireModelId.length === 0
|| raw.wireModelId.includes("/")
|| raw.wireModelId === selectedModelId
|| raw.reasoningMode !== "pro"
) {
throw new InvalidOpenAiVirtualModelRegistryError(selectedModelId);
}
return { selectedModelId, wireModelId: raw.wireModelId, reasoningMode: "pro" };
}
export function resolveOpenAiVirtualModel(
providerName: string,
selectedModelId: string,
): OpenAiVirtualModelResolution | undefined {
if (providerName !== OPENAI_API_PROVIDER_ID) return undefined;
const entry = PROVIDER_REGISTRY.find(row => row.id === OPENAI_API_PROVIDER_ID);
if (!entry?.virtualModels || !Object.hasOwn(entry.virtualModels, selectedModelId)) return undefined;
const definition = entry.virtualModels[selectedModelId];
return validateOpenAiVirtualModelDefinition(selectedModelId, definition);
}
export function captureOpenAiVirtualWirePolicy(
route: RouteResult,
resolution: OpenAiVirtualModelResolution,
inboundWire: InboundWire = "responses",
): void {
// applyOpenAiVirtualModel is also a public mutation helper with older focused callers that
// construct only providerName/modelId/provider. Production RouteResult builders always capture
// staticPolicy; a legacy partial shape has no authority to recapture and keeps the old rewrite.
if (!route.staticPolicy) return;
const entry = PROVIDER_REGISTRY.find(candidate => candidate.id === route.providerName);
route.staticPolicy = resolveModelPolicy({
providerName: route.providerName,
modelId: resolution.wireModelId,
provider: route.provider,
registryEntry: entry,
transportMatchedRegistry: !!entry
&& providerMatchesRegistryTransportWithStaticGuards(route.providerName, route.provider),
inboundWire,
modelCapabilities: route.provider.modelCapabilities?.[resolution.wireModelId],
...(route.provider.authMode ? { effectiveAuth: { authMode: route.provider.authMode } } : {}),
...(route.staticPolicy?.effectiveAlias !== undefined
? { effectiveAlias: route.staticPolicy.effectiveAlias }
: {}),
});
}
export function applyOpenAiVirtualModel(
parsed: OcxParsedRequest,
route: RouteResult,
logCtx: RequestLogContext,
inboundWire: InboundWire = "responses",
): OpenAiVirtualModelResolution | undefined {
// Routing has already removed the provider namespace and resolved model aliases. Never use
// logCtx.model for identity: it is reporting state and can still contain a namespaced selector.
const resolution = resolveOpenAiVirtualModel(route.providerName, route.modelId)
?? (() => {
// Preserve the public helper's idempotent second-call contract from its own mutation
// provenance, without promoting reporting state back into routing authority.
const selected = parsed._openAiVirtualSelectedModelId;
if (typeof selected !== "string") return undefined;
const remembered = resolveOpenAiVirtualModel(route.providerName, selected);
return remembered?.wireModelId === route.modelId ? remembered : undefined;
})();
if (!resolution) return undefined;
logCtx.model = resolution.selectedModelId;
logCtx.resolvedModel = resolution.wireModelId;
logCtx.wireModel = resolution.wireModelId;
route.modelId = resolution.wireModelId;
captureOpenAiVirtualWirePolicy(route, resolution, inboundWire);
parsed.modelId = resolution.wireModelId;
parsed._openAiVirtualSelectedModelId = resolution.selectedModelId;
if (parsed._rawBody && typeof parsed._rawBody === "object" && !Array.isArray(parsed._rawBody)) {
const raw = parsed._rawBody as Record<string, unknown>;
raw.model = resolution.wireModelId;
const existing = raw.reasoning;
raw.reasoning = existing && typeof existing === "object" && !Array.isArray(existing)
? { ...(existing as Record<string, unknown>), mode: resolution.reasoningMode }
: { mode: resolution.reasoningMode };
}
return resolution;
}
export function resolveOpenAiCompactModel(
providerName: string,
selectedModelId: string,
): OpenAiVirtualModelResolution | undefined {
return resolveOpenAiVirtualModel(providerName, selectedModelId);
}