@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
209 lines (202 loc) • 9.03 kB
text/typescript
import type { OcxConfig } from "../../types";
import type { RequestLogContext } from "../request-log";
import type {
HandleResponsesOptions,
ResponsesRequestContext,
ResponsesAdmissionState,
ResponsesDispatchers,
} from "./core-options";
import { createTranslatorBudget } from "../../lib/translator-budget";
import { captureExplicitOpenAiCallerAuth } from "../../providers/openai-sidecar";
import { captureCallerDirectAuth } from "../../providers/caller-authorization";
import { createInferenceSendBudget } from "../inference/context";
import { finalizeOwnedTranslatorBudget, finalizeAccountLease } from "./core-lifetime";
import type { TranslatorBudget } from "../../lib/translator-budget";
import { executeComboResponses } from "./core-combo";
import { prepareResponsesRequest } from "./request-prepare";
import { prepareResponsesTransport } from "./request-transport";
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 { runWithCompactionRecovery } from "./compaction-recovery";
/** Public Responses entry and compatibility exports. Implementations live with their owners. */
/**
* Route one `/v1/responses` request through the adapter pipeline: recovery loop, passthrough
* wire, image/web-search bridges, and the terminal-guard continuation.
*/
export async function handleResponses(
req: Request,
config: OcxConfig,
logCtx: RequestLogContext,
options: HandleResponsesOptions = {},
): Promise<Response> {
const ownsBudget = options.translatorBudget === undefined;
const translatorBudget = options.translatorBudget ?? createTranslatorBudget();
const accountLoad = { lease: null as import("../../oauth/kiro-account-load").AccountLease | null };
const abortSignal = options.abortSignal ?? req.signal;
const release = () => { accountLoad.lease?.release(); accountLoad.lease = null; abortSignal.removeEventListener("abort", release); };
abortSignal.addEventListener("abort", release, { once: true });
try {
const response = await runWithCompactionRecovery(req, config, logCtx, {
...options,
openAiSidecarAuth: options.openAiSidecarAuth === undefined
? captureExplicitOpenAiCallerAuth(req.headers, config) : options.openAiSidecarAuth,
nativeCallerAuth: options.nativeCallerAuth === undefined
? captureExplicitOpenAiCallerAuth(req.headers, config) : options.nativeCallerAuth,
callerDirectAuth: options.callerDirectAuth === undefined
? captureCallerDirectAuth(req.headers, config) : options.callerDirectAuth,
// Capture before combo replay rebuilds the Request headers; children carry options.
visionDescribeTerminal: options.visionDescribeTerminal === true
|| req.headers.get("x-opencodex-vision-describe") === "1",
translatorBudget,
accountLoad,
// Once at ingress, spend observer included: a combo child inherits the parent's holder.
sendBudget: options.sendBudget ?? createInferenceSendBudget(req, logCtx),
}, handleResponsesInner);
const finalResponse = ownsBudget ? finalizeOwnedTranslatorBudget(response, translatorBudget) : response;
if (!accountLoad.lease) { release(); return finalResponse; }
return finalizeAccountLease(finalResponse, release);
} catch (error) {
release();
if (ownsBudget) translatorBudget.dispose();
throw error;
}
}
export async function handleComboResponses(
req: Request,
rawBody: unknown,
comboId: string,
config: OcxConfig,
logCtx: RequestLogContext,
options: HandleResponsesOptions & { translatorBudget: TranslatorBudget },
): Promise<Response> {
return executeComboResponses(
req,
rawBody,
comboId,
config,
logCtx,
options,
requestDispatchers,
);
}
/** Compose request phases while retaining the original admission-finally ownership. */
async function handleResponsesInner(
req: Request,
config: OcxConfig,
logCtx: RequestLogContext,
options: HandleResponsesOptions & { translatorBudget: TranslatorBudget },
): Promise<Response> {
const requestContext: ResponsesRequestContext = { req, config, logCtx, options };
const admissionState: ResponsesAdmissionState = {
pendingHostAdmissionLease: null,
authCtx: { kind: "main", accountId: null },
};
try {
const requestState = await prepareResponsesRequest(requestContext, admissionState, requestDispatchers);
if (requestState instanceof Response) return requestState;
const transportState = await prepareResponsesTransport(requestContext, admissionState, requestState);
if (transportState instanceof Response) return transportState;
options.onCompactionRecoveryRoute?.(requestState.route);
const sidecarState = await prepareResponsesSidecarAuth(requestContext, requestState, transportState);
if (sidecarState instanceof Response) return sidecarState;
const responseEffects = createResponsesEffects(
requestContext,
admissionState,
requestState,
sidecarState,
);
const sendBudgetState = createResponsesSendBudget(requestContext);
if (sendBudgetState instanceof Response) return sendBudgetState;
if ("passthrough" in transportState.adapter && transportState.adapter.passthrough && !sidecarState.routedCompaction) {
return await executePassthroughResponse(
requestContext,
admissionState,
requestState,
transportState,
sidecarState,
responseEffects,
sendBudgetState,
);
}
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,
);
} finally {
if (admissionState.pendingHostAdmissionLease) {
releaseUpstreamHostAdmission(admissionState.pendingHostAdmissionLease);
releaseCodexAuthContextProbeLease(admissionState.authCtx);
}
}
}
const requestDispatchers: ResponsesDispatchers = { handleResponses, handleComboResponses };
export { adapterNeedsForcedContinuation } from "./core-replay";
export {
sidecarOutcomeRecorder, codexLogAccountId, usesCodexForwardPoolAuth, preAuthUpstreamHostCircuitKey,
upstreamHostCircuitOpenResponse, shouldRetryCodexPoolAccountQuota, shouldRetryCodexScopedQuotaOnAlternate,
shouldRetryCodexPoolAccountTransient, codexAccountGatedCanonicalWireModel, codexForwardTerminalOutcomeRecorder,
} from "./core-codex-account";
export { shouldAttemptOpaqueBlobRecovery } from "./core-opaque-recovery";
export { readDisplaySafeErrorText, decodeRequestErrorResponse, comboUnavailableResponse, clientCancelledResponse } from "./core-errors";
export type { ConsumedComboFailure, HandleResponsesOptions } from "./core-options";
export {
sanitizedRetryAfter, consumeComboFailure, usageFromComboFailureText, createChildPassthroughCallbackGate,
buildComboChildHeaders,
} from "./core-combo-failure";
export { UPSTREAM_JSON_BODY_READ_OPTIONS, linkAbortSignal } from "./core-lifetime";
export { poolCredentialRefreshIncompleteResponse } from "./core-auth";
export { applyServiceTierGate } from "./core-normalize";
export { DEFAULT_SHADOW_SOURCE_MODELS, isShadowSourceModel, shadowSourceModels } from "../../lib/shadow-call";