UNPKG

@bitkyc08/opencodex

Version:

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

816 lines (789 loc) • 38.4 kB
/** * Managed native Messages lane (PF-08, behind `protocols.rollout.managedMessagesNative`). * * A Messages request whose settled route is a proxy-managed key on the `anthropic` adapter is * sent as Messages: the source body (after the ingress's managed-client steps) cut to a field * allowlist, the wire model, and the provider's own key. With `managedMessagesNativeOAuth` on * (PF-10), an unpooled Anthropic OAuth account is sent the same way with the access token the * existing OAuth selection resolves at dispatch (`messages-native-oauth.ts`). Modelled on the native Chat lane and * built on the same shared pieces — attempt row, finish-once final log, spend tracker, proactive * key selection, key failover and 429 replay, connection policy — so nothing the Responses * pipeline enforces is bypassed. * * Authority. This lane reads no caller header. The ingress hands over one value, the caller's * `anthropic-beta`, which the builder reduces to an allowlist. The caller-forward passthrough in * `claude-messages.ts` (the caller's own Anthropic credential) is a different branch decided * before this one, and nothing here can reach it or be reached from it. * * Loaded lazily by `claude-messages.ts` only when the switch is on and a route is eligible. */ import { enforceAnthropicImageLimits } from "../adapters/anthropic-image-guard"; import { normalizeAnthropicImages } from "../adapters/anthropic-image-normalize"; import { formatAnthropicErrorBody } from "../adapters/anthropic"; import { anthropicMessagesNativeWireBody, buildAnthropicMessagesPassthroughRequest, type AnthropicMessagesPassthroughRequest, } from "../adapters/anthropic/passthrough"; import { resolveInboundModel } from "../claude/inbound"; import { anthropicErrorBody, anthropicErrorResponse, collectAnthropicMessage } from "../claude/outbound"; import type { AdmissionLease } from "../lib/admission"; import { readBoundedResponseBody } from "../lib/bounded-body"; import { classifyError } from "../lib/errors"; import { redactSecretString } from "../lib/redact"; import { resolveClientRetryAfter } from "../lib/retry-after"; import { isTranslatorBudgetExceededError, type TranslatorBudget } from "../lib/translator-budget"; import { applyReplayRefusalClientHeaders, applyUpstreamRecoveryInit, fetchWithResetRetry, fetchWithTransientRetry, isNonReplayableResponse, isReplayRefusalResponse, isTransientUpstreamStatus, prepareSameTarget429Wait, REPLAY_REFUSED_STATUS, retainReplayRefusal, UpstreamRetryEvidenceError, type UpstreamSendRecovery, UPSTREAM_RESET_REPLAY_REFUSED_CODE, } from "../lib/upstream-retry"; import { providerApiKeySelectionIsCurrent, resolveCurrentProviderApiKeyTransport } from "../providers/api-key-selection"; import { hasKeyPoolFailover, rateLimitRetryDelayMs, rateLimitRetryPolicyFor, rotateProviderTransportOn401, rotateProviderTransportOn429, selectProactiveApiKeyTransport, transientRetryPolicyFor, } from "../providers/key-failover"; import { stampApiKeyAccountLabel } from "../providers/label"; import { OAuthAccountPausedError, OAuthLoginRequiredError, publicOAuthAuthenticationErrorMessage } from "../oauth"; import { AnthropicAccountCooldownError, formatAnthropicProviderForLog, hasAnthropicFailoverQuorum } from "../oauth/anthropic-routing"; import { resolveProtocolSettings } from "../protocols/settings"; import { addProtocolEntryReason, markProtocolBlocked } from "../protocols/trace"; import type { OcxProviderTransport } from "../providers/xai-transport"; import { preservesPhysicalComboProvider, resolveComboId } from "../combos"; import { captureRouteStaticPolicy, routeModel, type RouteResult } from "../router"; import { POLICY_NAMESPACE, resolvePolicyProfileId } from "../routing/profile"; import type { OcxConfig, OcxProviderConfig, OcxUsage } from "../types"; import { resolveWireProtocolOverride } from "./adapter-resolve"; import { anthropicUsageToOcx, estimateClaudeRequestTokens, resolvePassthroughBodyGuard, sanitizePassthroughToolCallIds, tapAnthropicSseForLog, } from "./claude-messages"; import { beginInferenceAttempt } from "./inference/attempt"; import { createFinalRequestLog, type FinalRequestLogMeta } from "./inference/final-log"; import { registerTurn, unregisterTurn } from "./lifecycle"; import { nativeMessagesDeclineReason, type NativeMessagesSelector } from "./messages-native-eligibility"; import { nativeOAuthBindingIsCurrent, NativeOAuthSelectionChangedError, resolveNativeOAuthBinding, restoreOAuthToolNamesInMessage, restoreOAuthToolNamesInSse, type NativeOAuthBinding, } from "./messages-native-oauth"; import { noteProviderAttemptSend, recordAttemptCredentialSource, recordFirstOutput, recordKeyAttemptFailure, recordKeyWireAttemptUsage, type RequestLogContext, } from "./request-log"; import { fetchWithHeaderTimeout, providerFetch, safeHostLabel, sendWithConnectionPolicy } from "./responses/fetch-helpers"; import { linkAbortSignal } from "./responses/core-lifetime"; import { attachRequestSpendTracker } from "./responses/request-spend"; import { workflowRefusalResponse } from "./workflow-refusal"; import { sseFieldValue } from "../lib/sse-decoder"; export { isNativeMessagesRouteEligible, nativeMessagesDeclineReason, type NativeMessagesDeclineReason, } from "./messages-native-eligibility"; type Rec = Record<string, unknown>; const MAX_NATIVE_MESSAGES_JSON_BYTES = 32 * 1024 * 1024; const MAX_NATIVE_MESSAGES_ERROR_BYTES = 64 * 1024; class NativeMessagesSpendRefusal extends Error {} /** A rebuild for a destination that cannot carry the body's opaque state, under `reject`. */ class NativeOpaqueStateRefusal extends Error { constructor() { super("The selected route cannot carry thinking signatures or redacted_thinking blocks"); } } function isRec(value: unknown): value is Rec { return value !== null && typeof value === "object" && !Array.isArray(value); } export interface HandleNativeMessagesOptions { req: Request; config: OcxConfig; logCtx: RequestLogContext; logIds?: { requestId: string; start: number; turnAdmissionLease?: AdmissionLease }; /** The settled, eligible route (see `isNativeMessagesRouteEligible`). */ route: RouteResult; /** * The Messages body after the ingress's managed-client steps. Owned by this lane from here * on: a fresh envelope copy when an envelope exists, otherwise the ingress's own body. */ body: Rec; /** The selector the client sent, echoed on the request log. */ requestedModel: string; translatorBudget: TranslatorBudget; /** The facts the ingress judged eligibility with; re-applied if key selection changes. */ selector?: NativeMessagesSelector; /** * The caller's `anthropic-beta` header, handed over by the ingress. The builder keeps only * allowlisted values; no other caller header reaches this lane. */ callerAnthropicBeta?: string | null; } type FinishLog = (status: number, message?: string, meta?: FinalRequestLogMeta) => void; /** Relay an upstream body unchanged, recording first output on its first non-empty chunk. */ function observeFirstChunk(body: ReadableStream<Uint8Array>, onFirst: () => void): ReadableStream<Uint8Array> { const reader = body.getReader(); let seen = false; return new ReadableStream<Uint8Array>({ async pull(controller) { const { done, value } = await reader.read(); if (done) { controller.close(); return; } if (!seen && value.byteLength > 0) { seen = true; onFirst(); } controller.enqueue(value); }, cancel(reason) { return reader.cancel(reason); }, }); } /** How far into a stream the `message_start` frame is looked for before relaying untouched. */ const MODEL_ECHO_SCAN_BYTES = 64 * 1024; /** The `message_start` frame with `message.model` set to `model`, or undefined for any other frame. */ function messageStartWithModel(frame: string, model: string): string | undefined { const data = frame .split("\n") .map(line => sseFieldValue(line, "data")) .filter((value): value is string => value !== null) .join(""); if (!data) return undefined; let parsed: unknown; try { parsed = JSON.parse(data); } catch { return undefined; } if (!isRec(parsed) || parsed.type !== "message_start" || !isRec(parsed.message)) return undefined; parsed.message.model = model; return `event: message_start\ndata: ${JSON.stringify(parsed)}\n\n`; } /** * Echo the client's selector in `message_start.message.model`, as the translated lane does * (`responsesSseToAnthropicSse` is given the requested model). Works on bytes: frames before and * including `message_start` are split on the blank line, and everything after is relayed as is. */ function echoRequestedModel(body: ReadableStream<Uint8Array>, model: string): ReadableStream<Uint8Array> { const reader = body.getReader(); const encoder = new TextEncoder(); const decoder = new TextDecoder(); let pending = new Uint8Array(0); let scanning = true; let scanned = 0; const frameEnd = (bytes: Uint8Array): number => { for (let i = 0; i + 1 < bytes.length; i++) if (bytes[i] === 10 && bytes[i + 1] === 10) return i + 2; return -1; }; return new ReadableStream<Uint8Array>({ async pull(controller) { const { done, value } = await reader.read(); if (done) { if (pending.length > 0) controller.enqueue(pending); pending = new Uint8Array(0); controller.close(); return; } if (!scanning) { controller.enqueue(value); return; } scanned += value.byteLength; const joined = new Uint8Array(pending.length + value.byteLength); joined.set(pending); joined.set(value, pending.length); pending = joined; let end: number; while (scanning && (end = frameEnd(pending)) !== -1) { const frame = pending.subarray(0, end); pending = pending.subarray(end); const rewritten = messageStartWithModel(decoder.decode(frame), model); if (rewritten !== undefined) { controller.enqueue(encoder.encode(rewritten)); scanning = false; } else { controller.enqueue(frame); } } if (scanning && scanned > MODEL_ECHO_SCAN_BYTES) scanning = false; if (!scanning && pending.length > 0) { controller.enqueue(pending); pending = new Uint8Array(0); } }, cancel(reason) { return reader.cancel(reason); }, }); } /** A minimal valid Messages stream for a streaming caller whose upstream answered JSON. */ function messageAsSse(message: Rec): string { const frames: string[] = []; const emit = (name: string, data: Rec) => frames.push(`event: ${name}\ndata: ${JSON.stringify(data)}\n\n`); emit("message_start", { type: "message_start", message: { ...message, content: [], stop_reason: null } }); const blocks = Array.isArray(message.content) ? message.content.filter(isRec) : []; blocks.forEach((block, index) => { emit("content_block_start", { type: "content_block_start", index, content_block: block }); emit("content_block_stop", { type: "content_block_stop", index }); }); emit("message_delta", { type: "message_delta", delta: { stop_reason: message.stop_reason ?? "end_turn", stop_sequence: message.stop_sequence ?? null }, usage: message.usage ?? {}, }); emit("message_stop", { type: "message_stop" }); return frames.join(""); } /** Reject a body the Messages API cannot carry before anything is sent. */ async function prepareNativeBody(body: Rec, signal: AbortSignal): Promise<void> { if (!Array.isArray(body.messages)) return; // The adapter normally owns these; this lane bypasses it, so it runs the same steps as the // caller-forward passthrough: tier-normalize and guard images, then repair tool-call ids. await normalizeAnthropicImages(body.messages, { abortSignal: signal }); enforceAnthropicImageLimits(body.messages); sanitizePassthroughToolCallIds(body.messages); } /** * Handle one eligible Messages request natively. Opens the attempt, owns the request's final * log row, and answers in the Messages wire (SSE or JSON per the caller's own `stream`). */ export async function handleNativeMessages(options: HandleNativeMessagesOptions): Promise<Response> { const { req, config, logCtx, logIds, route, body, requestedModel, translatorBudget } = options; const requestedStream = body.stream === true; logCtx.inboundProtocol = "messages"; logCtx.model = route.modelId; logCtx.provider = route.providerName; logCtx.providerAdapter = route.provider.adapter; logCtx.requestedModel = requestedModel; if (route.routeReason === "model-alias" || route.modelId !== requestedModel) logCtx.requestedAlias = requestedModel; logCtx.requestedServiceTier = typeof body.service_tier === "string" ? body.service_tier : undefined; // Reserve spend the way native Chat does: an input estimate that never enters usage, and the // caller's own output ceiling. if (logCtx.usageLogInputTokens === undefined) { logCtx.spendInputEstimateTokens = estimateClaudeRequestTokens(body, requestedModel); } if (typeof body.max_tokens === "number" && body.max_tokens > 0) { logCtx.spendOutputCeilingTokens = Math.trunc(body.max_tokens); } const attemptHandle = beginInferenceAttempt(logCtx, { provider: route.providerName, model: route.modelId, adapter: "anthropic", }); attemptHandle.seal(logCtx.accountLogLabel); const { attempt } = attemptHandle; const finalLog = createFinalRequestLog(logIds, logCtx); const finishLog: FinishLog = (status, message, meta = { closeReason: "non_stream" }) => { if (finalLog.finished()) return; if (message) logCtx.upstreamError = redactSecretString(message).slice(0, 500); finalLog.finish(status, meta); }; const bindUsage = (usage: OcxUsage | undefined) => { if (!usage) return; if (!recordKeyWireAttemptUsage(logCtx, usage)) { logCtx.usage = usage; attempt.usage = usage; } }; const fail = (status: number, message: string, type?: string, code?: string): Response => { const safeMessage = redactSecretString(message); finishLog(status, safeMessage); return anthropicErrorResponse(status, safeMessage, type, code); }; const localOAuthFailure = (error: unknown): Response | null => { if (error instanceof AnthropicAccountCooldownError) { const response = fail(429, error.message, "rate_limit_error"); if (error.retryAfterSeconds !== null) response.headers.set("retry-after", String(error.retryAfterSeconds)); return response; } if (error instanceof OAuthAccountPausedError) return fail(403, publicOAuthAuthenticationErrorMessage(error), "permission_error"); if (error instanceof OAuthLoginRequiredError) return fail(401, publicOAuthAuthenticationErrorMessage(error), "authentication_error"); return null; }; try { await prepareNativeBody(body, req.signal); } catch (error) { if (req.signal.aborted) return fail(499, "Client cancelled request", "api_error"); if (isTranslatorBudgetExceededError(error)) { return fail(413, "request translation buffer exceeded the safe limit", "request_too_large", "translation_buffer_limit"); } // An AnthropicRequestError (empty tool id) or an image the guard cannot carry. return fail(400, error instanceof Error ? error.message : String(error), "invalid_request_error"); } const upstream = new AbortController(); const cleanupAbort = linkAbortSignal(upstream, req.signal); let streamTurnRegistered = false; const transferTurnToStream = () => { const lease = logIds?.turnAdmissionLease; if (!lease || typeof (lease as { bindAbortController?: unknown }).bindAbortController !== "function") return; registerTurn(upstream, lease); streamTurnRegistered = true; }; const releaseStreamTurn = () => { if (!streamTurnRegistered) return; streamTurnRegistered = false; unregisterTurn(upstream); }; const connectMs = config.connectTimeoutMs ?? 200_000; // An OAuth route is served by the account the existing OAuth selection commits now, at // dispatch; the token lives on this lane's provider copy only, never on the shared route. let oauthBinding: NativeOAuthBinding | undefined; const oauthProvider = (binding: NativeOAuthBinding): OcxProviderConfig => ({ ...route.provider, apiKey: binding.snapshot.accessToken }); if (route.provider.authMode === "oauth") { try { oauthBinding = await resolveNativeOAuthBinding(config); } catch (error) { cleanupAbort(); upstream.abort(); if (req.signal.aborted) return fail(499, "Client cancelled request", "api_error"); const localRefusal = localOAuthFailure(error); if (localRefusal) return localRefusal; if (error instanceof NativeOAuthSelectionChangedError) return fail(409, error.message, "api_error"); return fail(401, publicOAuthAuthenticationErrorMessage(error), "authentication_error"); } } else { // Same pre-dispatch key preference every direct send path applies (see chat-native.ts). const proactiveKeyProvider = selectProactiveApiKeyTransport(config, route.providerName, route.provider); if (proactiveKeyProvider) route.provider = proactiveKeyProvider; } let activeProvider: OcxProviderConfig = oauthBinding ? oauthProvider(oauthBinding) : route.provider; stampApiKeyAccountLabel(logCtx, route.providerName, activeProvider); if (oauthBinding) logCtx.provider = formatAnthropicProviderForLog(route.providerName, oauthBinding.snapshot.accountId, config); const spendTracker = attachRequestSpendTracker(req, logCtx); let activeRequest: AnthropicMessagesPassthroughRequest; let retainedRequestBytes = 0; const releaseRetainedRequest = () => { if (retainedRequestBytes === 0) return; translatorBudget.releaseRetained(retainedRequestBytes, { kind: "request_copies" }); retainedRequestBytes = 0; }; const retainRequest = (request: AnthropicMessagesPassthroughRequest) => { const bytes = Buffer.byteLength(request.body); translatorBudget.chargeRetained(bytes, { kind: "request_copies" }); retainedRequestBytes = bytes; }; // Every rebuild reads the same `body`; the builder copies and never mutates it, so no // credential, header or stripped block from an earlier build reaches the next one, and a build // for another credential domain decides opaque state from the full source again. const rejectUnrepresentable = resolveProtocolSettings(config).unrepresentable === "reject"; const buildActiveRequest = () => { recordAttemptCredentialSource(attempt, route.providerName, activeProvider, "anthropic"); const built = buildAnthropicMessagesPassthroughRequest(activeProvider, route.modelId, body, config, { callerAnthropicBeta: options.callerAnthropicBeta, }); if (built.strippedOpaqueState && rejectUnrepresentable) throw new NativeOpaqueStateRefusal(); if (built.droppedBetas) addProtocolEntryReason(logCtx, "anthropic-beta-dropped"); if (built.strippedOpaqueState) addProtocolEntryReason(logCtx, "opaque-state-stripped"); return built; }; const rebuildFor = (provider: OcxProviderConfig) => { activeProvider = provider; stampApiKeyAccountLabel(logCtx, route.providerName, activeProvider); releaseRetainedRequest(); activeRequest = buildActiveRequest(); retainRequest(activeRequest); }; try { activeRequest = buildActiveRequest(); retainRequest(activeRequest); } catch (error) { releaseRetainedRequest(); cleanupAbort(); upstream.abort(); if (isTranslatorBudgetExceededError(error)) { return fail(413, "request translation buffer exceeded the safe limit", "request_too_large", "translation_buffer_limit"); } if (error instanceof NativeOpaqueStateRefusal) { // Nothing was sent: this is a refusal before any upstream send. markProtocolBlocked(logCtx, { inbound: "messages", reasonCodes: ["feature-unrepresentable", "opaque-state-stripped"] }); logCtx.errorCode = "unsupported_feature"; return fail(400, error.message, "invalid_request_error", "unsupported_feature"); } return fail(400, error instanceof Error ? error.message : String(error), "invalid_request_error"); } // One inbound request owns one transient send allowance, captured before any key rotation. const requestTransientPolicy = transientRetryPolicyFor(activeProvider); let transientSendsUsed = 0; const remainingTransientSends = (): number => requestTransientPolicy ? Math.max(0, requestTransientPolicy.attempts - transientSendsUsed) : Number.POSITIVE_INFINITY; const transientSendAvailable = (): boolean => remainingTransientSends() > 0; const selector: NativeMessagesSelector = options.selector ?? {}; const send = async (recovery?: "rate-limit-429" | "key-429" | "key-401"): Promise<Response> => { const remaining = remainingTransientSends(); if (requestTransientPolicy && remaining <= 0) { throw new Error("native Messages transient send budget exhausted before recovery dispatch"); } const fetchWithPolicy = requestTransientPolicy ? fetchWithTransientRetry : fetchWithResetRetry; const request = activeRequest; return await fetchWithPolicy( (transportRecovery?: UpstreamSendRecovery) => fetchWithHeaderTimeout( request.url, applyUpstreamRecoveryInit({ method: "POST", headers: request.headers, body: request.body }, transportRecovery), upstream.signal, connectMs, requestedStream, providerFetch(activeProvider, undefined, { providerName: route.providerName, modelId: route.modelId, dispatchOverride: async (_input, init, execute) => { if (oauthBinding) { // The OAuth twin of the key check below: re-resolve through the same selection // owner when the committed account or its credential moved since the build. for (let attempt = 0; !nativeOAuthBindingIsCurrent(oauthBinding); attempt++) { if (attempt >= 3) throw new NativeOAuthSelectionChangedError(); try { oauthBinding = await resolveNativeOAuthBinding(config); } catch (error) { if (error instanceof OAuthAccountPausedError || error instanceof OAuthLoginRequiredError || error instanceof AnthropicAccountCooldownError) throw error; throw new NativeOAuthSelectionChangedError(); } rebuildFor(oauthProvider(oauthBinding)); logCtx.provider = formatAnthropicProviderForLog(route.providerName, oauthBinding.snapshot.accountId, config); } } else if (!providerApiKeySelectionIsCurrent(config, route.providerName, activeProvider)) { const current = resolveCurrentProviderApiKeyTransport(config, route.providerName, activeProvider); if (!current || nativeMessagesDeclineReason({ ...route, provider: current }, body, config, selector) !== undefined) { throw new Error("Provider key selection is no longer available for native Messages"); } rebuildFor(current); } // The retry closure may hold a pre-reselection request: send the current one whole. const wire = activeRequest; const headers = new Headers(wire.headers); const encoding = new Headers(init.headers).get("accept-encoding"); if (!headers.has("accept-encoding") && encoding) headers.set("accept-encoding", encoding); if (init.signal?.aborted) throw init.signal.reason; if (!spendTracker.charge()) throw new NativeMessagesSpendRefusal(); noteProviderAttemptSend(logCtx, route.providerName, activeProvider, logCtx.usageLogInputTokens, transportRecovery ?? recovery); const dispatched = await sendWithConnectionPolicy( (activeProvider as OcxProviderTransport).fetch ?? execute, wire.url, applyUpstreamRecoveryInit({ ...init, method: "POST", headers, body: wire.body }, transportRecovery), { providerName: route.providerName, provider: activeProvider }, ); if (!dispatched.ok) await recordKeyAttemptFailure(logCtx, dispatched, init.signal ?? upstream.signal); return dispatched; }, }), ), { abortSignal: upstream.signal, label: safeHostLabel(request.url), ...(requestTransientPolicy ? { attempts: remaining, onSendsConsumed: (sends: number) => { transientSendsUsed += Math.max(0, sends); }, } : {}), }, ); }; const discard = (response: Response) => { try { void response.body?.cancel().catch(() => {}); } catch { /* already closed */ } }; let response: Response; try { response = await send(); // A credential-scoped 401 on a static key pool says nothing about the sibling keys. while (response.status === 401 && hasKeyPoolFailover(activeProvider) && transientSendAvailable()) { const rotated = rotateProviderTransportOn401(config, route.providerName, activeProvider, { now: Date.now(), attemptedKey: activeProvider.apiKey, }); if (!rotated) break; discard(response); rebuildFor(rotated); response = await send("key-401"); } const retryPolicy = rateLimitRetryPolicyFor(activeProvider); let retries = 0; // A refusal this proxy synthesized for a reset replay is not a provider rate limit. while ( response.status === 429 && !isNonReplayableResponse(response) && retryPolicy && retries < retryPolicy.attempts && transientSendAvailable() ) { retries += 1; for await (const _ of prepareSameTarget429Wait({ body: response.body, signal: upstream.signal, delayMs: rateLimitRetryDelayMs(retryPolicy, response.headers.get("retry-after"), Date.now()), })) { /* pre-stream wait */ } if (upstream.signal.aborted) throw upstream.signal.reason; response = await send("rate-limit-429"); } while (response.status === 429 && !isNonReplayableResponse(response) && hasKeyPoolFailover(activeProvider)) { const rotated = rotateProviderTransportOn429(config, route.providerName, activeProvider, { retryAfter: response.headers.get("retry-after"), now: Date.now(), attemptedKey: activeProvider.apiKey, attemptedSelection: activeProvider._apiKeyAttempt, }); if (!rotated) break; // Rotation already recorded the cooldown; keep the terminal 429 when no send remains. if (!transientSendAvailable()) break; discard(response); rebuildFor(rotated); response = await send("key-429"); } } catch (error) { releaseRetainedRequest(); cleanupAbort(); upstream.abort(); if (req.signal.aborted) return fail(499, "Client cancelled request", "api_error"); const sendError = error instanceof UpstreamRetryEvidenceError ? error.cause : error; if (sendError instanceof NativeMessagesSpendRefusal) { const refusal = workflowRefusalResponse("workflow-spend-exhausted", logCtx); finishLog(429); return refusal; } const localRefusal = localOAuthFailure(sendError); if (localRefusal) return localRefusal; if (sendError instanceof NativeOAuthSelectionChangedError) return fail(409, sendError.message, "api_error"); if (sendError instanceof NativeOpaqueStateRefusal) { logCtx.errorCode = "unsupported_feature"; return fail(400, sendError.message, "invalid_request_error", "unsupported_feature"); } if (isTranslatorBudgetExceededError(error)) { return fail(413, "request translation buffer exceeded the safe limit", "request_too_large", "translation_buffer_limit"); } return fail(502, error instanceof Error ? error.message : String(error), "api_error"); } releaseRetainedRequest(); if (!response.ok) { let bodyText = ""; try { const read = await readBoundedResponseBody(response, { signal: upstream.signal, maxBytes: MAX_NATIVE_MESSAGES_ERROR_BYTES }); if (read.displaySafe) bodyText = read.text; } catch { /* status-only fallback */ } cleanupAbort(); if (req.signal.aborted) { upstream.abort(); return fail(499, "Client cancelled request", "api_error"); } return nativeMessagesErrorResponse(response, bodyText, finishLog); } const contentType = response.headers.get("content-type")?.toLowerCase() ?? ""; if (contentType.includes("text/event-stream") && response.body) { // `upstream` follows req.signal and is also what shutdown and turn release abort, so both // the client leaving and this lane's own abort read as a cancel, not as a failed stream. const bodyGuard = resolvePassthroughBodyGuard(config, upstream.signal); const observed = logIds ? observeFirstChunk(response.body, () => recordFirstOutput(logCtx, logIds.start)) : response.body; const renamed = activeRequest.oauthToolNames ? restoreOAuthToolNamesInSse(observed, activeRequest.oauthToolNames, translatorBudget) : observed; const source = echoRequestedModel(renamed, requestedModel); if (requestedStream) { transferTurnToStream(); const relayed = tapAnthropicSseForLog(source, logCtx, (status, meta) => { try { cleanupAbort(); bindUsage(logCtx.usage); finishLog(status, undefined, meta); if (meta.closeReason !== "terminal") upstream.abort(); } finally { releaseStreamTurn(); } }, bodyGuard); return new Response(relayed, { status: 200, headers: { "Content-Type": "text/event-stream; charset=utf-8", "Cache-Control": "no-cache", Connection: "keep-alive" }, }); } // A non-streaming caller whose upstream streamed anyway: fold the stream into one message. const tapState: { closeReason?: FinalRequestLogMeta["closeReason"]; meta?: FinalRequestLogMeta } = {}; const tapped = tapAnthropicSseForLog(source, logCtx, (_status, meta) => { tapState.closeReason = meta.closeReason; tapState.meta = meta; }, bodyGuard); try { const message = await collectAnthropicMessage(tapped, requestedModel, translatorBudget); cleanupAbort(); if (tapState.closeReason === "client_cancel" || req.signal.aborted) { return fail(499, "Client cancelled request", "api_error"); } bindUsage(logCtx.usage); if (message.type === "error") { const error = isRec(message.error) ? message.error : {}; const text = typeof error.message === "string" ? error.message : "upstream stream failed"; // The tap's own verdict (a reset, a stall, the byte cap) closes this row with the same meta // as the streaming lane's row; a plain upstream error event keeps the non_stream row. const tapMeta = tapState.meta; if (tapMeta && (tapMeta.terminalStatus || tapMeta.closeReason !== "terminal")) finishLog(502, text, tapMeta); return fail(502, text, "api_error"); } finishLog(200); return Response.json(message); } catch (error) { cleanupAbort(); upstream.abort(); if (req.signal.aborted) return fail(499, "Client cancelled request", "api_error"); if (isTranslatorBudgetExceededError(error)) { return fail(413, "upstream translation buffer exceeded the safe limit", "request_too_large", "translation_buffer_limit"); } return fail(502, error instanceof Error ? error.message : String(error), "api_error"); } } let read; try { read = await readBoundedResponseBody(response, { signal: upstream.signal, maxBytes: MAX_NATIVE_MESSAGES_JSON_BYTES, totalTimeoutMs: Math.max(connectMs, 5_000), inactivityTimeoutMs: Math.max(connectMs, 5_000), }); } catch (error) { cleanupAbort(); upstream.abort(); if (req.signal.aborted) return fail(499, "Client cancelled request", "api_error"); return fail(502, error instanceof Error ? error.message : String(error), "api_error"); } cleanupAbort(); if (read.oversized) { upstream.abort(); return fail(502, "upstream response exceeded the safe limit", "api_error", "translation_buffer_limit"); } let parsedMessage: unknown; try { parsedMessage = JSON.parse(read.text); } catch { return fail(502, "upstream returned malformed Messages JSON", "api_error"); } if (!isRec(parsedMessage) || parsedMessage.type !== "message") { return fail(502, "upstream response was not a Messages result", "api_error"); } const message = activeRequest.oauthToolNames ? restoreOAuthToolNamesInMessage(parsedMessage, activeRequest.oauthToolNames) : parsedMessage; bindUsage(anthropicUsageToOcx(isRec(message.usage) ? message.usage : undefined)); if (logIds) recordFirstOutput(logCtx, logIds.start); try { translatorBudget.chargeRetained(Buffer.byteLength(read.text) * 2, { kind: "live_transient" }); } catch (error) { if (isTranslatorBudgetExceededError(error)) { return fail(502, "upstream translation buffer exceeded the safe limit", "api_error", "translation_buffer_limit"); } throw error; } // The client's selector, not the wire id, as the translated lane answers. message.model = requestedModel; const serialized = JSON.stringify(message); finishLog(200); if (requestedStream) { return new Response(messageAsSse(message), { status: 200, headers: { "Content-Type": "text/event-stream; charset=utf-8", "Cache-Control": "no-cache" }, }); } return new Response(serialized, { status: 200, headers: { "Content-Type": "application/json" } }); } /** * A non-OK upstream answer in Anthropic shape. Status and retry policy follow the translated * Messages path, so a client sees the same contract on either lane: transient 5xx become 529 * with a retry hint, and a proxy-side replay refusal keeps its no-retry marking. */ function nativeMessagesErrorResponse(response: Response, bodyText: string, finishLog: FinishLog): Response { let upstreamType: string | undefined; let upstreamMessage: string | undefined; try { const parsed = JSON.parse(bodyText) as Rec; const details = isRec(parsed.error) ? parsed.error : parsed; if (typeof details.type === "string") upstreamType = details.type; if (typeof details.message === "string" && details.message.trim()) { upstreamMessage = redactSecretString(details.message.trim()); } } catch { /* keep generic classification */ } const detail = formatAnthropicErrorBody(response.status, response.headers, bodyText); const message = upstreamMessage ?? (detail ? `Provider error ${response.status}: ${detail}` : `Provider error ${response.status}`); const classified = classifyError( response.status, upstreamType ?? (response.status === 401 ? "authentication_error" : response.status === 429 ? "rate_limit_error" : response.status >= 500 ? "api_error" : "invalid_request_error"), message, ); const safeMessage = redactSecretString(classified.message); const replayRefusal = isReplayRefusalResponse(response); const transient = !replayRefusal && isTransientUpstreamStatus(response.status); const status = replayRefusal ? REPLAY_REFUSED_STATUS : transient ? 529 : response.status; const upstreamRetryAfter = response.headers.get("retry-after"); const retryAfter = replayRefusal ? undefined : resolveClientRetryAfter({ status: response.status, message: safeMessage, upstreamRetryAfter }) ?? (upstreamRetryAfter?.trim() === "0" ? "0" : undefined); finishLog(response.status, safeMessage); const headers = new Headers({ "Content-Type": "application/json" }); if (retryAfter) headers.set("Retry-After", retryAfter); else if (transient) headers.set("Retry-After", "2"); if (replayRefusal) applyReplayRefusalClientHeaders(headers); const out = new Response(JSON.stringify(anthropicErrorBody( status, safeMessage, transient ? "overloaded_error" : upstreamType, replayRefusal ? UPSTREAM_RESET_REPLAY_REFUSED_CODE : undefined, )), { status, headers }); return replayRefusal ? retainReplayRefusal(out) : out; } /** * The body `count_tokens` should count for this selector: what the native lane would send when * the route is eligible, else `undefined` so the caller keeps its existing estimate. Reads config * and the router's deterministic branches only; sends nothing. */ export function nativeMessagesCountBody( config: OcxConfig, cc: OcxConfig["claudeCode"], body: Rec, rows: Pick<NativeMessagesSelector, "effortRow" | "fastRow">, ): Rec | undefined { if (typeof body.model !== "string") return undefined; try { const selectorId = resolveInboundModel(body.model, cc); // Combo and policy selectors are never eligible, and routing them would advance round-robin // state or run the policy evaluator for a request that sends nothing. if (resolvePolicyProfileId(config, selectorId) !== null || selectorId.startsWith(`${POLICY_NAMESPACE}/`)) return undefined; if (!preservesPhysicalComboProvider(config) && resolveComboId(config, selectorId) !== null) return undefined; const route = routeModel(config, selectorId); route.staticPolicy = captureRouteStaticPolicy( route.providerName, route.modelId, route.provider, route.staticPolicy.effectiveAlias, "anthropic", ); route.provider = resolveWireProtocolOverride(route.providerName, route.modelId, route.provider, "anthropic", route.staticPolicy); const selector: NativeMessagesSelector = { ...rows, routeSelector: selectorId, claudeCode: cc, ...(route.provider.authMode === "oauth" ? { oauthFailoverQuorum: hasAnthropicFailoverQuorum() } : {}), }; if (nativeMessagesDeclineReason(route, body, config, selector) !== undefined) return undefined; // The body without a credential: counting never resolves or refreshes an OAuth account. return anthropicMessagesNativeWireBody(route.provider, route.modelId, body).wireBody; } catch { return undefined; } }