@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
1,993 lines • 115 kB
text/typescript
import { projectLocalModelRefusalLog, recordUpstreamProviderErrorDetail } from "../request-log-failure-detail";
import { providerAffinityGenerationIsCurrent } from "../../providers/api-key-selection";
import { clientFacingModelText } from "../../lib/error-destination";
import { createAnthropicImageRecovery, recoverAdapterImageContext, retainAdapterFailureResponse } from "./image-context-recovery";
import { responsesSpendTarget } from "./request-spend-target";
import { bindAdapterResponseSpend } from "./request-spend";
import { markProxyError, isProxyError } from "../../lib/client-error-body";
import { adapterBuildRefusal } from "./passthrough-build-error";
import { createAutoPauseRefreshErrorMapper, recoverAutoPausedAccount } from "./account-auto-pause-recovery";
import { wasAccountAutoPaused, wasPermanentAccountRefusal } from "../../oauth/account-auto-pause";
import { effectiveAccountAutoPause } from "../../config/account-auto-pause-revisions";
import { bindAnthropicRejectionResponse } from "../../adapters/anthropic-rejection-memo";
import { hostedAdvisorCredentials } from "../../adapters/anthropic/advisor-tool";
import { deferPhysicalSendReporter } from "./deferred-send-reporter";
import { usesApiKeyAccount } from "../../providers/label";
import { spendLedgerStorageErrorResponse } from "./spend-storage-error";
import { classifyAnthropic429 } from "../../oauth/anthropic-rate-limit-policy";
import { anthropicRefusalCredentialChanged, rotateAnthropicAccountOnResponseForInstance } from "../../oauth/anthropic-account-refusal";
import { authorizeResendForRecovery } from "../../lib/request-resend-gate";
import { ambiguousResendAllowanceFor, selfContainedResponsesBody } from "./reset-replay";
import { transientSendCapFor, type ResponsesSendBudget } from "./request-send-budget";
import { sanitizeNonReplayableUpstreamError } from "./non-replayable-error";
import { isLocalUpstream } from "../../lib/local-upstream";
import { providerConnectTimeoutMs, providerStallTimeoutSec, resolveConnectTimeoutMs, resolveStallTimeoutMs } from "../../stall-timeout";
import { responsesTimeoutProvider, type ResponsesRequestContext, type ResponsesAdmissionState } from "./core-options";
import type { PreparedResponsesRequest } from "./request-prepare";
import type { ResponsesTransport } from "./request-transport";
import type { ResponsesEffects } from "./response-effects";
import { linkAbortSignal } from "./core-lifetime";
import type { AdapterRequest } from "../../adapters/base";
import type { AdapterEvent } from "../../types";
import { bridgeToResponsesSSE, buildResponseJSON, formatErrorResponse, formatUpstreamFailureResponse } from "../../bridge";
import { trackStreamLifetime } from "../lifecycle";
import {
recordAdapterReasoning,
recordAdapterTier,
sealRequestAttemptIdentity,
recordAttemptCredentialSource,
} from "../request-log";
import { credentialRecoveryStatus } from "../request-log-attempt-recovery";
import { anthropicPoolCooldownResponse, clientCancelledResponse, readDisplaySafeErrorText } from "./core-errors";
import { isTranslatorBudgetExceededError } from "../../lib/translator-budget";
import { redactSecretString } from "../../lib/redact";
import { rewriteUpstreamPolicyRefusal } from "./policy-refusal";
import { carryPolicyCandidateRefusal, HostedAdvisorSpendRefusal } from "./policy-request-scope";
import { withProviderRequestSlot } from "../../providers/request-pacing";
import { providerFetch, fetchWithHeaderTimeout, safeHostLabel } from "./fetch-helpers";
import { isAnthropicBillingKeyPool, rotateAnthropicBillingKeyOnResponse } from "../../providers/anthropic-billing-recovery";
import {
transientRetryPolicyFor,
resetReplayPolicyFor,
rateLimitRetryPolicyFor,
hasKeyPoolFailover,
rotateProviderTransportOn401,
rateLimitRetryDelayMs,
readQuotaResetAt,
rotateProviderTransportOn429,
} from "../../providers/key-failover";
import {
fetchWithTransientRetry,
fetchWithResetRetry,
isNonReplayableResponse, isSameTargetRetryHold,
applyUpstreamRecoveryInit,
SendBudgetExhaustedError, errorDestinationLabel,
UpstreamRetryEvidenceError,
prepareSameTarget429Wait,
sleepWithAbort, RESET_RETRY_MAX_ATTEMPTS,
} from "../../lib/upstream-retry";
import { describeUpstreamConnectFailure } from "./upstream-error";
import { createProviderOfflineResendWait } from "../../lib/offline-resend";
import type { OpaqueBlobRecoveryGuard } from "./core-opaque-recovery";
import type { AttemptRecoveryKind } from "../../usage/log";
import type { OAuthAccessSnapshot } from "../../oauth";
import { publicOAuthErrorPresentation, OAuthAccountPausedError, OAuthLoginRequiredError, OAuthTokenRefreshBusyError, publicOAuthAuthenticationErrorMessage } from "../../oauth";
import { getAccountSet, markAccountNeedsReauthIfGeneration } from "../../oauth/store";
import { tryKiroAlternateAfterTerminalRefresh } from "../../oauth/kiro-terminal-failover";
import { classifyKiroRefusal } from "../../adapters/kiro-refusal";
import { normalizeFinalKiroHttpError } from "../../adapters/kiro-retry";
import { noteKiroMonthlyRefusal } from "../../providers/kiro-usage";
import { persistKiroAccountState } from "../../providers/kiro-account-state-disk";
import { isXaiGrokOAuth, isXaiLegacyPrivacyError, xaiPrivacyModeRefusal } from "../../providers/xai-privacy-mode";
import { isXaiResponsesDestination, resolveProviderTransport } from "../../providers/xai-transport";
import { resolveCopilotApiBaseUrl } from "../../oauth/github-copilot";
import { resolveWireProtocolOverride } from "../adapter-resolve";
import { bindRouteReasoningReplayScope } from "./core-replay";
import {
AnthropicAccountCooldownError,
anthropicRoutingFor,
formatAnthropicProviderForLog,
} from "../../oauth/anthropic-routing";
import {
isGenericOAuthFailoverEnabled,
rotateGenericOAuthAccountOn429,
rotateGenericOAuthAccountOnRefusal,
quarantineKiroSuspendedAccount,
failoverAccountSnapshot,
rotateAntigravityAccountOnAuthRefusal,
rotateAntigravityAccountOnUpstreamFault,
} from "../../oauth/generic-account-failover";
import {
attemptOpaqueBlobRecovery,
consoleGoUploadRejectionBody,
CONSOLE_GO_UPLOAD_RETRY_DELAY_MS,
refusedReasoningEffortDowngrade,
anthropicFastRefused,
} from "./core-opaque-recovery";
import { createAnthropicThinkingRecovery } from "./anthropic-thinking-recovery";
import { shouldAttemptImageTierRetry } from "../image-retry";
import { isTransientConsoleGoUploadRejection } from "../../providers/opencode-zen-rate-limit";
import { formatAdapterUpstreamFailure } from "./adapter-failure-message";
import { consumeComboFailure } from "./core-combo-failure";
import { streamingContextOverflowResponse, jsonContextOverflowResponse, lateAttributionLimitResponse } from "./context-overflow";
import { OllamaLateAttributionBudgetError } from "../../adapters/ollama-native";
import { isFixedCodexAccount } from "./core-codex-account";
import { recordSubagentQuotaFailureForThreadSpawn } from "../../codex/subagent-model-fallback";
import { CYBER_POLICY_ERROR_CODE } from "../../lib/errors";
import { resolveClientRetryAfter } from "../../lib/retry-after";
import { cancelBodyOnAbort } from "../../lib/abort";
import { createCodexAuthDispatchGuard, releaseCodexAuthContextProbeLease, unwrapUpstreamRetryEvidenceError } from "../../codex/auth-context";
import { isCanonicalOpenAiForwardProvider } from "../../providers/openai-tiers";
import { mapCodexAuthContextErrorToResponse } from "./codex-auth-error";
import { chargeWorkflowSends } from "../../lib/workflow-budget";
import { hasWorkflowSendObserver } from "../../lib/request-execution-budget";
import { captureAntigravityQuarantineTrust, classifyAntigravityQuarantine, isAntigravityAccessDeniedRefusal, isAntigravityValidationRefusal } from "./antigravity-validation-refusal";
import { createAntigravityModelDenialRecovery, recoverAntigravityAccount } from "./antigravity-model-denial-recovery";
import { isAntigravityFaultRotatable } from "./antigravity-fault-rotation";
import { adapterSendBudgetRefusal } from "../workflow-refusal";
import { AdmissionModelDeniedError, admissionModelDeniedResponse, projectAdmissionModelDeniedLog } from "../admission-model-scope";
import { rejectAnthropicPerMessageEffort } from "../../adapters/anthropic/per-message-effort";
/** One responsibility of the Responses request pipeline; state owners are explicit. */
export async function prepareAdapterExchange(
requestContext: Pick<ResponsesRequestContext, "options" | "config" | "logCtx" | "req">,
admissionState: ResponsesAdmissionState,
requestState: Pick<
PreparedResponsesRequest,
| "parsed"
| "toolBridgeMaps"
| "translatorBudget" | "completedToolBlocks"
| "selectedForwardHeaders"
| "route"
| "inboundWire"
| "clientRequestedStream"
| "subagentQuotaFailureModel"
| "subagentFallbackAccountId"
>,
transportState: Pick<
ResponsesTransport,
| "activeAdapter"
| "adapter"
| "pinAnthropicImageRecovery"
| "sameTargetRequest"
| "sameTargetParsed"
| "sameTargetToken"
| "transportToken"
| "oauthDispatch"
| "recoverAutoPausedSelection"
| "imageTierBias"
| "oauth401ReplayAttempted"
| "isOAuth401ReplayProvider"
| "sentOAuthSnapshot"
| "refreshResolvedOAuthSelection"
| "replayOAuthCredentialSnapshot"
| "invalidateSameTargetRequest"
| "resolveSelectionAdapter"
| "resolveCopilotSelection"
| "copilotRefusalResponse"
| "anthropicInstance"
| "currentAnthropicRouteDecision"
| "anthropicRouteDecision"
| "anthropicPoolAccountId"
| "anthropicPoolFailovers"
| "anthropicSessionKey"
| "commitResolvedOAuthSelection"
| "genericFailoverAccountId"
| "genericFailovers"
| "genericFailoverLimit" | "anthropicFailoverLimit"
| "applyFailoverSnapshot"
| "noteRoutedAttemptSend" | "attemptSendDeferred" | "deferPhysicalAttribution" | "commitAdapterAttemptSend"
| "createCredentialReplayAttempt" | "credentialReplayHandoff"
>,
responseEffects: Pick<ResponsesEffects, "cancelResponseCompletion" | "notifyResponseComplete" | "refreshRequestToolAliases">,
sendBudgetState: Pick<
ResponsesSendBudget,
| "adapterSendBudget"
| "adapterDispatchBudget"
| "noteAdapterPhysicalSend"
| "noteAdapterRecoveryWithheld"
| "imageRecoverySendReporter"
| "remainingTransientSendBudget"
| "transientSendReporter"
| "recoverySendAllowance"
| "recoveryClassFor"
| "sendBudgetExhausted"
| "reserveCredentialHop"
| "pendingHopPermit"
| "workflowRootId"
| "claimAmbiguousResend"
| "sendsUsed"
| "targetSendsUsed"
| "compactHandoffSendCeiling"
| "initialSendAllowance"
| "noteInitialDispatch"
>,
) {
const { options, config, logCtx, req } = requestContext;
const {
oauthDispatch,
isOAuth401ReplayProvider,
refreshResolvedOAuthSelection,
invalidateSameTargetRequest,
resolveSelectionAdapter,
resolveCopilotSelection,
copilotRefusalResponse,
anthropicInstance,
currentAnthropicRouteDecision,
anthropicSessionKey,
commitResolvedOAuthSelection,
applyFailoverSnapshot,
} = transportState;
const {
parsed,
toolBridgeMaps,
translatorBudget,
route,
inboundWire,
clientRequestedStream,
subagentQuotaFailureModel,
} = requestState;
const { cancelResponseCompletion, notifyResponseComplete, refreshRequestToolAliases } = responseEffects;
const {
adapterSendBudget,
adapterDispatchBudget,
noteAdapterPhysicalSend,
noteAdapterRecoveryWithheld,
remainingTransientSendBudget,
transientSendReporter,
recoverySendAllowance,
recoveryClassFor,
sendBudgetExhausted,
reserveCredentialHop,
claimAmbiguousResend,
} = sendBudgetState;
let selfContainedJudgment: boolean | undefined;
// On the Antigravity direct lane the raw body carries only settings; judge the body the bridge
// would have sent, built only if an ambiguous reset actually asks.
const directRequest = options.directRequest;
const requestIsSelfContained = (): boolean =>
selfContainedJudgment ??= selfContainedResponsesBody(directRequest
? { ...(parsed._rawBody as Record<string, unknown>), ...directRequest.bridgeConversation() }
: parsed._rawBody);
const claimPreHeaderResend = (): boolean => authorizeResendForRecovery(
"pre-header", "connection-reset",
ambiguousResendAllowanceFor(route.provider, requestIsSelfContained, claimAmbiguousResend),
).allowed;
const upstream = new AbortController();
const cleanupUpstreamAbort = linkAbortSignal(upstream, options.abortSignal);
/** Contain replacement negotiation before adapter admission and release its upstream abort link. */
const resolveRotatedCopilotSelection = async (provider = route.provider): Promise<Response | undefined> => {
try { await resolveCopilotSelection(parsed, false, provider); }
catch (error) {
cleanupUpstreamAbort();
upstream.abort();
if ((options.abortSignal ?? req.signal).aborted) return clientCancelledResponse();
return copilotRefusalResponse(error)
?? formatErrorResponse(502, "upstream_error", "GitHub Copilot Auto negotiation failed.");
}
};
// Trusted local upstreams default to no stall timeout.
const localUpstream = isLocalUpstream(route.provider.baseUrl);
// Header arrival and body silence are separate clocks (structure/transports/timeouts.md).
const connectTimeoutMs = () => providerConnectTimeoutMs(config, responsesTimeoutProvider(options, route.provider));
const connectMs = resolveConnectTimeoutMs(connectTimeoutMs(), { localUpstream });
const sendConnectMs = () => route.provider.authMode === "forward" ? resolveConnectTimeoutMs(connectTimeoutMs(), { localUpstream: isLocalUpstream(route.provider.baseUrl) }) : 0;
transportState.activeAdapter = transportState.adapter;
const antigravityPoolActivated = route.providerName === "google-antigravity"
&& isGenericOAuthFailoverEnabled(config, route.providerName);
const antigravityDenial = createAntigravityModelDenialRecovery();
const antigravityQuarantineTrust = captureAntigravityQuarantineTrust(route.providerName);
// One immutable, body-safe outbound request per same-target sequence (URL, serialized body,
// Reuse the cached body while the parsed request, credential, wire and tier are unchanged.
const handoffReplay = transportState.credentialReplayHandoff;
transportState.credentialReplayHandoff = undefined;
let initialRequest: AdapterRequest | undefined;
let inputTokenEstimate: number | undefined;
// An adapter may know the turn needs no inference at all — Kiro's replayed history ending in a
// delivered final answer. Answer it locally: no build (so no token estimate), no send (so
// sendCount stays 0), and crucially no empty-completion guard, which treats an outputless
// terminal as a failed turn and re-invokes the identical request. Routing this through the
// ordinary event path would therefore reinstate the loop it exists to end.
const localTerminal = transportState.activeAdapter.localTerminal?.(parsed);
if (localTerminal) {
logCtx.localTerminalReason = localTerminal.reason;
// Mark the physical attempt too, not just the parent row. `finishRequestAttempt` finalizes the
// attempt through the same estimated-provider path, so without this the row reads exact while
// its own attempt still claims an estimate — the detailed accounting a maintainer actually
// reads for a zero-send turn.
if (logCtx.activeAttempt) logCtx.activeAttempt.locallyAnswered = true;
cleanupUpstreamAbort();
upstream.abort();
const terminalEvents: AdapterEvent[] = [{
type: "done",
endTurn: true,
usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
}];
if (parsed.stream) {
const localSse = bridgeToResponsesSSE(
(async function* () { yield* terminalEvents; })(),
parsed._responseModelId ?? parsed.modelId,
toolBridgeMaps.toolNsMap,
toolBridgeMaps.freeformToolNames,
toolBridgeMaps.toolSearchToolNames,
cancelResponseCompletion,
2_000,
{
translatorBudget,
onCompletedResponse: notifyResponseComplete,
...(options.forceEmptyResponseId ? { responseId: "" } : {}),
...(options.onFirstOutput ? { onFirstOutput: options.onFirstOutput } : {}),
},
);
// Same lifetime tracking as every other streaming return in this function: the turn
// admission lease is released when the body finishes or the client disconnects. Returning
// the raw stream would hold a lease for a turn that already has all of its output.
const localTurnAc = new AbortController();
return new Response(
trackStreamLifetime(localSse, localTurnAc, undefined, options.turnAdmissionLease),
{
headers: {
"Content-Type": "text/event-stream",
"Cache-Control": "no-cache",
"Connection": "keep-alive",
"X-Accel-Buffering": "no",
},
},
);
}
const json = buildResponseJSON(terminalEvents, parsed._responseModelId ?? parsed.modelId, { translatorBudget });
notifyResponseComplete(json);
return new Response(JSON.stringify(json), { headers: { "Content-Type": "application/json" } });
}
try {
initialRequest = await transportState.activeAdapter.buildRequest(parsed, {
headers: requestState.selectedForwardHeaders, completedToolBlocks: requestState.completedToolBlocks,
providerName: route.providerName,
translatorBudget,
abortSignal: upstream.signal,
});
refreshRequestToolAliases(initialRequest);
if (!handoffReplay && !transportState.activeAdapter.fetchResponse) {
recordAdapterReasoning(logCtx, initialRequest); recordAdapterTier(logCtx, initialRequest);
}
inputTokenEstimate = typeof initialRequest.usageLog?.inputTokens === "number"
? initialRequest.usageLog.inputTokens
: undefined;
if (!handoffReplay && inputTokenEstimate !== undefined) logCtx.usageLogInputTokens = inputTokenEstimate;
} catch (err) {
// A throwing buildRequest never returned a request; if a post-build step threw, release
// the serialized-body observation (idempotent) so the translator budget is not leaked.
// The build runs after linkAbortSignal, so a failure must also tear the link down and
// abort the upstream controller instead of escaping handleResponses unmapped.
initialRequest?.releaseBodyObservation?.();
cleanupUpstreamAbort();
upstream.abort();
if (options.abortSignal?.aborted) return clientCancelledResponse();
if (err instanceof OllamaLateAttributionBudgetError) return lateAttributionLimitResponse();
// An adapter can also throw the shared translator budget while sizing generated
// request content (e.g. Ollama late-tool attribution); keep its established 413.
if (isTranslatorBudgetExceededError(err)) {
return formatErrorResponse(413, "request_too_large", "request translation buffer exceeded the safe limit", {
code: "translation_buffer_limit",
});
}
const buildRefusal = adapterBuildRefusal(err, admissionState.authCtx, route.codexAccountNamespace);
if (buildRefusal) return buildRefusal;
const msg = err instanceof Error ? err.message : String(err);
return formatErrorResponse(400, "invalid_request_error", redactSecretString(msg));
}
// The catch path above always returns, so the request is definitely assigned here.
// Capture it in a const so the fetch callbacks read a narrowed, immutable value
// (TypeScript drops narrowing for a `let` captured by a nested function).
const builtInitialRequest = initialRequest;
type CredentialReplay = ReturnType<typeof transportState.createCredentialReplayAttempt>;
transportState.sameTargetRequest = builtInitialRequest;
transportState.sameTargetParsed = parsed;
transportState.sameTargetToken = transportState.transportToken;
const initialRecovery = route.providerName === "github-copilot"
? sendBudgetState.pendingHopPermit?.sendClass === "auth-recovery" ? "oauth-account-429"
: transportState.oauth401ReplayAttempted ? "oauth-401" : undefined
: undefined;
let upstreamResponse: Response;
const retainFailureResponse = async () => upstreamResponse = (await retainAdapterFailureResponse(upstreamResponse, upstream.signal)).response;
const imageRecovery = route.provider.anthropicImageContextRecovery === true && transportState.activeAdapter.name === "anthropic"
? createAnthropicImageRecovery(requestContext, requestState, transportState, sendBudgetState, connectMs)
: undefined;
const autoPauseEnabled = effectiveAccountAutoPause(config.providers[route.providerName]) !== undefined;
const billingPoolRequest = isAnthropicBillingKeyPool(route.provider);
// Hosted Advisor revalidates the credential after the upstream rewrite, before the receipt.
const shouldDeferGenericSend = (request: AdapterRequest) => billingPoolRequest
|| (route.providerName === "github-copilot" && route.provider.authMode !== "forward")
|| hostedAdvisorCredentials.has(request);
let billingRecoveryActive = false;
const reserveCompactRetrySpend = () => sendBudgetState.compactHandoffSendCeiling !== undefined
&& sendBudgetState.adapterSendBudget?.spendEnforced === true;
const genericRefetchCountsSends = () => !!sendBudgetState.workflowRootId || options.comboAttempt === true || sendBudgetState.adapterSendBudget?.spendEnforced === true
|| transientRetryPolicyFor(route.provider) !== null || resetReplayPolicyFor(route.provider) !== null
|| !!anthropicInstance || billingPoolRequest || billingRecoveryActive || autoPauseEnabled || imageRecovery !== undefined;
let handoffPermit: ResponsesSendBudget["pendingHopPermit"];
try {
if (transportState.activeAdapter.fetchResponse) {
let published = false;
const publish = (): void => {
if (published) return;
if (handoffReplay) handoffReplay(builtInitialRequest, transportState.activeAdapter.name);
else transportState.commitAdapterAttemptSend(builtInitialRequest, transportState.activeAdapter.name, initialRecovery);
published = true;
};
const producer = adapterDispatchBudget?.beginSpendProducer?.();
try {
upstreamResponse = await withProviderRequestSlot(route.providerName, route.provider, route.modelId, upstream.signal, pacingSlot =>
transportState.activeAdapter.fetchResponse!(builtInitialRequest, {
kiroPreferAccountFailover: route.providerName === "kiro" && isGenericOAuthFailoverEnabled(config, "kiro"),
abortSignal: upstream.signal,
timeoutMs: sendConnectMs(),
sendBudget: adapterDispatchBudget,
onPhysicalSend: send => {
if (transportState.activeAdapter.reportsPhysicalSends) publish();
antigravityDenial.beforeSend(); noteAdapterPhysicalSend(inputTokenEstimate, send);
},
onRecoveryWithheld: noteAdapterRecoveryWithheld,
stream: parsed.stream,
executor: providerFetch(route.provider, options.codexWsRuntimeIdentity, {
pacingSlotAcquired: true,
pacingSlot,
dispatchOverride: oauthDispatch(builtInitialRequest, parsed, "adapter", true),
onPhysicalDispatch: publish,
providerName: route.providerName,
modelId: route.modelId,
beforeDispatch: isCanonicalOpenAiForwardProvider(route.provider)
? createCodexAuthDispatchGuard(admissionState.authCtx, options.codexAuthPolicy ?? config, route.modelId, options.admission, options.visionDescribeTerminal === true) : undefined,
}),
}));
} finally { producer?.close(); }
} else {
// #1851 scope guard: transient-5xx retry on this generic adapter path is opt-in for
// direct Google AI Studio only (Vertex/Antigravity use fetchResponse above). Other
// adapters keep reset-only retry so combo failover still hops on the first 5xx
// instead of burning ~1.2s of same-target retries per hop.
// #2643: an opted-in key-auth openai-chat provider also gets transient-5xx retry. The
// legacy direct-Google exception is preserved exactly; every other adapter still keeps
// reset-only semantics so combo failover hops on the first 5xx.
const transientPolicy = transientRetryPolicyFor(route.provider);
const resetPolicy = resetReplayPolicyFor(route.provider);
// Rebook a native Copilot hop against the negotiated destination before dispatch.
// Raw externally counted permits settle through the retry helper's send reporter.
if (route.providerName === "github-copilot" && adapterSendBudget && sendBudgetState.pendingHopPermit
&& sendBudgetState.pendingHopPermit.sendClass === "auth-recovery") {
const original = sendBudgetState.pendingHopPermit;
sendBudgetState.pendingHopPermit = undefined;
original.release();
const decision = adapterSendBudget.reserveDispatch({
sendClass: original.sendClass,
targetKey: `${route.providerName}|${builtInitialRequest.url}|${route.modelId}`,
countedExternally: true,
});
if (!decision.allowed) throw new SendBudgetExhaustedError(errorDestinationLabel(builtInitialRequest.url));
handoffPermit = decision.permit;
}
const compactPrepaid = handoffPermit ?? (options.compactionRecoveryAttempted ? sendBudgetState.pendingHopPermit : undefined);
if (compactPrepaid) sendBudgetState.pendingHopPermit = undefined;
let compactPrepaidUsed = false;
// A combo-owned or compaction-prepaid send is settled by the physical-dispatch receipt
// when spend enforcement is off. Enforced spend and direct requests keep the shared
// physical-send reporter, which already owns the permit lifecycle there.
// Stable per request: a Combo or compaction permit comes from `reserveDispatch`, which starts
// (and freezes) the spend policy first, so `spendEnforced` cannot change before dispatch.
const receiptMode = !sendBudgetState.adapterSendBudget?.spendEnforced
&& Boolean(options.comboInitialSend || compactPrepaid);
// Combo and emergency compaction admission already book this target's first send.
// Its configured initial ceiling is target-local; the shared remainder below still
// accounts for earlier targets without deducting their sends from this target twice.
const initialSendCap = transientPolicy || resetPolicy
|| (options.comboAttempt && route.provider.adapter === "google")
? transientSendCapFor(transientPolicy?.attempts,
(options.comboAttempt || compactPrepaid) ? 0 : sendBudgetState.sendsUsed)
// Anthropic sends are counted for the funded roster, not narrowed: keep the reset ladder.
: anthropicInstance && !options.comboAttempt && !compactPrepaid && !autoPauseEnabled ? RESET_RETRY_MAX_ATTEMPTS : 1;
const fetchWithRetryPolicy = (route.provider.adapter === "google" || transientPolicy)
? fetchWithTransientRetry
: fetchWithResetRetry;
const initialReporter = transientSendReporter(compactPrepaid ?? options.comboDispatchPermit);
const deferredInitial = !receiptMode && shouldDeferGenericSend(builtInitialRequest) ? deferPhysicalSendReporter(initialReporter) : undefined;
try { upstreamResponse = await fetchWithRetryPolicy(
recovery => {
// Unconfigured generic sends may omit the counting reporter. Capture policy
// independently so a later recovery still belongs to this request's start.
sendBudgetState.adapterSendBudget?.startRequest?.(responsesSpendTarget(logCtx, route.providerName));
// Receipt mode books the physical send at executor admission instead of here.
if (!deferredInitial && !receiptMode && compactPrepaid && !compactPrepaidUsed) {
if (!compactPrepaid.use()) throw new SendBudgetExhaustedError(errorDestinationLabel(builtInitialRequest.url));
compactPrepaidUsed = true;
}
// Key transport keeps this metadata pending until it binds the actual selection.
if (!handoffReplay) transportState.noteRoutedAttemptSend(inputTokenEstimate, recovery ?? initialRecovery);
return fetchWithHeaderTimeout(builtInitialRequest.url, applyUpstreamRecoveryInit({
method: builtInitialRequest.method,
headers: builtInitialRequest.headers,
body: builtInitialRequest.body,
}, recovery), upstream.signal, sendConnectMs(), parsed.stream,
providerFetch(route.provider, options.codexWsRuntimeIdentity, {
dispatchOverride: oauthDispatch(builtInitialRequest, parsed, "adapter", Boolean(handoffReplay)),
providerName: route.providerName,
modelId: route.modelId,
onPhysicalDispatch: () => {
if (deferredInitial) {
if (!deferredInitial.beforeDispatch()) throw new SendBudgetExhaustedError(errorDestinationLabel(builtInitialRequest.url));
if (compactPrepaid && !compactPrepaidUsed) {
if (!compactPrepaid.use()) throw new SendBudgetExhaustedError(errorDestinationLabel(builtInitialRequest.url));
compactPrepaidUsed = true;
}
}
// Preserve the unconfigured direct-adapter accounting contract; Combo admission
// and explicit retry/compaction budgets require a receipt for their booked send.
if (receiptMode) {
sendBudgetState.noteInitialDispatch(compactPrepaid && !compactPrepaidUsed ? compactPrepaid : undefined);
compactPrepaidUsed = true;
}
handoffReplay?.(builtInitialRequest, transportState.activeAdapter.name, recovery);
},
beforeDispatch: isCanonicalOpenAiForwardProvider(route.provider)
? createCodexAuthDispatchGuard(admissionState.authCtx, options.codexAuthPolicy ?? config, route.modelId, options.admission, options.visionDescribeTerminal === true) : undefined,
}));
},
{
abortSignal: upstream.signal,
label: safeHostLabel(builtInitialRequest.url), destination: errorDestinationLabel(builtInitialRequest.url),
claimAmbiguousResend: claimPreHeaderResend,
reserveRetrySpend: reserveCompactRetrySpend,
offlineWait: options.comboAttempt ? undefined : createProviderOfflineResendWait(route.providerName, route.provider, builtInitialRequest.url, config.offlineResendWaitSec),
...(sendBudgetState.workflowRootId || sendBudgetState.adapterSendBudget?.spendEnforced || options.comboDispatchPermit || transientPolicy || resetPolicy || compactPrepaid || options.comboAttempt
|| anthropicInstance || billingPoolRequest || autoPauseEnabled || imageRecovery
? {
// A pending compaction permit already booked this leg's first physical send.
...(transientPolicy || resetPolicy || compactPrepaid || options.comboAttempt || anthropicInstance || autoPauseEnabled
? {
attempts: Math.min(initialSendCap,
sendBudgetState.initialSendAllowance(initialSendCap) + (compactPrepaid ? 1 : 0)),
}
: {}),
// Reporter path: direct requests and enforced spend. Receipt-mode sends are
// settled by `onPhysicalDispatch`, so a reporter here would count them twice.
...(receiptMode
? {}
: { onSendsConsumed: deferredInitial?.report ?? initialReporter }),
}
: {}),
},
); } finally { compactPrepaid?.release(); }
}
} catch (err) {
cleanupUpstreamAbort();
upstream.abort();
if (options.abortSignal?.aborted) return clientCancelledResponse();
const storageRefusal = spendLedgerStorageErrorResponse(err, logCtx);
if (storageRefusal) {
releaseCodexAuthContextProbeLease(admissionState.authCtx);
return storageRefusal;
}
const refusal = err instanceof UpstreamRetryEvidenceError ? err.cause : err;
if (refusal instanceof HostedAdvisorSpendRefusal) return refusal.response();
if (refusal instanceof AdmissionModelDeniedError) {
releaseCodexAuthContextProbeLease(admissionState.authCtx);
return admissionModelDeniedResponse(projectAdmissionModelDeniedLog(refusal, logCtx));
}
const codexRefusal = mapCodexAuthContextErrorToResponse(unwrapUpstreamRetryEvidenceError(err), {
now: Date.now(), accountSelector: route.codexAccountNamespace,
});
if (codexRefusal) {
releaseCodexAuthContextProbeLease(admissionState.authCtx);
return codexRefusal;
}
// A pause committed during pacing is local admission policy, not a failed upstream.
if (refusal instanceof OAuthAccountPausedError) {
return markProxyError(formatErrorResponse(403, "permission_error", publicOAuthAuthenticationErrorMessage(refusal)), publicOAuthErrorPresentation(refusal));
}
if (refusal instanceof OAuthLoginRequiredError) {
return markProxyError(formatErrorResponse(401, "authentication_error", publicOAuthAuthenticationErrorMessage(refusal)), publicOAuthErrorPresentation(refusal));
}
if (refusal instanceof AnthropicAccountCooldownError) {
return anthropicPoolCooldownResponse(refusal, { comboAttempt: options.comboAttempt, logCtx });
}
// A budget refusal is a decision this process made, not an upstream fault. Reporting it as
// 502 does more than mislabel it: the Codex client retries 5xx and does not retry a 429, so
// blaming the provider makes the caller send the whole turn again -- the amplification this
// budget exists to stop. The passthrough path has answered 429 here since #4546.
if (err instanceof SendBudgetExhaustedError) {
return adapterSendBudgetRefusal(logCtx, sendBudgetState.workflowRootId, err.message);
}
const msg = describeUpstreamConnectFailure(err, connectMs);
return formatErrorResponse(502, "upstream_error", msg);
} finally {
handoffPermit?.release();
builtInitialRequest.releaseBodyObservation?.();
}
// Same-target 429 retry budget is per REQUEST: it lives OUTSIDE the recovery loop (so a 413/401
// replay that comes back 429 cannot silently re-arm a fresh budget) and is SHARED with the
// terminal-guard continuation below, so the main loop + one continuation can never exceed
// `attempts` same-key replays in total (bounded per request).
const rateLimitPolicy = rateLimitRetryPolicyFor(route.provider);
let rateLimitRetries = 0;
// Shared with the terminal-guard continuation below: an image-tier reduction that let the
// main request clear a 413 must not be forgotten on the very next continuation build.
// Recovery helpers also serve initial HTTP-200 adapter errors during delivery.
// Recovery loop: multi-key 429 failover + at most ONE opaque-state rebuild and ONE
// anthropic 413 tightened retry
// (devlog/260714_image_normalization_pipeline/030). One mutable activeAdapter serves
// both paths so a 429→413 sequence never rebuilds against a stale pre-rotation
// adapter, and imageTierBias — once armed — rides EVERY subsequent rebuild so a
// 413→429 rotation cannot silently undo the tightening.
let imageRetryAttempted = false;
const opaqueBlobRecoveryGuard: OpaqueBlobRecoveryGuard = { attempted: false };
const thinkingSignatureRecovery = createAnthropicThinkingRecovery(
parsed, upstream.signal, opaqueBlobRecoveryGuard, () => !sendBudgetExhausted(), logCtx,
);
// Console Go answers a transient 400 "Invalid upload request." for bodies it accepts
// moments later; at most one byte-identical replay is allowed per request.
const consoleGoUploadRetryGuard: { attempted: boolean } = { attempted: false };
let oauth401ReplayAttempted = transportState.oauth401ReplayAttempted;
let antigravityAuthRotationAttempted = false;
let antigravityFaultRotationAttempted = false;
const antigravityFaultRotatable = (response: Response) => isAntigravityFaultRotatable(route.providerName, response,
transportState, antigravityPoolActivated, antigravityFaultRotationAttempted);
// Direct requests get one reasoning-effort downgrade. Combo candidates may walk down the
// published ladder one refused rung at a time; the request send budget bounds those retries.
const reasoningEffortDowngradeGuard: { attempted: boolean } = { attempted: false };
// At most one Anthropic fast-mode downgrade per request, for the same reason.
const anthropicFastDowngradeGuard: { attempted: boolean } = { attempted: false };
const rebuildAndRefetch = async (
recovery: AttemptRecoveryKind,
// A caller holding a reserved hop confirms it after the rebuilt send is admitted.
onDispatch?: () => void,
preserveFailureResponse?: Response,
staged?: CredentialReplay,
): Promise<Response | { failed: Response }> => {
const replay = staged ?? (!logCtx.activeAttempt?.sendCount || credentialRecoveryStatus(recovery) === undefined ? undefined
: transportState.createCredentialReplayAttempt(upstreamResponse.status, recovery));
let replacementAdmitted = false, dispatchConfirmed = false;
// Only budgets without a physical observer need this legacy workflow report.
let fastDowngradeWorkflowCharged = false;
const chargeFastDowngradeWorkflowSend = (): void => {
if (recovery !== "anthropic-fast-downgrade" || fastDowngradeWorkflowCharged) return;
fastDowngradeWorkflowCharged = true;
if (!sendBudgetState.adapterSendBudget || !hasWorkflowSendObserver(sendBudgetState.adapterSendBudget))
chargeWorkflowSends(sendBudgetState.workflowRootId, 1);
};
let retryRequest: AdapterRequest;
if (transportState.sameTargetRequest !== undefined && transportState.sameTargetParsed === parsed && transportState.sameTargetToken === transportState.transportToken) {
// Same target (key/adapter/parsed/tier unchanged): replay the exact cached request.
retryRequest = transportState.sameTargetRequest;
} else {
try {
retryRequest = await transportState.activeAdapter.buildRequest(parsed, {
headers: requestState.selectedForwardHeaders, completedToolBlocks: requestState.completedToolBlocks,
providerName: route.providerName,
translatorBudget,
abortSignal: upstream.signal,
...(transportState.imageTierBias > 0 ? { imageTierBias: transportState.imageTierBias } : {}),
});
if (!replay && !transportState.activeAdapter.fetchResponse) {
recordAdapterReasoning(logCtx, retryRequest); recordAdapterTier(logCtx, retryRequest);
}
} catch (err) {
const buildRefusal = options.abortSignal?.aborted ? undefined : adapterBuildRefusal(err, admissionState.authCtx, route.codexAccountNamespace, () => { cleanupUpstreamAbort(); upstream.abort(); });
if (buildRefusal) return { failed: buildRefusal };
// A rotated credential that cannot be shaped keeps the refusal it was meant to
// replace. The image-tier and reasoning-effort rebuilds are different: the request itself
// failed to shape, and their established build-error contracts stay authoritative.
if (preserveFailureResponse && recovery !== "image-413" && recovery !== "reasoning-effort-downgrade" && !options.abortSignal?.aborted) {
return { failed: preserveFailureResponse };
}
// A rotated/rebuilt adapter build failure is a request-shaping error, not an
// upstream connect failure: tear the abort link down and map it as 400.
cleanupUpstreamAbort();
upstream.abort();
if (options.abortSignal?.aborted) return { failed: clientCancelledResponse() };
if (err instanceof OllamaLateAttributionBudgetError) {
return { failed: lateAttributionLimitResponse() };
}
if (isTranslatorBudgetExceededError(err)) {
return { failed: formatErrorResponse(413, "request_too_large", "request translation buffer exceeded the safe limit", {
code: "translation_buffer_limit",
}) };
}
const msg = err instanceof Error ? err.message : String(err);
return { failed: formatErrorResponse(400, "invalid_request_error", redactSecretString(msg)) };
}
transportState.sameTargetRequest = retryRequest;
transportState.sameTargetParsed = parsed;
transportState.sameTargetToken = transportState.transportToken;
}
refreshRequestToolAliases(retryRequest);
const retryEstimate = typeof retryRequest.usageLog?.inputTokens === "number"
? retryRequest.usageLog.inputTokens
: undefined;
if (!replay) {
if (retryEstimate !== undefined) logCtx.usageLogInputTokens = retryEstimate;
if (!transportState.deferPhysicalAttribution) {
logCtx.providerAdapter = transportState.activeAdapter.name;
sealRequestAttemptIdentity(logCtx.activeAttempt, logCtx.provider, transportState.activeAdapter.name, logCtx.accountLogLabel);
}
recordAttemptCredentialSource(logCtx.activeAttempt, route.providerName, route.provider, transportState.activeAdapter.name);
}
try {
try {
if (transportState.activeAdapter.fetchResponse) {
const publish = () => {
if (dispatchConfirmed) return;
upstream.signal.throwIfAborted();
onDispatch?.();
dispatchConfirmed = true;
if (replay) replay(retryRequest, transportState.activeAdapter.name);
else transportState.commitAdapterAttemptSend(retryRequest, transportState.activeAdapter.name, recovery);
replacementAdmitted = true;
};
const producer = adapterDispatchBudget?.beginSpendProducer?.();
try {
return await withProviderRequestSlot(route.providerName, route.provider, route.modelId, upstream.signal, pacingSlot => {
return transportState.activeAdapter.fetchResponse!(retryRequest, {
kiroPreferAccountFailover: route.providerName === "kiro" && isGenericOAuthFailoverEnabled(config, "kiro"),
abortSignal: upstream.signal,
timeoutMs: sendConnectMs(),
sendBudget: adapterDispatchBudget,
onPhysicalSend: send => {
antigravityDenial.beforeSend();
// An adapter that supplies its own guarded receipt can bypass providerFetch.
if (transportState.activeAdapter.reportsPhysicalSends) publish();
noteAdapterPhysicalSend(retryEstimate, send);
chargeFastDowngradeWorkflowSend();
},
onRecoveryWithheld: noteAdapterRecoveryWithheld,
stream: parsed.stream,
executor: providerFetch(route.provider, options.codexWsRuntimeIdentity, {
pacingSlotAcquired: true,
pacingSlot,
dispatchOverride: oauthDispatch(retryRequest, parsed, "adapter", true),
onPhysicalDispatch: publish,
providerName: route.providerName,
modelId: route.modelId,
beforeDispatch: isCanonicalOpenAiForwardProvider(route.provider)
? createCodexAuthDispatchGuard(admissionState.authCtx, options.codexAuthPolicy ?? config, route.modelId, options.admission, options.visionDescribeTerminal === true) : undefined,
}),
});
});
} finally { producer?.close(); }
}
// An opted-in 5xx ladder spends only the remainder of this request's budget.
const refetchTransientPolicy = transientRetryPolicyFor(route.provider);
const refetchWithPolicy = (route.provider.adapter === "google" || refetchTransientPolicy)
? fetchWithTransientRetry
: fetchWithResetRetry;
const helperCountsSends = genericRefetchCountsSends();
const prepaid = sendBudgetState.pendingHopPermit;
const configuredTotal = refetchTransientPolicy?.attempts;
const refetchCap = transientSendCapFor(configuredTotal, sendBudgetState.targetSendsUsed);
// An exact total includes a booked hop, even when it consumed the last base slot.
// Keep that funded send while forbidding the final reserve from widening the total.
const prepaidLastSlot = helperCountsSends && configuredTotal !== undefined && prepaid
&& refetchCap > 0 && remainingTransientSendBudget(refetchCap) === 0;
if (prepaidLastSlot) sendBudgetState.pendingHopPermit = undefined;
const refetchAllowance = helperCountsSends
? prepaidLastSlot ? { attempts: 1, permit: prepaid } : recoverySendAllowance(
refetchCap, recoveryClassFor(recovery),
`${route.providerName}|${route.modelId}|${recovery}`,
{ allowFinalRecoveryReserve: configuredTotal === undefined },
)
: undefined;
let refetchPermitUsed = false;
const refetchReporter = refetchAllowance ? transientSendReporter(refetchAllowance.permit) : undefined;
const deferredRefetch = refetchReporter && (shouldDeferGenericSend(retryRequest) || options.comboAttempt) ? deferPhysicalSendReporter(refetchReporter) : undefined;
const pendingKeyMetadata = !replay && deferredRefetch && transportState.attemptSendDeferred();
try {
const response = await refetchWithPolicy(
recoveryKind => {
sendBudgetState.adapterSendBudget?.startRequest?.(responsesSpendTarget(logCtx, route.providerName));
if (pendingKeyMetadata) transportState.noteRoutedAttemptSend(retryEstimate, recoveryKind ?? recovery);
const confirmDispatch = () => {
if (refetchAllowance?.permit && !refetchPermitUsed && (!onDispatch || refetchAllowance.permit !== prepaid)) {
if (!refetchAllowance.permit.use()) throw new SendBudgetExhaustedError(errorDestinationLabel(retryRequest.url));
refetchPermitUsed = true;
}
if (!replay && !pendingKeyMetadata) transportState.noteRoutedAttemptSend(retryEstimate, recoveryKind ?? recovery);
if (!dispatchConfirmed) { onDispatch?.(); dispatchConfirmed = true; }
if (preserveFailureResponse) replacementAdmitted = true;
if (!refetchAllowance) chargeFastDowngradeWorkflowSend();
};
if (!deferredRefetch && !replay) confirmDispatch();
return fetchWithHeaderTimeout(retryRequest.url,
applyUpstreamRecoveryInit({
method: retryRequest.method, headers: retryRequest.headers, body: retryRequest.body,
}, recoveryKind), upstream.signal, sendConnectMs(), parsed.stream,
providerFetch(route.provider, options.codexWsRuntimeIdentity, {
dispatchOverride: oauthDispatch(retryRequest, parsed, "adapter", Boolean(replay)),
onPhysicalDispatch: () => {
if (replay) upstream.signal.throwIfAborted();
if (deferredRefetch && !deferredRefetch.beforeDispatch()) throw new SendBudgetExhaustedError(errorDestinationLabel(retryRequest.url));
if (deferredRefetch || replay) confirmDispatch();
replay?.(retryRequest, transportState.activeAdapter.name, recoveryKind);
},
providerName: route.providerName,
modelId: route.modelId,
beforeDispatch: isCanonicalOpenAiForwardProvider(route.provider)
? createCodexAuthDispatchGuard(admissionState.authCtx, options.codexAuthPolicy ?? config, route.modelId, options.admission, options.visionDescribeTerminal === true) : undefined,
}));
},
{
abortSignal: upstream.signal,
label: safeHostLabel(retryRequest.url), destination: errorDestinationLabel(retryRequest.url),
claimAmbiguousResend: claimPreHeaderResend,
reserveRetrySpend: reserveCompactRetrySpend,
...(refetchAllowance
? {
attempts: refetchAllowance.attempts,
onSendsConsumed: deferredRefetch?.report ?? refetchReporter,
}
: {}),
},
);
if (parsed._anthropicImageOwner && sendBudgetState.adapterSendBudget?.spendEnforced) {
bindAdapterResponseSpend(response, refetchReporter?.recordUsage);
}
return response;
} finally {
// Refund only a reservation whose send never reached its admission boundary.
// A used or externally settled permit ignores this.
refetchAllowance?.permit?.release();
}
} finally {
retryRequest.releaseBodyObservation?.();
}
} catch (err) {
const storageRefusal = !options.abortSignal?.aborted && spendLedgerStorageErrorResponse(err, logCtx);
if (storageRefusal) {
cleanupUpstreamAbort();
upstream.abort();
releaseCodexAuthContextProbeLease(admissionState.authCtx);
return { failed: storageRefusal };
}
const scopeRefusal = unwrapUpstreamRetryEvidenceError(err);
if (!options.abortSignal?.aborted && (scopeRefusal instanceof AdmissionModelDeniedError || scopeRefusal instanceof HostedAdvisorSpendRefusal)) {
cleanupUpstreamAbort();
upstream.abort();
releaseCodexAuthContextProbeLease(admissionState.authCtx);
return { failed: scopeRefusal instanceof HostedAdvisorSpendRefusal ? scopeRefusal.response()
: admissionModelDeniedResponse(projectAdmissionModelDeniedLog(scopeRefusal, logCtx)) };
}
const codexRefusal = !options.abortSignal?.aborted && mapCodexAuthContextErrorToResponse(unwrapUpstreamRetryEvidenceError(err), {
now: Date.now(), accountSelector: route.codexAccountNamespace,
});
if (codexRefusal) {
cleanupUpstreamAbort();
upstream.abort();
releaseCodexAuthContextProbeLease(admissionState.authCtx);
return { failed: codexRefusal };
}
if (preserveFailureResponse && (recovery !== "reasoning-effort-downgrade" || err instanceof SendBudgetExhaustedError) && !replacementAdmitted && !options.abortSignal?.aborted)
return { failed: preserveFailureResponse };
cleanupUpstreamAbort();
upstream.abort();
if (options.abortSignal?.aborted) {
return { failed: clientCancelledResponse() };
}
const refusal = err instanceof UpstreamRetryEvidenceError ? err.cause : err;
if (refusal instanceof OAuthAccountPausedError) {
return { failed: markProxyError(formatErrorResponse(403, "permission_error", publicOAuthAuthenticationErrorMessage(refusal)), publicOAuthErrorPresentation(refusal)) };
}
if (refusal instanceof OAuthLoginRequiredError) {
return { failed: markProxyError(formatErrorResponse(401, "authentication_error", publicOAuthAuthenticationErrorMessage(refusal)), publicOAuthErrorPresentation(refusal)) };
}
if (refusal instanceof AnthropicAccountCooldownError) {
return { failed: anthropicPoolCooldownResponse(refusal, { comboAttempt: options.comboAttempt, logCtx }) };
}
// Same rule on the recovery leg: the ladder refused to send again, so the answer names
// this proxy rather than the provider it never reached.
if (err instanceof SendBudgetExhaustedError) {
return { failed: adapterSendBudgetRefusal(logCtx, sendBudgetState.workflowRootId, err.message) };
}
const msg = describeUpstreamConnectFailure(err, connectMs);
return { failed: formatErrorResponse(502, "upstream_error", msg) };
}
};
const refetchThinkingSignature = () => {
invalidateSameTargetRequest();
return rebuildAndRefetch("opaque-blob-rejection");
};
if (!upstreamResponse.ok) {
const rotateAntigravityAuth = async (
failedResponse: Response,
recovery: AttemptRecoveryKind,
// An account id (model-404 recovery already chose it) or a selector; the 403 refusal default.
pick: string | ((sent: { accountId: string; generation: string }) => string | null) = sent =>
rotateAntigravityAccountOnAuthRefusal(antigravityPoolActivated, sent.accountId, sent.generation, route.modelId),
): Promise<Response | null> => {
const sent = transportState.replayOAuthCredentialSnapshot ?? transportState.sentOAuthSnapshot;
if (!antigravityPoolActivated || !sent
|| transportState.genericFailovers >= transportState.genericFailoverLimit) return null;
const nextId = typeof pick === "string" ? pick : pick(sent);
if (!nextId) return null;
const adapterOwnsDispatch = transportState.activeAdapter.fetchResponse !== undefined;
return recoverAntigravityAccount({ nextId, failedResponse, adapterOwnsDispatch,
reserve: () => reserveCredentialHop("auth-recovery", `${route.providerName}|${route.modelId}|antigravity-auth`,
!adapterOwnsDispatch && genericRefetchCountsSends()),
applyFailoverSnapshot, setPermit: permit => { sendBudgetState.pendingHopPermit = permit; },
complete: () => { transportState.genericFailovers += 1; },
refetch: onDispatch => rebuildAndRefetch(recovery, onDispatch, failedResponse,
transportState.createCredentialReplayAttempt(failedResponse.status, recovery)),
prepare: () => {
invalidateSameTargetRequest();
transportState.activeAdapter = resolveSelectionAdapter(
resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire, route.staticPolicy),
config.cacheRetention);
bindRouteReasoningReplayScope({
parsed, providerName: route.providerName, provider: route.provider,
adapterName: transportState.activeAdapter.name,
oauthCredentialSnapshot: transportState.replayOAuthCredentialSnapshot,
});
},
});
};
// Keep recovery kinds in sync with the native Responses `passthroughRecovery:` loop above.
recovery: for (;;) {
const modelRotation = await antigravityDenial.recover(upstreamResponse,
transportState.replayOAuthCredentialSnapshot ?? transportState.sentOAuthSnapshot, {
config, model: route.modelId, enabled: antigravityPoolActivated && transportState.activeAdapter.name === "google",
remaining: transportState.genericFailovers < transportState.genericFailoverLimit, signal: options.abortSignal,
rotate: id => rotateAntigravityAuth(upstreamResponse, "oauth-account-403", id),
});
if (modelRotation) { upstreamResponse = modelRotation; continue recovery; }
if (wasAccountAutoPaused(upstreamResponse) && route.provider.authMode !== "forward") {
const recovered = await recoverAutoPausedAccount({ requestKey: transportState, reserve: reserveCredentialHop,
remaining: transientSendCapFor(transientRetryPolicyFor(route.provider)?.attempts, sendBudgetState.targetSendsUsed),
mapRefreshError: createAutoPauseRefreshErrorMapper(upstreamResponse, upstream, cleanupUpstreamAbort, copilotRefusalResponse, () => (options.abortSignal ?? req.signal).aborted, clientCancelledResponse),
refresh: () => transportState.recoverAutoPausedSelection(parsed), refetch: () => rebuildAndRefetch("oauth-account-429"), setPermit: permit => { sendBudgetState.pendingHopPermit = permit; } });
if (!recovered) break;
if ("failed" in recovered) return recovered.failed;
upstreamResponse = recovered; continue recovery;
}
// Preserve the terminal verdict through adapter and combo error formatting.
// This also covers a reset reached by a 401/429/413 recovery refetch.
await rejectAnthropicPerMessageEffort(parsed, upstreamResponse, upstream.signal);
if (isNonReplayableResponse(upstreamResponse)) {
try {
return await sanitizeNonReplayableUpstreamError(upstreamResponse, upstream.signal,
isXaiGrokOAuth(route.providerName, route.provider) ? logCtx : undefined);
} finally { cleanupUpstreamAbort(); }
}
bindAnthropicRejectionResponse(transportState.sameTargetRequest, upstreamResponse);
if (await thinkingSignatureRecovery.prepareHttp(
upstreamResponse, transportState.activeAdapter.name,
)) {
try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* closed */ }
invalidateSameTargetRequest();
const result = await rebuildAndRefetch("opaque-blob-rejection");
if ("failed" in result) return result.failed;
upstreamResponse = result;
continue recovery;
}
if (
upstreamResponse.status === 401 && !wasPermanentAccountRefusal(upstreamResponse)
&& isOAuth401ReplayProvider
&& transportState.sentOAuthSnapshot
&& !oauth401ReplayAttempted
&& !sendBudgetExhausted()
) {
oauth401ReplayAttempted = transportState.oauth401ReplayAttempted = true;
const replay = transportState.createCredentialReplayAttempt(upstreamResponse.status, "oauth-401");
let refreshed: OAuthAccessSnapshot;
try {
refreshed = await refreshResolvedOAuthSelection(transportState.sentOAuthSnapshot);
} catch (err) {
const cancelled = options.abortSignal?.aborted || req.signal.aborted;
if (cancelled || err instanceof OAuthTokenRefreshBusyError) {
cleanupUpstreamAbort();
upstream.abort();
try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* already closed */ }
releaseCodexAuthContextProbeLease(admissionState.authCtx);
return cancelled ? clientCancelledResponse()
: markProxyError(formatErrorResponse(503, "server_error", publicOAuthAuthenticationErrorMessage(err), { retryAfter: "1" }), publicOAuthErrorPresentation(err));
}
const failed = transportState.sentOAuthSnapshot;
if (route.providerName === "google-antigravity" && !antigravityAuthRotationAttempted
&& err instanceof OAuthLoginRequiredError && failed
&& getAccountSet(route.providerName)?.accounts.some(row =>
row.id === failed.accountId && row.needsReauth === true)) {
antigravityAuthRotationAttempted = true;
const rotated = await rotateAntigravityAuth(upstreamResponse, "oauth-401");
if (rotated) { upstreamResponse = rotated; continue recovery; }
}
if (route.providerName === "kiro" && err instanceof OAuthLoginRequiredError && failed
&& transportState.genericFailovers < transportState.genericFailoverLimit) {
const alternate = await tryKiroAlternateAfterTerminalRefresh(config, failed.accountId, failed.generation);
if (alternate) {
const adapterOwnsDispatch = transportState.activeAdapter.fetchResponse !== undefined;
const hop = reserveCredentialHop("auth-recovery",
`${route.providerName}|${route.modelId}|terminal-refresh-account`,
!adapterOwnsDispatch && genericRefetchCountsSends());
if (hop.allowed) {
try {
const admitted = await applyFailoverSnapshot(alternate);
if (admitted?.accountId === alternate.accountId) {
transportState.genericFailovers += 1;
invalidateSameTargetRequest();
transportState.activeAdapter = resolveSelectionAdapter(
resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire, route.staticPolicy),
config.cacheRetention);
bindRouteReasoningReplayScope({
parsed, providerName: route.providerName, provider: route.provider,
adapterName: transportState.activeAdapter.name,
oauthCredentialSnapshot: transportState.replayOAuthCredentialSnapshot,
});
sendBudgetState.pendingHopPermit = hop.permit;
const result = await rebuildAndRefetch("oauth-account-429", () => {
if (!adapterOwnsDispatch && hop.permit?.use() === false) throw new SendBudgetExhaustedError();
});
if ("failed" in result) return result.failed;
upstreamResponse = result;
continue recovery;
}
} catch { /* Keep the original public authentication error. */ }
finally { sendBudgetState.pendingHopPermit = undefined; hop.permit?.release(); }
}
}
}
cleanupUpstreamAbort();
if (err instanceof OAuthAccountPausedError) {
return markProxyError(formatErrorResponse(403, "permission_error", publicOAuthAuthenticationErrorMessage(err)), publicOAuthErrorPresentation(err));
}
return markProxyError(formatErrorResponse(401, "authentication_error", publicOAuthAuthenticationErrorMessage(err)), publicOAuthErrorPresentation(err));
}
if (route.provider.googleMode === "cloud-code-assist" && !refreshed.projectId) {
cleanupUpstreamAbort();
return markProxyError(formatErrorResponse(401, "authentication_error", publicOAuthAuthenticationErrorMessage(new Error("Cloud Code Assist project is required"))));
}
if (route.providerName === "kiro") {
parsed._kiroAuthContext = { ...(refreshed.kiro ?? {}) };
}
let refreshedProvider = resolveProviderTransport(
route.providerName,
{
...route.provider,
apiKey: refreshed.accessToken,
...(refreshed.projectId ? { project: refreshed.projectId } : {}),
},
parsed.options.promptCacheKey,
route.providerName === "github-copilot"
? resolveCopilotApiBaseUrl(refreshed.apiBaseUrl)
: undefined,
);
const copilotRefusal = await resolveRotatedCopilotSelection(refreshedProvider);
if (copilotRefusal) return copilotRefusal;
refreshedProvider = route.provider;
if (route.providerName !== "github-copilot") {
transportState.sentOAuthSnapshot = refreshed;
transportState.replayOAuthCredentialSnapshot = { accountId: refreshed.accountId, generation: refreshed.generation };
}
invalidateSameTargetRequest();
transportState.activeAdapter = resolveSelectionAdapter(
resolveWireProtocolOverride(route.providerName, route.modelId, refreshedProvider, inboundWire, route.staticPolicy),
config.cacheRetention,
);
bindRouteReasoningReplayScope({
parsed,
providerName: route.providerName,
provider: refreshedProvider,
adapterName: transportState.activeAdapter.name,
oauthCredentialSnapshot: transportState.replayOAuthCredentialSnapshot,
});
const result = await rebuildAndRefetch("oauth-401", undefined, undefined, replay);
if ("failed" in result) return result.failed;
upstreamResponse = result;
continue recovery;
}
if (route.providerName === "google-antigravity" && upstreamResponse.status === 401 && !wasPermanentAccountRefusal(upstreamResponse)
&& oauth401ReplayAttempted && !antigravityAuthRotationAttempted
&& !isNonReplayableResponse(upstreamResponse)) {
antigravityAuthRotationAttempted = true;
const rotated = await rotateAntigravityAuth(upstreamResponse, "oauth-401");
if (rotated) { upstreamResponse = rotated; continue recovery; }
}
if (route.providerName === "google-antigravity" && upstreamResponse.status === 403
&& transportState.activeAdapter.name === "google"
&& antigravityPoolActivated
&& !isNonReplayableResponse(upstreamResponse)
&& transportState.genericFailovers < transportState.genericFailoverLimit
&& (!antigravityAuthRotationAttempted && await isAntigravityValidationRefusal(upstreamResponse, options.abortSignal)
// A plain access-denied 403 keeps rotating while siblings remain: each refused account is
// cooled before the hop, so the ring advances and `genericFailoverLimit` bounds the sends.
|| await isAntigravityAccessDeniedRefusal(upstreamResponse, options.abortSignal))) {
antigravityAuthRotationAttempted = true;
const rotated = await rotateAntigravityAuth(upstreamResponse, "oauth-account-403");
if (rotated) { upstreamResponse = rotated; continue recovery; }
}
// A 502/503/504 that outlived the same-account ladder replays once on a live sibling.
if (antigravityFaultRotatable(upstreamResponse)) {
antigravityFaultRotationAttempted = true;
const rotated = await rotateAntigravityAuth(upstreamResponse, "transient-5xx", sent =>
rotateAntigravityAccountOnUpstreamFault(antigravityPoolActivated, sent.accountId, sent.generation, route.modelId));
if (rotated) { upstreamResponse = rotated; continue recovery; }
}
// Static API-key pools can recover a credential-scoped 401 without abandoning the
// provider: one revoked or mistyped key says nothing about its siblings. OAuth providers
// refresh above and never enter here — `hasKeyPoolFailover` rejects oauth/forward modes.
// Runs after the OAuth replay so a refreshable token is never treated as a dead key.
while (upstreamResponse.status === 401 && hasKeyPoolFailover(route.provider)) {
const rotated = rotateProviderTransportOn401(config, route.providerName, route.provider, {
now: Date.now(),
attemptedKey: route.provider.apiKey,
promptCacheKey: parsed.options.promptCacheKey,
});
if (!rotated) break;
if (billingRecoveryActive && (options.abortSignal?.aborted || upstream.signal.aborted)) {
cleanupUpstreamAbort(); upstream.abort(); return clientCancelledResponse();
}
const billingHop = (billingPoolRequest || billingRecoveryActive)
? reserveCredentialHop("auth-recovery", `${route.providerName}|${route.modelId}|key-401`,
transportState.activeAdapter.fetchResponse === undefined)
: undefined;
if (billingHop && !billingHop.allowed) break;
const failedResponse = billingPoolRequest || billingRecoveryActive ? await retainFailureResponse() : undefined;
try {
// Release the failed response's socket before retrying; unread bodies otherwise linger
// until runtime cleanup (one per rotated key).
if (!failedResponse) try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
route.provider = rotated;
const selectionFailure = await resolveRotatedCopilotSelection();
if (selectionFailure) return selectionFailure;
invalidateSameTargetRequest();
transportState.activeAdapter = resolveSelectionAdapter(
resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire, route.staticPolicy),
config.cacheRetention,
);
bindRouteReasoningReplayScope({
parsed,
providerName: route.providerName,
provider: route.provider,
adapterName: transportState.activeAdapter.name,
});
if (billingHop) sendBudgetState.pendingHopPermit = billingHop.permit;
const result = await rebuildAndRefetch("key-401",
billingHop ? () => { if (billingHop.permit?.use() === false) throw new SendBudgetExhaustedError(); } : undefined, failedResponse);
if ("failed" in result) {
if (result.failed !== failedResponse) return result.failed;
break;
}
if (failedResponse) {
try { void failedResponse.body?.cancel().catch(() => {}); } catch { /* closed */ }
}
upstreamResponse = result;
// A recovery refetch can itself die on an ambiguous pre-header reset, and the refusal
// that answers it is a 429. Every arm below keys on 429, so letting it fall through
// hands the marked refusal to the next waiting arm and replays the send it exists to
// stop. Re-enter the loop guard instead, which returns it unchanged.
if (isNonReplayableResponse(upstreamResponse)) continue recovery;
} finally {
if (billingHop) { sendBudgetState.pendingHopPermit = undefined; billingHop.permit?.release(); }
}
}
while ((upstreamResponse.status === 400 || upstreamResponse.status === 402) && hasKeyPoolFailover(route.provider)) {
const rotated = await rotateAnthropicBillingKeyOnResponse(upstreamResponse, config, route.providerName, route.provider,
{ signal: upstream.signal, promptCacheKey: parsed.options.promptCacheKey });
if (upstream.signal.aborted || options.abortSignal?.aborted) {
cleanupUpstreamAbort(); upstream.abort(); return clientCancelledResponse();
}
if (!rotated) break;
billingRecoveryActive = true;
const hop = reserveCredentialHop("auth-recovery", `${route.providerName}|${route.modelId}|key-401`,
transportState.activeAdapter.fetchResponse === undefined);
if (!hop.allowed) break;
const failedResponse = await retainFailureResponse();
try {
route.provider = rotated;
invalidateSameTargetRequest();
transportState.activeAdapter = resolveSelectionAdapter(
resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire, route.staticPolicy), config.cacheRetention);
bindRouteReasoningReplayScope({ parsed, providerName: route.providerName, provider: route.provider, adapterName: transportState.activeAdapter.name });
sendBudgetState.pendingHopPermit = hop.permit;
const result = await rebuildAndRefetch("key-401", () => { if (hop.permit?.use() === false) throw new SendBudgetExhaustedError(); }, failedResponse);
if ("failed" in result) {
if (result.failed !== failedResponse) return result.failed;
break;
}
try { void failedResponse.body?.cancel().catch(() => {}); } catch { /* closed */ }
upstreamResponse = result;
continue recovery;
} finally { sendBudgetState.pendingHopPermit = undefined; hop.permit?.release(); }
}
// Anthropic fast mode refused (no usage credits, organization not enabled, model outside
// the lane, fast pool empty): resend once at standard speed, as Claude Code does. This
// sits before every 429 arm because the refusal says nothing about the account's standard
// lane; waiting, cooling, or rotating on it would punish a healthy credential. The
// resend is reserved and confirmed exactly like the generic OAuth hop below, and the
// decision lives on this request, so every later rebuild of it stays standard.
if (await anthropicFastRefused(
upstreamResponse,
transportState.sameTargetRequest,
transportState.activeAdapter.name,
anthropicFastDowngradeGuard.attempted,
upstream.signal,
)) {
const adapterOwnsDispatch = transportState.activeAdapter.fetchResponse !== undefined;
const hop = reserveCredentialHop(
"repair",
`${route.providerName}|${route.modelId}|anthropic-fast-downgrade`,
!adapterOwnsDispatch && genericRefetchCountsSends(),
);
if (hop.allowed) {
anthropicFastDowngradeGuard.attempted = true;
parsed.options.tierDecision = { kind: "drop" };
parsed.options.serviceTier = undefined;
if (parsed.options.tierObservation) {
parsed.options.tierObservation = { ...parsed.options.tierObservation, upstreamDeclinedFast: true };
}
invalidateSameTargetRequest();
try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
sendBudgetState.pendingHopPermit = hop.permit;
let result: Response | { failed: Response };
try {
result = await rebuildAndRefetch("anthropic-fast-downgrade", () => {
if (!adapterOwnsDispatch && hop.permit?.use() === false) throw new SendBudgetExhaustedError();
});
} finally {
sendBudgetState.pendingHopPermit = undefined;
}
if ("failed" in result) {
hop.permit?.release();
return result.failed;
}
upstreamResponse = result;
continue recovery;
}
}
// Honor retryOn429 on the same key before rotating it (#487).
while (
upstreamResponse.status === 429 && !isSameTargetRetryHold(upstreamResponse)
&& rateLimitPolicy !== null && providerAffinityGenerationIsCurrent(config, route.providerName, route.provider)
&& rateLimitRetries < rateLimitPolicy.attempts
&& !sendBudgetExhausted()
) {
rateLimitRetries += 1;
const retryAfterHeader = upstreamResponse.headers.get("retry-after");
const preceding = reserveCompactRetrySpend() ? await retainFailureResponse() : undefined;
try {
for await (const _ of prepareSameTarget429Wait({
body: preceding ? null : upstreamResponse.body,
signal: options.abortSignal,
delayMs: rateLimitRetryDelayMs(rateLimitPolicy, retryAfterHeader, Date.now()),
})) {
// pre-stream: no stall watchdog to feed
}
} catch {
cleanupUpstreamAbort();
upstream.abort();
return clientCancelledResponse();
}
// Recheck cancellation after the wait.
if (options.abortSignal?.aborted || upstream.signal.aborted) {
cleanupUpstreamAbort();
upstream.abort();
return clientCancelledResponse();
}
const result = await rebuildAndRefetch("rate-limit-429", undefined, preceding);
if ("failed" in result) return result.failed;
void preceding?.body?.cancel().catch(() => undefined);
upstreamResponse = result;
// The refusal is a 429 too: without this the while condition is still true and the
// next configured attempt replays it on the same target.
if (isNonReplayableResponse(upstreamResponse)
|| (isAnthropicBillingKeyPool(route.provider)
&& [400, 402].includes(upstreamResponse.status))) continue recovery;
}
// Multi-key 429 failover: rotate to the next pool key (cooldown-aware) and retry the
// SAME request once per remaining key. OAuth/forward providers and single-key pools
// return null immediately, so this stays a no-op for them (src/providers/key-failover.ts).
while (upstreamResponse.status === 429 && hasKeyPoolFailover(route.provider)) {
// A quota exhaustion is dated in the BODY, not in `Retry-After` — OpenRouter
// sends no header for it (#4024). Read a bounded prefix before the socket is
// released below; a failed or slow read just leaves the header path in charge.
// Peeks a bounded prefix and hands back a Response still carrying the whole
// body, so the cancel below still releases the socket.
let peeked: Awaited<ReturnType<typeof readQuotaResetAt>>;
try {
peeked = await readQuotaResetAt(upstreamResponse, { signal: options.abortSignal });
} catch {
cleanupUpstreamAbort();
upstream.abort();
return clientCancelledResponse();
}
if (options.abortSignal?.aborted) {
cleanupUpstreamAbort();
upstream.abort();
return clientCancelledResponse();
}
upstreamResponse = peeked.response;
const quotaResetAt = peeked.at;
const rotated = rotateProviderTransportOn429(config, route.providerName, route.provider, {
retryAfter: upstreamResponse.headers.get("retry-after"),
now: Date.now(),
attemptedKey: route.provider.apiKey,
promptCacheKey: parsed.options.promptCacheKey,
quotaResetAt,
});
if (!rotated) break;
if (billingRecoveryActive && (options.abortSignal?.aborted || upstream.signal.aborted)) {
cleanupUpstreamAbort(); upstream.abort(); return clientCancelledResponse();
}
const billingHop = (billingPoolRequest || billingRecoveryActive)
? reserveCredentialHop("auth-recovery", `${route.providerName}|${route.modelId}|key-429`,
transportState.activeAdapter.fetchResponse === undefined)
: undefined;
if (billingHop && !billingHop.allowed) break;
const failedResponse = billingPoolRequest || billingRecoveryActive ? await retainFailureResponse() : undefined;
try {
// Release the failed response's socket before retrying; unread bodies otherwise linger
// until runtime cleanup (one per rotated key under a rate-limit storm).
if (!failedResponse) try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
route.provider = rotated;
const selectionFailure = await resolveRotatedCopilotSelection();
if (selectionFailure) return selectionFailure;
invalidateSameTargetRequest();
transportState.activeAdapter = resolveSelectionAdapter(
resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire, route.staticPolicy),
config.cacheRetention,
);
bindRouteReasoningReplayScope({
parsed,
providerName: route.providerName,
provider: route.provider,
adapterName: transportState.activeAdapter.name,
});
if (billingHop) sendBudgetState.pendingHopPermit = billingHop.permit;
const result = await rebuildAndRefetch("key-429",
billingHop ? () => { if (billingHop.permit?.use() === false) throw new SendBudgetExhaustedError(); } : undefined, failedResponse);
if ("failed" in result) {
if (result.failed !== failedResponse) return result.failed;
break;
}
if (failedResponse) {
try { void failedResponse.body?.cancel().catch(() => {}); } catch { /* closed */ }
}
upstreamResponse = result;
// Rotating on the refusal would also write a cooldown against a key that rate-limited
// nothing, which outlives the request.
if (isNonReplayableResponse(upstreamResponse)
|| (billingRecoveryActive && upstreamResponse.status === 401)
|| (route.provider.adapter === "anthropic" && [400, 402].includes(upstreamResponse.status))) continue recovery;
} finally {
if (billingHop) { sendBudgetState.pendingHopPermit = undefined; billingHop.permit?.release(); }
}
}
// Anthropic OAuth: recover a rate limit or proven account entitlement refusal
// before output, within the shared request and account rotation limits.
while (
(upstreamResponse.status === 429 || upstreamResponse.status === 403 || upstreamResponse.status === 401)
&& anthropicInstance
&& transportState.anthropicPoolAccountId
) {
// Same admission as the other rotation ladders: the roster cap cannot see the shared
// send budget. A canRetry term, not a break -- the call also records the refusal.
const adapterOwnsDispatch = transportState.activeAdapter.fetchResponse !== undefined;
const hop = reserveCredentialHop(
"auth-recovery",
`${route.providerName}|${route.modelId}|anthropic-pool-rotation`,
!adapterOwnsDispatch && genericRefetchCountsSends(),
);
let nextAccountId: string | null;
try {
nextAccountId = await rotateAnthropicAccountOnResponseForInstance(anthropicInstance, upstreamResponse, {
config, accountId: transportState.anthropicPoolAccountId, sessionKey: anthropicSessionKey,
model: route.modelId, requestKey: transportState, decision: transportState.anthropicRouteDecision, currentDecision: currentAnthropicRouteDecision, signal: upstream.signal,
// A denied reservation must not rotate on base headroom its bounds cannot see.
canRetry: hop.allowed && (hop.permit !== undefined || !sendBudgetExhausted())
&& transportState.anthropicPoolFailovers < transportState.anthropicFailoverLimit,
});
} catch (rotationError) {
hop.permit?.release();
throw rotationError;
}
if (!nextAccountId) {
hop.permit?.release();
break;
}
try {
const admitted = await commitResolvedOAuthSelection(await anthropicRoutingFor(anthropicInstance).getAnthropicPoolAccessSnapshot(nextAccountId));
if (!admitted) throw new Error("OAuth selection changed during recovery");
try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
transportState.anthropicPoolAccountId = admitted.accountId;
transportState.anthropicPoolFailovers += 1;
route.provider = { ...route.provider, apiKey: admitted.accessToken };
invalidateSameTargetRequest();
logCtx.provider = formatAnthropicProviderForLog(anthropicInstance, admitted.accountId, config);
transportState.activeAdapter = resolveSelectionAdapter(
resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire, route.staticPolicy),
config.cacheRetention,
);
bindRouteReasoningReplayScope({
parsed,
providerName: route.providerName,
provider: route.provider,
adapterName: transportState.activeAdapter.name,
oauthCredentialSnapshot: transportState.replayOAuthCredentialSnapshot,
});
// The replay IS this hop's send; the dispatching layer settles the reservation.
sendBudgetState.pendingHopPermit = hop.permit;
let result: Response | { failed: Response };
try {
result = await rebuildAndRefetch(!anthropicRefusalCredentialChanged(upstreamResponse, admitted) ? "rate-limit-429"
: upstreamResponse.status === 401 ? "oauth-401"
: upstreamResponse.status === 403 ? "oauth-account-403" : "anthropic-oauth-429",
() => { if (!adapterOwnsDispatch && hop.permit?.use() === false) throw new SendBudgetExhaustedError(); });
} finally {
sendBudgetState.pendingHopPermit = undefined;
}
if ("failed" in result) {
// A no-op once the boundary was reached; a refund when the rebuild died first.
hop.permit?.release();
return result.failed;
}
upstreamResponse = result;
if (isNonReplayableResponse(upstreamResponse)) continue recovery;
} catch {
// release() refunds a pre-send hop and is a no-op once the send settled it.
hop.permit?.release();
break;
}
}
// Generic OAuth account failover (#2568) rotates reactively after a refusal when
// two accounts are stored. Kiro additionally classifies bounded 400/403 refusals;
// all other providers retain the original 429 loop below.
if (route.providerName === "kiro") {
while (
(upstreamResponse.status === 429 || upstreamResponse.status === 400 || upstreamResponse.status === 403)
&& transportState.genericFailoverAccountId
) {
const refusal = classifyKiroRefusal(upstreamResponse.status,
await readDisplaySafeErrorText(upstreamResponse.clone(), upstream.signal, ""));
if (refusal.kind === "other") break;
const sent = transportState.sentOAuthSnapshot;
const monthlyCooldownMs = refusal.kind === "monthly_quota" && sent
? noteKiroMonthlyRefusal(sent.accountId, sent.generation, Date.now()) : undefined;
if (monthlyCooldownMs !== undefined) persistKiroAccountState();
if (refusal.kind === "suspended")
quarantineKiroSuspendedAccount(transportState.genericFailoverAccountId, sent?.generation);
if (transportState.genericFailovers >= transportState.genericFailoverLimit
|| !isGenericOAuthFailoverEnabled(config, "kiro")) break;
// Intersection with the shared request budget. This arm re-sends through
// rebuildAndRefetch, so the roster cap alone would let one request walk the roster on
// an allowance the rest of the request cannot see. A refusal ends the ladder with the
// original HTTP response already in hand.
//
// Who settles this reservation depends on who dispatches the replay (#4709). An
// adapter that owns its ladder -- Kiro's reset loop, Cursor's transport loop --
// reserves once per physical send and would charge the same replay again; the helper
// path reports it again through `onSendsConsumed`. Both turned one physical send into
// two charges, and once the allowance was spent, into a synthetic error in place of
// the refusal this hop was recovering from. The wire protocol is resolved from the
// provider and model, not from the account, so an account rotation cannot move the
// replay between these two shapes.
const adapterOwnsDispatch = transportState.activeAdapter.fetchResponse !== undefined;
const hop = reserveCredentialHop(
"auth-recovery",
`${route.providerName}|${route.modelId}|adapter-recovery-oauth-429`,
// Counted generic helpers report physical sends; an adapter-owned
// ladder settles its own booking.
!adapterOwnsDispatch && genericRefetchCountsSends(),
);
if (!hop.allowed) break;
const nextAccountId = rotateGenericOAuthAccountOnRefusal(
config,
route.providerName,
transportState.genericFailoverAccountId,
refusal.kind,
upstreamResponse.headers.get("retry-after"),
Date.now(),
route.modelId,
monthlyCooldownMs,
);
if (!nextAccountId) {
hop.permit?.release();
break;
}
const replay = transportState.createCredentialReplayAttempt(upstreamResponse.status, "oauth-account-429");
try {
// The FULL snapshot, not just the bearer: Antigravity pairs an account-matched
// projectId with its token and Kiro carries routing metadata, so a token-only swap
// would mix one account's credential with another's routing data.
const snapshot = await failoverAccountSnapshot(route.providerName, nextAccountId);
if (!await applyFailoverSnapshot(snapshot)) {
hop.permit?.release();
break;
}
transportState.genericFailovers += 1;
invalidateSameTargetRequest();
transportState.activeAdapter = resolveSelectionAdapter(
resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire, route.staticPolicy),
config.cacheRetention,
);
bindRouteReasoningReplayScope({
parsed, providerName: route.providerName, provider: route.provider,
adapterName: transportState.activeAdapter.name,
oauthCredentialSnapshot: transportState.replayOAuthCredentialSnapshot,
});
// The replay IS this hop's send, so hand the reservation down and let the layer that
// dispatches settle it: `adapterDispatchBudget` spends it on the adapter's first
// reservation, and the retry helper's reporter settles the external booking.
sendBudgetState.pendingHopPermit = hop.permit;
let result: Response | { failed: Response };
try {
// Confirm at the dispatch boundary, not here: a rebuild can fail while shaping the
// request and return `{ failed }` without reaching the wire, and a permit confirmed
// before that would hold the charge for a send that never happened. An
// adapter-owned ladder is the exception -- its own reservation is the confirmation,
// and settling here first would hand it a dead permit, which it reads as an
// exhausted request and stops sending on.
result = await rebuildAndRefetch("oauth-account-429", () => {
if (!adapterOwnsDispatch && hop.permit?.use() === false) throw new SendBudgetExhaustedError();
}, upstreamResponse, replay);
} finally {
sendBudgetState.pendingHopPermit = undefined;
}
if ("failed" in result) {
// A no-op if the boundary was reached; a refund if the rebuild died before it.
hop.permit?.release();
if (result.failed !== upstreamResponse) return result.failed;
break;
}
try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
upstreamResponse = result;
// The hop's permit is already settled by the dispatch boundary above; continuing
// only skips the remaining arms, it does not abandon a reservation.
if (isNonReplayableResponse(upstreamResponse)) continue recovery;
} catch {
// A throw before the send — snapshot fetch, credential application, adapter
// resolution — must hand the reservation back. Without this the ladder charges the
// request for a send it never made, and a later recovery in the same request is
// refused on an allowance nothing spent. release() is idempotent and a no-op once
// used, so a throw from the rebuild keeps its charge.
hop.permit?.release();
break;
}
}
} else {
while (
upstreamResponse.status === 429
&& transportState.genericFailoverAccountId
&& transportState.genericFailovers < transportState.genericFailoverLimit
&& isGenericOAuthFailoverEnabled(config, route.providerName)
) {
// Intersection with the shared request budget. This arm re-sends through
// rebuildAndRefetch, so the roster cap alone would let one request walk the roster on
// an allowance the rest of the request cannot see. A refusal ends the ladder with the
// real 429 already in hand, which is the decided exhaustion contract.
//
// Who settles this reservation depends on who dispatches the replay (#4709). An
// adapter that owns its ladder -- Kiro's reset loop, Cursor's transport loop --
// reserves once per physical send and would charge the same replay again; the helper
// path reports it again through `onSendsConsumed`. Both turned one physical send into
// two charges, and once the allowance was spent, into a synthetic error in place of
// the 429 this hop was recovering from. The wire protocol is resolved from the
// provider and model, not from the account, so an account rotation cannot move the
// replay between these two shapes.
const adapterOwnsDispatch = transportState.activeAdapter.fetchResponse !== undefined;
const hop = reserveCredentialHop(
"auth-recovery",
`${route.providerName}|${route.modelId}|adapter-recovery-oauth-429`,
// Counted generic helpers report physical sends; an adapter-owned
// ladder settles its own booking.
!adapterOwnsDispatch && genericRefetchCountsSends(),
);
if (!hop.allowed) break;
const nextAccountId = rotateGenericOAuthAccountOn429(
config,
route.providerName,
transportState.genericFailoverAccountId,
upstreamResponse.headers.get("retry-after"),
Date.now(),
route.modelId,
);
if (!nextAccountId) {
hop.permit?.release();
break;
}
try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
try {
// The FULL snapshot, not just the bearer: Antigravity pairs an account-matched
// projectId with its token and Kiro carries routing metadata, so a token-only swap
// would mix one account's credential with another's routing data.
const snapshot = await failoverAccountSnapshot(route.providerName, nextAccountId);
transportState.genericFailovers += 1;
if (!await applyFailoverSnapshot(snapshot)) {
hop.permit?.release();
break;
}
invalidateSameTargetRequest();
transportState.activeAdapter = resolveSelectionAdapter(
resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire, route.staticPolicy),
config.cacheRetention,
);
// Same contract as the Kiro refusal arm: the replay must carry the replacement
// account's continuation owner and reasoning scope, never the account that just 429'd.
bindRouteReasoningReplayScope({
parsed, providerName: route.providerName, provider: route.provider,
adapterName: transportState.activeAdapter.name,
oauthCredentialSnapshot: transportState.replayOAuthCredentialSnapshot,
});
// The replay IS this hop's send, so hand the reservation down and let the layer that
// dispatches settle it: `adapterDispatchBudget` spends it on the adapter's first
// reservation, and the retry helper's reporter settles the external booking.
sendBudgetState.pendingHopPermit = hop.permit;
let result: Response | { failed: Response };
try {
// Confirm at the dispatch boundary, not here: a rebuild can fail while shaping the
// request and return `{ failed }` without reaching the wire, and a permit confirmed
// before that would hold the charge for a send that never happened. An
// adapter-owned ladder is the exception -- its own reservation is the confirmation,
// and settling here first would hand it a dead permit, which it reads as an
// exhausted request and stops sending on.
result = await rebuildAndRefetch("oauth-account-429", () => {
if (!adapterOwnsDispatch && hop.permit?.use() === false) throw new SendBudgetExhaustedError();
});
} finally {
sendBudgetState.pendingHopPermit = undefined;
}
if ("failed" in result) {
// A no-op if the boundary was reached; a refund if the rebuild died before it.
hop.permit?.release();
return result.failed;
}
upstreamResponse = result;
// The hop's permit is already settled by the dispatch boundary above; continuing
// only skips the remaining arms, it does not abandon a reservation. A replacement's
// surviving 502/503/504 re-enters recovery so the one-hop fault rotation can run.
if (isNonReplayableResponse(upstreamResponse) || antigravityFaultRotatable(upstreamResponse)) continue recovery;
} catch (err) {
// A local admission denial is terminal for the whole request: rotating to another
// account cannot re-scope the key, so the refusal answers in place of the 429.
const scopeRefusal = unwrapUpstreamRetryEvidenceError(err);
if (!options.abortSignal?.aborted && scopeRefusal instanceof AdmissionModelDeniedError) {
hop.permit?.release();
cleanupUpstreamAbort();
upstream.abort();
releaseCodexAuthContextProbeLease(admissionState.authCtx);
return admissionModelDeniedResponse(projectAdmissionModelDeniedLog(scopeRefusal, logCtx));
}
// A throw before the send — snapshot fetch, credential application, adapter
// resolution — must hand the reservation back. Without this the ladder charges the
// request for a send it never made, and a later recovery in the same request is
// refused on an allowance nothing spent. release() is idempotent and a no-op once
// used, so a throw from the rebuild keeps its charge.
hop.permit?.release();
break;
}
}
// Antigravity verify-account quarantine: a 403 demanding account verification
// is terminal for THAT account — its grant still refreshes, so only a manual
// verification followed by a re-login clears it. Mark it needsReauth (durable,
// shown as `needs-reauth(verify)` in `ocx account list` with a `verify_account`
// health reason in the management API, excluded from the pool until re-login)
// and replay the same request on the next eligible account so the pool keeps
// serving.
while (
upstreamResponse.status === 403
&& route.providerName === "google-antigravity"
&& transportState.genericFailoverAccountId
) {
const refusal = await classifyAntigravityQuarantine(upstreamResponse, route.provider, antigravityQuarantineTrust, upstream.signal);
if (refusal.kind === "other") break;
const sent = transportState.sentOAuthSnapshot;
const failedAccountId = transportState.genericFailoverAccountId;
// Fenced write: a 403 arriving after the credential rotated (refresh or
// re-login) must not quarantine the new login. Without the matching sent
// snapshot there is no owner for this write, so skip marking.
if (!sent || sent.accountId !== failedAccountId) break;
try {
await markAccountNeedsReauthIfGeneration(route.providerName, failedAccountId, sent.generation, undefined, refusal.kind);
} catch {
// A failed quarantine write must preserve the refusal, not authorize another send.
break recovery;
}
if (!antigravityPoolActivated || transportState.genericFailovers >= transportState.genericFailoverLimit) break;
const adapterOwnsDispatch = transportState.activeAdapter.fetchResponse !== undefined;
const hop = reserveCredentialHop(
"auth-recovery",
`${route.providerName}|${route.modelId}|adapter-recovery-oauth-verify`,
!adapterOwnsDispatch && genericRefetchCountsSends(),
);
if (!hop.allowed) break;
// Auth-refusal rotation, not the rate-limit one: a verification refusal
// must not record rate-limit cooldown semantics against the account.
const nextAccountId = rotateAntigravityAccountOnAuthRefusal(
antigravityPoolActivated,
failedAccountId,
sent.generation,
route.modelId,
);
if (!nextAccountId) {
hop.permit?.release();
break;
}
// The refusal body stays alive until the replacement owns the outcome: it
// is also the preserveFailureResponse below, so cancelling it early would
// hand back a 403 with a destroyed body when the rebuild is refused.
const failedResponse = upstreamResponse;
try {
// The FULL snapshot, not just the bearer: Antigravity pairs an
// account-matched projectId with its token, so a token-only swap would mix
// one account's credential with another's routing data.
const snapshot = await failoverAccountSnapshot(route.providerName, nextAccountId);
if (!await applyFailoverSnapshot(snapshot)) {
hop.permit?.release();
break;
}
invalidateSameTargetRequest();
transportState.activeAdapter = resolveSelectionAdapter(
resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, inboundWire, route.staticPolicy),
config.cacheRetention,
);
bindRouteReasoningReplayScope({
parsed,
providerName: route.providerName,
provider: route.provider,
adapterName: transportState.activeAdapter.name,
oauthCredentialSnapshot: transportState.replayOAuthCredentialSnapshot,
});
sendBudgetState.pendingHopPermit = hop.permit;
let result: Response | { failed: Response };
try {
result = await rebuildAndRefetch("oauth-account-403", () => {
if (!adapterOwnsDispatch && hop.permit?.use() === false) throw new SendBudgetExhaustedError();
}, failedResponse);
} finally {
sendBudgetState.pendingHopPermit = undefined;
}
if ("failed" in result) {
hop.permit?.release();
if (result.failed !== failedResponse) return result.failed;
// Preserve common redaction and combo consumption without another recovery send.
break recovery;
}
transportState.genericFailovers += 1;
try { void failedResponse.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
upstreamResponse = result;
if (isNonReplayableResponse(upstreamResponse) || antigravityFaultRotatable(upstreamResponse)) continue recovery;
} catch {
hop.permit?.release();
break;
}
}
}
// Unknown provenance is deliberately fail-soft in pre-flight: after a restart, TTL expiry,
// or LRU eviction, a valid same-backend blob must survive. A decoder's own 4xx identity is
// the missing authoritative signal. Rebuild once through the same sanitation path used by a
// known route switch; invalidating is mandatory because `parsed` mutates in place and the
// same-target cache would otherwise replay the rejected bytes verbatim.
const opaqueBlobRecovery = await attemptOpaqueBlobRecovery({
response: upstreamResponse,
outboundBody: transportState.sameTargetRequest?.body,
adapterName: transportState.activeAdapter.name,
parsed,
guard: opaqueBlobRecoveryGuard,
signal: upstream.signal,
}, recovery => {
invalidateSameTargetRequest();
return rebuildAndRefetch(recovery);
});
if (opaqueBlobRecovery.kind === "failed") return opaqueBlobRecovery.response;
if (opaqueBlobRecovery.kind === "recovered") {
upstreamResponse = opaqueBlobRecovery.response;
continue recovery;
}
if (imageRecovery && upstreamResponse.status === 413) {
const recovered = await recoverAdapterImageContext(imageRecovery, upstreamResponse, parsed, transportState, upstream.signal, refreshRequestToolAliases);
if (!recovered) { cleanupUpstreamAbort(); return clientCancelledResponse(); }
upstreamResponse = recovered;
break recovery;
}
if (shouldAttemptImageTierRetry({
status: upstreamResponse.status,
adapterName: transportState.activeAdapter.name,
parsed,
alreadyAttempted: imageRetryAttempted,
})) {
imageRetryAttempted = true;
transportState.imageTierBias = 1;
invalidateSameTargetRequest();
const failedResponse = await retainFailureResponse();
const result = await rebuildAndRefetch("image-413", undefined, failedResponse);
if ("failed" in result) {
if (result.failed !== failedResponse) return result.failed;
break recovery;
}
try { void failedResponse.body?.cancel().catch(() => {}); } catch { /* closed */ }
upstreamResponse = result;
continue recovery;
}
// Console Go (opencode-zen / opencode-go) intermittently rejects a body it accepts seconds
// later with 400 invalid_request_error / "Invalid upload request." Replay the
// byte-identical request once after the exact gateway rejection.
if (!consoleGoUploadRetryGuard.attempted) {
const uploadRejectionBody = await consoleGoUploadRejectionBody(
upstreamResponse,
consoleGoUploadRetryGuard.attempted,
upstream.signal,
);
if (uploadRejectionBody !== undefined
&& isTransientConsoleGoUploadRejection({
status: upstreamResponse.status,
errorBody: uploadRejectionBody,
outboundUrl: transportState.sameTargetRequest?.url,
})) {
consoleGoUploadRetryGuard.attempted = true;
try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
if (!upstream.signal.aborted) {
try {
await sleepWithAbort(CONSOLE_GO_UPLOAD_RETRY_DELAY_MS, upstream.signal);
} catch { cleanupUpstreamAbort(); return clientCancelledResponse(); }
}
if (upstream.signal.aborted) { cleanupUpstreamAbort(); return clientCancelledResponse(); }
const result = await rebuildAndRefetch("console-go-upload-retry");
if ("failed" in result) return result.failed;
upstreamResponse = result;
continue recovery;
}
}
// Learn a refused rung and retry at the next published one. Direct requests are limited
// to one repair; combo candidates may continue down the finite ladder within the send budget.
const downgrade = await refusedReasoningEffortDowngrade(upstreamResponse, upstream.signal, reasoningEffortDowngradeGuard,
options.comboAttempt, { provider: route.provider, modelId: parsed.modelId, requested: parsed.options.reasoning });
if (downgrade) {
reasoningEffortDowngradeGuard.attempted = true;
parsed.options.reasoning = downgrade.effort;
// The same-target cache keys on parsed identity, so a mutated effort needs a token bump.
invalidateSameTargetRequest();
// A combo keeps the refusal, so an unfunded rung still reaches combo failover as the original 400.
const refusal = options.comboAttempt ? await retainFailureResponse() : undefined;
if (!refusal) try { void upstreamResponse.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
const result = await rebuildAndRefetch("reasoning-effort-downgrade", undefined, refusal);
if ("failed" in result) {
if (result.failed !== refusal) return result.failed;
break recovery;
}
if (refusal) try { void refusal.body?.cancel().catch(() => {}); } catch { /* already consumed/closed */ }
upstreamResponse = result;
continue recovery;
}
break;
}
if (!upstreamResponse.ok) {
if (route.providerName === "kiro")
upstreamResponse = await normalizeFinalKiroHttpError(upstreamResponse, upstream.signal);
const grokOAuth = isXaiGrokOAuth(route.providerName, route.provider);
if (options.comboAttempt) {
// No pre-read guard: `consumeComboFailure` -> `readBoundedResponseBody` reads
// `response.body` itself with the abort signal threaded through, and the combo
// contract is that this body's getter is touched exactly once. A guard here would be
// a second `.body` access for no gain, since the bounded reader owns settlement.
const failure = await consumeComboFailure(upstreamResponse, options.abortSignal, Date.now(), logCtx, !isProxyError(upstreamResponse), grokOAuth)
.finally(cleanupUpstreamAbort);
options.onConsumedComboFailure?.(failure);
return failure.response;
}
let errorText: string;
try {
errorText = await readDisplaySafeErrorText(
upstreamResponse,
upstream.signal,
"unknown error",
);
} finally {
cleanupUpstreamAbort();
}
if (grokOAuth && isXaiLegacyPrivacyError(upstreamResponse.status, errorText)) return xaiPrivacyModeRefusal(logCtx);
// The provider's own body (not a proxy-normalized one) may name its closed error class (#8446).
if (!isProxyError(upstreamResponse)) recordUpstreamProviderErrorDetail(logCtx, upstreamResponse.status, errorText, upstreamResponse);
if (upstreamResponse.status === 413) {
if (options.clientModelLabel) projectLocalModelRefusalLog(logCtx, options.clientModelLabel);
return clientRequestedStream
? streamingContextOverflowResponse(clientFacingModelText(options.clientModelLabel), translatorBudget)
: jsonContextOverflowResponse();
}
const policyRefusal = rewriteUpstreamPolicyRefusal({
status: upstreamResponse.status,
errorText,
stream: clientRequestedStream,
modelId: clientFacingModelText(options.clientModelLabel),
// The same host check covers the openai-chat wire: both xAI hosts serve Chat too.
destinationIsXai: isXaiResponsesDestination(route.provider),
translatorBudget,
turnAdmissionLease: options.turnAdmissionLease,
});
if (policyRefusal) {
// Codex-facing incomplete/content_filter. openai-responses passthrough
// uses the same helper after its 413 block.
return policyRefusal;
}
if (!isFixedCodexAccount(admissionState.authCtx)) {
recordSubagentQuotaFailureForThreadSpawn(
req.headers,
subagentQuotaFailureModel,
upstreamResponse.status === 429 || upstreamResponse.status === 402
? upstreamResponse.status
: `Provider error ${upstreamResponse.status}: ${redactSecretString(errorText.slice(0, 500))}`,
config,
requestState.subagentFallbackAccountId,
);
}
// The last pool account just refused on spent quota and recovery found no replacement:
// answer the usage limit now (#6991), so Codex stops instead of retrying into the local
// refusal that every later attempt meets until the first window reopens.
const poolUsageLimit = upstreamResponse.status === 429 && anthropicInstance && route.provider.authMode === "oauth"
? anthropicRoutingFor(anthropicInstance).anthropicPoolUsageLimitAfterRefusal(Date.now(), transportState.anthropicRouteDecision, route.modelId)
: null;
// Combo children returned above; the flag is passed anyway so this site states the same rule.
if (poolUsageLimit) return anthropicPoolCooldownResponse(poolUsageLimit, { comboAttempt: options.comboAttempt, logCtx });
// Upstreams occasionally echo request details in error bodies — scrub token-shaped
// material before it reaches the client-facing error surface.
const upstreamRetryAfter = upstreamResponse.headers.get("retry-after");
const { normalized, message } = formatAdapterUpstreamFailure({
status: upstreamResponse.status,
errorText,
route,
upstreamRetryAfter,
denialMessage: fallback => antigravityDenial.message(route.modelId, fallback),
logCtx,
});
options.onCompactionRecoveryAdapterEvent?.({
type: "error", status: upstreamResponse.status,
errorType: normalized.type, code: normalized.code,
message: "Structured upstream failure observed before client formatting",
});
const retryAfter = normalized.cyberPolicy
? undefined
: resolveClientRetryAfter({
status: upstreamResponse.status,
message,
upstreamRetryAfter,
includeDefault: !(transportState.anthropicPoolAccountId && classifyAnthropic429(upstreamResponse.headers) === "request-scoped-unknown"),
});
return carryPolicyCandidateRefusal(upstreamResponse, formatUpstreamFailureResponse(upstreamResponse, normalized.code,
upstreamResponse.status,
normalized.cyberPolicy ? (normalized.type ?? CYBER_POLICY_ERROR_CODE) : "upstream_error",
message,
{
...(normalized.cyberPolicy ? { code: CYBER_POLICY_ERROR_CODE } : {}),
...(retryAfter !== undefined ? { retryAfter } : {}),
},
));
}
}
bindAnthropicRejectionResponse(transportState.sameTargetRequest, upstreamResponse);
cancelBodyOnAbort(upstreamResponse.body, upstream.signal);
return {
upstream,
cleanupUpstreamAbort,
get connectMs() { return resolveConnectTimeoutMs(connectTimeoutMs(), { localUpstream: this.localUpstream }); },
get stallTimeoutMs() { return resolveStallTimeoutMs(providerStallTimeoutSec(config, responsesTimeoutProvider(options, route.provider)), { localUpstream: this.localUpstream }); },
get localUpstream() { return isLocalUpstream(transportState.sameTargetRequest?.url ?? route.provider.baseUrl); },
upstreamResponse,
thinkingSignatureRecovery,
refetchThinkingSignature,
rateLimitPolicy,
get rateLimitRetries(): typeof rateLimitRetries {
return rateLimitRetries;
},
set rateLimitRetries(value: typeof rateLimitRetries) {
rateLimitRetries = value;
},
};
}
export type AdapterExchange = Exclude<Awaited<ReturnType<typeof prepareAdapterExchange>>, Response>;