UNPKG

@bitkyc08/opencodex

Version:

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

203 lines (193 loc) • 10.2 kB
import type { OcxConfig } from "../../types"; import { getCombo, resolveComboId } from "../../combos"; import { isBareOpenAiFamilyModel, previewRouteModel, routeConcreteModel } from "../../router"; import { resolveChosenTarget } from "./shadow-target-availability"; import { getRoutingProfile, resolvePolicyProfileId } from "../../routing/profile"; import { NATIVE_RESERVE_MODEL } from "../../codex/catalog/native-models"; import { getMainAccountHardLockStatus, resolveMainAccountHardLockFallback, } from "../../codex/main-account-hard-lock"; import { codexQuotaScopeForModel } from "../../codex/routing/health-store"; import { getEligiblePoolAccounts } from "../../codex/routing/selection"; import { OPENAI_CODEX_PROVIDER_ID, isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers"; import { providerCodexAccountMode } from "../../providers/registry"; import { FallbackRefusedError, fallbackDeviceIds, fallbackHopKind, guardFallbackHop, resolveFallbackPolicy, type FallbackAdmission, type FallbackHop, type FallbackTarget, } from "../../routing/fallback-policy"; /** Resolves to a synchronous ownership proof, or null when the caller does not own the locked main. */ export type MainHardLockCallerCheck = (sourceModel: string) => Promise<(() => boolean) | null>; function isConfiguredComboSelector(config: OcxConfig, modelId: string): boolean { const comboId = resolveComboId(config, modelId); return Boolean(comboId && Object.hasOwn(config.combos ?? {}, comboId)); } function targetsBlockedCanonicalOpenAi(config: OcxConfig, modelId: string): boolean { if (isBareOpenAiFamilyModel(modelId) && !isConfiguredComboSelector(config, modelId)) return true; const slash = modelId.indexOf("/"); if (slash <= 0) return false; const providerName = modelId.slice(0, slash); const rest = modelId.slice(slash + 1); if (providerName !== OPENAI_CODEX_PROVIDER_ID || !isBareOpenAiFamilyModel(rest)) return false; const provider = config.providers?.[OPENAI_CODEX_PROVIDER_ID]; return !provider || isCanonicalOpenAiForwardProvider({ ...provider, ...(provider.authMode === undefined ? { authMode: "forward" as const } : {}), }); } /** * What one rewritten request carries so the log can show the model the client asked for * while the pipeline routes the fallback. The rewrite happens before combo dispatch reads * `model`, so the rest of the pipeline sees an ordinary request for the target selector. */ export interface MainHardLockFallbackOverride { sourceModel: string; targetModel: string; } function rawModelOf(body: unknown): { raw: Record<string, unknown>; model: string } | undefined { if (!body || typeof body !== "object" || Array.isArray(body)) return undefined; const raw = body as Record<string, unknown>; return typeof raw.model === "string" && raw.model.trim().length > 0 ? { raw, model: raw.model } : undefined; } /** * Extended main-account hard-lock settings: when the lock blocks and no Codex account can * serve the request, rewrite it to the configured fallback model instead of letting the * dispatch refuse. * * Every guard bounds the rewrite to exactly the traffic the lock would otherwise fail, so * the setting can never widen what the lock protects: * * - The lock must be enabled AND reading `blocked` right now — `ready`, `unknown` and the * explicit opt-out all admit, and the release is this same observation, so the reroute * ends on its own the moment the blocking windows drop below their thresholds. * - `getEligiblePoolAccounts` is the selection choke point the dispatch itself consults, * so "the pool can serve it" is one shared answer, not a second opinion: a usable pool * account (or any eligible account) keeps the request on Codex, and a pool drained to * empty is what makes the fallback the request's only way through. The main account is * already excluded there while blocked. * - Only bare Codex-native selectors qualify. Provider-qualified rows, combos, account * namespaces and policy routes name their own destination on purpose; rewriting those * would override an explicit choice, so they keep the lock's refusal. * - A Codex-native fallback target is refused outright: rerouting gpt-* to gpt-* would * re-enter the same refusal, and the honest behavior is the refusal, not a loop. * - Luna Reserve keeps its own admission policy (`assertReserveAdmission`); its helper * traffic is not operator chat and must not silently change models. */ export async function applyMainHardLockFallbackOverride( body: unknown, config: OcxConfig, now?: number, callerCheck?: MainHardLockCallerCheck, admission?: FallbackAdmission, ): Promise<MainHardLockFallbackOverride | null> { const parsed = rawModelOf(body); if (!parsed) return null; const fallback = resolveMainAccountHardLockFallback(config); if (!fallback) return null; if (targetsBlockedCanonicalOpenAi(config, fallback.model)) return null; if (!isBareOpenAiFamilyModel(parsed.model) || parsed.model === NATIVE_RESERVE_MODEL || isConfiguredComboSelector(config, parsed.model)) return null; const accountMode = providerCodexAccountMode( OPENAI_CODEX_PROVIDER_ID, config.providers?.[OPENAI_CODEX_PROVIDER_ID], ); if (accountMode === "direct") { // Direct may forward a different caller's healthy credential. Only stored-main substitution // or an observed-main match owes this lock. Recheck usage after the startup binding wait. const stillOwnsLockedMain = callerCheck ? await callerCheck(parsed.model) : null; // Everything from here to the rewrite is synchronous, so this proof cannot go stale before it. if (!stillOwnsLockedMain?.()) return null; if (getMainAccountHardLockStatus(config, now ?? Date.now()).state !== "blocked") return null; } else { if (getMainAccountHardLockStatus(config, now ?? Date.now()).state !== "blocked") return null; if (getEligiblePoolAccounts(config, undefined, now ?? Date.now(), codexQuotaScopeForModel(parsed.model)).length > 0) return null; } // Combos and policies keep their own dispatch admission and declared failover/evidence. // Other chosen targets must resolve now; a removed qualifier cannot become a default send. const policyId = resolvePolicyProfileId(config, fallback.model); const profile = policyId ? getRoutingProfile(config, policyId) : undefined; const comboId = resolveComboId(config, fallback.model); const combo = comboId ? getCombo(config, comboId) : undefined; if (profile || combo) { // Match the actual first guard's selector order. This neither picks nor filters a target. const denied = allDeclaredTargetsDenied(config, profile?.candidates ?? combo!.targets, { site: "hard-lock", route: profile ? parsed.model : `combo/${comboId}`, aliases: profile ? [`policy/${policyId}`] : [parsed.model], from: { provider: OPENAI_CODEX_PROVIDER_ID, model: parsed.model }, trigger: "hard_lock", admission, ...(now !== undefined ? { now } : {}), }); if (denied) { // One refusal witness for an all-denied declaration, never a speculative taken event. const hop = guardFallbackHop(config, denied); if (!hop.ok) throw new FallbackRefusedError(hop.response); } // Mixed or unresolved declarations grant nothing: actual first/retry guards still decide. // A selector rewrite is not a selected hop and reserves no send or taken event here. } else { try { const target = resolveChosenTarget(fallback.model, model => previewRouteModel(config, model)); if ("unavailable" in target) return null; } catch { // An unavailable target keeps the source lock's refusal without touching the body. return null; } // Concrete targets keep their existing proactive admission at body rewrite. const hop = guardFallbackHop(config, { site: "hard-lock", route: parsed.model, from: { provider: OPENAI_CODEX_PROVIDER_ID, model: parsed.model }, to: hardLockTargetOf(config, fallback.model), trigger: "hard_lock", admission, ...(now !== undefined ? { now } : {}), }); if (!hop.ok) throw new FallbackRefusedError(hop.response); hop.commit(); } parsed.raw.model = fallback.model; if (fallback.reasoningEffort !== undefined) { const reasoning = parsed.raw.reasoning; parsed.raw.reasoning = { ...(reasoning && typeof reasoning === "object" && !Array.isArray(reasoning) ? reasoning as Record<string, unknown> : {}), effort: fallback.reasoningEffort, }; } return { sourceModel: parsed.model, targetModel: fallback.model }; } /** * Pure policy feasibility over declared concrete destinations. Unknown resolution is not denial. * No picker, history, cooldown, event or send-budget operation runs for individual candidates. * The first denied hop is only a refusal witness once every declaration is known denied. */ function allDeclaredTargetsDenied( config: OcxConfig, targets: readonly FallbackTarget[], hop: Omit<FallbackHop, "to">, ): FallbackHop | undefined { const deviceIds = fallbackDeviceIds(config, hop.admission, hop.now); const routes = [hop.route, ...(hop.aliases ?? [])]; let witness: FallbackHop | undefined; for (const target of targets) { let to: FallbackTarget; try { const route = routeConcreteModel(config, `${target.provider}/${target.model}`); to = { provider: route.providerName, model: route.modelId }; } catch { return undefined; } const kind = fallbackHopKind(hop.from, to); if (kind === null || resolveFallbackPolicy(config, { kind, routes, provider: hop.from.provider, deviceIds }).allowed) return undefined; witness ??= { ...hop, to }; } return witness; } /** Concrete and account-qualified targets retain the existing config-only resolution. */ function hardLockTargetOf(config: OcxConfig, model: string): FallbackTarget { try { const route = previewRouteModel(config, model); return { provider: route.providerName, model: route.modelId }; } catch { const slash = model.indexOf("/"); return slash > 0 ? { provider: model.slice(0, slash), model: model.slice(slash + 1) } : { provider: "", model }; } }