clauderipple 0.2.0 → 0.3.0

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

@@ -4,7 +4,8 @@
 // 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.
+// same reason. `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";
 function blockText(c) {
@@ -13,10 +14,39 @@ function blockText(c) {
     if (!Array.isArray(c))
         return "";
     return c
-        .map((b) => (b.type === "text" ? b.text : b.type === "image" ? "[image omitted]" : ""))
+        .map((b) => (b.type === "text" ? b.text : b.type === "image" ? "[image]" : ""))
         .filter((s) => s.length > 0)
         .join("\n");
 }
+function toolResultText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((block) => block.type === "text")
+        .map((block) => String(block.text ?? ""))
+        .filter(Boolean)
+        .join("\n");
+}
+function imageUrl(block) {
+    const source = block.source;
+    if (!source || typeof source !== "object")
+        return null;
+    if (source.type === "base64" && typeof source.data === "string")
+        return `data:${typeof source.media_type === "string" ? source.media_type : "image/png"};base64,${source.data}`;
+    if (source.type === "url" && typeof source.url === "string")
+        return source.url;
+    return null;
+}
+function toolResultImages(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content
+        .filter((block) => block.type === "image")
+        .map(imageUrl)
+        .filter((url) => url !== null);
+}
 // Claude Code's first system block is Anthropic billing telemetry ("x-anthropic-billing-header: …
 // cch=<hash> …") whose hash changes on every turn. Left in, it sits at the top of `instructions`
 // and invalidates the prompt cache for everything after it (measured 2026-09-13: cached_tokens
@@ -32,16 +62,55 @@ export function systemText(system) {
         .filter((s) => s.length > 0 && !BILLING_BLOCK.test(s))
         .join("\n\n");
 }
+// A request with no `metadata.user_id` and one lone user turn is not a conversation: it is one of
+// the things the CLI sends beside one — the web-search side request, a title, a summary. Its single
+// message differs every time, so seeding on it minted a fresh key per request and the prefix all of
+// them share (system prompt, tool definitions) was never cached: measured `cached_tokens: 0` on all
+// 68 smallFast calls in a day's log, where the same wire asked twice under one key returns 94%.
+// The system prompt is the part of such a request that does not vary, so it is what names the class.
+// A real conversation that simply was not given metadata — the OpenAI ingress builds none — keeps
+// the old seed from its second turn on; only its opening turn shares the class key, and what that
+// turn reads there is the same fixed prefix it would have paid for anyway.
 export function conversationKey(req) {
+    const userId = req.metadata?.user_id;
     const first = req.messages.find((m) => m.role === "user");
-    const seed = `${req.metadata?.user_id ?? ""}\n${first ? blockText(first.content).slice(0, 4000) : ""}`;
+    // `side` keeps the two seeds in separate spaces: without it a conversation whose opening message
+    // happened to equal a system prompt would land on that class's key.
+    const seed = !userId && req.messages.length <= 1
+        ? `side\n${systemText(req.system).slice(0, 4000)}`
+        : `${userId ?? ""}\n${first ? blockText(first.content).slice(0, 4000) : ""}`;
     return crypto.createHash("sha256").update(seed).digest("hex").slice(0, 32);
 }
+/**
+ * The conversation key as a UUID, which is what the backend wants a conversation to be called.
+ *
+ * `prompt_cache_key` alone stopped earning a prompt cache between 2026-09-15 and 2026-09-19: five
+ * turns with byte-identical instructions, tools and input prefix, 3–6s apart under one key, all
+ * came back `cached_tokens: 0` and `cache_write_tokens: 0` (2026-09-20, GPT-6 Astra; the same
+ * adapter read 93% on 2026-09-13). The Codex CLI got 99.8% on the same day. Bisecting its request
+ * against ours: a stable per-conversation id in `session-id`/`thread-id`, `x-client-request-id`
+ * or body `client_metadata` turns the cache on (any one of them; `x-codex-turn-metadata` alone
+ * does not, nor does echoing `x-codex-turn-state` alone). The backend now keys the cache on the
+ * conversation's identity, not on the cache key. We send the same set the CLI sends, derived
+ * from the same seed the cache key is, so a conversation is one thing everywhere.
+ */
+export function conversationId(req) {
+    return conversationKey(req).replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "$1-$2-$3-$4-$5");
+}
 // The Codex backend validates every `pattern` in a tool schema with a regex engine that has no
 // lookaround or backreferences; one such pattern anywhere fails the whole request with
 // "Invalid schema for function 'X': '...' is not a 'regex'" (measured 2026-09-13 with the
 // Claude Code Artifact tool). Those patterns are dropped; the client validates inputs itself.
