UNPKG

@bitkyc08/opencodex

Version:

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

689 lines (654 loc) • 31.3 kB
import { formatRetryAfterAdvice, parseRetryAfterFromMessage } from "./retry-delay"; export interface OcxErrorPayload { message: string; type: string; code: string | null; } export const ENCRYPTED_FUNCTION_OUTPUT_REJECTION = "Encrypted function output content could not be decrypted or decoded."; /** * The error identity for a send this proxy declined to make (#4708). * * Declared here rather than only on the error class because the classifier is what decides * whether the identity survives serialization, and every dispatch path has to name the same * string for a client to be able to tell this apart from a provider rate limit. */ export const SEND_BUDGET_EXHAUSTED_CODE = "request_send_budget_exhausted"; /** Canonical human-readable message paths used by Responses upstream failures. */ export function upstreamErrorMessageFromPayload(payload: unknown): string | undefined { if (!payload || typeof payload !== "object" || Array.isArray(payload)) return undefined; const json = payload as { type?: unknown; message?: unknown; error?: { message?: unknown }; last_error?: { message?: unknown }; response?: { error?: { message?: unknown }; incomplete_details?: { message?: unknown }; }; }; const message = json.error?.message ?? json.last_error?.message ?? json.response?.error?.message ?? json.response?.incomplete_details?.message // The Responses stream error event carries a flat message (type/code/message), // unlike the response.failed envelope the branches above already cover. ?? (json.type === "error" ? json.message : undefined); return typeof message === "string" ? message : undefined; } /** OpenAI / Codex hard block for high-risk cybersecurity activity (HTTP 400 or mid-stream). */ export const CYBER_POLICY_ERROR_CODE = "cyber_policy"; export const CYBER_POLICY_FALLBACK_MESSAGE = "Request blocked by the upstream cybersecurity policy."; export function isCyberPolicyCode(code: string | null | undefined): boolean { return code === CYBER_POLICY_ERROR_CODE; } /** Preserve a structured upstream error type; otherwise use the dedicated policy identity. */ export function cyberPolicyErrorType(type: string | null | undefined): string { const trimmed = typeof type === "string" ? type.trim() : ""; return trimmed || CYBER_POLICY_ERROR_CODE; } /** * Detect OpenAI cyber-policy refusals from message text when structured `code` was stripped. * Matches Codex fallback copy and Cursor/API agent wording (session evidence 2026-07-24). * Does not treat a bare `cyber_policy` token as conclusive — model ids / routing errors can * include that substring without being a policy refusal. */ export function isCyberPolicyMessage(text: string): boolean { const lower = text.toLowerCase(); // Serialized error-code signatures only (not bare model-id collisions). if (/"code"\s*:\s*"cyber_policy"/.test(lower)) return true; if (/\bcode\s*[:=]\s*["']?cyber_policy\b/.test(lower)) return true; if (lower.includes("high-risk cybersecurity")) return true; if (lower.includes("high-risk cyber activity") || lower.includes("high-risk cyber ")) return true; if (lower.includes("possible cybersecurity risk")) return true; if (lower.includes("flagged") && lower.includes("cybersecurity")) return true; if (lower.includes("flagged") && lower.includes("cyber activity")) return true; return false; } /** * Refusal codes Codex ends a turn on. * * Its Responses parser classifies a `response.failed` terminal by `error.code` * alone (codex-rs/codex-api/src/sse/responses.rs:423-462). These four become a * fatal `ApiError` the client reports instead of reconnecting. A code outside * this set is never read as a refusal: `server_is_overloaded` and `slow_down` * take the overload arm, `rate_limit_exceeded` takes the rate-limit arm, and * everything else falls through to `ApiError::Retryable` and is reconnected up * to `stream_max_retries`. * * Deliberately scoped to content refusals. `insufficient_quota` and * `context_length_exceeded` are terminal for Codex too, but they are separate * failure families this proxy already classifies through its own quota and * context paths, and pulling them in here would change their retry behavior * with no evidence asking for it. */ const TERMINAL_REFUSAL_CODES = new Set<string>([ CYBER_POLICY_ERROR_CODE, "misalignment_policy_violation", "invalid_prompt", "bio_policy", ]); /** True when an upstream error code is a refusal the client must not retry. */ export function isTerminalRefusalCode(code: string | null | undefined): boolean { return typeof code === "string" && TERMINAL_REFUSAL_CODES.has(code); } /** Stand-in copy for a refusal the upstream sent without a message of its own. */ export const TERMINAL_REFUSAL_FALLBACK_MESSAGE = "The upstream refused this request."; /** Readable copy for a refusal code, used when the upstream carried no message. */ export function terminalRefusalFallbackMessage(code: string): string { return code === CYBER_POLICY_ERROR_CODE ? CYBER_POLICY_FALLBACK_MESSAGE : TERMINAL_REFUSAL_FALLBACK_MESSAGE; } /** * Name the refusal code behind upstream safety copy when the structured code * was not carried on the wire. * * Same discipline as {@link isCyberPolicyMessage}: whole distinctive phrases * only. A loose match here is the mirror-image defect — it would end a turn * that a genuine transient failure would have retried successfully — so a * message that merely mentions safety or blocking does not qualify. Callers * must consult this only when the upstream carried no structured code at all, * so that a transport failure quoting a refusal in its diagnostic text cannot * be promoted past the verdict the upstream actually gave. * * Copy provenance: "limited access to this content for safety reasons" is the * prefix Codex itself matches (tui/src/chatwidget/turn_runtime.rs:8-15) and * pairs with `invalid_prompt` in its parser fixture (sse/responses.rs:1358-1366), * which also pairs "flagged for possible biological risk" with `bio_policy`. * "blocked by our safety systems" is the copy reported in #5176; pairing it * with `invalid_prompt` is an inference from the two verified pairings above, * not something the upstream source states. */ export function safetyRefusalCodeFromMessage(text: string): string | undefined { const lower = String(text ?? "").toLowerCase(); if (lower.includes("flagged for possible biological risk")) return "bio_policy"; if ( lower.includes("blocked by our safety systems") || lower.includes("limited access to this content for safety reasons") ) return "invalid_prompt"; return undefined; } function isSubscriptionGateMessage(text: string): boolean { return ( text.includes("requires a subscription") || text.includes("requires subscription") || text.includes("subscription required") || text.includes("upgrade for access") || text.includes("upgrade to pro") || text.includes("pro subscription") || text.includes("ollama.com/upgrade") || (text.includes("upgrade") && text.includes("subscription")) ); } /** * xAI (and similar Chat Completions gateways) sometimes refuse a turn with HTTP 403 * and a model-refusal sentence instead of 200 + finish_reason=content_filter. * Codex treats that 403 as a transport failure, so the user message is never * recorded as a completed turn and retries loop. Keep this allowlist narrow: * entitlement / plan / model-access 403s must stay errors. */ const POLICY_REFUSAL_PHRASES = [ "i can't help with that request", "i cannot help with that request", "i'm unable to help with that request", "i am unable to help with that request", ] as const; function hasModelAccessCue(text: string): boolean { return ( text.includes("not allowed to use this model") || text.includes("not allowed to use this operation") ); } /** * xAI plan and credit 403 wording. Checked only by the refusal matcher below: adding these to * the global subscription classifier would also change status and error-code inference for * every message-only error that happens to mention credits. */ function hasEntitlementCue(text: string): boolean { return ( isSubscriptionGateMessage(text) || text.includes("need a grok subscription") || text.includes("run out of credits") ); } /** Lowercase, collapse whitespace, and strip trailing .!? so an exact phrase match is stable. */ function normalizePolicyRefusalSentence(text: string): string { return text .trim() .toLowerCase() .replace(/\s+/g, " ") .replace(/[.!?]+$/g, "") .trim(); } /** * True only when the extracted error sentence is exactly a known model-refusal * phrase. JSON / "Provider error 403:" wrappers are unwrapped first. Extra * plan, credit, entitlement, or model-access wording keeps the error path. */ export function isUpstreamPolicyRefusalMessage(text: string): boolean { const extracted = extractPolicyRefusalText(text); const originalLower = text.toLowerCase(); const extractedLower = extracted.toLowerCase(); if (hasEntitlementCue(originalLower) || hasEntitlementCue(extractedLower)) return false; if (hasModelAccessCue(originalLower) || hasModelAccessCue(extractedLower)) return false; const normalized = normalizePolicyRefusalSentence(extracted); return (POLICY_REFUSAL_PHRASES as readonly string[]).includes(normalized); } /** HTTP 403 plus {@link isUpstreamPolicyRefusalMessage}; other statuses never rewrite. */ export function isUpstreamPolicyRefusal(status: number, text: string): boolean { return status === 403 && isUpstreamPolicyRefusalMessage(text); } /** Pull the human-readable refusal sentence out of a JSON or prefixed error body. */ export function extractPolicyRefusalText(raw: string): string { const trimmed = raw.trim(); try { const parsed = JSON.parse(trimmed) as { error?: unknown; message?: unknown }; const nested = parsed.error; if (typeof nested === "string" && nested.trim()) return nested.trim(); if (nested && typeof nested === "object") { const msg = (nested as { message?: unknown; error?: unknown }).message ?? (nested as { error?: unknown }).error; if (typeof msg === "string" && msg.trim()) return msg.trim(); } if (typeof parsed.message === "string" && parsed.message.trim()) return parsed.message.trim(); } catch { /* not JSON */ } // The proxy's own error text wraps the upstream JSON (`Provider error 403: {"error": ...}`), // so the remainder after the prefix gets the same unwrapping. const prefixed = trimmed.match(/^Provider error 403:\s*([\s\S]+)$/i); if (prefixed?.[1]?.trim()) return extractPolicyRefusalText(prefixed[1]); return trimmed; } function isLocalAclHardeningMessage(text: string): boolean { const secretPathHardening = text.includes("secret path") && ( text.includes("acl") || text.includes("harden") || text.includes("permission") || text.includes("access denied") || text.includes("inheritance") ); return ( text.includes("icacls") || text.includes("acl hardening") || text.includes("ntfs") || secretPathHardening || text.includes("inheritance:r") || /\bwindows\b.*\bacl\b/.test(text) || text.includes("/grant:r") ); } function isAuthenticationMessage(text: string): boolean { const accessDeniedWithCredentialCue = ( text.includes("access denied") || text.includes("accessdeniedexception") ) && ( text.includes("authentication") || text.includes("credential") || text.includes("api key") || text.includes("token") || text.includes("signature") ); return ( text.includes("authentication failed") || text.includes("authentication") || text.includes("invalid_api_key") || text.includes("invalid api key") || text.includes("invalid token") || text.includes("unauthorizedexception") || text.includes("unrecognizedclientexception") || text.includes("unrecognizedclient") || text.includes("expired token") || text.includes("expiredtoken") || text.includes("unauthenticated") || text.includes("unauthorized") || accessDeniedWithCredentialCue ); } function isPermissionMessage(text: string): boolean { return ( text.includes("permission_denied") || text.includes("permission denied") || text.includes("forbidden") || text.includes("access denied") || text.includes("accessdeniedexception") || text.includes("not allowed to use") || text.includes("model access") ); } /** * Geographic / network-location denials. Google's Cloud Code Assist API returns these as * HTTP 400 `FAILED_PRECONDITION: User location is not supported for the API use.` — the * request is well-formed, the caller's location is refused. Treated as a permission-class * rejection, never as an invalid request (#3467). */ const LOCATION_UNSUPPORTED_PATTERNS = [ "location is not supported", "location not supported", "unsupported location", "region is not supported", "unsupported region", "country is not supported", "not supported in your country", "not supported in your region", ] as const; export function isLocationUnsupportedMessage(text: string): boolean { const lower = text.toLowerCase(); return LOCATION_UNSUPPORTED_PATTERNS.some(needle => lower.includes(needle)); } /** * Client cancelled / closed the turn. Matches ONLY abort phrases this codebase * produces — "client closed request during web-search" (src/web-search/loop.ts), * "Client cancelled request" (src/server/responses.ts) — plus the explicit * "request cancel(l)ed by client" forms. Deliberately narrow: bare "client closed" * would also swallow legitimate upstream failures like "upstream HTTP client * closed idle connection" and turn a real 502 into a 499. */ export function isClientClosedMessage(text: string): boolean { const lower = text.toLowerCase(); return ( lower.includes("client closed request") || lower.includes("client cancelled request") || lower.includes("client canceled request") || lower.includes("request canceled by client") || lower.includes("request cancelled by client") ); } /** * Ambiguous-reset refusal wording owned by this proxy (src/lib/upstream-retry.ts): * the upstream exchange did not complete reliably, so the request may already have * been processed and automatic replay was stopped. Matched narrowly so a * provider-sent message is never relabeled by it. */ export function isUpstreamResetReplayRefusedMessage(text: string): boolean { return text.toLowerCase().includes( "the upstream exchange did not complete reliably. the request may already have been processed", ); } export function classifyError(status: number, type: string, message: string): OcxErrorPayload { const text = message.toLowerCase(); if (type === "previous_response_not_found") { return { message, type: "invalid_request_error", code: "previous_response_not_found" }; } // Preserve explicit cancel types used by compact/combo JSON errors; unify message-inferred // client closes (web-search abort text) onto client_closed_request for /api/logs. if (type === "client_cancelled") { return { message, type: "client_cancelled", code: "client_cancelled" }; } if ( status === 499 || type === "client_closed_request" || isClientClosedMessage(text) ) { return { message, type: "invalid_request_error", code: "client_closed_request" }; } // Codex only shows the dedicated cyber UI when error.code === "cyber_policy". // The public wire does not establish invalid_request_error as the canonical type, so // message-only classification keeps the dedicated identity instead of inventing one. // Structured callers re-apply their real upstream type with cyberPolicyErrorType(). if (type === CYBER_POLICY_ERROR_CODE || isCyberPolicyMessage(text)) { return { message, type: CYBER_POLICY_ERROR_CODE, code: CYBER_POLICY_ERROR_CODE }; } // A LOCAL preflight refusal keeps its own code (#1524). The message necessarily says // "context window" -- that is what it is refusing on -- so the generic remap below would // rewrite it to `context_length_exceeded` and make it indistinguishable from an UPSTREAM // verdict. The two need opposite fallback handling: ours means "this candidate does not // fit", theirs means "the request is impossible", so collapsing them ended the chain at // the first candidate that was merely too small. if (type === "input_admission_refused") { return { message, type: "invalid_request_error", code: "input_admission_refused" }; } // A LOCAL inbound admission refusal (#3573) keeps its own code for the same reason as the // preflight refusal above. #4112 gave the UPSTREAM 413 on this surface // `context_length_exceeded`; without a distinct code here a client cannot tell a body the // proxy never read from a turn the provider itself rejected, and only one of the two is // fixed by raising `maxInboundBodyBytes`. if (type === "inbound_body_too_large") { return { message, type: "invalid_request_error", code: "inbound_body_too_large" }; } if ( text.includes("context_length_exceeded") || text.includes("context window") || text.includes("context length") || text.includes("maximum context") || text.includes("too many tokens") || (status === 400 && /\binput token count(?:\s*\([\d,]+\))?\s+exceeds\s+the maximum number of tokens allowed\b/.test(text)) ) { return { message, type: "invalid_request_error", code: "context_length_exceeded" }; } // "Cursor resource limit exceeded" is emitted only for explicit request-size overflow // details (isCursorRequestTooLargeDetail in cursor-errors.ts); "Cursor context limit // exceeded" is the bare payload-overflow shape (isCursorZeroTokenResourceExhausted); // quota-style resource exhaustion arrives as "Cursor rate limit exceeded" and falls // through to 429 below. if (text.includes("cursor resource limit exceeded")) { return { message, type: "invalid_request_error", code: "tool_catalog_too_large" }; } if (text.includes("cursor context limit exceeded")) { return { message, type: "invalid_request_error", code: "context_length_exceeded" }; } // The Cursor adapter's classified rate-limit prefix is authoritative: its DETAIL may echo // quota wording ("... quota exhausted") that would otherwise hit the insufficient_quota // branch below and break the planned retry-with-backoff contract (WP3 review blocker 1). if (text.includes("cursor rate limit exceeded")) { return { message, type: "rate_limit_error", code: "rate_limit_exceeded" }; } if ( text.includes("insufficient_quota") || text.includes("exceeded your current quota") || text.includes("quota exhausted") || text.includes("account quota exceeded") || text.includes("monthly quota exceeded") || text.includes("daily quota exceeded") ) { return { message, type: "insufficient_quota", code: "insufficient_quota" }; } // A refusal this proxy made itself, kept apart from the provider rate limits below. The HTTP // semantics are identical -- 429, do not send this again now -- but the code is the only thing // that tells an operator reading a log whether the provider throttled the request or whether // this process declined to send it. Folding it into the generic rate-limit code sent them to // the provider's dashboard to explain a decision that was never made there. if (type === SEND_BUDGET_EXHAUSTED_CODE) { return { message, type: "rate_limit_error", code: SEND_BUDGET_EXHAUSTED_CODE }; } if ( status === 429 || text.includes("rate limit") || text.includes("rate limited") || text.includes("too many requests") || text.includes("resource_exhausted") || text.includes("resource exhausted") || text.includes("throttlingexception") || text.includes("throttling") ) { return { message, type: "rate_limit_error", code: "rate_limit_exceeded" }; } if (type === "origin_rejected") { return { message, type: "invalid_request_error", code: "origin_rejected" }; } // Local ACL setup failures can contain provider-like auth wording (for example // "access denied" or "authentication") but represent unavailable infrastructure. if (status === 503 && isLocalAclHardeningMessage(text)) { return { message, type: "server_error", code: "upstream_server_error" }; } // HTTP 401 and explicit auth failures are authoritative even when provider text // also advertises an upgrade or subscription. if ( status === 401 || type === "authentication_error" || isAuthenticationMessage(text) ) { return { message, type: "authentication_error", code: "invalid_api_key" }; } // An explicit permission enum must not acquire a more specific inferred reason. if (type === "PERMISSION_DENIED" || text.includes("permission_denied")) { return { message, type: "permission_error", code: "permission_denied" }; } // Location denials outrank generic permission / subscription wording, but never an // authoritative 5xx. Message-only adapter terminals arrive here with inferred 403. if (status < 500 && (type === "location_not_supported" || isLocationUnsupportedMessage(text))) { return { message, type: "permission_error", code: "location_not_supported" }; } // Subscription labels are valid only in a known permission context. if ( (status === 403 || type === "permission_error") && isSubscriptionGateMessage(text) ) { return { message, type: "permission_error", code: "subscription_required" }; } if ( status === 403 || type === "permission_error" || isPermissionMessage(text) ) { return { message, type: "permission_error", code: "permission_denied" }; } if ( status === 503 || text.includes("overloaded") || text.includes("server is busy") || text.includes("temporarily unavailable") ) { // Codex recognizes "server_is_overloaded" and applies retry-after backoff // (responses.rs is_server_overloaded_error); generic "upstream_server_error" is not recognized. return { message, type: "server_error", code: "server_is_overloaded" }; } if ( text.includes("validationexception") || text.includes("invalid request") || text.includes("model unavailable") || text.includes("model not found") || text.includes("unsupported model") || text.includes("profile arn") || text.includes("wrong region") || text.includes("invalid region") ) { return { message, type: "invalid_request_error", code: "invalid_request_error" }; } if (status >= 500) { return { message, type: "server_error", code: "upstream_server_error" }; } if (status === 400 || type === "invalid_request_error") { return { message, type: "invalid_request_error", code: "invalid_request_error" }; } return { message, type, code: type || null }; } /** * True when a provider failure should participate in rate-limit / quota health blocking. * Reuses {@link classifyError} so generic 429 wording and quota phrases stay aligned. */ export function isRateLimitOrQuotaFailureMessage(message: string): boolean { const normalized = String(message ?? "").trim(); if (!normalized) return false; const numericStatus = Number(normalized); if (numericStatus === 429 || numericStatus === 402) return true; const statusHint = Number.isInteger(numericStatus) && numericStatus > 0 ? numericStatus : 0; const classified = classifyError(statusHint, "", normalized); if ( classified.type === "rate_limit_error" || classified.code === "rate_limit_exceeded" || classified.type === "insufficient_quota" || classified.code === "insufficient_quota" ) { return true; } // Retained quota cue used by subagent health before classifyError covered it. return normalized.toLowerCase().includes("usage limit"); } export { parseRetryAfterFromMessage }; /** Infer HTTP status from adapter terminal error text (provider-agnostic keyword matching). */ export function inferHttpStatusFromAdapterMessage(message: string): number { const lower = message.toLowerCase(); // Client aborts (e.g. mid web-search loop) must not look like upstream 502s in /api/logs. if (isClientClosedMessage(lower)) return 499; // Codex Transport maps cyber_policy only on HTTP 400 (SSE is code-based). if (isCyberPolicyMessage(lower)) return 400; // See classifyError: this prefix now only means explicit request-size overflow (400); // quota-style Cursor resource exhaustion carries the rate-limit prefix and maps to 429. if (lower.includes("cursor resource limit exceeded")) return 400; if (lower.includes("cursor context limit exceeded")) return 400; if ( lower.includes("resource_exhausted") || lower.includes("resource exhausted") || lower.includes("rate limit") || lower.includes("too many requests") || lower.includes("throttling") ) return 429; // Local Windows filesystem hardening is infrastructure, not provider authentication. // Keep this ahead of auth/permission and timeout keyword inference. if (isLocalAclHardeningMessage(lower)) return 503; // Strong authentication signals win when a message contains mixed auth and // subscription/permission wording. if (isAuthenticationMessage(lower)) return 401; // A location denial is a permission-class rejection; keep it aligned with the // `permission_error` envelope status so message-only and classified paths agree. if (isLocationUnsupportedMessage(lower)) return 403; if (isSubscriptionGateMessage(lower) || isPermissionMessage(lower)) return 403; // Same precedence rule as classifyCursorError: an explicit gRPC FAILED_PRECONDITION is a // structured, deterministic rejection, so it outranks the overload keywords that routinely // appear beside it ("failed_precondition: model unavailable for this plan"). Without this, // the message matched "unavailable" and returned a retryable 503, so clients kept retrying // a rejection that can never succeed. if (lower.includes("failed_precondition") || lower.includes("failed precondition")) return 400; // Bytes the upstream itself produced and then mangled are a provider protocol failure, not a // malformed client request. This must sit ahead of the generic "malformed" -> 400 branch so a // combo can fail over instead of returning a terminal 4xx the caller cannot act on. Scoped to // the "malformed upstream" phrase our adapters emit; plain "malformed" keeps its 400 verdict. if (lower.includes("malformed upstream")) return 502; if ( lower.includes("unavailable") || lower.includes("overloaded") || lower.includes("temporarily") || lower.includes("server is busy") ) return 503; if ( lower.includes("invalid") || lower.includes("not found") || lower.includes("unsupported") || lower.includes("malformed") || lower.includes("unimplemented") ) return 400; if ( lower.includes("timed out") || lower.includes("timeout") || lower.includes("etimedout") || lower.includes("deadline") ) return 504; return 502; } /** Map an adapter terminal error message to HTTP status + classified Codex error payload. */ export function adapterFailureFromMessage(message: string): { httpStatus: number; error: OcxErrorPayload } { const httpStatus = inferHttpStatusFromAdapterMessage(message); let finalMessage = message; const retryAfterSeconds = parseRetryAfterFromMessage(message); if (retryAfterSeconds && !/please try again in /i.test(message)) { finalMessage = `${message} Please try again in ${retryAfterSeconds}s.`; } const errorType = httpStatus === 499 ? "client_closed_request" : httpStatus === 429 ? "rate_limit_error" : httpStatus === 401 ? "authentication_error" : httpStatus === 403 ? "permission_error" : httpStatus === 503 || httpStatus === 504 ? "server_error" : httpStatus === 400 ? "invalid_request_error" : "upstream_error"; const error = classifyError(httpStatus, errorType, finalMessage); if (httpStatus === 429 && error.type === "rate_limit_error" && ["rate_limit_exceeded", "slow_down"].includes(error.code ?? "")) { error.message = formatRetryAfterAdvice(message) ?? error.message; } return { httpStatus, error }; } /** Map a terminal Responses error object to the HTTP status we record in /api/logs. */ export function httpStatusFromTerminalError(error: { type?: string; code?: string | null; message?: string; } | undefined): number { if (!error) return 502; if (error.code === "client_closed_request" || error.code === "client_cancelled") return 499; if (isCyberPolicyCode(error.code) || (error.message ? isCyberPolicyMessage(error.message) : false)) { return 400; } if (error.type === "rate_limit_error" || error.code === "rate_limit_exceeded") return 429; if (error.type === "authentication_error" || error.code === "invalid_api_key") return 401; if ( error.type === "permission_error" || error.code === "permission_denied" || error.code === "subscription_required" ) return 403; if (error.type === "insufficient_quota" || error.code === "insufficient_quota") return 429; if (error.type === "server_error" && error.code === "server_is_overloaded") return 503; // Client-closed messages often arrive as invalid_request_error after classifyError; check message // before treating every invalid_request_error as HTTP 400. const message = error.message ?? ""; if (message && isClientClosedMessage(message)) return 499; if (error.type === "invalid_request_error") return 400; if (error.type === "proxy_error") return 500; // A structured server class must not be downgraded to a CLIENT error by message wording. // classifyError assigns `server_error` + `upstream_server_error` to every 5xx it sees, so // the class is authoritative about blame: the upstream failed, the caller did not send a // bad request. What it is NOT authoritative about is which server status fits — a stall is // genuinely 504 and an overload genuinely 503, and flattening those to 502 discards // information both the log surface and the retry policy read. So message inference still // chooses the specific status, and only a client-error verdict is overridden. // // The override is deliberately narrowed to 400 alone. 429, 499, 401 and 403 are all // actionable signals the caller routes on — retry-after, client cancellation, re-auth, // entitlement — and overriding them would trade one kind of misreport for another. 400 is // the single verdict that both blames the caller and stops the retry, which is the failure // being fixed: an upstream 500 whose text happens to contain "malformed" or "invalid // request" used to return 400, so Claude Code stopped retrying a retryable failure. const structuredServerClass = error.type === "server_error" || error.code === "upstream_server_error"; if (message) { const inferred = inferHttpStatusFromAdapterMessage(message); return structuredServerClass && inferred === 400 ? 502 : inferred; } return 502; }