clauderipple 0.9.3 → 0.9.5

package/dist/router/src/providers/chatgpt/translate.js

@@ -3,11 +3,15 @@
 // Prompt-cache rule: the Responses `input` we build must be a byte-stable prefix of the
 // next turn's `input`. Claude Code resends the whole history every turn, so the mapping
 // has to be deterministic and must not inject anything that varies (timestamps, salts,
-// re-signed reasoning). Thinking blocks from earlier assistant turns are dropped for the
-// same reason. `prompt_cache_key` is derived from the conversation's first user message — or,
+// re-signed reasoning). A reasoning item that came back from the backend is the exception
+// that proves the rule: it is put back exactly as it arrived, so the bytes are the
+// backend's own, and a turn that carried one maps the same way every time. Thinking
+// blocks with no stored item still have nothing to put back and are dropped as before.
+// `prompt_cache_key` is derived from the conversation's first user message — or,
 // for a request that is not a conversation at all, from its system prompt (see `conversationKey`).
 import crypto from "node:crypto";
 import { identityLine } from "../../identity.js";
+import { encodeEnvelope, envelopeFor, isOurSignature, replayableReasoning } from "../../reasoning.js";
 function blockText(c) {
     if (typeof c === "string")
         return c;
@@ -235,6 +239,7 @@ export function toResponsesRequest(req, opts) {
     // whose call_id has no function_call in the same input ("No tool call found…", measured 2026-09-13).
     // Such results are sent as plain user text instead.
     const knownCalls = new Set();
+    let lastCallId;
     for (const m of req.messages) {
         const role = m.role === "assistant" ? "assistant" : "user";
         if (typeof m.content === "string") {
@@ -251,6 +256,32 @@ export function toResponsesRequest(req, opts) {
             pending = [];
         };
         for (const b of m.content) {
+            // The reasoning this turn came back with, put back exactly where it was: the CLI replays the
+            // block in front of the function calls it belongs to, so iterating in order reproduces the
+            // original positions, parallel calls included. `lastCallId` is the call the carrier arrived
+            // after — the response path addresses the next turn's summary to it (see `onArrival`) — and is
+            // undefined for a lead-in item, which is where such a summary belongs.
+            const decoded = envelopeFor(b, "responses", opts.env, (reason) => {
+                (opts.carried ?? (opts.carried = { replayed: 0, undecodable: 0 })).undecodable++;
+                if (opts.replay !== false)
+                    opts.log?.(`dropped a reasoning carrier: ${reason}`);
+            });
+            // A carrier for the other wire is not ours to touch and falls through to the drop below.
+            if (decoded) {
+                if (opts.replay !== false) {
+                    const item = replayableReasoning(decoded.r);
+                    if (item) {
+                        flush();
+                        input.push(item);
+                        (opts.carried ?? (opts.carried = { replayed: 0, undecodable: 0 })).replayed++;
+                        opts.onArrival?.(item, lastCallId);
+                    }
+                    else {
+                        (opts.carried ?? (opts.carried = { replayed: 0, undecodable: 0 })).undecodable++;
+                    }
+                }
+                continue;
+            }
             switch (b.type) {
                 case "text": {
                     const t = b.text;
@@ -272,6 +303,7 @@ export function toResponsesRequest(req, opts) {
                     flush();
                     const tu = b;
                     knownCalls.add(tu.id);
+                    lastCallId = tu.id;
                     input.push({ type: "function_call", call_id: tu.id, name: toolNameForResponses(tu.name), arguments: typeof tu.input === "string" ? tu.input : JSON.stringify(tu.input ?? {}) });
                     break;
                 }
@@ -293,7 +325,8 @@ export function toResponsesRequest(req, opts) {
                     break;
                 }
                 default:
-                    // thinking / redacted_thinking / unknown: dropped on purpose (see header comment)
+                    // thinking, an unmarked redacted_thinking, anything unknown: no stored item to put back,
+                    // so dropped as before (see header comment)
                     break;
             }
         }
@@ -327,6 +360,11 @@ export function toResponsesRequest(req, opts) {
         prompt_cache_key: conversationId(req),
         client_metadata: { session_id: conversationId(req), thread_id: conversationId(req), turn_id: crypto.randomUUID(), "x-codex-window-id": `${conversationId(req)}:0` },
     };
+    // On every turn, as Codex asks. With `store: false` the backend keeps nothing, and without
+    // `include` it hands back no sealed item either — so a conversation that waited until it already
+    // carried reasoning before asking would never carry any. Only the retry after a refusal leaves it off.
+    if (opts.replay !== false)
+        out.include = ["reasoning.encrypted_content"];
     if (tools.length > 0) {
         out.tools = tools;
         out.parallel_tool_calls = !(tc?.disable_parallel_tool_use ?? false);
@@ -348,6 +386,7 @@ export function estimateTokens(req) {
 export class StreamMapper {
     started = false;
     blockIndex = -1;
+    /** `signed` marks a thinking block that already carries its signature — the envelope we wrote. */
     open = null;
     sawToolCall = false;
     finished = false;
@@ -360,14 +399,30 @@ export class StreamMapper {
     /** Accumulated content for non-streaming responses. */
     content = [];
     stopReason = "end_turn";
+    /**
+     * How many reasoning items this response carried whole — the ones the client will replay. The
+     * `reasoning=` figure the request log shows next to `replayed=`.
+     */
+    reasoningCount = 0;
+    /** The reasoning item being assembled: its identity so far and the call it followed. */
+    pendingReasoning = null;
+    /** The most recent function_call item added, which is what a following reasoning item describes. */
+    lastCallId;
     /** Input-token figure announced in message_start (the real one only arrives with response.completed). */
     startInput;
     /** Mangled tool name → the name Claude Code knows, from `toolNameRestoreMap`. */
     toolNames;
-    constructor(model, startInput = 0, toolNames = new Map()) {
+    /**
+     * The provider name that goes in each reasoning envelope (see reasoning.ts). A blob sealed here is
+     * only sent back here: reasoning outlives the request that made it, and a conversation moved to
+     * another provider must not carry this one's sealed state with it.
+     */
+    provider;
+    constructor(model, startInput = 0, toolNames = new Map(), provider = "") {
         this.model = model;
         this.startInput = startInput;
         this.toolNames = toolNames;
+        this.provider = provider;
         this.messageId = `msg_${crypto.randomBytes(12).toString("hex")}`;
     }
     get isFinished() {
@@ -393,11 +448,17 @@ export class StreamMapper {
             },
         ];
     }
+    /**
+     * A thinking block must carry a signature even when there is none to give — an unsigned one is
+     * refused the moment the session moves to a Claude model (`thinking.ts`) — so a block that was
+     * opened without one gets an empty `signature_delta` as it closes. A block that already carries
+     * the envelope is left alone: a second, empty delta would replace it on the client.
+     */
     closeBlock() {
         if (!this.open)
             return [];
         const evs = [];
-        if (this.open.kind === "thinking")
+        if (this.open.kind === "thinking" && !this.open.signed)
             evs.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.blockIndex, delta: { type: "signature_delta", signature: "" } } });
         evs.push({ event: "content_block_stop", data: { type: "content_block_stop", index: this.blockIndex } });
         this.open = null;
@@ -410,6 +471,56 @@ export class StreamMapper {
         evs.push({ event: "content_block_start", data: { type: "content_block_start", index: this.blockIndex, content_block: block } });
         return evs;
     }
+    /**
+     * Finish the reasoning item being assembled and hand the client the block that carries it: a
+     * thinking block whose text is the summary (empty when the backend sent none — measured
+     * 2026-10-14: Claude Code keeps and replays such a block, signature and all) and whose signature
+     * is the envelope around the sealed reasoning.
+     *
+     * An item with nothing sealed is only worth its summary, and then only if it has one: there is
+     * nothing to replay, and an empty thinking block is refused by Anthropic the moment the session
+     * switches to a Claude model (`thinking.ts`).
+     */
+    sealReasoning() {
+        const pending = this.pendingReasoning;
+        if (!pending)
+            return [];
+        this.pendingReasoning = null;
+        const text = pending.text.trim() || (typeof pending.summary === "string" ? pending.summary.trim() : "");
+        const events = [];
+        if (!pending.encrypted) {
+            if (text) {
+                events.push(...this.openBlock("thinking", { type: "thinking", thinking: "" }));
+                events.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.blockIndex, delta: { type: "thinking_delta", thinking: text } } });
+                events.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.blockIndex, delta: { type: "signature_delta", signature: "" } } });
+                events.push(...this.closeBlock());
+                this.content.push({ type: "thinking", thinking: text, signature: "" });
+            }
+            return events;
+        }
+        const item = { type: "reasoning", encrypted_content: pending.encrypted };
+        if (pending.id)
+            item.id = pending.id;
+        if (Array.isArray(pending.summary))
+            item.summary = pending.summary;
+        const signature = encodeEnvelope(this.envelopeFor(item));
+        events.push(...this.openBlock("thinking", { type: "thinking", thinking: "" }));
+        if (text)
+            events.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.blockIndex, delta: { type: "thinking_delta", thinking: text } } });
+        // The signature must arrive on this very block: it is the carrier, and the client keeps the block
+        // whole or not at all. It goes last, after the text, which is the order Anthropic's own blocks use.
+        events.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.blockIndex, delta: { type: "signature_delta", signature } } });
+        if (this.open)
+            this.open.signed = true;
+        events.push(...this.closeBlock());
+        this.content.push({ type: "thinking", thinking: text, signature });
+        this.reasoningCount++;
+        return events;
+    }
+    /** Where this item's envelope says it came from — this adapter's own provider and model. */
+    envelopeFor(item) {
+        return { w: "responses", p: this.provider, m: this.model, r: item };
+    }
     /** Map one upstream event. Returns Anthropic events to emit (possibly none). */
     feed(ev) {
         const type = ev.type;
@@ -426,12 +537,23 @@ export class StreamMapper {
                     // The model echoes the mangled name; Claude Code only recognises the original.
                     const called = item.name ?? "tool";
                     const name = this.toolNames.get(called) ?? called;
+                    this.lastCallId = id;
                     this.content.push({ type: "tool_use", id, name, input: {}, _args: "" });
                     out.push(...this.openBlock("tool", { type: "tool_use", id, name, input: {} }, item.id));
                 }
                 else if (item.type === "reasoning") {
-                    this.content.push({ type: "thinking", thinking: "", signature: "" });
-                    out.push(...this.openBlock("thinking", { type: "thinking", thinking: "" }, item.id));
+                    // The item's reasoning is held until it is complete and handed over whole (see
+                    // `sealReasoning`): one thinking block whose signature carries the envelope. The summary,
+                    // when the backend sends one, is that block's text — and the summary deltas below fill it
+                    // in. Passing the summary through `openBlock` here as well would split one item across two
+                    // blocks, so this opens nothing.
+                    this.pendingReasoning = {
+                        ...(item.id ? { id: item.id } : {}),
+                        ...(typeof item.encrypted_content === "string" && item.encrypted_content ? { encrypted: item.encrypted_content } : {}),
+                        ...(item.summary !== undefined ? { summary: item.summary } : {}),
+                        text: "",
+                        callId: this.lastCallId,
+                    };
                 }
                 else if (item.type === "message") {
                     this.content.push({ type: "text", text: "" });
@@ -454,6 +576,13 @@ export class StreamMapper {
             case "response.reasoning_summary_text.delta":
             case "response.reasoning_text.delta": {
                 const delta = String(ev.delta ?? "");
+                // The summary is the text of the reasoning item's block, and that block also carries the
+                // envelope — both are written when the item is done, so the block is not opened here. One
+                // item is one block; streaming the text into a block of its own would hand the client two.
+                if (this.pendingReasoning) {
+                    this.pendingReasoning.text += delta;
+                    break;
+                }
                 if (!this.open || this.open.kind !== "thinking") {
                     this.content.push({ type: "thinking", thinking: "", signature: "" });
                     out.push(...this.openBlock("thinking", { type: "thinking", thinking: "" }));
@@ -488,7 +617,18 @@ export class StreamMapper {
                 break;
             }
             case "response.output_item.done": {
+                const done = ev.item;
+                // The backend may put `encrypted_content` only on the completed item, so the seal is taken
+                // here as well as from `response.output_item.added`, and the item is only handed over now
+                // anyway — a half-assembled reasoning block must not reach the client.
+                if (done?.type === "reasoning" && this.pendingReasoning) {
+                    if (typeof done.encrypted_content === "string" && done.encrypted_content)
+                        this.pendingReasoning.encrypted = done.encrypted_content;
+                    if (done.summary !== undefined)
+                        this.pendingReasoning.summary = done.summary;
+                }
                 out.push(...this.closeBlock());
+                out.push(...this.sealReasoning());
                 break;
             }
             case "response.completed":

package/dist/router/src/providers/openai/index.js

@@ -8,6 +8,8 @@ import { credentialHeaderValues, redactErrorText } from "../../redact.js";
 import { SseParser } from "../chatgpt/sse.js";
 import { fetchWithRetry } from "../retry.js";
 import { estimateTokens, formatSse, OpenAiStreamMapper, toOpenAiRequest } from "./translate.js";
+import { refusesReplayedReasoning } from "../../reasoning.js";
+import { PRESETS } from "../../presets.js";
 import { conversationKey, serverToolNames, toolNameRestoreMap } from "../chatgpt/translate.js";
 const PING_MS = 15_000;
 function anthropicError(status, type, message) {
@@ -110,15 +112,25 @@ export class OpenAiCompatibleAdapter {
         const serverTools = serverToolNames(json.tools);
         if (serverTools.size > 0)
             this.log.warn(`${this.tag} ${this.name}: dropped server tools for ${model}: ${[...serverTools].join(", ")} (Anthropic runs these; this provider cannot)`);
-        const upstreamRequest = toOpenAiRequest(json, {
+        // The conversation is the storage for a reasoning model's reasoning (reasoning.ts), so what to
+        // replay is read out of the request itself and the tally is reported in the request log. `env`
+        // names this provider and model: reasoning sealed by another model is never replayed here.
+        const carried = { replayed: 0, undecodable: 0 };
+        const translate = (replay = true) => toOpenAiRequest(json, {
             model,
             wire,
             ...(effort ? { effort } : {}),
             caps,
+            replay,
+            env: { p: this.name, m: model },
+            ...(PRESETS.find((entry) => entry.id === this.cfg.preset)?.sealedReasoning ? { sealedReasoning: true } : {}),
+            carried,
+            log: (line) => this.log.info(`${this.tag} ${this.name}: ${line} (${model})`),
             ...(this.cfg.identity === undefined ? {} : { identity: this.cfg.identity }),
             ...(this.cfg.instructionsAppend ? { instructionsAppend: this.cfg.instructionsAppend } : {}),
         });
-        const requestBody = JSON.stringify(upstreamRequest);
+        const upstreamRequest = translate();
+        let requestBody = JSON.stringify(upstreamRequest);
         // Some vendors key their prompt cache on a session header rather than on the request's own
         // shape, and hand a cold cache to anyone who does not send one. `conversationKey` is the value
         // this codebase already trusts to be stable for one conversation and different between two.
@@ -173,6 +185,17 @@ export class OpenAiCompatibleAdapter {
                     upstream = new Response(refusal, { status: 401 });
                 }
             }
+            // A 4xx that names reasoning is this vendor refusing the reasoning the conversation carried
+            // back — a field it does not take, or a value from another model. The turn goes again without
+            // it: replaying is an optimisation the user's turn must never depend on (reasoning.ts).
+            if (carried.replayed > 0 && refusesReplayedReasoning(upstream.status, await upstream.clone().text().catch(() => ""))) {
+                const refusal = await upstream.text().catch(() => "");
+                this.log.warn(`${this.tag} ${this.name}: upstream ${upstream.status} refused ${carried.replayed} replayed reasoning turn(s) for ${model}; asking again without them: ${refusal.replace(/\s+/g, " ").slice(0, 200)}`);
+                carried.replayed = 0;
+                carried.undecodable = 0;
+                requestBody = JSON.stringify(translate(false));
+                upstream = await ask();
+            }
         }
         catch (error) {
             res.off("close", onClose);
@@ -202,7 +225,8 @@ export class OpenAiCompatibleAdapter {
             return { status: out.status, bytes: Buffer.byteLength(out.body), note: `upstream ${upstream.status}`, exhaustion: providerExhaustion(upstream.status, text, retryAfterMs(Object.fromEntries(upstream.headers))) };
         }
         const wantStream = json.stream === true;
-        const mapper = new OpenAiStreamMapper(model, startInput, toolNameRestoreMap(json));
+        const mapper = new OpenAiStreamMapper(model, startInput, toolNameRestoreMap(json), { p: this.name, m: model });
+        mapper.wire = wire;
         mapper.redactError = redact;
         const parser = new SseParser();
         const reader = upstream.body.getReader();
@@ -283,8 +307,8 @@ export class OpenAiCompatibleAdapter {
             exhaustion: failure ? providerExhaustion(429, `${failure.code ?? ""} ${failure.message}`, retryAfterMs(Object.fromEntries(upstream.headers))) : undefined,
             bytes,
             note: failure
-                ? `${wantStream ? "mid-stream " : ""}${failure.type}: ${failure.message} (in=${usage.input_tokens} cached=${usage.cache_read_input_tokens} out=${usage.output_tokens})`
-                : `in=${usage.input_tokens} cached=${usage.cache_read_input_tokens} out=${usage.output_tokens} stop=${mapper.stopReason}`,
+                ? `${wantStream ? "mid-stream " : ""}${failure.type}: ${failure.message} (in=${usage.input_tokens} cached=${usage.cache_read_input_tokens} out=${usage.output_tokens} replayed=${carried.replayed} reasoning=${mapper.reasoningCount})`
+                : `in=${usage.input_tokens} cached=${usage.cache_read_input_tokens} out=${usage.output_tokens} stop=${mapper.stopReason} replayed=${carried.replayed} reasoning=${mapper.reasoningCount}`,
             usage: { input: usage.input_tokens, cached: usage.cache_read_input_tokens, output: usage.output_tokens },
             stopReason: mapper.stopReason,
             ...(wantStream || !failure ? { messageId: mapper.messageId } : {}),