-const UNSUPPORTED_REGEX = /\(\?[=!<]|\\[1-9]/;
+//
+// `\0` belongs in the same class and was missed, because the rule was written as the
+// backreferences 1-9 rather than as the escapes a strict engine will not take. The Artifact tool
+// declares `file_paths` items as `^[^\0]*$` — any string without a NUL — and OpenCode Go refuses
+// the whole request over it: `Invalid JSON schema: {…"pattern":"^[^\\0]*$"…} is not valid under
+// any of the schemas listed in the 'anyOf' keyword` (measured 2026-09-19 against
+// muse-spark-1.3-contributor; the same schema with the pattern removed is accepted, and
+// `\d`, `propertyNames`, nested `anyOf`, `const`, `format` and `$schema` all pass, so this escape
+// is the whole of it). Two backends now, which is why the rule is the escape class, not a list.
+const UNSUPPORTED_REGEX = /\(\?[=!<]|\\[0-9]/;
 export function unsupportedPattern(p) {
     return UNSUPPORTED_REGEX.test(p);
 }
@@ -68,6 +137,62 @@ export function normalizeSchema(s) {
         delete out.required;
     return out;
 }
+// The Responses API constrains a function name to `^[a-zA-Z0-9_-]{1,64}$`, and one name that
+// breaks it fails the whole request, not just that tool. Claude Code names MCP tools
+// `mcp__<server>__<tool>`, and a claude.ai connector's server name is a UUID, so the prefix alone
+// eats 43 characters: names past 64 are routine, not exotic.
+//
+// The mangling has to be deterministic, because the same tool list is resent every turn and a name
+// that moved would break the cache prefix (see the header rule). Hash of the original, not a
+// counter or a salt. Names already inside the constraint are returned untouched, so a session with
+// no MCP tools produces byte-identical output to before this existed.
+const TOOL_NAME_OK = /^[A-Za-z0-9_-]{1,64}$/;
+export function toolNameForResponses(name) {
+    if (TOOL_NAME_OK.test(name))
+        return name;
+    // Sanitising alone would let `a.b` and `a-b` collapse onto the same name, so every mangled name
+    // carries the hash: 55 + "_" + 8 = 64 exactly.
+    const hash = crypto.createHash("sha256").update(name).digest("hex").slice(0, 8);
+    return `${name.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 55)}_${hash}`;
+}
+// Anthropic's server-side tools (`web_search` and friends) are run by Anthropic, not by the model
+// holding them. Declaring one to a translated provider offers a tool that cannot possibly execute:
+// the model calls it, nothing answers, and the turn comes back empty with no error anywhere — the
+// worst failure shape there is. `compat.ts` has dropped them on the anthropic-compatible path from
+// the start; the rule belongs here too, and is the same rule, not a second one.
+//
+// These do not arrive today. Claude Code runs its web search as a separate side request on a fixed
+// small model — measured 2026-09-17: an Opus session and a DeepSeek-routed session both sent it to
+// `claude-haiku-4-5`, which passes through to Anthropic and never reaches an adapter. Which model
+// that is, is a server-side flag we do not own, so this guards the day it changes.
+export function isServerTool(tool) {
+    const type = tool.type;
+    return type !== undefined && type !== "custom";
+}
+/** Names of the tools this request declares that no translated provider can run. */
+export function serverToolNames(tools) {
+    const names = new Set();
+    for (const t of tools ?? [])
+        if (typeof t.name === "string" && isServerTool(t))
+            names.add(t.name);
+    return names;
+}
+/**
+ * Mangled name → original, for the tools declared in this request. The model echoes the name it was
+ * given and Claude Code matches `tool_use.name` against its own tool list, so the response path has
+ * to undo the mangling. Empty when nothing needed mangling.
+ */
+export function toolNameRestoreMap(req) {
+    const map = new Map();
+    for (const t of req.tools ?? []) {
+        if (typeof t.name !== "string" || isServerTool(t))
+            continue;
+        const mangled = toolNameForResponses(t.name);
+        if (mangled !== t.name)
+            map.set(mangled, t.name);
+    }
+    return map;
+}
 export function toResponsesRequest(req, opts) {
     const parts = [];
     // Effort is named here because the model cannot see its own reasoning setting and will otherwise guess.
@@ -122,19 +247,24 @@ export function toResponsesRequest(req, opts) {
                     flush();
                     const tu = b;
                     knownCalls.add(tu.id);
-                    input.push({ type: "function_call", call_id: tu.id, name: tu.name, arguments: typeof tu.input === "string" ? tu.input : JSON.stringify(tu.input ?? {}) });
+                    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;
                 }
                 case "tool_result": {
                     flush();
                     const tr = b;
-                    let out = blockText(tr.content);
+                    let out = toolResultText(tr.content);
+                    const images = toolResultImages(tr.content);
                     if (tr.is_error && !out)
                         out = "Tool execution failed";
+                    if (!out && images.length > 0)
+                        out = "Tool returned image content.";
                     if (knownCalls.has(tr.tool_use_id))
                         input.push({ type: "function_call_output", call_id: tr.tool_use_id, output: out });
                     else
                         pending.push({ type: "input_text", text: `[Tool result]\n${out}` });
+                    for (const image_url of images)
+                        pending.push({ type: "input_image", image_url });
                     break;
                 }
                 default:
@@ -144,9 +274,10 @@ export function toResponsesRequest(req, opts) {
         }
         flush();
     }
+    const dropped = serverToolNames(req.tools);
     const tools = (req.tools ?? [])
-        .filter((t) => typeof t.name === "string")
-        .map((t) => ({ type: "function", name: t.name, description: t.description ?? "", parameters: normalizeSchema(t.input_schema), strict: false }));
+        .filter((t) => typeof t.name === "string" && !dropped.has(t.name))
+        .map((t) => ({ type: "function", name: toolNameForResponses(t.name), description: t.description ?? "", parameters: normalizeSchema(t.input_schema), strict: false }));
     let tool_choice;
     const tc = req.tool_choice;
     if (tools.length > 0) {
@@ -156,8 +287,9 @@ export function toResponsesRequest(req, opts) {
             tool_choice = "required";
         else if (tc.type === "none")
             tool_choice = "none";
-        else if (tc.type === "tool" && tc.name)
-            tool_choice = { type: "function", name: tc.name };
+        // A choice that named a dropped tool would force the model onto something no longer declared.
+        else if (tc.type === "tool" && tc.name && !dropped.has(tc.name))
+            tool_choice = { type: "function", name: toolNameForResponses(tc.name) };
     }
     const out = {
         model: opts.model,
@@ -167,7 +299,8 @@ export function toResponsesRequest(req, opts) {
         text: { verbosity: "medium" },
         store: false,
         stream: true,
-        prompt_cache_key: conversationKey(req),
+        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` },
     };
     if (tools.length > 0) {
         out.tools = tools;
@@ -199,14 +332,19 @@ export class StreamMapper {
     stopReason = "end_turn";
     /** Input-token figure announced in message_start (the real one only arrives with response.completed). */
     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;
         this.messageId = `msg_${crypto.randomBytes(12).toString("hex")}`;
     }
     get isFinished() {
         return this.finished;
     }
+    /** The error `fail` reported, so a non-streaming caller can answer with it instead of a 200. */
+    failure;
     start() {
         if (this.started)
             return [];
@@ -255,8 +393,11 @@ export class StreamMapper {
                 if (item.type === "function_call") {
                     this.sawToolCall = true;
                     const id = item.call_id ?? item.id ?? `call_${crypto.randomBytes(8).toString("hex")}`;
-                    this.content.push({ type: "tool_use", id, name: item.name ?? "tool", input: {}, _args: "" });
-                    out.push(...this.openBlock("tool", { type: "tool_use", id, name: item.name ?? "tool", input: {} }, item.id));
+                    // 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.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: "" });
@@ -366,6 +507,7 @@ export class StreamMapper {
             return [];
         this.finished = true;
         const type = code === "server_is_overloaded" ? "overloaded_error" : code === "rate_limit_exceeded" || code === "usage_limit_reached" ? "rate_limit_error" : "api_error";
+        this.failure = { type, message };
         return [...this.start(), ...this.closeBlock(), { event: "error", data: { type: "error", error: { type, message } } }];
     }
     /** Non-streaming body once finished. */

package/dist/router/src/providers/claude-oauth.js

@@ -6,12 +6,13 @@
 // Wire facts are behaviorally measured against Claude Code's public client and are not an
 // Anthropic guarantee (docs/ARCHITECTURE.md §4b). The browser is sent to claude.ai; the code comes
 // back either to a loopback listener on the registered port or, when that port is taken, through
-// the manual "paste the code" page (`code#state`). Tokens are stored only in <home>/claude-auth.json
-// (mode 0600) and never logged or returned by the admin API.
+// the manual "paste the code" page (`code#state`). Grants are stored only in the 0600
+// <home>/claude-accounts.json pool and never logged or returned by the admin API.
 import crypto from "node:crypto";
 import http from "node:http";
 import net from "node:net";
-import { saveClaudeOAuthFile } from "./anthropic-token-file.js";
+import { redactErrorText } from "../redact.js";
+import { saveClaudeOAuthAccount } from "./anthropic-accounts.js";
 // Endpoints, scopes and body shapes are what Claude Code 2.1.271 sends (read from its binary on
 // 2026-09-16): the claude.ai login is `claude.com/cai/oauth/authorize`, tokens come from
 // `platform.claude.com`. The previous `claude.ai/oauth/authorize` answers "Invalid request format".
@@ -35,13 +36,32 @@ export const CLAUDE_OAUTH = {
 function base64url(buffer) {
     return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
+export class ClaudeOAuthTokenError extends Error {
+    status;
+    code;
+    needsReauth;
+    constructor(message, status, code) {
+        super(message);
+        this.name = "ClaudeOAuthTokenError";
+        this.status = status;
+        this.code = code;
+        this.needsReauth = status === 400 && code !== null && /^(invalid_grant|invalid_token|access_denied|expired_token)$/.test(code);
+    }
+}
 async function postToken(fetchImpl, body) {
-    const response = await fetchImpl(CLAUDE_OAUTH.tokenUrl, {
-        method: "POST",
-        headers: { "content-type": "application/json", accept: "application/json" },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(30_000),
-    });
+    let response;
+    try {
+        response = await fetchImpl(CLAUDE_OAUTH.tokenUrl, {
+            method: "POST",
+            headers: { "content-type": "application/json", accept: "application/json" },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(30_000),
+        });
+    }
+    catch (error) {
+        const raw = error instanceof Error ? error.message : String(error);
+        throw new Error(`Claude token endpoint request failed: ${redactErrorText(raw, Object.values(body), 300)}`);
+    }
     const text = await response.text();
     let parsed = {};
     try {
@@ -51,8 +71,10 @@ async function postToken(fetchImpl, body) {
         // A non-JSON body is reported through the status below.
     }
     if (!response.ok) {
-        const detail = typeof parsed.error_description === "string" ? parsed.error_description : typeof parsed.error === "string" ? parsed.error : `HTTP ${response.status}`;
-        throw new Error(`Claude sign-in was refused by the token endpoint: ${detail}`);
+        const code = typeof parsed.error === "string" ? parsed.error : null;
+        const rawDetail = typeof parsed.error_description === "string" ? parsed.error_description : code ?? `HTTP ${response.status}`;
+        const detail = redactErrorText(rawDetail, Object.values(body), 300);
+        throw new ClaudeOAuthTokenError(`Claude sign-in was refused by the token endpoint: ${detail}`, response.status, code);
     }
     return parsed;
 }
@@ -65,7 +87,18 @@ function grantFrom(reply, now, previousRefresh) {
     // A missing or absurd expires_in is treated as one hour: better an early refresh than a token
     // believed valid forever.
     const expiresIn = typeof reply.expires_in === "number" && Number.isFinite(reply.expires_in) && reply.expires_in > 0 ? reply.expires_in : 3600;
-    return { accessToken: reply.access_token, refreshToken, expiresAt: now + expiresIn * 1000 };
+    const accountId = typeof reply.account?.uuid === "string" && reply.account.uuid.length > 0 ? reply.account.uuid : undefined;
+    const emailValue = typeof reply.account?.email_address === "string"
+        ? reply.account.email_address.replace(/[\x00-\x1f\x7f]/g, "").trim().slice(0, 320)
+        : "";
+    const email = emailValue || undefined;
+    return {
+        accessToken: reply.access_token,
+        refreshToken,
+        expiresAt: now + expiresIn * 1000,
+        ...(accountId ? { accountId } : {}),
+        ...(email ? { email } : {}),
+    };
 }
 /** Exchanges a refresh token; the caller persists the result. */
 export async function refreshClaudeOAuth(refreshToken, options = {}) {
@@ -89,16 +122,17 @@ export class ClaudeOAuthSession {
     settle;
     grant;
     timer = null;
+    exchanging = false;
     finished = false;
-    stateSnapshot = { running: false, url: null, manual: false, startedAt: null, finishedAt: null, ok: null, error: null };
+    stateSnapshot = { running: false, url: null, manual: false, startedAt: null, finishedAt: null, ok: null, error: null, account: null };
     constructor(options) {
         this.options = options;
         this.grant = new Promise((resolve, reject) => {
             this.settle = { resolve, reject };
         });
         this.result = this.grant.then((grant) => {
-            saveClaudeOAuthFile(options.home, grant);
-            this.stateSnapshot = { ...this.stateSnapshot, running: false, finishedAt: new Date().toISOString(), ok: true };
+            const account = saveClaudeOAuthAccount(options.home, grant);
+            this.stateSnapshot = { ...this.stateSnapshot, running: false, finishedAt: new Date().toISOString(), ok: true, account };
         }, (error) => {
             this.stateSnapshot = { ...this.stateSnapshot, running: false, finishedAt: new Date().toISOString(), ok: false, error: error.message };
             throw error;
@@ -128,11 +162,13 @@ export class ClaudeOAuthSession {
         }).toString();
         this.timer = setTimeout(() => this.fail(new Error("Claude sign-in timed out; start it again")), CLAUDE_OAUTH.timeoutMs);
         this.timer.unref();
-        this.stateSnapshot = { running: true, url: url.toString(), manual, startedAt: new Date().toISOString(), finishedAt: null, ok: null, error: null };
+        this.stateSnapshot = { running: true, url: url.toString(), manual, startedAt: new Date().toISOString(), finishedAt: null, ok: null, error: null, account: null };
         return { url: url.toString(), manual };
     }
     /** Accepts `code`, `code#state`, or the full redirect URL the browser landed on. */
     async submitCode(input) {
+        if (this.finished || this.exchanging)
+            return;
         let code = input.trim();
         let state = null;
         try {
@@ -179,8 +215,9 @@ export class ClaudeOAuthSession {
                     return;
                 }
                 if (error || !code) {
-                    res.writeHead(400, { "content-type": "text/plain; charset=utf-8" }).end(`Claude sign-in failed: ${error}. You can close this tab.`);
-                    this.fail(new Error(`Claude refused the sign-in: ${error}`));
+                    const detail = redactErrorText(error ?? "missing authorization code", [], 200);
+                    res.writeHead(400, { "content-type": "text/plain; charset=utf-8" }).end(`Claude sign-in failed: ${detail}. You can close this tab.`);
+                    this.fail(new Error(`Claude refused the sign-in: ${detail}`));
                     return;
                 }
                 res.writeHead(200, { "content-type": "text/plain; charset=utf-8" }).end("ClaudeRipple: Claude subscription connected. You can close this tab.");
@@ -196,6 +233,10 @@ export class ClaudeOAuthSession {
                 const six = http.createServer(handler);
                 six.once("error", () => { });
                 six.listen(this.port, "::1", () => {
+                    if (this.finished) {
+                        six.close();
+                        return;
+                    }
                     this.server6 = six;
                 });
                 resolve(true);
@@ -203,8 +244,9 @@ export class ClaudeOAuthSession {
         });
     }
     async exchange(code) {
-        if (this.finished)
+        if (this.finished || this.exchanging)
             return;
+        this.exchanging = true;
         try {
             const reply = await postToken(this.options.fetch ?? fetch, {
                 grant_type: "authorization_code",

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

@@ -4,11 +4,17 @@
 import http from "node:http";
 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 { conversationKey, serverToolNames, toolNameRestoreMap } from "../chatgpt/translate.js";
 const PING_MS = 15_000;
 function anthropicError(status, type, message) {
     return { status, body: JSON.stringify({ type: "error", error: { type, message } }) };
 }
+/** The HTTP status Anthropic uses for each error type a mapper can report. */
+function failureStatus(failure) {
+    return failure?.type === "overloaded_error" ? 529 : failure?.type === "rate_limit_error" ? 429 : 502;
+}
 function vendorMessage(text) {
     try {
         const json = JSON.parse(text);
@@ -19,10 +25,22 @@ function vendorMessage(text) {
     catch { /* retain the response text */ }
     return text.replace(/\s+/g, " ").trim().slice(0, 500) || "upstream request failed";
 }
+/** Whether a 403 body is about the credential rather than about what the account may do. */
+export function looksLikeAuth(text) {
+    return /\b(api[_ -]?key|token|credential|unauthori[sz]ed|authentication|invalid[_ -]?key|expired)\b/i.test(text);
+}
 export function mapHttpError(status, text) {
     const message = `OpenAI-compatible provider: ${vendorMessage(text)}`;
-    if (status === 401 || status === 403)
+    if (status === 401)
         return anthropicError(401, "authentication_error", message);
+    // A 403 is often not the credential at all: a data-sharing policy that needs opting into, a
+    // region, a model the account may not use. Calling it an authentication error sends the user
+    // back to check a key that was never the problem — which is most of an afternoon.
+    if (status === 403) {
+        return looksLikeAuth(text)
+            ? anthropicError(401, "authentication_error", message)
+            : anthropicError(403, "permission_error", message);
+    }
     if (status === 429)
         return anthropicError(429, "rate_limit_error", message);
     if (status >= 500)
@@ -72,6 +90,11 @@ export class OpenAiCompatibleAdapter {
                 reasoning: modelEffortLevels && modelEffortLevels.length > 0 ? "effort" : "none",
                 effortLevels: modelEffortLevels ?? this.cfg.caps?.effortLevels ?? [],
             };
+        // Dropping a tool the model was meant to have is worth a line: the alternative to this drop is
+        // an empty answer with nothing logged anywhere.
+        const serverTools = serverToolNames(json.tools);
+        if (serverTools.size > 0)
+            this.log.warn(`openai ${this.name}: dropped server tools for ${model}: ${[...serverTools].join(", ")} (Anthropic runs these; this provider cannot)`);
         const upstreamRequest = toOpenAiRequest(json, {
             model,
             wire,
@@ -81,7 +104,13 @@ export class OpenAiCompatibleAdapter {
             ...(this.cfg.instructionsAppend ? { instructionsAppend: this.cfg.instructionsAppend } : {}),
         });
         const requestBody = JSON.stringify(upstreamRequest);
-        const upstreamHeaders = { "content-type": "application/json", accept: "text/event-stream", ...(this.cfg.headers ?? {}) };
+        // 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.
+        const sessionHeader = this.cfg.sessionHeader
+            ? { [this.cfg.sessionHeader]: conversationKey(json) }
+            : {};
+        const upstreamHeaders = { "content-type": "application/json", accept: "text/event-stream", ...sessionHeader, ...(this.cfg.headers ?? {}) };
         const upstreamSecrets = credentialHeaderValues(Object.entries(upstreamHeaders));
         // Same input floor behavior as the ChatGPT adapter: the CLI snapshots message_start before usage arrives.
         const key = JSON.stringify({ model, wire, system: json.system ?? "", user: json.messages.find((message) => message.role === "user")?.content ?? "" });
@@ -91,12 +120,15 @@ export class OpenAiCompatibleAdapter {
         res.on("close", onClose);
         let upstream;
         try {
-            upstream = await fetch(endpoint(this.cfg.url, wire), {
+            // Nothing has been written to the client yet, so a failure another attempt could answer is
+            // asked again here rather than handed to the user as an error they would have to retry by
+            // hand. Once this returns, the response is written straight through (see `fetchWithRetry`).
+            upstream = await fetchWithRetry(endpoint(this.cfg.url, wire), {
                 method: "POST",
                 headers: upstreamHeaders,
                 body: requestBody,
                 signal: controller.signal,
-            });
+            }, { log: (line) => this.log.info(`openai ${this.name}: ${line}`) });
         }
         catch (error) {
             res.off("close", onClose);
@@ -117,7 +149,7 @@ export class OpenAiCompatibleAdapter {
             return { status: out.status, bytes: Buffer.byteLength(out.body), note: `upstream ${upstream.status}` };
         }
         const wantStream = json.stream === true;
-        const mapper = new OpenAiStreamMapper(model, startInput);
+        const mapper = new OpenAiStreamMapper(model, startInput, toolNameRestoreMap(json));
         const parser = new SseParser();
         const reader = upstream.body.getReader();
         const decoder = new TextDecoder();
@@ -150,7 +182,12 @@ export class OpenAiCompatibleAdapter {
                     break;
             }
             if (!mapper.isFinished) {
-                const tail = mapper.finish();
+                // Only a vendor that said it was done is finished. A stream that just stopped — muse went
+                // quiet for up to 300s and then closed, 2026-09-19 — is reported as overloaded so the
+                // client asks again, instead of taking an empty turn as the model's final answer.
+                const tail = mapper.completed || parser.sawDone
+                    ? mapper.finish()
+                    : mapper.fail(`${model}: upstream stream ended before the response completed`, "server_is_overloaded");
                 if (wantStream)
                     for (const event of tail)
                         bytes += write(res, formatSse(event));
@@ -158,7 +195,7 @@ export class OpenAiCompatibleAdapter {
         }
         catch (error) {
             if (!controller.signal.aborted) {
-                const tail = mapper.fail(`stream interrupted: ${error.message}`);
+                const tail = mapper.fail(`stream interrupted: ${error.message}`, "server_is_overloaded");
                 if (wantStream)
                     for (const event of tail)
                         bytes += write(res, formatSse(event));
@@ -173,19 +210,26 @@ export class OpenAiCompatibleAdapter {
             }
             catch { /* already closed */ }
         }
+        const failure = mapper.failure;
+        const failedStatus = failureStatus(failure);
         if (!wantStream) {
-            const body = JSON.stringify(mapper.message());
+            // A failed turn is an error here too: answering it as a 200 with whatever content had
+            // arrived is the same silent truncation the stream path used to commit.
+            const body = failure ? anthropicError(failedStatus, failure.type, failure.message).body : JSON.stringify(mapper.message());
             bytes = Buffer.byteLength(body);
-            res.writeHead(200, { "content-type": "application/json", "content-length": String(bytes) }).end(body);
+            res.writeHead(failure ? failedStatus : 200, { "content-type": "application/json", "content-length": String(bytes) }).end(body);
         }
         else if (!res.writableEnded) {
             res.end();
         }
         const usage = mapper.usage;
         return {
-            status: 200,
+            // A stream has already sent 200; the record still says the turn failed.
+            status: failure ? failedStatus : 200,
             bytes,
-            note: `in=${usage.input_tokens} cached=${usage.cache_read_input_tokens} out=${usage.output_tokens} stop=${mapper.stopReason}`,
+            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}`,
             usage: { input: usage.input_tokens, cached: usage.cache_read_input_tokens, output: usage.output_tokens },
             stopReason: mapper.stopReason,
         };