@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
212 lines (196 loc) • 8.82 kB
text/typescript
import { comboFailureDecision } from "../../combos/failover";
import { readBoundedResponseBody } from "../../lib/bounded-body";
import { isNonReplayableResponse } from "../../lib/upstream-retry";
import { finishRequestAttempt, type RequestLogContext } from "../request-log";
import { linkRequestSessionLane } from "../request-log-conversation";
import type { OcxConfig } from "../../types";
import type { RouteCandidateTrace, RouteDecisionTraceV1 } from "../../routing/trace";
import { handleResponses as handleResponsesCore } from "./core";
import { requestPacingOverloadResponse } from "./pacing-overload";
import { captureExplicitOpenAiCallerAuth } from "../../providers/openai-sidecar";
import { captureCallerDirectAuth } from "../../providers/caller-authorization";
import { resolvePolicyProfileId } from "../../routing/profile";
import { parseSyntheticRowId } from "../fast-row";
type CoreHandler = typeof handleResponsesCore;
type CoreOptions = Parameters<CoreHandler>[3];
export interface PolicyFallbackDeps {
runCore?: CoreHandler;
}
function candidateKey(candidate: Pick<RouteCandidateTrace, "provider" | "model">): string {
return `${candidate.provider}\u0000${candidate.model}`;
}
/**
* Rank the remaining candidates from the ORIGINAL policy trace. The initial
* decision stays immutable; fallback execution belongs in attempts[], not in a
* rewritten decision trace.
*/
export function rankPolicyFallbackCandidates(
trace: RouteDecisionTraceV1,
tried: ReadonlySet<string>,
): RouteCandidateTrace[] {
return trace.candidates
.map((candidate, index) => ({ candidate, index }))
.filter(({ candidate }) =>
candidate.eligible
&& candidate.exclusions.length === 0
&& !tried.has(candidateKey(candidate)))
.sort((left, right) => {
const scoreDelta = (right.candidate.score?.total ?? Number.NEGATIVE_INFINITY)
- (left.candidate.score?.total ?? Number.NEGATIVE_INFINITY);
return scoreDelta || left.index - right.index;
})
.map(({ candidate }) => candidate);
}
function requestWithCandidate(
req: Request,
rawBody: Record<string, unknown>,
candidate: Pick<RouteCandidateTrace, "provider" | "model">,
): Request {
const headers = new Headers(req.headers);
// The next candidate owns a different physical credential domain. Typed
// admission and any claimed Claude snapshot stay in caller-owned CoreOptions.
headers.delete("authorization");
headers.delete("chatgpt-account-id");
headers.delete("content-encoding");
headers.delete("content-length");
headers.set("content-type", "application/json");
const retryRequest = new Request(req.url, {
method: req.method,
headers,
body: JSON.stringify({ ...rawBody, model: `${candidate.provider}/${candidate.model}` }),
signal: req.signal,
});
// A sessionless request keeps the lane it was already allocated. Without this the second
// candidate reaches OpenCode Go under a different x-opencode-session than the first attempt,
// which is the same conversation split the header exists to prevent.
linkRequestSessionLane(req, retryRequest);
return retryRequest;
}
function errorCodeFromText(text: string): string | undefined {
if (!text) return undefined;
try {
const payload = JSON.parse(text) as { error?: { code?: unknown; type?: unknown }; code?: unknown };
const candidate = payload.error?.code ?? payload.error?.type ?? payload.code;
return typeof candidate === "string" ? candidate : undefined;
} catch {
return undefined;
}
}
async function shouldHopPolicyCandidate(response: Response, signal?: AbortSignal): Promise<boolean> {
if (response.status < 400 || signal?.aborted) return false;
// A response that must not be sent again cannot open a policy-candidate retry either.
if (isNonReplayableResponse(response)) return false;
try {
const inspected = await readBoundedResponseBody(response.clone(), { signal });
const text = inspected.displaySafe ? inspected.text : "";
return comboFailureDecision(response.status, text, { code: errorCodeFromText(text) }) === "hop";
} catch {
return false;
}
}
function isPolicyDecision(trace: RouteDecisionTraceV1 | undefined): trace is RouteDecisionTraceV1 {
return trace?.routeKind === "policy" && !!trace.profile;
}
/** Finalize the failed physical attempt so the retry receives a fresh attempt row. */
function finishFailedPolicyAttempt(logCtx: RequestLogContext, status: number): void {
const attempt = logCtx.activeAttempt;
if (attempt) {
const startedAt = logCtx.activeAttemptStartedAt ?? Date.now();
finishRequestAttempt(attempt, status, Math.max(0, Date.now() - startedAt), attempt.usage ?? logCtx.usage);
}
delete logCtx.activeAttempt;
delete logCtx.activeAttemptStartedAt;
delete logCtx.usage;
delete logCtx.usageFromBridge;
delete logCtx.upstreamError;
delete logCtx.terminalHttpStatus;
delete logCtx.terminalErrorCode;
delete logCtx.terminalIncompleteReason;
}
/**
* Run a Responses request and, only for an explicitly selected policy profile,
* hop to the next eligible policy candidate after a retryable pre-success
* failure. The initial policy trace remains the canonical selection evidence;
* physical retries continue to accumulate in the existing request attempts.
*/
export async function handleResponsesWithPolicyFallback(
req: Request,
config: OcxConfig,
logCtx: RequestLogContext,
options: CoreOptions = {},
deps: PolicyFallbackDeps = {},
): Promise<Response> {
const runCore = deps.runCore ?? handleResponsesCore;
let requestBodyReadNotified = false;
let storedPool401ReplayDispatched = false;
let rawBody: Record<string, unknown> | null = null;
const coreOptions: CoreOptions = {
...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,
...(options.onRequestBodyRead ? {
onRequestBodyRead: () => {
if (requestBodyReadNotified) return;
requestBodyReadNotified = true;
options.onRequestBodyRead?.();
},
} : {}),
onRequestBodyParsed: body => {
options.onRequestBodyParsed?.(body);
if (rawBody === null && body && typeof body === "object" && !Array.isArray(body)
&& typeof (body as { model?: unknown }).model === "string") {
const model = (body as { model: string }).model;
const { fastRow, effortRow } = parseSyntheticRowId(model, config);
if (resolvePolicyProfileId(config, fastRow?.baseId ?? effortRow?.baseId ?? model) === null) return;
// Recovery and other core preparation may mutate the parsed body in place. Keep an
// immutable snapshot of the original wire body so a retry cannot serialize those
// mutations. Object-identity metadata is re-established by each attempt, not serialized.
rawBody = structuredClone(body as Record<string, unknown>);
}
},
onStoredPool401ReplayDispatched: () => {
storedPool401ReplayDispatched = true;
options.onStoredPool401ReplayDispatched?.();
},
};
let response: Response;
try {
response = await runCore(req, config, logCtx, coreOptions);
} catch (error) {
const overload = requestPacingOverloadResponse(error);
if (overload) return overload;
throw error;
}
const initialTrace = logCtx.routeDecision;
const initialRequestedModel = logCtx.requestedModel;
if (!rawBody || !isPolicyDecision(initialTrace)) return response;
const tried = new Set<string>([
candidateKey({ provider: initialTrace.selected.provider, model: initialTrace.selected.model }),
]);
while (!storedPool401ReplayDispatched && await shouldHopPolicyCandidate(response, req.signal)) {
if (req.signal.aborted) return response;
const next = rankPolicyFallbackCandidates(initialTrace, tried)[0];
if (!next) return response;
tried.add(candidateKey(next));
finishFailedPolicyAttempt(logCtx, response.status);
const retryRequest = requestWithCandidate(req, rawBody, next);
try {
try {
response = await runCore(retryRequest, config, logCtx, coreOptions);
} catch (error) {
const overload = requestPacingOverloadResponse(error);
if (overload) return overload;
throw error;
}
} finally {
logCtx.requestedModel = initialRequestedModel;
logCtx.routeDecision = initialTrace;
}
}
return response;
}
export const handleResponses = handleResponsesWithPolicyFallback;