clauderipple 0.2.0 → 0.3.0

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

@@ -3,7 +3,7 @@
 // stable prompt prefix can retain their native prompt-cache behavior.
 import crypto from "node:crypto";
 import { clampEffort } from "../../compat.js";
-import { conversationKey, estimateTokens, normalizeSchema, systemText } from "../chatgpt/translate.js";
+import { conversationKey, estimateTokens, normalizeSchema, serverToolNames, systemText, toolNameForResponses } from "../chatgpt/translate.js";
 import { identityPrefix, instructionsSuffix } from "../../identity.js";
 function textOf(content) {
     if (typeof content === "string")
@@ -11,10 +11,19 @@ function textOf(content) {
     if (!Array.isArray(content))
         return "";
     return content
-        .flatMap((block) => block.type === "text" ? [String(block.text ?? "")] : block.type === "image" ? ["[image omitted]"] : [])
+        .filter((block) => block.type === "text")
+        .map((block) => String(block.text ?? ""))
         .filter((text) => text.length > 0)
         .join("\n");
 }
+function imagesOf(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content
+        .filter((block) => block.type === "image")
+        .map(imageUrl)
+        .filter((url) => url !== null);
+}
 function imageUrl(block) {
     const source = block.source;
     if (!source || typeof source !== "object")
@@ -25,10 +34,17 @@ function imageUrl(block) {
         return source.url;
     return null;
 }
+// Anthropic's server-side tools cannot run here; see the rule in the ChatGPT translator.
 function functionTools(tools) {
+    const dropped = serverToolNames(tools);
     return (tools ?? [])
-        .filter((tool) => typeof tool.name === "string")
-        .map((tool) => ({ type: "function", function: { name: tool.name, description: tool.description ?? "", parameters: normalizeSchema(tool.input_schema) } }));
+        .filter((tool) => typeof tool.name === "string" && !dropped.has(tool.name))
+        .map((tool) => ({ type: "function", function: { name: toolNameForResponses(tool.name), description: tool.description ?? "", parameters: normalizeSchema(tool.input_schema) } }));
+}
+/** A choice that named a dropped tool would force the model onto something no longer declared. */
+function choiceSurvives(req) {
+    const choice = req.tool_choice;
+    return choice?.type === "tool" && !!choice.name && !serverToolNames(req.tools).has(choice.name);
 }
 function mapToolChoice(req, tools) {
     if (!tools.length)
@@ -40,7 +56,7 @@ function mapToolChoice(req, tools) {
         return "required";
     if (choice.type === "none")
         return "none";
-    return choice.type === "tool" && choice.name ? { type: "function", function: { name: choice.name } } : undefined;
+    return choiceSurvives(req) ? { type: "function", function: { name: toolNameForResponses(choice.name) } } : undefined;
 }
 function mapResponsesToolChoice(req, tools) {
     if (!tools.length)
@@ -52,7 +68,7 @@ function mapResponsesToolChoice(req, tools) {
         return "required";
     if (choice.type === "none")
         return "none";
-    return choice.type === "tool" && choice.name ? { type: "function", name: choice.name } : undefined;
+    return choiceSurvives(req) ? { type: "function", name: toolNameForResponses(choice.name) } : undefined;
 }
 /** The system text this provider should see: what it is, the caller's prompt, the configured addendum. */
 function systemWithIdentity(sys, opts) {
@@ -94,7 +110,7 @@ export function toChatMessages(req, opts) {
                 if (block.type === "tool_use") {
                     const call = block;
                     knownCalls.add(call.id);
-                    calls.push({ id: call.id, type: "function", function: { name: call.name, arguments: typeof call.input === "string" ? call.input : JSON.stringify(call.input ?? {}) } });
+                    calls.push({ id: call.id, type: "function", function: { name: toolNameForResponses(call.name), arguments: typeof call.input === "string" ? call.input : JSON.stringify(call.input ?? {}) } });
                 }
             }
             if (text.some(Boolean) || calls.length)
@@ -124,12 +140,17 @@ export function toChatMessages(req, opts) {
                 flush();
                 const result = block;
                 let output = textOf(result.content);
+                const images = imagesOf(result.content);
                 if (result.is_error && !output)
                     output = "Tool execution failed";
+                if (!output && images.length > 0)
+                    output = "Tool returned image content.";
                 if (knownCalls.has(result.tool_use_id))
                     messages.push({ role: "tool", tool_call_id: result.tool_use_id, content: output });
                 else
                     parts.push({ type: "text", text: `[Tool result]\n${output}` });
+                for (const url of images)
+                    parts.push({ type: "image_url", image_url: { url } });
             }
         }
         flush();
@@ -170,18 +191,23 @@ export function toResponsesInput(req) {
                 flush();
                 const call = block;
                 knownCalls.add(call.id);
-                input.push({ type: "function_call", call_id: call.id, name: call.name, arguments: typeof call.input === "string" ? call.input : JSON.stringify(call.input ?? {}) });
+                input.push({ type: "function_call", call_id: call.id, name: toolNameForResponses(call.name), arguments: typeof call.input === "string" ? call.input : JSON.stringify(call.input ?? {}) });
             }
             else if (block.type === "tool_result") {
                 flush();
                 const result = block;
                 let output = textOf(result.content);
+                const images = imagesOf(result.content);
                 if (result.is_error && !output)
                     output = "Tool execution failed";
+                if (!output && images.length > 0)
+                    output = "Tool returned image content.";
                 if (knownCalls.has(result.tool_use_id))
                     input.push({ type: "function_call_output", call_id: result.tool_use_id, output });
                 else
                     parts.push({ type: "input_text", text: `[Tool result]\n${output}` });
+                for (const image_url of images)
+                    parts.push({ type: "input_image", image_url });
             }
         }
         flush();
@@ -232,8 +258,13 @@ export function toOpenAiRequest(req, opts) {
         if (choice)
             out.tool_choice = choice;
     }
+    // Responses will not accept a cap below sixteen, and answers a smaller one with a 400 naming the
+    // parameter. Anthropic Messages has no such floor, so a client that asks for a single token is
+    // asking something legal that this wire cannot express: Claude Code checks a model by requesting
+    // one token, and every switch to a Responses model failed on it (measured 2026-09-22). Raise the
+    // floor rather than pass the refusal on — a cap is a limit, and a larger one still obeys it.
     if (typeof req.max_tokens === "number")
-        out.max_output_tokens = req.max_tokens;
+        out.max_output_tokens = Math.max(16, req.max_tokens);
     if (typeof req.temperature === "number")
         out.temperature = req.temperature;
     if (effort)
@@ -257,11 +288,24 @@ export class OpenAiStreamMapper {
     stopReason = "end_turn";
     model;
     startInput;
-    constructor(model, startInput = 0) {
+    /** Mangled tool name → the name Claude Code knows, from `toolNameRestoreMap`. */
+    toolNames;
+    constructor(model, startInput = 0, toolNames = new Map()) {
         this.model = model;
         this.startInput = startInput;
+        this.toolNames = toolNames;
     }
     get isFinished() { return this.finished; }
+    /**
+     * Whether the vendor said the answer was over: `response.completed`/`response.incomplete` on
+     * Responses, a `finish_reason` on Chat. A stream that closes without either was cut off, and
+     * finishing it as `end_turn` hands the client an empty or half answer it accepts as final — the
+     * worker that "stalls and dies" (muse, 84 of 1,815 turns, 2026-09-18..22).
+     */
+    get completed() { return this.sawCompletion; }
+    sawCompletion = false;
+    /** The error `fail` reported, so a non-streaming caller can answer with it instead of a 200. */
+    failure;
     start() {
         if (this.started)
             return [];
@@ -294,11 +338,15 @@ export class OpenAiStreamMapper {
         const cached = typeof cachedValue === "number" && Number.isFinite(cachedValue) ? Math.max(0, cachedValue) : 0;
         this.usage = { input_tokens: Math.max(0, (input ?? this.usage.input_tokens + cached) - cached), output_tokens: Math.max(0, output ?? this.usage.output_tokens), cache_read_input_tokens: cached, cache_creation_input_tokens: 0 };
     }
+    /** The vendor echoes the name it was given; Claude Code only recognises the original. */
+    restore(name) {
+        return this.toolNames.get(name) ?? name;
+    }
     toolFor(index, delta) {
         let tool = this.content.find((block) => block.type === "tool_use" && block.index === index);
         if (!tool) {
             const id = typeof delta.id === "string" ? delta.id : `call_${crypto.randomBytes(8).toString("hex")}`;
-            const name = typeof delta.function?.name === "string" ? delta.function.name : "tool";
+            const name = typeof delta.function?.name === "string" ? this.restore(delta.function.name) : "tool";
             tool = { type: "tool_use", id, name, input: {}, args: "", index };
             this.content.push(tool);
             this.sawTool = true;
@@ -306,7 +354,7 @@ export class OpenAiStreamMapper {
         if (typeof delta.id === "string")
             tool.id = delta.id;
         if (typeof delta.function?.name === "string")
-            tool.name = delta.function.name;
+            tool.name = this.restore(delta.function.name);
         return tool;
     }
     feedChat(ev) {
@@ -317,6 +365,20 @@ export class OpenAiStreamMapper {
         const choices = Array.isArray(ev.choices) ? ev.choices : [];
         for (const choice of choices) {
             const delta = choice.delta ?? {};
+            // Thinking arrives before the answer, so it opens the first block of the turn. `reasoning` is
+            // accepted alongside `reasoning_content` because vendors on this wire disagree on the name.
+            const reasoning = typeof delta.reasoning_content === "string" && delta.reasoning_content ? delta.reasoning_content
+                : typeof delta.reasoning === "string" && delta.reasoning ? delta.reasoning : "";
+            if (reasoning) {
+                if (!this.open || this.open.kind !== "thinking") {
+                    this.content.push({ type: "thinking", thinking: "" });
+                    out.push(...this.openBlock("thinking", { type: "thinking", thinking: "" }));
+                }
+                const last = this.content[this.content.length - 1];
+                if (last?.type === "thinking")
+                    last.thinking += reasoning;
+                out.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.open.index, delta: { type: "thinking_delta", thinking: reasoning } } });
+            }
             if (typeof delta.content === "string" && delta.content) {
                 if (!this.open || this.open.kind !== "text") {
                     this.content.push({ type: "text", text: "" });
@@ -343,8 +405,10 @@ export class OpenAiStreamMapper {
                     }
                 }
             }
-            if (typeof choice.finish_reason === "string" && choice.finish_reason)
+            if (typeof choice.finish_reason === "string" && choice.finish_reason) {
                 this.finishReason = choice.finish_reason;
+                this.sawCompletion = true;
+            }
         }
         return out;
     }
@@ -452,6 +516,7 @@ export class OpenAiStreamMapper {
             this.setUsage(response?.usage);
             if (response?.incomplete_details?.reason === "max_output_tokens")
                 this.finishReason = "length";
+            this.sawCompletion = true;
         }
         else if (type === "response.failed" || type === "error") {
             const error = (type === "error" ? ev.error : ev.response?.error);
@@ -482,7 +547,10 @@ export class OpenAiStreamMapper {
         if (this.finished)
             return [];
         this.finished = true;
-        const type = code === "rate_limit_exceeded" ? "rate_limit_error" : "api_error";
+        // `overloaded_error` is the one mid-stream error Claude Code retries on its own (CLI 2.1.278
+        // matches `"type":"overloaded_error"` in the message); `api_error` ends the turn for good.
+        const type = code === "rate_limit_exceeded" ? "rate_limit_error" : code === "server_is_overloaded" ? "overloaded_error" : "api_error";
+        this.failure = { type, message };
         return [...this.start(), ...this.closeBlock(), { event: "error", data: { type: "error", error: { type, message } } }];
     }
     message() {

package/dist/router/src/providers/retry.js

@@ -0,0 +1,88 @@
+// Retrying a translated provider before its turn is committed.
+//
+// A provider behind a relay fails for reasons that have nothing to do with the request: the relay's
+// own upstream breaks, an edge hiccups, a connection is refused. The user then sees an error, asks
+// again, and the identical request succeeds — which is the whole evidence that the request was
+// never the problem (2026-09-21, OpenCode Go relaying DeepSeek: every failing turn answered 403
+// `Upstream request failed`, and every retry by hand worked).
+//
+// Only a failure another attempt could answer is retried. `classify` already owns that judgement
+// for what failed — a 400 is our request being wrong and is refused everywhere, a 403 wrapping a
+// relay's broken upstream is not about us at all. Reusing it keeps one vocabulary rather than two.
+//
+// It is not quite the same question, though, and the difference is the whole of `isWorthRetrying`.
+// `classify` answers it for a *pool*: a 401 is retryable because another credential could answer.
+// Here there is only the one credential the adapter already holds, so a 401 would be re-sent — nine
+// times — to the key that just refused it, and a 429 to the limit that just refused it. Those fail
+// identically on every attempt and only delay the error the user eventually sees. What is left is
+// `transient`: a connect failure, a 502/503/504, a relay with a broken upstream. Those are the ones
+// where the identical request genuinely succeeds a moment later.
+//
+// **Nothing may have been written to the client.** This is called around the `fetch` alone, before
+// any status or byte is sent, so a retry cannot splice two answers together. Once the first byte is
+// out the turn is committed and this must not be used.
+import { setTimeout as sleep } from "node:timers/promises";
+import { classify } from "../pool.js";
+/** Attempts in total — one ask plus nine retries, matching the CLI's own ceiling (2026-09-21). */
+export const DEFAULT_ATTEMPTS = 10;
+const RETRY_BASE_MS = 250;
+const RETRY_MAX_MS = 2_000;
+/**
+ * 250ms, 500ms, 1s, then 2s each. A hiccup is absorbed in a blink, which is the observed case; a
+ * sustained outage is not hammered, and the ceiling is deliberately low so a dead relay fails to the
+ * user in seconds rather than tens of them.
+ */
+function backoffMs(attempt) {
+    return Math.min(RETRY_MAX_MS, RETRY_BASE_MS * 2 ** (attempt - 1));
+}
+/** Whether asking the same provider the identical request again could plausibly work. */
+function isWorthRetrying(status, text) {
+    const verdict = classify(status, undefined, text);
+    return verdict.retryable && verdict.kind === "transient";
+}
+/** Wait between attempts, but stop immediately when the client abandons the turn. */
+async function wait(ms, signal) {
+    await sleep(ms, undefined, signal ? { signal } : undefined);
+}
+/**
+ * Ask until an answer arrives, a status says asking again is pointless, or the attempt ceiling is
+ * reached. The last `Response` is returned either way, so the caller still reports the vendor's own
+ * refusal when retrying was not going to help.
+ *
+ * `init.body` must be reusable (a string or buffer). A stream would already have been consumed.
+ */
+export async function fetchWithRetry(url, init, opts) {
+    const attempts = opts.attempts ?? DEFAULT_ATTEMPTS;
+    for (let n = 1; n <= attempts; n++) {
+        let res;
+        try {
+            res = await fetch(url, init);
+        }
+        catch (e) {
+            // An abort is the client going away, not the provider: retrying it would keep working on a
+            // turn nobody is waiting for.
+            if (init.signal?.aborted)
+                throw e;
+            if (n === attempts)
+                throw e;
+            opts.log(`attempt ${n}/${attempts} could not connect (${e.message}); retrying`);
+            await wait(backoffMs(n), init.signal);
+            continue;
+        }
+        if (res.ok)
+            return res;
+        // A 403's meaning is in its body and a relay reports its own broken upstream there; every other
+        // status is judged from the status alone. Cloned rather than read, so the caller still gets the
+        // body to show when this attempt turns out to be the last one.
+        const text = res.status === 403 ? await res.clone().text().catch(() => "") : "";
+        if (!isWorthRetrying(res.status, text) || n === attempts)
+            return res;
+        // This response will never reach the caller. Cancel it before opening another request so a relay
+        // with a slow or unbounded error body cannot hold one connection per discarded attempt.
+        await res.body?.cancel().catch(() => { });
+        opts.log(`attempt ${n}/${attempts}: upstream ${res.status} (transient); retrying`);
+        await wait(backoffMs(n), init.signal);
+    }
+    // Unreachable: the loop returns or throws on its last iteration.
+    throw new Error("retry loop fell through");
+}