@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
211 lines (201 loc) • 12 kB
text/typescript
import type { AdapterRequest, IncomingMeta, ProviderAdapter } from "../../adapters/base";
import type { OcxParsedRequest } from "../../types";
import type { PhysicalSendReporter } from "../../lib/request-execution-budget";
import { readBoundedResponseBody } from "../../lib/bounded-body";
import { isRewrittenUpstreamError, markRewrittenUpstreamError } from "../../adapters/upstream-http-error";
import { carryProxyError, isProxyError } from "../../lib/client-error-body";
import { checkOutboundBodySize } from "./outbound-body-guard";
import { releaseTranslatedEvent, type TranslatorBudget } from "../../lib/translator-budget";
import { isNonReplayableResponse, SendBudgetExhaustedError } from "../../lib/upstream-retry";
import { COMPACT_PROMPT, SUMMARY_PREFIX } from "../../responses/compaction";
import { sameProviderContinuationOwner } from "../../responses/provider-continuation";
import { deferPhysicalSendReporter } from "./deferred-send-reporter";
import { fetchWithHeaderTimeout, providerFetch } from "./fetch-helpers";
import { transientSendCapFor, type ResponsesSendBudget } from "./request-send-budget";
import { bindAdapterResponseSpend } from "./request-spend";
import { splitAnthropicImageContext } from "./anthropic-image-context";
import type { ResponsesRequestContext } from "./core-options";
import type { PreparedResponsesRequest } from "./request-prepare";
import type { ResponsesTransport } from "./request-transport";
import { transientRetryPolicyFor } from "../../providers/key-failover";
type RecoveryBudget = Pick<ResponsesSendBudget, "remainingTransientSendBudget" | "targetSendsUsed" | "imageRecoverySendReporter">;
type ImageRecoveryTransport = Pick<ResponsesTransport, "pinAnthropicImageRecovery" | "noteRoutedAttemptSend">;
type RecoveredExchange = { response: Response; request?: AdapterRequest };
const SUMMARY_MAX_TOKENS = 1024;
function wireOutputLimit({ body }: AdapterRequest): number | undefined {
const { max_tokens } = JSON.parse(body) as { max_tokens: number };
return Number.isSafeInteger(max_tokens) && max_tokens > 0 ? max_tokens : undefined;
}
export type AnthropicImageRecovery = (
response: Response, parsed: OcxParsedRequest, adapter: ProviderAdapter, signal: AbortSignal,
) => Promise<RecoveredExchange>;
/** Preserve the bounded refusal while releasing its original pacing lease. */
export async function retainAdapterFailureResponse(response: Response, signal: AbortSignal): Promise<{
response: Response; text: string;
}> {
// Same contract as readDisplaySafeErrorText, but remembering whether the whole body survived: a
// retained copy of a truncated, unsafe or unreadable body is not the provider's evidence (#9017).
let text = "";
let complete = false;
try {
const body = await readBoundedResponseBody(response, { signal });
text = body.displaySafe ? body.text : "";
complete = body.displaySafe && !body.truncated;
} catch {
text = "";
}
const headers = new Headers(response.headers);
headers.delete("content-length");
headers.delete("content-encoding");
const retained = new Response(text, { status: response.status, statusText: response.statusText, headers });
if (!complete || isRewrittenUpstreamError(response)) markRewrittenUpstreamError(retained);
return { response: carryProxyError(response, retained), text };
}
export async function recoverAdapterImageContext(
recover: AnthropicImageRecovery, response: Response, parsed: OcxParsedRequest,
transport: Pick<ResponsesTransport, "activeAdapter" | "sameTargetRequest" | "sameTargetParsed" | "sameTargetToken" | "transportToken">,
signal: AbortSignal, refreshToolAliases: (request: AdapterRequest) => void,
): Promise<Response | undefined> {
try {
const recovered = await recover(response, parsed, transport.activeAdapter, signal);
if (recovered.request) {
transport.sameTargetRequest = recovered.request;
transport.sameTargetParsed = parsed;
transport.sameTargetToken = transport.transportToken;
refreshToolAliases(recovered.request);
}
return recovered.response;
} catch (error) {
if (!signal.aborted) throw error;
}
}
// The ingress translator budget is shared by combo targets and compaction attempts.
const recoveryAttempted = new WeakSet<TranslatorBudget>();
/** One summary and one resend, using the original route, pacing, ledger and caller signal. */
export function createAnthropicImageRecovery(
{ config, options }: Pick<ResponsesRequestContext, "config" | "options">,
{ route, translatorBudget, selectedForwardHeaders, completedToolBlocks }: Pick<PreparedResponsesRequest,
"route" | "translatorBudget" | "selectedForwardHeaders" | "completedToolBlocks">,
transport: ImageRecoveryTransport,
budget: RecoveryBudget,
connectMs: number,
): AnthropicImageRecovery {
return async (response, parsed, adapter, signal) => {
if (recoveryAttempted.has(translatorBudget) || adapter.name !== "anthropic" || parsed._compactionRequest
|| response.status !== 413 || isProxyError(response) || isNonReplayableResponse(response)) return { response };
signal.throwIfAborted();
const owner = parsed._providerContinuationOwner;
const pin = transport.pinAnthropicImageRecovery(response);
if (!owner || !pin || !sameProviderContinuationOwner(owner, pin.owner)) return { response };
const split = splitAnthropicImageContext(parsed.context.messages);
if (!split || !adapter.parseResponse || !pin.request.body.includes('"type":"image"')) return { response };
const total = transientRetryPolicyFor(route.provider)?.attempts;
const remaining = () => budget.remainingTransientSendBudget(transientSendCapFor(total, budget.targetSendsUsed));
if (remaining() < 2) return { response };
const { response: retained, text } = await retainAdapterFailureResponse(response, signal);
signal.throwIfAborted();
// Require a provider size refusal and an actual image-bearing, compactable history.
if (recoveryAttempted.has(translatorBudget)
|| !/request_too_large|payload_too_large|(?:request|payload|image|body)[^\n]{0,60}too large/i.test(text)) {
return { response: retained };
}
recoveryAttempted.add(translatorBudget);
const originalBytes = Buffer.byteLength(pin.request.body, "utf8");
const incoming: IncomingMeta = { headers: selectedForwardHeaders, completedToolBlocks,
providerName: route.providerName, translatorBudget, abortSignal: signal };
const send = async (wire: AdapterRequest, input: OcxParsedRequest, minimum: number, outputLimit: number) => {
signal.throwIfAborted();
if (!pin.isCurrent() || remaining() < minimum) throw new SendBudgetExhaustedError();
const physical = budget.imageRecoverySendReporter(wire.body, outputLimit);
const receipt = deferPhysicalSendReporter(physical);
try {
const run = () => fetchWithHeaderTimeout(wire.url, {
method: wire.method, headers: wire.headers, body: wire.body,
}, signal, connectMs, input.stream, providerFetch(route.provider, options.codexWsRuntimeIdentity, {
httpOnly: true, providerName: route.providerName, modelId: route.modelId,
dispatchOverride: pin.dispatchOverride(wire, input),
onPhysicalDispatch: () => {
if (remaining() < minimum || !receipt.beforeDispatch()) throw new SendBudgetExhaustedError();
if (input._anthropicImageSummary) pin.recordRefusalSpend?.();
transport.noteRoutedAttemptSend(undefined, "image-413");
},
}));
const response = await (receipt.report.execute ? receipt.report.execute(run) : run());
return { response, recordUsage: physical.recordUsage };
} finally {
receipt.report.close?.();
}
};
const fits = (wire: AdapterRequest) => Buffer.byteLength(wire.body, "utf8") < originalBytes
&& checkOutboundBodySize(wire.body, config.maxUpstreamBodyBytes).admitted;
try {
signal.throwIfAborted();
if (!pin.isCurrent()) return { response: retained };
const originalLimit = wireOutputLimit(pin.request);
if (originalLimit === undefined) return { response: retained };
const summaryLimit = Math.min(originalLimit, SUMMARY_MAX_TOKENS);
const summaryInput: OcxParsedRequest = {
...parsed, stream: false, _anthropicImageOwner: owner, _anthropicImageSummary: true,
_anthropicServerTools: undefined, _anthropicServerReplay: undefined,
options: { toolChoice: "none", reasoning: "none", thinkingEnabled: false, maxOutputTokens: summaryLimit },
context: { ...parsed.context, tools: undefined, messages: [...split.history, {
role: "user", timestamp: 0,
content: `${COMPACT_PROMPT}\n\nReturn only the handoff summary. Do not call tools or continue the task.`,
}] },
};
const summaryRequest = await adapter.buildRequest(summaryInput, incoming);
let summarySend: Awaited<ReturnType<typeof send>>;
try {
if (!fits(summaryRequest) || !summaryRequest.body.includes('"type":"image"')) return { response: retained };
const outputLimit = wireOutputLimit(summaryRequest);
if (outputLimit === undefined || outputLimit > summaryLimit) return { response: retained };
summarySend = await send(summaryRequest, summaryInput, 2, outputLimit);
} finally { summaryRequest.releaseBodyObservation?.(); }
const { response: summaryResponse, recordUsage: recordSummaryUsage } = summarySend;
if (!summaryResponse.ok) {
void summaryResponse.body?.cancel().catch(() => {});
return { response: retained };
}
const payload = await readBoundedResponseBody(summaryResponse, { signal });
if (!payload.displaySafe) return { response: retained };
const { content } = JSON.parse(payload.text) as { content?: Array<{ type?: unknown }> };
const textOnly = Array.isArray(content)
&& content.every(block => ["text", "thinking", "redacted_thinking"].includes(String(block?.type)));
const events = await adapter.parseResponse(new Response(payload.text, { headers: summaryResponse.headers }),
translatorBudget, summaryRequest.tierLog);
let summary = "";
let completed = false;
let invalid = false;
for (const event of events) {
if ("usage" in event && event.usage) recordSummaryUsage?.(event.usage);
if (event.type === "done") completed = event.stopReason === "end_turn" || event.stopReason === "stop_sequence";
else if (event.type === "text_delta" && !event.anthropicThinkingSignature) summary += event.text;
else if (event.type.startsWith("tool_call") || event.type.startsWith("web_search")
|| event.type === "error" || event.type === "incomplete") invalid = true;
releaseTranslatedEvent(event, translatorBudget);
}
if (!textOnly || invalid || !completed || !summary.trim()) return { response: retained };
const successor: OcxParsedRequest = { ...parsed, _anthropicImageOwner: owner,
context: { ...parsed.context, messages: [
{ role: "user", timestamp: 0, content: `${SUMMARY_PREFIX}\n\n${summary}` }, ...split.retained,
] },
};
const request = await adapter.buildRequest(successor, incoming);
try {
if (!fits(request)) return { response: retained };
const outputLimit = wireOutputLimit(request);
if (outputLimit === undefined) return { response: retained };
const { response: replacement, recordUsage } = await send(request, successor, 1, outputLimit);
if (replacement.ok) {
bindAdapterResponseSpend(replacement, recordUsage);
parsed.context.messages = successor.context.messages;
parsed._anthropicImageOwner = owner;
}
return { response: replacement, request };
} finally { request.releaseBodyObservation?.(); }
} catch (error) {
if (signal.aborted) throw error;
return { response: retained };
}
};
}