UNPKG

@bitkyc08/opencodex

Version:

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

220 lines (203 loc) • 9.3 kB
import { parseRetryAfterMs } from "../../combos"; import type { ConsumedComboFailure, HandleResponsesOptions } from "./core-options"; import type { OcxUsage } from "../../types"; import { readBoundedResponseBody } from "../../lib/bounded-body"; import { codexQuotaFailureMessage, codexQuotaOutcomeMeta } from "./core-codex-account"; import { isRateLimitOrQuotaFailureMessage, isCyberPolicyCode, isCyberPolicyMessage, CYBER_POLICY_ERROR_CODE, CYBER_POLICY_FALLBACK_MESSAGE, } from "../../lib/errors"; import { normalizeUpstreamErrorText } from "./core-errors"; import { resolveClientRetryAfter } from "../../lib/retry-after"; import { formatErrorResponse } from "../../bridge"; import { isNonReplayableResponse, markResponseNonReplayable } from "../../lib/upstream-retry"; import { usageFromResponsesPayload } from "../request-log"; import type { ResponsesTerminalStatus } from "../../bridge"; export function sanitizedRetryAfter(value: string | null, now: number): string | undefined { const trimmed = value?.trim(); if (!trimmed || trimmed.length > 128) return undefined; return parseRetryAfterMs(trimmed, now) !== undefined ? trimmed : undefined; } export async function consumeComboFailure( response: Response, signal?: AbortSignal, now = Date.now(), ): Promise<ConsumedComboFailure> { // Read before the body: the marker lives on this Response object, and the failure below is // rebuilt as a new one that would otherwise lose it. const nonReplayable = isNonReplayableResponse(response); const fallback = `Provider error ${response.status}`; let classificationText = fallback; let usage: OcxUsage | undefined; let upstreamCode: string | undefined; let upstreamMessage: string | undefined; let upstreamType: string | undefined; // Whether the body itself confirms a quota/rate-limit refusal, computed on the SAME read as // the classification below. `shouldRetryCodexPoolAccountQuota` cannot be called here without // a second body read, so this mirrors its normalization: raw 402/429, or a 5xx whose intact, // display-safe body carries a recognized quota message. let quotaConfirmedByBody = false; const serverError = response.status >= 500 && response.status < 600; try { const body = await readBoundedResponseBody(response, { signal, reportUtf8Validity: serverError }); // A 5xx body counts as quota or classification evidence only when it decoded as valid // UTF-8, matching shouldRetryCodexPoolAccountQuota. A malformed byte keeps the status-only // fallback, with one exception: a cyber-policy refusal must still stop the combo, so the // replacement-decoded text may carry that verdict and nothing else. const utf8Trusted = !serverError || body.utf8Valid === true; if (utf8Trusted) usage = usageFromComboFailureText(body.text); if (serverError && utf8Trusted && body.displaySafe && !body.truncated) { const quotaMessage = codexQuotaFailureMessage(body.text); quotaConfirmedByBody = quotaMessage !== undefined && isRateLimitOrQuotaFailureMessage(quotaMessage); } if (body.displaySafe && !body.truncated) { const normalized = normalizeUpstreamErrorText(body.text, fallback); if (utf8Trusted || isCyberPolicyCode(normalized.code) || isCyberPolicyMessage(normalized.safeText)) { classificationText = normalized.safeText; upstreamCode = normalized.code; upstreamMessage = normalized.message; upstreamType = normalized.type; } } } catch (error) { if (signal?.aborted) throw error; classificationText = fallback; } const cyberFailure = isCyberPolicyCode(upstreamCode) || isCyberPolicyMessage(classificationText); const normalizedUpstreamCode = cyberFailure ? CYBER_POLICY_ERROR_CODE : upstreamCode; const message = cyberFailure ? upstreamMessage ?? (isCyberPolicyCode(upstreamCode) ? CYBER_POLICY_FALLBACK_MESSAGE : classificationText) : classificationText === fallback ? fallback : `${fallback}: ${classificationText}`; const upstreamRetryAfter = response.headers.get("retry-after"); // Past HTTP dates are an immediate retry directive, just like the numeric value zero. // Normalize before the client helper discards them and substitutes a default delay. const effectiveRetryAfter = parseRetryAfterMs(upstreamRetryAfter, now) === undefined && parseRetryAfterMs(upstreamRetryAfter, now, { preserveImmediate: true }) !== undefined ? "0" : upstreamRetryAfter; // Client response may get the synthetic "2" fallback; cooldown metadata must not — // otherwise coolComboTarget treats it as a 2s cooldown instead of the 60s default. const clientRetryAfter = resolveClientRetryAfter({ status: response.status, message, upstreamRetryAfter: effectiveRetryAfter, now, }); const cooldownRetryAfter = resolveClientRetryAfter({ status: response.status, message, upstreamRetryAfter: effectiveRetryAfter, now, includeDefault: false, }); const failureResponse = formatErrorResponse( response.status, cyberFailure ? (upstreamType ?? CYBER_POLICY_ERROR_CODE) : "upstream_error", message, { ...(normalizedUpstreamCode !== undefined ? { code: normalizedUpstreamCode } : {}), ...(clientRetryAfter !== undefined ? { retryAfter: clientRetryAfter } : {}), }, ); if (nonReplayable) markResponseNonReplayable(failureResponse); return { response: failureResponse, ...(nonReplayable ? { nonReplayable: true } : {}), classificationText, ...(normalizedUpstreamCode !== undefined ? { upstreamCode: normalizedUpstreamCode } : {}), ...(upstreamType !== undefined ? { upstreamType } : {}), ...(!cyberFailure && cooldownRetryAfter !== undefined ? { retryAfter: cooldownRetryAfter } : {}), // The EFFECTIVE classification decides, not the raw status. An upstream that wraps a quota // refusal in a 5xx still carries `x-codex-*-reset-at`, and gating on 402/429 alone threw // those away, so the combo target came back up immediately instead of waiting for the // window it was told about. `cyberFailure` stays excluded: a policy block is not a quota. ...(!cyberFailure && (response.status === 429 || response.status === 402 || quotaConfirmedByBody) ? { resetAt: codexQuotaOutcomeMeta(response).resetAt } : {}), ...(usage ? { usage } : {}), }; } export function usageFromComboFailureText(text: string): OcxUsage | undefined { try { const payload = JSON.parse(text) as Record<string, unknown>; const nested = payload.response; const source = nested && typeof nested === "object" && !Array.isArray(nested) ? nested as Record<string, unknown> : payload; return usageFromResponsesPayload(source.usage); } catch { return undefined; } } export function createChildPassthroughCallbackGate(options: HandleResponsesOptions) { type Pending = | { kind: "terminal"; status: ResponsesTerminalStatus } | { kind: "cancel" }; let state: "pending" | "committed" | "discarded" = "pending"; let pending: Pending | undefined; let accepted = false; let pendingModel: string | undefined; let completionAccepted = false; let completionRejected = false; const publish = (value: Pending): void => { if (value.kind === "terminal") options.onNativePassthroughTerminal?.(value.status); else options.onNativePassthroughCancel?.(); }; const publishCompletion = (): void => { if (state !== "committed" || completionRejected || pendingModel === undefined) return; const model = pendingModel; pendingModel = undefined; options.onResponseComplete?.(model); }; const receive = (value: Pending): void => { if (state === "discarded" || accepted) return; accepted = true; if (value.kind === "cancel" || value.status !== "completed") { completionRejected = true; pendingModel = undefined; } if (state === "committed") return publish(value); pending ??= value; }; return { onTerminal: (status: ResponsesTerminalStatus) => receive({ kind: "terminal", status }), onCancel: () => receive({ kind: "cancel" }), onResponseComplete: (model: string) => { if (state === "discarded" || completionRejected || completionAccepted || !model.trim()) return; completionAccepted = true; pendingModel = model; publishCompletion(); }, commit: () => { if (state !== "pending") return; state = "committed"; if (pending) publish(pending); pending = undefined; publishCompletion(); }, discard: () => { state = "discarded"; pending = undefined; pendingModel = undefined; }, }; } export function buildComboChildHeaders(parentHeaders: HeadersInit): Headers { const childHeaders = new Headers(parentHeaders); // A provisional caller credential is not authoritative for a Combo child. childHeaders.delete("authorization"); childHeaders.delete("chatgpt-account-id"); // Combo children re-serialize already-decoded JSON. Keeping transport metadata from // the parent would make the child decoder treat plain JSON as compressed bytes. childHeaders.delete("content-length"); childHeaders.delete("content-encoding"); return childHeaders; }