UNPKG

@bitkyc08/opencodex

Version:

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

180 lines (178 loc) • 9.13 kB
import { markProxyError, rememberProxyErrorMessage } from "../../lib/client-error-body"; import { supportsNativeResponsesCompactionTrigger } from "../../providers/openai-tiers"; import type { OcxConfig } from "../../types"; import type { RequestLogContext } from "../request-log"; import type { HandleResponsesOptions, ResponsesRequestContext, ResponsesAdmissionState, ResponsesDispatchers, } from "./core-options"; import type { TranslatorBudget } from "../../lib/translator-budget"; import { prepareResponsesRequest } from "./request-prepare"; import { prepareResponsesTransport } from "./request-transport"; import { initialHostedAdvisorSpendRefusal } from "./hosted-advisor-spend"; import { prepareResponsesSidecarAuth } from "./request-sidecar-auth"; import { createResponsesEffects } from "./response-effects"; import { createResponsesSendBudget } from "./request-send-budget"; import { executePassthroughResponse } from "./passthrough-execution"; import { executeResponsesSidecars } from "./sidecar-execution"; import { createResponsesCompletionPolicy } from "./completion-policy"; import { executeResponsesRunTurn } from "./run-turn-execution"; import { prepareAdapterExchange } from "./adapter-dispatch"; import { createAdapterContinuations } from "./adapter-continuation"; import { deliverAdapterResponse } from "./adapter-delivery"; import { releaseUpstreamHostAdmission } from "../../codex/upstream-host-health"; import { releaseCodexAuthContextProbeLease } from "../../codex/auth-context"; import { formatErrorResponse } from "../../bridge"; import { InvalidRetainedCompactionSummary, prepareCompactionRetention } from "./compaction-retention"; import { responsesHasInstructionImage } from "../../adapters/claude-cli/instruction-images"; import { markResponseNonReplayable } from "../../lib/upstream-retry"; import { agyAcpPreflightResponse } from "./agy-acp-preflight"; import { commandCodeDecisionRouteRefusal } from "./command-code-decision-refusal"; /** Compose request phases while retaining the original admission-finally ownership. */ export async function handleResponsesInner( req: Request, config: OcxConfig, logCtx: RequestLogContext, options: HandleResponsesOptions & { translatorBudget: TranslatorBudget }, requestDispatchers: ResponsesDispatchers, ): Promise<Response> { const requestContext: ResponsesRequestContext = { req, config, logCtx, options }; const admissionState: ResponsesAdmissionState = { pendingHostAdmissionLease: null, authCtx: { kind: "main", accountId: null }, }; let retention: ReturnType<typeof prepareCompactionRetention>; let releasePendingSend = () => {}; try { const requestState = await prepareResponsesRequest(requestContext, admissionState, requestDispatchers); if (requestState instanceof Response) return requestState; // #8997: refuse a Command Code decision model before transport preparation (OAuth credential // resolution or refresh), sidecar auth or sidecar work. Nothing is sent, so the candidate is not // reported as a compaction-recovery source route either. const decisionRefusal = commandCodeDecisionRouteRefusal(requestState.route.provider, requestState.parsed.modelId, logCtx); if (decisionRefusal) return decisionRefusal; const transportState = await prepareResponsesTransport(requestContext, admissionState, requestState); if (transportState instanceof Response) return markProxyError(transportState); const agyAcpRefusal = agyAcpPreflightResponse({ adapterName: transportState.runTurnAdapter.name, requestHeaders: req.headers, forwardHeaders: requestState.selectedForwardHeaders, body: requestState.parsed._rawBody, comboAttempt: options.comboAttempt === true, internalDecisionCall: options.internalDecisionCall === true, subagentFallback: requestState.subagentFallbackSelected, inboundTransport: options.inboundTransport, unattendedHttpTurn: options.agyAcpUnattendedHttpTurn, logCtx, }); if (agyAcpRefusal) return agyAcpRefusal; const hostedAdvisorRefusal = initialHostedAdvisorSpendRefusal(requestContext, requestState, transportState); if (hostedAdvisorRefusal) return hostedAdvisorRefusal; if (transportState.runTurnAdapter.name === "claude-cli") { const instructionImage = options.chatInstructionImage || options.responsesInstructionImage || responsesHasInstructionImage(requestState.parsed._rawBody) || requestState.parsed.context.messages.some(message => message.role === "developer" && Array.isArray(message.content) && message.content.some(part => part.type === "image")); if (instructionImage || options.responsesFileImage) { const message = instructionImage ? "Claude Code CLI does not support images in developer instructions." : "Claude Code CLI does not support file-backed image references."; const response = new Response(JSON.stringify({ error: { type: "invalid_request_error", code: "unsupported_input_modality", param: null, message, } }), { status: 400, headers: { "Content-Type": "application/json" } }); rememberProxyErrorMessage(logCtx, message, { status: 400, type: "invalid_request_error", code: "unsupported_input_modality" }); markProxyError(response); markResponseNonReplayable(response); return response; } } options.onCompactionRecoveryRoute?.(requestState.route); if (requestState.parsed._compactionRequest && options.compactionRecoveryKind !== "compaction-v1" && (requestState.parsed._portableCompaction || !supportsNativeResponsesCompactionTrigger(requestState.route.provider))) { retention = prepareCompactionRetention(requestState.parsed, config, requestState.route.staticPolicy.model.contextWindow ?? requestState.route.staticPolicy.model.maxInputTokens, options.translatorBudget, options.abortSignal ?? req.signal); } const execute = async (): Promise<Response> => { const sidecarState = await prepareResponsesSidecarAuth(requestContext, requestState, transportState); if (sidecarState instanceof Response) return markProxyError(sidecarState); const responseEffects = createResponsesEffects( requestContext, admissionState, requestState, sidecarState, ); const sendBudgetState = createResponsesSendBudget(requestContext); if (sendBudgetState instanceof Response) return markProxyError(sendBudgetState); if ("passthrough" in transportState.adapter && transportState.adapter.passthrough && !sidecarState.routedCompaction) { const passthroughResult = await executePassthroughResponse( requestContext, admissionState, requestState, transportState, sidecarState, responseEffects, sendBudgetState, ); if (passthroughResult instanceof Response) return passthroughResult; const unclaimedHop = sendBudgetState.pendingHopPermit; releasePendingSend = () => { if (sendBudgetState.pendingHopPermit === unclaimedHop) { unclaimedHop?.release(); sendBudgetState.pendingHopPermit = undefined; } }; } const sidecarPlans = await executeResponsesSidecars( requestContext, requestState, transportState, sidecarState, responseEffects, sendBudgetState, ); if (sidecarPlans instanceof Response) return sidecarPlans; const completionPolicy = createResponsesCompletionPolicy(requestContext, sidecarState); if (transportState.adapter.runTurn) return await executeResponsesRunTurn( requestContext, admissionState, requestState, transportState, sidecarState, responseEffects, sendBudgetState, completionPolicy, ); const adapterExchange = await prepareAdapterExchange( requestContext, admissionState, requestState, transportState, responseEffects, sendBudgetState, ); if (adapterExchange instanceof Response) return adapterExchange; const continuationState = createAdapterContinuations( requestContext, requestState, transportState, sidecarState, sendBudgetState, adapterExchange, ); return await deliverAdapterResponse( requestContext, requestState, transportState, sidecarState, responseEffects, completionPolicy, adapterExchange, continuationState, ); }; const response = await execute(); return retention ? retention.deliver(response) : response; } catch (error) { retention?.dispose(); if (error instanceof InvalidRetainedCompactionSummary) return formatErrorResponse(502, "invalid_compaction_summary", error.message); throw error; } finally { releasePendingSend(); if (admissionState.pendingHostAdmissionLease) { releaseUpstreamHostAdmission(admissionState.pendingHostAdmissionLease); releaseCodexAuthContextProbeLease(admissionState.authCtx); } } }