UNPKG

@bitkyc08/opencodex

Version:

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

243 lines (230 loc) • 11.9 kB
import { CodexInstallationIdUnavailableError } from "../../codex/installation-id"; import type { ResponsesRequestContext } from "./core-options"; import type { PreparedResponsesRequest } from "./request-prepare"; import type { ResponsesTransport } from "./request-transport"; import type { OcxConfig, OcxParsedRequest } from "../../types"; import type { ComboTargetRoute } from "../../combos/request-capability"; import { ComboVisionDescriptionUnavailableError, policyCandidateRefusalResponse } from "./policy-request-scope"; import { intersectAdmissionModelScopes, resolveAdmissionModelScope } from "../admission-model-scope"; import { captureAdmissionPolicy } from "../capture-admission-policy"; import type { ResolvedOpenAiForwardSidecar } from "../../providers/openai-sidecar"; import { isCanonicalOpenAiForwardProvider, supportsNativeResponsesCompactionTrigger } from "../../providers/openai-tiers"; import { omitEarlierCompactionImages } from "../../responses/compaction-images"; import { shouldResolveOpenAiVisionSidecar, resolveOpenAiVisionModel, planVisionSidecar, describeImagesInPlace, requiresVisionPreprocessing, stripImagesInPlace, } from "../../vision"; import { shouldResolveOpenAiWebSearchSidecar } from "../../web-search"; import { shouldResolveOpenAiPassthroughWebSearchBridge } from "../../web-search/passthrough-bridge"; import { listOpenAiForwardSidecarCandidates, captureExplicitOpenAiCallerAuth, resolveFirstUsableOpenAiSidecar, } from "../../providers/openai-sidecar"; import { tryClaimNativeMainProfileForTurn as tryClaimStoredSidecarMainProfile, } from "../../codex/native-main-admission"; import { codexAccountSelectionForTurn } from "../lifecycle"; import { CodexPoolAuthenticationError, CodexAuthContextError, CodexAccountCooldownError, CodexThreadAffinityExpiredError, CodexMainProfileDrainingError, } from "../../codex/auth-context"; type SidecarRequestContext = Pick<ResponsesRequestContext, "options" | "config" | "req">; /** The config vision planning reads: a combo request plans with its request-start sidecar settings. */ export function responsesVisionConfig({ config, options }: Pick<SidecarRequestContext, "config" | "options">): OcxConfig { const admitted = options.comboVisionSidecar; return admitted ? { ...config, visionSidecar: admitted.settings } : config; } async function resolveResponsesOpenAiSidecar( { options, config, req }: SidecarRequestContext, route: Pick<ComboTargetRoute, "codexAccountId">, ): Promise<ResolvedOpenAiForwardSidecar | undefined> { try { const candidates = listOpenAiForwardSidecarCandidates(config); let sidecarAuth = options.openAiSidecarAuth; if (!sidecarAuth && options.allowStoredOpenAiSidecarAuth === true && route.codexAccountId === undefined && candidates.some(candidate => candidate.accountMode === "direct") && tryClaimStoredSidecarMainProfile(options.turnAdmissionLease)) { // Request-local helper authority only: never promote this pair to caller, primary, // or retry credentials. Claim before reading so profile switches remain fenced. try { const { getMainAccountToken } = await import("../../codex/main-account"); const token = getMainAccountToken(); if (token) sidecarAuth = captureExplicitOpenAiCallerAuth(new Headers({ authorization: `Bearer ${token.accessToken}`, "chatgpt-account-id": token.chatgptAccountId, }), config); } catch { /* stored enrichment is optional */ } } // Preserve explicit OpenAI helper auth across route changes without returning it to // primary-provider headers or alternate-main retry. The resolver revalidates scope. const sidecarHeaders = new Headers(req.headers); sidecarHeaders.delete("authorization"); sidecarHeaders.delete("chatgpt-account-id"); if (sidecarAuth) { sidecarHeaders.set("authorization", sidecarAuth.authorization); sidecarHeaders.set("chatgpt-account-id", sidecarAuth.chatgptAccountId); } return await resolveFirstUsableOpenAiSidecar( candidates, sidecarHeaders, config, { admission: options.admission, signal: options.abortSignal, codexAuthPolicy: options.codexAuthPolicy, // Account-qualified native routes are passthrough, so their in-turn helper is vision. // Scope its cooldown and outcome to the helper model, not the routed text model. ...(route.codexAccountId !== undefined ? { exactAccount: { accountId: route.codexAccountId, modelId: resolveOpenAiVisionModel(responsesVisionConfig({ config, options })) } } : {}), beginCodexAccountSelection: codexAccountSelectionForTurn(options.turnAdmissionLease), }, ); } catch (err) { // Sidecars are optional helpers for an otherwise independent routed turn. // An unavailable/cooling/expired Multi credential disables the helper; it // must not turn a valid routed-provider request into a Codex-auth failure. if ( !(err instanceof CodexInstallationIdUnavailableError) && !(err instanceof CodexPoolAuthenticationError) && !(err instanceof CodexAuthContextError) && !(err instanceof CodexAccountCooldownError) && !(err instanceof CodexThreadAffinityExpiredError) && !(err instanceof CodexMainProfileDrainingError) ) throw err; } } function responsesVisionPlan( { config, options }: SidecarRequestContext, { provider, providerName, modelId }: ComboTargetRoute, parsed: OcxParsedRequest, openAiSidecar: ResolvedOpenAiForwardSidecar | undefined, ) { const admissionScope = visionAdmissionScope(config, options); const plan = planVisionSidecar(responsesVisionConfig({ config, options }), provider, modelId, parsed, openAiSidecar, { admission: options.admission, codexAuthPolicy: options.codexAuthPolicy, providerName, admissionScope, }); if (plan?.backend === "routed") { const callerPolicy = options.advisorAdmissionPolicy ?? captureAdmissionPolicy(config, options.admission, admissionScope); plan.advisorAdmissionPolicy = { ...callerPolicy, modelScope: admissionScope ?? callerPolicy.modelScope }; } return plan; } function visionAdmissionScope(config: SidecarRequestContext["config"], options: SidecarRequestContext["options"]) { return intersectAdmissionModelScopes( options.admissionScope ?? resolveAdmissionModelScope(config, options.admission), options.advisorAdmissionPolicy?.modelScope, ); } /** Use the child's real planner and auth rules, then return any unused recovery probe. */ export async function canDescribeComboImages( context: SidecarRequestContext, route: ComboTargetRoute, parsed: OcxParsedRequest, ): Promise<boolean> { if (context.options.visionDescribeTerminal) return false; const openAiSidecar = shouldResolveOpenAiVisionSidecar(responsesVisionConfig(context), route.provider, route.modelId, parsed, route.providerName, visionAdmissionScope(context.config, context.options)) ? await resolveResponsesOpenAiSidecar(context, route) : undefined; try { const plan = responsesVisionPlan(context, route, parsed, openAiSidecar); return plan !== undefined && plan.maxDescriptionsPerTurn > 0; } finally { openAiSidecar?.releaseProbeLease?.(); } } /** One responsibility of the Responses request pipeline; state owners are explicit. */ export async function prepareResponsesSidecarAuth( requestContext: SidecarRequestContext, requestState: Pick< PreparedResponsesRequest, | "parsed" | "route" | "selectedForwardHeaders" | "translatorBudget" >, transportState: Pick<ResponsesTransport, "adapter" | "isPassthrough">, ) { const { options, config } = requestContext; const { parsed, route, translatorBudget } = requestState; const { isPassthrough } = transportState; let openAiSidecar: ResolvedOpenAiForwardSidecar | undefined; const visionDescribeTerminal = options.visionDescribeTerminal === true; const skipVision = visionDescribeTerminal || options.comboOmitImages === true; const routedCompaction = parsed._compactionRequest === true && (!supportsNativeResponsesCompactionTrigger(route.provider) || parsed._portableCompaction === true); const preserveCompactionPrefix = routedCompaction && transportState.adapter.name === "anthropic"; if (routedCompaction) parsed.context.messages = omitEarlierCompactionImages(parsed.context.messages); const needsOpenAiVision = !skipVision && shouldResolveOpenAiVisionSidecar(responsesVisionConfig(requestContext), route.provider, route.modelId, parsed, route.providerName, visionAdmissionScope(config, options)); // LOCAL PATCH (runturn-websearch): runTurn adapters can run the web-search // sidecar through src/web-search/run-turn-loop.ts, so resolve the helper // credential for them too. The passthrough bridge stays fetch-only. const needsOpenAiSearch = !routedCompaction && (transportState.adapter.runTurn ? shouldResolveOpenAiWebSearchSidecar(config, parsed, isPassthrough) : (shouldResolveOpenAiWebSearchSidecar(config, parsed, isPassthrough) || shouldResolveOpenAiPassthroughWebSearchBridge(route.provider, parsed, isPassthrough))); if (needsOpenAiVision || needsOpenAiSearch) { openAiSidecar = await resolveResponsesOpenAiSidecar(requestContext, route); } // Vision sidecar: the routed model can't see images (provider.noVisionModels). Describe each // attached image through the selected sidecar backend and replace it with text BEFORE the main // call, so the text-only model can reason about it. // Terminal describe fence (roadmap 180): the sidecar's OWN loopback describe // call must never plan another describe. The flag arrives from the Chat // surface (whose bridge rebuilds headers) or as the raw header for native // Responses callers. Marked + text-only routed model → strip, depth cap 1. const visionPlan = skipVision ? undefined : responsesVisionPlan(requestContext, route, parsed, openAiSidecar); const recordSidecarOutcome = openAiSidecar?.recordOutcome; if (visionPlan && (!options.comboRequiresVisionPlan || visionPlan.maxDescriptionsPerTurn > 0)) { try { const complete = await describeImagesInPlace( parsed, visionPlan, openAiSidecar?.headers ?? requestState.selectedForwardHeaders, options.abortSignal, recordSidecarOutcome, translatorBudget, options.comboRequiresVisionPlan, ); if (!complete && options.comboRequiresVisionPlan) { openAiSidecar?.releaseProbeLease?.(); openAiSidecar = undefined; return policyCandidateRefusalResponse(new ComboVisionDescriptionUnavailableError())!; } } finally { // Local validation can reject every image before the sidecar fetch records an outcome. // Vision-only turns must hand that unused cooldown probe back; when a fetch did run the // outcome already consumed it, so this generation-bound release is a safe no-op. if (!needsOpenAiSearch) openAiSidecar?.releaseProbeLease?.(); } } else if (requiresVisionPreprocessing(config, route.provider, route.modelId, route.providerName)) { // Image capability is not positively proven but no sidecar plan is dispatchable: fail closed. // Never forward raw image bytes to an unverified upstream. if (options.comboRequiresVisionPlan) { openAiSidecar?.releaseProbeLease?.(); return policyCandidateRefusalResponse(new ComboVisionDescriptionUnavailableError())!; } stripImagesInPlace(parsed, translatorBudget); if (!needsOpenAiSearch) openAiSidecar?.releaseProbeLease?.(); } return { openAiSidecar, routedCompaction, preserveCompactionPrefix, }; } export type ResponsesSidecarAuth = Exclude<Awaited<ReturnType<typeof prepareResponsesSidecarAuth>>, Response>;