@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
621 lines (608 loc) • 30.2 kB
text/typescript
import type { MessagesSseErrorFilter } from "./messages-sse-error-filter";
import { MessagesSseFrameContext, messagesSseLocalFrame, type MessagesSseLocalOrigin } from "../lib/messages-sse-error-presentation";
import { markProxyError } from "../lib/client-error-body";
/**
* Accounting and measurement pieces shared by the two Claude Messages lanes.
*
* claude-messages.ts (caller-credential passthrough and translate-and-replay) and
* messages-native.ts (the proxy-managed native lane) both need this layer, and
* neither may import the other. It once closed a cycle: messages-native.ts took this
* code statically from claude-messages.ts while claude-messages.ts reached back
* dynamically to dispatch, so every install that only serves caller-forward
* passthrough still loaded the whole native lane.
*
* Everything here is a leaf: lib/, adapters/ primitives, and types only. Nothing
* reaches another server/ module, so either lane can take it without pulling in the
* other.
*/
import { sniffImageDimensions } from "../adapters/anthropic-image-guard";
import { anthropicCacheWrite1hTokens } from "../adapters/anthropic/cache-retention";
import { createToolCallIdAllocator } from "../adapters/tool-call-id";
import { idleDeadline } from "../lib/abort";
import {
CLAUDE_NATIVE_THINKING,
projectClaudeRequest,
type ClaudeThinkingProjection,
} from "../lib/claude-request-projection";
import { redactSecretString } from "../lib/redact";
import { sseFieldValue } from "../lib/sse-decoder";
import { estimateTokens } from "../lib/token-estimate";
import { isTranslatorBudgetExceededError } from "../lib/translator-budget";
import { httpStatusFromTerminalError } from "../lib/errors";
import { AnthropicRequestError, isRec, type Rec } from "../claude/inbound-records";
import type { RequestLogContext } from "./request-log";
import { recordGenerationEvent } from "./request-log-generation-window";
import { recordLocalFailureDetail } from "./request-log-failure-detail";
import type { OcxConfig } from "../types";
export function anthropicUsageToOcx(usage: Rec | undefined): { inputTokens: number; outputTokens: number; cachedInputTokens?: number; cacheReadInputTokens?: number; cacheCreationInputTokens?: number; cacheCreation1hInputTokens?: number } | undefined {
if (!usage) return undefined;
const num = (v: unknown) => typeof v === "number" ? v : 0;
const hasCache = usage.cache_read_input_tokens !== undefined || usage.cache_creation_input_tokens !== undefined;
const read = num(usage.cache_read_input_tokens);
const write = num(usage.cache_creation_input_tokens);
const write1h = anthropicCacheWrite1hTokens(usage, write);
// Anthropic input_tokens excludes cache read/write; normalize to the canonical
// inclusive convention (types.ts OcxUsage / devlog 070). cached = READS only.
return {
inputTokens: num(usage.input_tokens) + read + write,
outputTokens: num(usage.output_tokens),
...(hasCache ? {
cachedInputTokens: read,
cacheReadInputTokens: read,
cacheCreationInputTokens: write,
...(write1h !== undefined ? { cacheCreation1hInputTokens: write1h } : {}),
} : {}),
};
}
/** Body-occupancy guard for the native passthrough (devlog 260716_passthrough_followups/010). */
/**
* True when an undelimited SSE tail (LF-normalized) holds nothing a client would act on: only
* whitespace, comments, or a ping. Anything else is a message event cut off at EOF.
*/
export function isHarmlessSseTail(tail: string): boolean {
const lines = tail.split("\n").filter(line => line.trim() !== "");
let event: string | null = null;
const data: string[] = [];
for (const line of lines) {
if (line.startsWith(":")) continue;
const eventValue = sseFieldValue(line, "event");
if (eventValue !== null) { event = eventValue; continue; }
const dataValue = sseFieldValue(line, "data");
if (dataValue !== null) { data.push(dataValue); continue; }
return false;
}
if (data.length === 0) return event === null || event === "ping";
try {
const payload: unknown = JSON.parse(data.join("\n"));
return isRec(payload) && payload.type === "ping" && (event === null || event === "ping");
} catch {
return false;
}
}
export interface PassthroughBodyGuard {
/** Idle window in ms — raw upstream-byte inactivity while a read is pending. 0 disables. */
stallMs: number;
/** Cumulative body byte cap. 0 disables. */
maxBytes: number;
/** Client request signal for deterministic cancel classification. */
reqSignal?: AbortSignal;
/** Lets an observer before frame buffering refresh the tap's pending-read deadline. */
rawActivity?: { refresh?: () => void };
/**
* The routed provider opted into anthropicEofTolerance: a content-only clean EOF (no
* message_stop, no stop_reason, nothing cut) stays a completed turn, as it always was.
*/
eofTolerant?: boolean;
}
export type PassthroughCloseReason = "terminal" | "client_cancel" | "body_stall" | "body_overflow";
export type PassthroughFinalizeMeta = { closeReason: PassthroughCloseReason; terminalStatus?: "failed" | "incomplete" };
/**
* Tap an Anthropic-vocabulary SSE stream for the request log (usage + terminal),
* bounding body occupancy: idle (silence-only, timed ONLY while a reader.read() is
* pending so downstream backpressure never counts as upstream inactivity) and a
* cumulative byte cap. On stall/overflow, or when the upstream read fails after the
* headers went out, it appends a protocol-compatible Anthropic `event: error` terminal
* frame after a blank-line boundary, closes, and cancels the upstream reader — never a
* total-wall-clock bound (slow-but-alive streams live).
* Exported for deterministic unit tests.
*/
export function tapAnthropicSseForLog(
upstream: ReadableStream<Uint8Array>,
logCtx: RequestLogContext,
finalize: (status: number, meta: PassthroughFinalizeMeta) => void,
guard?: PassthroughBodyGuard,
frames?: MessagesSseFrameContext,
clientFilter?: MessagesSseErrorFilter,
): ReadableStream<Uint8Array> {
const decoder = new TextDecoder();
const encoder = new TextEncoder();
let frameParts: string[] = [];
let pendingParts: string[] = [];
let pendingChars = 0;
let heldCr = false;
let heldLf = false;
const appendPart = (part: string) => {
if (!part) return;
pendingParts.push(part);
pendingChars += part.length;
// Coalesce tiny transport fragments: a one-byte feed must not retain one array
// entry per byte for the entire event. Each character is joined at most twice.
if (pendingChars >= 4096) {
frameParts.push(pendingParts.join(""));
pendingParts = [];
pendingChars = 0;
}
};
const takeFrame = () => {
if (pendingParts.length) frameParts.push(pendingParts.join(""));
const frame = frameParts.join("");
frameParts = [];
pendingParts = [];
pendingChars = 0;
return frame;
};
let usageAcc: Rec = {};
// message_stop or an upstream error event: the turn's own terminal already went through.
let terminalSeen = false;
let errorSeen = false;
// stop_reason of the latest message event the client received as a complete SSE event. Any
// later message event (resumed content) clears it; pings and comments do not.
let lastDeliveredStop: string | null = null;
// A frame is evidence of an event only when its payload type and its event name agree (or the
// event line is absent): clients and the non-stream fold dispatch on the event name.
const named = (event: string | null, data: Rec, type: string) => data.type === type && (event === null || event === type);
const inspectFrame = (frame: string, delivered = true) => {
const lines = frame.split("\n");
// SSE dispatches on the last event field of a frame.
const eventLine = lines.map(l => sseFieldValue(l, "event")).findLast((v): v is string => v !== null);
// The value is used as SSE delivers it (one leading space stripped, nothing trimmed).
const event = eventLine === undefined ? null : eventLine;
const dataLine = lines
.map(l => sseFieldValue(l, "data"))
.filter((v): v is string => v !== null)
.join("\n");
if (!dataLine) return;
let data: unknown;
try { data = JSON.parse(dataLine); } catch { data = null; }
if (errorSeen && !(isRec(data) && named(event, data, "ping"))) logCtx.streamErrorFollowed = true;
if (!isRec(data)) {
// A malformed event after a stop reason means the turn kept going and was cut.
if (delivered) lastDeliveredStop = null;
return;
}
recordGenerationEvent(logCtx, data.type);
if (data.type === "message_start" && isRec(data.message) && isRec(data.message.usage)) {
usageAcc = { ...usageAcc, ...data.message.usage };
} else if (data.type === "message_delta" && isRec(data.usage)) {
usageAcc = { ...usageAcc, ...data.usage };
}
if (named(event, data, "message_stop") || named(event, data, "error")) {
terminalSeen = true;
if (data.type === "error") {
errorSeen = true;
const error = isRec(data.error) ? data.error : {};
logCtx.streamErrorStatus = httpStatusFromTerminalError({ type: typeof error.type === "string" ? error.type : undefined,
code: typeof error.code === "string" ? error.code : undefined, message: typeof error.message === "string" ? error.message : undefined });
}
} else if (delivered && !named(event, data, "ping")) {
const delta = isRec(data.delta) ? data.delta : undefined;
lastDeliveredStop = named(event, data, "message_delta") && typeof delta?.stop_reason === "string"
? delta.stop_reason
: null;
}
};
const inspect = (chunk: Uint8Array) => {
// Normalize and scan only new text. Keep an unfinished frame in fragments so a long
// SSE event arriving in small chunks is never flattened or rescanned on each read.
let text = (heldCr ? "\r" : "") + decoder.decode(chunk, { stream: true });
heldCr = text.endsWith("\r");
text = (heldCr ? text.slice(0, -1) : text).replace(/\r\n?/g, "\n");
let start = 0;
if (text && heldLf) {
heldLf = false;
if (text[0] === "\n") {
inspectFrame(takeFrame());
start = 1;
} else appendPart("\n");
}
let sep: number;
while ((sep = text.indexOf("\n\n", start)) !== -1) {
appendPart(text.slice(start, sep));
inspectFrame(takeFrame());
start = sep + 2;
}
if (start < text.length) {
heldLf = text.endsWith("\n");
const end = text.length - (heldLf ? 1 : 0);
appendPart(text.slice(start, end));
}
// The relay may reframe this read: a combo child judges a retryable error by what followed it here.
if (errorSeen && !logCtx.streamErrorFollowed
&& (frameParts.length > 0 || !isHarmlessSseTail(pendingParts.join("")))) logCtx.streamErrorFollowed = true;
};
// The last block can sit in the buffer without its blank line: an upstream that stopped after
// it, or a held trailing CR. Count it before deciding how the turn ended (the Responses relay
// flushes the same candidate). terminalInTail: this flush found the terminal in a block the
// client has not seen a blank line after, so the caller restores one. tailClean: nothing but
// comments or a ping is left undelimited, so no message event was cut off.
const flushTail = (): { terminalInTail: boolean; tailClean: boolean } => {
// Rebuild the unscanned text in wire order (fragments, held LF, held CR). At EOF a held CR is
// a line ending, so it can complete a frame the client already has.
const rest = (takeFrame() + (heldLf ? "\n" : "") + (heldCr ? "\r" : "") + decoder.decode()).replace(/\r\n?/g, "\n");
heldCr = false;
heldLf = false;
let start = 0;
let sep: number;
while ((sep = rest.indexOf("\n\n", start)) !== -1) {
inspectFrame(rest.slice(start, sep));
start = sep + 2;
}
const tail = rest.slice(start);
const terminalBefore = terminalSeen;
if (tail) inspectFrame(tail, false);
return {
terminalInTail: terminalSeen && !terminalBefore,
tailClean: isHarmlessSseTail(tail),
};
};
const reader = upstream.getReader();
let settled = false;
let bodyBytes = 0;
let tapController: ReadableStreamDefaultController<Uint8Array> | undefined;
let deliveryFailed = false;
const enqueue = (bytes: Uint8Array): number => {
let count = 0;
try {
if (clientFilter) clientFilter.push(bytes, value => { tapController!.enqueue(value); count++; });
else { tapController!.enqueue(bytes); count++; }
return count;
} catch (error) {
deliveryFailed = clientFilter !== undefined;
clientFilter?.dispose();
throw error;
}
};
const close = () => { clientFilter?.finish(value => tapController!.enqueue(value)); tapController!.close(); };
const recordUsage = () => {
logCtx.usage = anthropicUsageToOcx(Object.keys(usageAcc).length > 0 ? usageAcc : undefined);
};
const closeWithErrorFrame = (errType: string, message: string, origin: MessagesSseLocalOrigin) => {
const payload = JSON.stringify({ type: "error", error: { type: errType, message } });
try {
// Leading blank line terminates any partial SSE block so the frame parses cleanly
// (relaySseWithFailedTail policy, Anthropic wire shape).
const bytes = encoder.encode(`\n\nevent: error\ndata: ${payload}\n\n`);
frames?.register(bytes, { client: messagesSseLocalFrame(origin, message) });
enqueue(bytes);
close();
} catch { /* client already torn down */ }
};
const failBody = (closeReason: "body_stall" | "body_overflow", errType: string, message: string) => {
if (settled) return;
settled = true;
idle.cancel();
detachAbort();
const { terminalInTail } = flushTail();
recordUsage();
if (terminalSeen) {
// The turn already ended (message_stop or an upstream error event): an upstream that then
// idles or keeps sending did not cut it short. Same rule as the read-error branch,
// including the restored blank line for a terminal found only in the tail.
finalize(200, { closeReason: "terminal" });
try {
if (terminalInTail) enqueue(encoder.encode("\n\n"));
close();
} catch { /* client already torn down */ }
} else {
// A cut-short turn, logged as the Responses relay logs a stall-timeout incomplete
// (httpStatusForRequestLogTerminal: only a max_output_tokens incomplete is a 200). A 200
// row with no terminalStatus also lost its failure diagnostics in usage.jsonl.
recordLocalFailureDetail(logCtx, message, closeReason === "body_stall"
? { code: "body_stall", value: guard?.stallMs ?? 0 } : { code: "body_overflow", value: guard?.maxBytes ?? 0 });
finalize(502, { terminalStatus: "incomplete", closeReason });
closeWithErrorFrame(errType, message, closeReason === "body_stall" ? "stall" : "cap");
}
reader.cancel(new DOMException(message, closeReason === "body_stall" ? "TimeoutError" : "QuotaExceededError")).catch(() => {});
};
const idle = idleDeadline(guard?.stallMs ?? 0, () => {
failBody(
"body_stall",
"timeout_error",
`anthropic passthrough body stalled: no upstream bytes for ${Math.round((guard?.stallMs ?? 0) / 1000)}s`,
);
});
const rawActivity = guard?.rawActivity;
// Deterministic client-cancel classification: Bun may surface a client abort as a
// reader.read() rejection OR a resolved done (src/lib/abort.ts cancelBodyOnAbort
// rationale), so the listener performs first-wins settlement itself instead of
// relying on which shape the read takes.
const onClientAbort = () => {
if (settled) return;
settled = true;
idle.cancel();
detachAbort();
recordUsage();
finalize(499, { closeReason: "client_cancel" });
clientFilter?.dispose();
try { tapController?.close(); } catch { /* downstream already torn down */ }
reader.cancel(guard?.reqSignal?.reason).catch(() => {});
};
const detachAbort = (() => {
const signal = guard?.reqSignal;
if (!signal) return () => {};
if (signal.aborted) {
queueMicrotask(onClientAbort);
return () => {};
}
signal.addEventListener("abort", onClientAbort, { once: true });
return () => signal.removeEventListener("abort", onClientAbort);
})();
return new ReadableStream<Uint8Array>({
start(controller) {
tapController = controller;
},
async pull(controller) {
if (settled) return;
try {
for (;;) {
idle.reset();
if (rawActivity) rawActivity.refresh = idle.reset;
const { done, value } = await reader.read();
if (rawActivity) rawActivity.refresh = undefined;
idle.pause();
if (settled) return; // stall/overflow/abort won the race while we awaited
if (done) {
// Bun can resolve a cancelled read as done before the abort listener runs: a client
// that left is a cancel, not a cut upstream.
if (guard?.reqSignal?.aborted) {
onClientAbort();
return;
}
settled = true;
idle.cancel();
detachAbort();
const { terminalInTail, tailClean } = flushTail();
recordUsage();
// A clean EOF ends the turn only when the client already has its terminal, or a
// complete non-error stop_reason with nothing cut after it (compatible providers may
// omit message_stop; the translated adapter accepts the same shape). The opt-in
// anthropicEofTolerance profile keeps a content-only EOF as it always was.
const failure = terminalSeen
? null
: lastDeliveredStop === "error"
? 'upstream ended the turn with stop_reason "error"'
: !tailClean
? "anthropic passthrough upstream stream ended before message_stop"
: lastDeliveredStop !== null || guard?.eofTolerant === true
? null
: "anthropic passthrough upstream stream ended before message_stop";
if (failure === null) {
finalize(200, { closeReason: "terminal" });
if (terminalInTail) enqueue(encoder.encode("\n\n"));
close();
return;
}
// A body that stopped short is a failed turn, logged and surfaced like a mid-stream
// reset (below), so the client never reads a partial answer as a finished message.
logCtx.transportPhase = "mid_stream";
logCtx.terminalSource = "synthetic";
recordLocalFailureDetail(logCtx, failure, { code: lastDeliveredStop === "error" ? "stream_error_stop" : "stream_ended_early" });
if (logCtx.activeAttempt) logCtx.activeAttempt.streamAborted = true;
finalize(502, { terminalStatus: "failed", closeReason: "terminal" });
closeWithErrorFrame("api_error", failure, lastDeliveredStop === "error" ? "stop-error" : "eof");
return;
}
if (value.byteLength > 0) {
bodyBytes += value.byteLength;
if (guard && guard.maxBytes > 0 && bodyBytes > guard.maxBytes) {
failBody(
"body_overflow",
"api_error",
`anthropic passthrough body exceeded ${guard.maxBytes} bytes`,
);
return;
}
}
inspect(value);
if (enqueue(value) > 0) return;
}
} catch (err) {
if (rawActivity) rawActivity.refresh = undefined;
if (settled) return;
// Bun can settle a fetch body read before it dispatches the abort listeners
// (consumeForInspection in relay.ts): read the signal itself before calling this
// rejection an upstream failure.
if (guard?.reqSignal?.aborted) {
onClientAbort();
return;
}
settled = true;
idle.cancel();
detachAbort();
const { terminalInTail } = flushTail();
recordUsage();
if (isTranslatorBudgetExceededError(err)) {
// A local cap, not an upstream failure: the non-streaming native Messages fold
// maps this error to a 413 itself, so it still errors the stream.
finalize(200, { closeReason: "terminal" });
clientFilter?.dispose();
try { controller.error(err); } catch { /* torn down */ }
return;
}
if (terminalSeen) {
// Only the transport trailer was lost; the client already has the turn's terminal.
// The Responses relay likewise reports a read error only without a seen terminal.
finalize(200, { closeReason: "terminal" });
try {
// An SSE parser drops an event that EOF cuts off before its blank line, so restore
// the delimiter when the terminal was only found in that unterminated tail.
if (deliveryFailed) controller.error(err);
else {
if (terminalInTail) enqueue(encoder.encode("\n\n"));
close();
}
} catch { /* torn down */ }
reader.cancel(err).catch(() => {});
return;
}
// The upstream read failed after the 200 went out (a mid-stream socket reset). Log it
// the way the Responses relay does (onReadError): a truncated body is a failed turn,
// not a completed one. The client gets the same Anthropic error terminal as a stall,
// instead of a connection reset — or, on some Bun releases, a bare EOF that reads as
// a finished message.
const message = redactSecretString(`anthropic passthrough upstream stream failed: ${err instanceof Error ? err.message : String(err)}`);
logCtx.transportPhase = "mid_stream";
logCtx.terminalSource = "synthetic";
// The runtime error text stays internal; the row keeps the fixed sentence only.
recordLocalFailureDetail(logCtx, "anthropic passthrough upstream stream failed", { code: "stream_failed" });
logCtx.upstreamError = message.slice(0, 500);
if (logCtx.activeAttempt) logCtx.activeAttempt.streamAborted = true;
finalize(502, { terminalStatus: "failed", closeReason: "terminal" });
if (deliveryFailed) { clientFilter?.dispose(); try { controller.error(err); } catch { /* torn down */ } }
else closeWithErrorFrame("api_error", message, "read");
reader.cancel(err).catch(() => {});
}
},
cancel(reason) {
clientFilter?.dispose();
if (!settled) {
settled = true;
idle.cancel();
detachAbort();
recordUsage();
finalize(499, { closeReason: "client_cancel" });
}
reader.cancel(reason).catch(() => {});
},
});
}
/**
* `tool_use.id` / `tool_result.tool_use_id` must match Anthropic's wire contract
* (`^[a-zA-Z0-9_-]+$`, <=64 chars). Third-party models mint other shapes — Devin's
* swe-2 emits `Bash:0#<hex>` — and a session history carrying them 400s the moment it
* is switched to a native Anthropic model ("messages.N.content.M.tool_use.id: String
* should match pattern"). The adapter path normalizes these via
* adapters/tool-call-id.ts (#1780); this passthrough bypasses that adapter, so the same
* allocator runs here. Stateless per request: conforming ids pass through byte-identical
* (prompt-cache keys untouched), rewritten ids keep call/result pairing stable.
* An empty id has no representable wire form, and forwarding `""` is what Anthropic
* rejects (#1767), so the request fails locally with a 400 before any upstream fetch.
*/
export function sanitizePassthroughToolCallIds(messages: unknown[]): void {
const blocks: Rec[] = [];
for (const message of messages) {
if (!isRec(message) || !Array.isArray(message.content)) continue;
for (const block of message.content) if (isRec(block)) blocks.push(block);
}
const fieldOf = (block: Rec): "id" | "tool_use_id" | undefined => {
if (typeof block.type !== "string") return undefined;
if (block.type.endsWith("tool_use")) return "id";
if (block.type.endsWith("tool_result")) return "tool_use_id";
return undefined;
};
const callIds = createToolCallIdAllocator();
for (const block of blocks) {
const field = fieldOf(block);
if (field && typeof block[field] === "string") callIds.reserve(block[field] as string);
}
for (const block of blocks) {
const field = fieldOf(block);
if (!field || typeof block[field] !== "string") continue;
const wire = callIds.allocate(block[field] as string);
if (wire === undefined) throw markProxyError(new AnthropicRequestError(field === "id" ? "tool_use block has an empty id" : "tool_result block has an empty tool_use_id"));
block[field] = wire;
}
}
const DEFAULT_BODY_STALL_SEC = 90;
const DEFAULT_BODY_MAX_BYTES = 64 * 1024 * 1024;
/**
* Normalize the claudeCode body-guard config (devlog 260716_passthrough_followups/010).
* Policy: exactly 0 disables; finite positive values are honored (stall clamped to
* min 1s); negative/non-finite/absent values fall back to the defaults.
*/
export function resolvePassthroughBodyGuard(config: OcxConfig, reqSignal?: AbortSignal): PassthroughBodyGuard {
const rawSec = config.claudeCode?.bodyStallSec;
const stallSec = rawSec === 0
? 0
: typeof rawSec === "number" && Number.isFinite(rawSec) && rawSec > 0
? Math.max(1, rawSec)
: DEFAULT_BODY_STALL_SEC;
const rawBytes = config.claudeCode?.bodyMaxBytes;
const maxBytes = rawBytes === 0
? 0
: typeof rawBytes === "number" && Number.isFinite(rawBytes) && rawBytes > 0
? Math.floor(rawBytes)
: DEFAULT_BODY_MAX_BYTES;
return { stallMs: stallSec * 1000, maxBytes, ...(reqSignal ? { reqSignal } : {}) };
}
/** Per-attachment token estimate for a base64 payload: real image dimensions when the
* header is sniffable (Anthropic prices images at ~pixels/750), else decoded bytes/512,
* min 256 — the same shape as the Kiro usage estimator (estimateKiroImageTokens). */
function estimateBase64AttachmentTokens(data: string): number {
const dims = sniffImageDimensions(data);
if (dims) return Math.max(256, Math.ceil((dims.width * dims.height) / 750));
const unpadded = data.endsWith("==") ? data.length - 2 : data.endsWith("=") ? data.length - 1 : data.length;
return Math.max(256, Math.ceil(Math.floor((unpadded * 3) / 4) / 512));
}
/**
* Char-based token estimate for an Anthropic-shaped request body. Base64 attachment
* payloads (image/document blocks in message content, including blocks nested in
* tool_result.content) are counted as a bounded per-attachment estimate instead of raw
* characters: one 2MB screenshot is ~2.7M base64 chars, which the plain chars/token
* divide reports as hundreds of thousands of tokens versus a real cost around 1.6k.
* That breaks the >2x drift bound the estimator is held to (devlog 260711_claude_inbound
* 040 §3); a live 260-message turn whose replayed thinking was 78.8% of the body breached
* it at 3.28x, which is why the estimate is projected onto the settled route. Text and url
* sources are left in place and counted as characters, as is
* anything outside protocol content positions (tool_use.input, tool schemas).
*
* `thinking` selects which replayed thinking fields the SETTLED route serializes, so the measure
* describes the prompt this proxy forwards rather than the one the caller typed. Omitted, the
* whole body counts — correct for the Anthropic-native wire, where nothing is projected away.
* See `claude-request-projection.ts` for why a routed wire must project it out.
*/
export function estimateClaudeRequestTokens(
raw: { system?: unknown; messages?: unknown; tools?: unknown },
modelId: string | undefined,
thinking: ClaudeThinkingProjection = CLAUDE_NATIVE_THINKING,
): number {
let attachmentTokens = 0;
// Blank base64 payloads ONLY in protocol content positions: message content blocks and
// blocks nested in tool_result.content. tool_use.input and tool schemas can legitimately
// contain attachment-shaped JSON, and those bytes ARE serialized into function_call
// arguments / tool definitions for routed providers, so they must keep counting as text.
// system is text-only per the Anthropic protocol (no attachment sources), so it is
// stringified as-is.
const sanitizeBlock = (block: unknown): unknown => {
if (!block || typeof block !== "object") return block;
const b = block as Record<string, unknown>;
if (b.type === "image" || b.type === "document") {
const source = b.source as { type?: unknown; data?: unknown } | undefined;
if (source && typeof source === "object" && source.type === "base64" && typeof source.data === "string") {
attachmentTokens += estimateBase64AttachmentTokens(source.data);
return { ...b, source: { ...(source as Record<string, unknown>), data: "" } };
}
return block;
}
if (b.type === "tool_result" && Array.isArray(b.content)) {
return { ...b, content: (b.content as unknown[]).map(sanitizeBlock) };
}
return block;
};
const sanitizedMessages = (messages: unknown): unknown =>
Array.isArray(messages)
? messages.map(message => {
if (!message || typeof message !== "object") return message;
const m = message as Record<string, unknown>;
return Array.isArray(m.content) ? { ...m, content: (m.content as unknown[]).map(sanitizeBlock) } : message;
})
: messages;
const parts: string[] = [];
if (raw.system !== undefined) parts.push(typeof raw.system === "string" ? raw.system : JSON.stringify(raw.system));
if (raw.messages !== undefined) {
const projected = projectClaudeRequest(raw, thinking);
parts.push(JSON.stringify(sanitizedMessages(projected.messages)));
}
if (raw.tools !== undefined) parts.push(JSON.stringify(raw.tools));
return Math.max(1, estimateTokens(parts.join("\n"), modelId) + attachmentTokens);
}