@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
102 lines (96 loc) • 4.81 kB
text/typescript
/**
* Project a Messages request body onto the content a settled route actually serializes.
*
* `estimateClaudeRequestTokens` measures the caller's body as JSON. That is exactly right for the
* Anthropic-native wire, where a replayed `thinking` block — signature included — is forwarded
* verbatim. A routed wire may serialize far less, and on the Chat wire it does: replayed thinking
* becomes an optional `reasoning_content` string, the signature is never sent at all
* (`src/adapters/openai-chat/messages.ts` has no `signature` reference), and the text is dropped
* outright unless the model is on the provider's `preserveReasoningContentModels` list.
*
* The gap that opens is not a rounding error. On a captured 260-message Claude Code turn, replayed
* thinking blocks were 78.8% of the body's JSON characters and 56.7% of those characters were
* base64 signatures — bytes that are not prompt text under any tokenizer. Counting them made the
* published `message_start.usage.input_tokens` 3.28x the count the upstream actually reported
* (#4857 + the Paseo context meter it feeds), well past the >2x drift bound this estimator is held
* to (devlog 260711_claude_inbound 040 §3).
*
* The projection is therefore applied to the ESTIMATE only. The body the caller sent is never
* rewritten; this is a measurement that describes the route, not a transformation of the request.
*/
/** Which replayed reasoning blocks and fields a wire serializes. */
export interface ClaudeThinkingProjection {
/** Serialize `thinking.thinking`, the model's own replayed text. */
text: boolean;
/**
* Serialize `thinking.signature`, the provider's base64 replay token. Real prompt size for
* wires that carry it; pure overhead for wires that do not.
*/
signature: boolean;
/**
* Serialize a `redacted_thinking` block, whose `data` is an opaque provider blob. It rides
* alongside `thinking` rather than inside it: a wire can reconstruct the model's reasoning
* without carrying the encrypted form, and the Chat wire does exactly that.
*/
redacted: boolean;
}
/**
* The Anthropic-native wire forwards a replayed thinking block verbatim, signature included, so
* nothing is projected away. This is the default: an unknown route keeps the measured body.
*/
export const CLAUDE_NATIVE_THINKING: ClaudeThinkingProjection = { text: true, signature: true, redacted: true };
interface ProjectableBody {
system?: unknown;
messages?: unknown;
tools?: unknown;
}
/**
* One content block as the given wire would carry it.
*
* `undefined` means the wire sends nothing for it, and the caller drops the entry. A `thinking`
* block that keeps its text but not its signature is returned as a copy rather than edited: the
* block object is shared with the outbound request builder, which must stay untouched.
*/
function projectBlock(block: unknown, thinking: ClaudeThinkingProjection): unknown {
if (!block || typeof block !== "object") return block;
if (!("type" in block)) return block;
if (block.type === "redacted_thinking") return thinking.redacted ? block : undefined;
if (block.type !== "thinking") return block;
if (!thinking.text) return undefined;
if (thinking.signature || !("signature" in block)) return block;
// Copy without the signature: the caller's block object is shared with the outbound request
// builder, so it must never be edited in place.
const { signature: _dropped, ...rest } = block;
return rest;
}
/**
* A copy of `raw` whose message content carries only the replayed thinking this route serializes.
*
* Pure and idempotent; the input is never mutated. Blocks are dropped only inside array-valued
* message `content`, which is the sole protocol position a replayed thinking block occupies.
* A message whose content array empties out is left as an empty array rather than deleted: the
* adapter's own "nothing left to send" rule is keyed on text, tool calls and reasoning together,
* and re-deriving it here would be a second copy of that rule to keep in sync.
*/
export function projectClaudeRequest(
raw: ProjectableBody,
thinking: ClaudeThinkingProjection,
): ProjectableBody {
if (thinking.text && thinking.signature && thinking.redacted) return raw;
if (!Array.isArray(raw.messages)) return raw;
const messages = raw.messages as unknown[];
return {
...raw,
messages: messages.map(message => {
if (!message || typeof message !== "object") return message;
if (!("content" in message) || !Array.isArray(message.content)) return message;
const content = message.content as unknown[];
return {
...message,
content: content
.map(block => projectBlock(block, thinking))
.filter(block => block !== undefined),
};
}),
};
}