@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
160 lines (152 loc) • 7.29 kB
text/typescript
import { formatErrorResponse } from "../../bridge";
import { isCyberPolicyCode, isCyberPolicyMessage } from "../../lib/errors";
import {
applyReplayRefusalClientHeaders,
isReplayRefusalCode,
retainReplayRefusal,
UPSTREAM_RESET_REPLAY_REFUSED_CODE,
} from "../../lib/upstream-retry";
import {
resolveClientRetryAfter,
validateClientRetryAfterHeader,
} from "../../lib/retry-after";
function isCyberPolicyBody(body: string): boolean {
if (isCyberPolicyMessage(body)) return true;
try {
const parsed = JSON.parse(body) as Record<string, unknown>;
const response = parsed.response && typeof parsed.response === "object" && !Array.isArray(parsed.response)
? parsed.response as Record<string, unknown>
: undefined;
for (const candidate of [parsed.error, response?.error, response?.last_error, parsed.last_error, parsed]) {
if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) continue;
const record = candidate as Record<string, unknown>;
if (isCyberPolicyCode(typeof record.code === "string" ? record.code : undefined)) return true;
if (typeof record.message === "string" && isCyberPolicyMessage(record.message)) return true;
}
} catch {
/* non-JSON body — message detection above is the only safe fallback */
}
return false;
}
/**
* True for a body this proxy wrote to refuse replaying an ambiguous pre-header reset.
*
* It is read off the body rather than a marker because this formatter is handed bytes, not
* the response they came from, and the refusal reaches it after the original body was read.
* The code is this proxy's own, so an upstream echoing it is not a case worth widening for.
*/
function isReplayRefusalBody(body: string): boolean {
if (!body.includes(UPSTREAM_RESET_REPLAY_REFUSED_CODE)) return false;
try {
const parsed = JSON.parse(body) as Record<string, unknown>;
const error = parsed.error && typeof parsed.error === "object" && !Array.isArray(parsed.error)
? parsed.error as Record<string, unknown>
: undefined;
return isReplayRefusalCode(error?.code) || isReplayRefusalCode(parsed.code);
} catch {
return false;
}
}
/**
* Passthrough adapters historically relayed upstream non-2xx bodies verbatim.
* Codex maps an *empty* body to the literal client string "Unknown error"
* (UnexpectedResponseError) — issue #452. Only empty bodies need wrapping.
*
* Non-empty bodies (including ChatGPT `{detail: ...}` account-model 400s and
* HTML/text errors) must keep their original bytes and headers so pool-retry
* activation and client diagnostics stay honest.
*
* Retry-After is validated independently of the body path:
* - valid upstream values are preserved
* - missing/malformed values are replaced when resolveClientRetryAfter yields a value
* - malformed/expired values are removed when the resolver returns undefined
* (e.g. quota-exhausted 429s must not keep junk headers or get the synthetic "2")
* - a replay refusal this proxy wrote gets none and keeps none: the whole point of the
* refusal is that the turn may already be running, and the synthetic default for a
* retryable 429 is a direct instruction to the client to send it a second time
*
* A refusal also leaves with the shared no-retry header and the in-process marker, so the
* verdict survives this re-wrap as a property of the response rather than as a status a later
* reader would have to guess from.
*/
export function formatPassthroughUpstreamError(
status: number,
bodyText: string,
options?: {
statusText?: string;
headers?: Headers;
now?: number;
/** Caller holds an authoritative fatal verdict; neither inherited nor inferred waits apply. */
suppressRetryAfter?: boolean;
/**
* Provenance from the caller that still holds the response: this body is a refusal this
* proxy synthesized. The body check below is the fallback for a re-wrapped body, and it
* cannot answer at all when the bounded read returned nothing display-safe -- which is
* precisely when the empty-body branch would invent the retryable-429 default.
*/
replayRefusal?: boolean;
},
): Response {
const trimmed = bodyText.trim();
const now = options?.now ?? Date.now();
const upstreamRetryAfter = options?.headers?.get("retry-after")?.trim() || undefined;
const originalValid = validateClientRetryAfterHeader(upstreamRetryAfter, now);
const cyberPolicyFailure = isCyberPolicyBody(trimmed);
const replayRefusal = options?.replayRefusal === true || isReplayRefusalBody(trimmed);
// Two different reasons to answer with no wait at all, handled the same way: a hard policy
// block will not become servable, and a refusal we made was never a rate limit.
const suppressRetryAfter = options?.suppressRetryAfter === true || cyberPolicyFailure || replayRefusal;
const resolved = suppressRetryAfter
? undefined
: resolveClientRetryAfter({
status,
message: trimmed || `Provider error ${status}: (empty body)`,
upstreamRetryAfter,
now,
});
if (trimmed) {
const needsSet = resolved !== undefined && upstreamRetryAfter !== resolved;
const needsDelete = (suppressRetryAfter && upstreamRetryAfter !== undefined)
|| (resolved === undefined
&& upstreamRetryAfter !== undefined
&& originalValid === undefined);
// A refusal always takes the rewriting path: it has a header to add even when the
// upstream named no wait for it to remove.
if (!needsSet && !needsDelete && !replayRefusal) {
return new Response(bodyText, {
status,
...(options?.statusText ? { statusText: options.statusText } : {}),
...(options?.headers ? { headers: options.headers } : { headers: { "Content-Type": "application/json" } }),
});
}
const headers = options?.headers
? new Headers(options.headers)
: new Headers({ "Content-Type": "application/json" });
if (needsSet) headers.set("Retry-After", resolved!);
else headers.delete("Retry-After");
if (replayRefusal) applyReplayRefusalClientHeaders(headers);
const rewritten = new Response(bodyText, {
status,
...(options?.statusText ? { statusText: options.statusText } : {}),
headers,
});
return replayRefusal ? retainReplayRefusal(rewritten) : rewritten;
}
const response = formatErrorResponse(
status,
"upstream_error",
`Provider error ${status}: (empty body)`,
// Provenance is all that is left when the bounded read returned nothing display-safe, and
// it is enough: the formatter allowlists this code, restates the refusal status and marks
// the response, so an unreadable refusal reaches the client as the same refusal.
replayRefusal
? { code: UPSTREAM_RESET_REPLAY_REFUSED_CODE }
: resolved !== undefined ? { retryAfter: resolved } : undefined,
);
const headers = new Headers(response.headers);
headers.set("Content-Type", "application/json");
if (resolved !== undefined) headers.set("Retry-After", resolved);
if (replayRefusal) applyReplayRefusalClientHeaders(headers);
const wrapped = new Response(response.body, { status: response.status, headers });
return replayRefusal ? retainReplayRefusal(wrapped) : wrapped;
}