clauderipple 0.9.0 → 0.9.2

package/dist/router/src/proxy.js

@@ -20,7 +20,7 @@ import tls from "node:tls";
 import zlib from "node:zlib";
 import { ProviderHealth, providerExhaustion, UpstreamHealth } from "./health.js";
 import { BOOTSTRAP_PATH, injectBootstrap } from "./bootstrap.js";
-import { THREAD_UNSUPPORTED, effortOf, resolve, rewriteBody, stripThreadFields, threadDecision, unroutableReason } from "./routing.js";
+import { THREAD_UNSUPPORTED, effortOf, isAutoModeClassifier, resolve, rewriteBody, stripThreadFields, threadDecision, unroutableReason } from "./routing.js";
 import { defaultAgentDir, withAgentAliases } from "./agents.js";
 import { forwardCompatibleHeader, resolveCompatibleCaps, sanitizeForCompatible } from "./compat.js";
 import { applyIdentityToAnthropicBody } from "./identity.js";
@@ -30,6 +30,7 @@ import { PRESETS } from "./presets.js";
 import { ChatGptAdapter } from "./providers/chatgpt/index.js";
 import { OpenAiCompatibleAdapter } from "./providers/openai/index.js";
 import { GoogleAdapter } from "./providers/google/index.js";
+import { GrokAdapter } from "./providers/grok/index.js";
 import { conversationKey } from "./providers/chatgpt/translate.js";
 import { providerFor, searchProviderFor, terminateHosts } from "./config.js";
 import { chatPickerModels, injectPickerModels, isBootstrapPath } from "./picker.js";
@@ -186,6 +187,7 @@ export class Proxy {
     chatgptAdapters = new Map();
     openaiAdapters = new Map();
     googleAdapters = new Map();
+    grokAdapters = new Map();
     claudeAccounts;
     /** Each Claude subscription account's usage, for the admin status (never a token). */
     claudeUsage;
@@ -304,6 +306,15 @@ export class Proxy {
         this.openaiAdapters.set(name, { key, adapter });
         return adapter;
     }
+    grok(name, cfg) {
+        const key = JSON.stringify(cfg);
+        const cur = this.grokAdapters.get(name);
+        if (cur && cur.key === key)
+            return cur.adapter;
+        const adapter = new GrokAdapter(name, cfg, this.deps.log);
+        this.grokAdapters.set(name, { key, adapter });
+        return adapter;
+    }
     google(name, cfg) {
         const key = JSON.stringify(cfg);
         const cur = this.googleAdapters.get(name);
@@ -629,6 +640,16 @@ export class Proxy {
                     completed.note = note;
                 if (extra?.resent && !completed.ok)
                     completed.resent = true;
+                if (extra?.messageId !== undefined)
+                    completed.messageId = extra.messageId;
+                if (extra?.requestedTier !== undefined)
+                    completed.requestedTier = extra.requestedTier;
+                if (extra?.servedTier !== undefined)
+                    completed.servedTier = extra.servedTier;
+                if (extra?.upstreamCalled === false)
+                    completed.upstreamCalled = false;
+                if (extra?.refusal !== undefined)
+                    completed.refusal = extra.refusal;
                 this.deps.requests.add(completed);
             }
         };
@@ -639,7 +660,7 @@ export class Proxy {
             const msg = JSON.stringify({ type: "error", error: { type: "overloaded_error", message: "ClaudeRipple is restarting; retry" } });
             res.writeHead(503, { "content-type": "application/json", "retry-after": "3", connection: "close", "content-length": String(Buffer.byteLength(msg)) }).end(msg);
             req.resume();
-            finish("503", msg.length, "refused during drain (client retries)", false, { resent: true });
+            finish("503", msg.length, "refused during drain (client retries)", false, { resent: true, upstreamCalled: false, refusal: "drain" });
             return;
         }
         let body;
@@ -673,9 +694,17 @@ export class Proxy {
         // backend is configured: `cfg.webSearch` decides who answers it, but knowing that this is a
         // search is what lets the guard below refuse a provider that cannot run one. Tying the two
         // together meant an unconfigured router could not tell a search from any other turn.
+        if (json) {
+            record.source = record.target = typeof model === "string" ? model : "-";
+            record.stream = json.stream === true;
+            if (isAutoModeClassifier(json))
+                record.purpose = "auto-mode-classifier";
+        }
         const search = json && isApiHost && pathname === "/v1/messages" ? webSearchQuery(json) : null;
+        let searchAttempted = false;
+        const markSearchAttempted = () => { searchAttempted = true; };
         if (search && cfg.webSearch) {
-            const served = await this.serveWebSearch(res, json, search, cfg.webSearch, record, finish);
+            const served = await this.serveWebSearch(res, json, search, cfg.webSearch, record, finish, markSearchAttempted);
             if (served)
                 return;
             // Fall through on failure: the ordinary path still answers, and a search that quietly
@@ -694,7 +723,7 @@ export class Proxy {
                 res.writeHead(400, { "content-type": "application/json", "content-length": String(Buffer.byteLength(payload)) }).end(payload);
                 tag = `REFUSE ${model}`;
                 record = { ...record, provider: "refused" };
-                finish("400", payload.length, `ClaudeRipple: ${reason}`, true);
+                finish("400", payload.length, `ClaudeRipple: ${reason}`, true, { ...(!searchAttempted ? { upstreamCalled: false } : {}), refusal: "unroutable" });
                 return;
             }
         }
@@ -735,7 +764,7 @@ export class Proxy {
             // The same holds for a plan that searches on another of its endpoints (`anthropicSearch`).
             const own = (cfg.providers[route.provider]?.type === "chatgpt" || searchProviderFor(cfg.providers[route.provider], route.model) !== undefined) &&
                 cfg.webSearch?.provider !== route.provider;
-            if (own && (await this.serveWebSearch(res, json, search, { provider: route.provider, model: route.model }, record, finish)))
+            if (own && (await this.serveWebSearch(res, json, search, { provider: route.provider, model: route.model }, record, finish, markSearchAttempted)))
                 return;
             const blocks = webSearchErrorBlocks(search, "unavailable");
             const model = typeof json.model === "string" ? json.model : "unknown";
@@ -745,7 +774,8 @@ export class Proxy {
                 ? { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" }
                 : { "content-type": "application/json" }).end(payload);
             log.warn(`web search: ${route.provider} cannot run server tools and no webSearch backend is configured; refused rather than answered with invented results`);
-            finish("200", Buffer.byteLength(payload), `web search refused: ${route.provider} runs no server tools`, false);
+            record = { ...record, target: route.model, provider: route.provider, purpose: "web-search" };
+            finish("200", Buffer.byteLength(payload), `web search refused: ${route.provider} runs no server tools`, false, { ...(!searchAttempted ? { upstreamCalled: false } : {}), refusal: "web-search-unsupported" });
             return;
         }
         let compatCaps;
@@ -755,9 +785,10 @@ export class Proxy {
         let penalised = null;
         let target;
         if (route && json) {
+            record = { ...record, target: route.model, provider: route.provider };
             const configured = cfg.providers[route.provider];
             if (!configured) {
-                finish("500", 0, `unknown provider ${route.provider}`);
+                finish("500", 0, `unknown provider ${route.provider}`, true, { ...(!searchAttempted ? { upstreamCalled: false } : {}), refusal: "unknown-provider" });
                 res.writeHead(500, { "content-type": "application/json" }).end(JSON.stringify({ error: { type: "clauderipple_config", message: `unknown provider ${route.provider}` } }));
                 return;
             }
@@ -771,12 +802,11 @@ export class Proxy {
                 if (td === "refuse") {
                     const out = JSON.stringify(THREAD_UNSUPPORTED);
                     res.writeHead(400, { "content-type": "application/json", "content-length": String(Buffer.byteLength(out)) }).end(out);
-                    finish("400", out.length, "thread continue refused → CLI resends stateless", false, { resent: true });
+                    finish("400", out.length, "thread continue refused → CLI resends stateless", false, { resent: true, ...(!searchAttempted ? { upstreamCalled: false } : {}), refusal: "thread-continue" });
                     return;
                 }
                 if (td === "strip")
                     stripThreadFields(json);
-                record = { ...record, target: route.model, provider: route.provider };
                 const routeEffort = effortOf(json);
                 if (routeEffort)
                     record.effort = routeEffort;
@@ -787,7 +817,7 @@ export class Proxy {
                     const o = await this.chatgpt(route.provider, provider).handle(req, res, path, json, route.model, effortOf(json));
                     if (!path.startsWith("/v1/messages/count_tokens"))
                         this.providerHealth.observe(route.provider, o.status, o.exhaustion);
-                    finish(String(o.status), o.bytes, o.note, o.status >= 400, { ...(o.usage ? { usage: o.usage } : {}), ...(o.stopReason ? { stopReason: o.stopReason } : {}) });
+                    finish(String(o.status), o.bytes, o.note, o.status >= 400, { ...o, ...(searchAttempted ? { upstreamCalled: undefined } : {}) });
                 }
                 catch (e) {
                     finish("-", 0, `chatgpt error ${e.code ?? ""} ${e.message}`);
@@ -803,12 +833,11 @@ export class Proxy {
                 if (td === "refuse") {
                     const out = JSON.stringify(THREAD_UNSUPPORTED);
                     res.writeHead(400, { "content-type": "application/json", "content-length": String(Buffer.byteLength(out)) }).end(out);
-                    finish("400", out.length, "thread continue refused → CLI resends stateless", false, { resent: true });
+                    finish("400", out.length, "thread continue refused → CLI resends stateless", false, { resent: true, ...(!searchAttempted ? { upstreamCalled: false } : {}), refusal: "thread-continue" });
                     return;
                 }
                 if (td === "strip")
                     stripThreadFields(json);
-                record = { ...record, target: route.model, provider: route.provider };
                 const routeEffort = effortOf(json);
                 if (routeEffort)
                     record.effort = routeEffort;
@@ -818,7 +847,7 @@ export class Proxy {
                     this.recordOutcome(route.provider, o.status);
                     if (!path.startsWith("/v1/messages/count_tokens"))
                         this.providerHealth.observe(route.provider, o.status, o.exhaustion);
-                    finish(String(o.status), o.bytes, o.note, o.status >= 400, { ...(o.usage ? { usage: o.usage } : {}), ...(o.stopReason ? { stopReason: o.stopReason } : {}) });
+                    finish(String(o.status), o.bytes, o.note, o.status >= 400, { ...o, ...(searchAttempted ? { upstreamCalled: undefined } : {}) });
                 }
                 catch (e) {
                     this.recordOutcome(route.provider, 0);
@@ -837,12 +866,11 @@ export class Proxy {
                 if (td === "refuse") {
                     const out = JSON.stringify(THREAD_UNSUPPORTED);
                     res.writeHead(400, { "content-type": "application/json", "content-length": String(Buffer.byteLength(out)) }).end(out);
-                    finish("400", out.length, "thread continue refused → CLI resends stateless", false, { resent: true });
+                    finish("400", out.length, "thread continue refused → CLI resends stateless", false, { resent: true, ...(!searchAttempted ? { upstreamCalled: false } : {}), refusal: "thread-continue" });
                     return;
                 }
                 if (td === "strip")
                     stripThreadFields(json);
-                record = { ...record, target: route.model, provider: route.provider };
                 const routeEffort = effortOf(json);
                 if (routeEffort)
                     record.effort = routeEffort;
@@ -852,7 +880,7 @@ export class Proxy {
                     this.recordOutcome(route.provider, o.status);
                     if (!path.startsWith("/v1/messages/count_tokens"))
                         this.providerHealth.observe(route.provider, o.status, o.exhaustion);
-                    finish(String(o.status), o.bytes, o.note, o.status >= 400, { ...(o.usage ? { usage: o.usage } : {}), ...(o.stopReason ? { stopReason: o.stopReason } : {}) });
+                    finish(String(o.status), o.bytes, o.note, o.status >= 400, { ...o, ...(searchAttempted ? { upstreamCalled: undefined } : {}) });
                 }
                 catch (e) {
                     this.recordOutcome(route.provider, 0);
@@ -864,6 +892,38 @@ export class Proxy {
                 }
                 return;
             }
+            if (provider.type === "grok") {
+                // The chat proxy keeps no server-side thread, so a `continue` is refused like on the other
+                // translated providers and the CLI resends the turn with the full history.
+                const td = threadDecision(json);
+                if (td === "refuse") {
+                    const out = JSON.stringify(THREAD_UNSUPPORTED);
+                    res.writeHead(400, { "content-type": "application/json", "content-length": String(Buffer.byteLength(out)) }).end(out);
+                    finish("400", out.length, "thread continue refused → CLI resends stateless", false, { resent: true });
+                    return;
+                }
+                if (td === "strip")
+                    stripThreadFields(json);
+                record = { ...record, target: route.model, provider: route.provider };
+                const routeEffort = effortOf(json);
+                if (routeEffort)
+                    record.effort = routeEffort;
+                tag = `GROK ${route.tag} effort=${routeEffort ?? "-"}`;
+                try {
+                    const o = await this.grok(route.provider, provider).handle(req, res, path, json, route.model, routeEffort);
+                    this.recordOutcome(route.provider, o.status);
+                    finish(String(o.status), o.bytes, o.note, o.status >= 400, { ...(o.usage ? { usage: o.usage } : {}), ...(o.stopReason ? { stopReason: o.stopReason } : {}) });
+                }
+                catch (e) {
+                    this.recordOutcome(route.provider, 0);
+                    finish("-", 0, `grok error ${e.code ?? ""} ${e.message}`);
+                    if (!res.headersSent)
+                        res.writeHead(502, { "content-type": "application/json" }).end(JSON.stringify({ type: "error", error: { type: "api_error", message: e.message } }));
+                    else
+                        res.destroy();
+                }
+                return;
+            }
             if (provider.type === "anthropic") {
                 if (!provider.accountPool || provider.auth !== "claude-code") {
                     finish("400", 0, "native Anthropic provider is available through OpenAI ingress only", false);
@@ -876,7 +936,7 @@ export class Proxy {
                 if (credentials.length === 0) {
                     const out = JSON.stringify({ type: "error", error: { type: "authentication_error", message: "ClaudeRipple: no usable Claude account; sign in or reauthenticate an account" } });
                     res.writeHead(401, { "content-type": "application/json", "content-length": String(Buffer.byteLength(out)) }).end(out);
-                    finish("401", out.length, "no usable Claude account");
+                    finish("401", out.length, "no usable Claude account", true, { ...(!searchAttempted ? { upstreamCalled: false } : {}), refusal: "no-account" });
                     return;
                 }
                 dropForeignThinking(json);
@@ -895,7 +955,6 @@ export class Proxy {
                     dropHeaders: new Set(credentials.flatMap((credential) => Object.keys(credential.headers).map((name) => name.toLowerCase()))),
                     dropHeaderPrefixes: ["anthropic-client-", "x-stainless-"],
                 };
-                record = { ...record, target: route.model, provider: route.provider };
                 const routeEffort = effortOf(json);
                 if (routeEffort)
                     record.effort = routeEffort;
@@ -910,7 +969,7 @@ export class Proxy {
                 if (threadDecision(json) === "refuse") {
                     const out = JSON.stringify(THREAD_UNSUPPORTED);
                     res.writeHead(400, { "content-type": "application/json", "content-length": String(Buffer.byteLength(out)) }).end(out);
-                    finish("400", out.length, "thread continue refused → CLI resends stateless", false, { resent: true });
+                    finish("400", out.length, "thread continue refused → CLI resends stateless", false, { resent: true, ...(!searchAttempted ? { upstreamCalled: false } : {}), refusal: "thread-continue" });
                     return;
                 }
                 const preset = provider.preset ? PRESETS.find((entry) => entry.id === provider.preset) : undefined;
@@ -961,7 +1020,6 @@ export class Proxy {
                     // vendor's website, which answered 200 with HTML (measured 2026-09-13 with OpenRouter).
                     basePath: u.pathname.replace(/\/+$/, ""),
                 };
-                record = { ...record, target: route.model, provider: route.provider };
                 const routeEffort = effortOf(json);
                 if (routeEffort)
                     record.effort = routeEffort;
@@ -979,6 +1037,8 @@ export class Proxy {
             target = { protocol: "https:", host: reqHost, port: 443, agent: this.agentFor(`host:${reqHost}`, "https:"), extraHeaders: {} };
             tag = `WEB ${reqHost}`;
         }
+        if (json && typeof json.service_tier === "string")
+            record.requestedTier = json.service_tier;
         // Two kinds of response editing: the CLI bootstrap (api host) and the claude.ai bootstrap (picker mode).
         const isCliBootstrap = isApiHost && !route && path.startsWith(BOOTSTRAP_PATH);
         const isPickerBootstrap = !isApiHost && !!cfg.picker?.enabled && method === "GET" && isBootstrapPath(path);
@@ -1231,6 +1291,9 @@ export class Proxy {
                 send(withCredential(headers, retry.headers, usedCredentialHeaders));
                 return;
             }
+            const native = isApiHost && (!route || cfg.providers[route.provider]?.type === "anthropic");
+            if (native && typeof upRes.headers["request-id"] === "string")
+                record.upstreamRequestId = upRes.headers["request-id"];
             const outHeaders = [];
             const r = upRes.rawHeaders;
             for (let i = 0; i < r.length; i += 2) {
@@ -1343,6 +1406,10 @@ export class Proxy {
                 const observed = tap.finish();
                 observedUsage = observed.usage;
                 observedStopReason = observed.stopReason;
+                if (!native && observed.messageId !== undefined)
+                    record.messageId = observed.messageId;
+                if (observed.servedTier !== undefined)
+                    record.servedTier = observed.servedTier;
                 res.end();
                 const errorBody = status >= 400 ? decodeBodyToText(Buffer.concat(errorHead), upRes.headers["content-encoding"]) : "";
                 if (route && path.startsWith("/v1/messages") && !path.startsWith("/v1/messages/count_tokens")) {
@@ -1371,7 +1438,7 @@ export class Proxy {
      * model. Returns false when it could not be served, and the caller falls back to the normal path:
      * an empty search result is the one outcome worth avoiding, because nothing anywhere reports it.
      */
-    async serveWebSearch(res, json, query, settings, record, finish) {
+    async serveWebSearch(res, json, query, settings, record, finish, markAttempted) {
         const configured = this.deps.config().providers[settings.provider];
         if (!configured) {
             this.deps.log.warn(`web search: unknown provider ${settings.provider}; leaving the request alone`);
@@ -1422,6 +1489,7 @@ export class Proxy {
         const model = typeof json.model === "string" ? json.model : "unknown";
         let blocks;
         try {
+            markAttempted();
             const outcome = await backend.search(query);
             blocks = webSearchBlocks(query, outcome).blocks;
         }
@@ -1430,6 +1498,8 @@ export class Proxy {
             return false;
         }
         record.target = `${settings.provider}/${settings.model}`;
+        record.provider = settings.provider;
+        record.purpose = "web-search";
         const wantStream = json.stream === true;
         const payload = wantStream ? webSearchSse(model, blocks, 1) : JSON.stringify(webSearchMessage(model, blocks, 1));
         const headers = wantStream

package/dist/router/src/redact.js

@@ -11,8 +11,13 @@ function credentialHeaderName(name) {
 export function credentialHeaderValues(headers) {
     const secrets = new Set();
     for (const [rawName, value] of headers) {
-        if (credentialHeaderName(rawName) && value)
-            secrets.add(value);
+        if (!credentialHeaderName(rawName) || !value)
+            continue;
+        secrets.add(value);
+        // A vendor that echoes the credential echoes the token, not the scheme in front of it.
+        const bare = /^(?:Bearer|Basic|Token)\s+(\S+)$/i.exec(value)?.[1];
+        if (bare)
+            secrets.add(bare);
     }
     return [...secrets].sort((a, b) => b.length - a.length);
 }

package/dist/router/src/requestlog.js

@@ -130,6 +130,7 @@ export class ResponseUsageTap {
     isSse;
     decoder = new TextDecoder();
     carry = "";
+    skipSseLine = false;
     event = "";
     data = [];
     dropUntilNewline = false;
@@ -138,6 +139,13 @@ export class ResponseUsageTap {
     jsonUsageText = "";
     stopCarry = "";
     stopReason;
+    messageId;
+    servedTier;
+    jsonDepth = 0;
+    jsonString = null;
+    jsonEscaped = false;
+    jsonKey;
+    jsonValue = false;
     usage;
     // Compressed responses (Anthropic answers the CLI with gzip/br) are collected side-band up to a cap
     // and inflated once at the end; the forwarded bytes are never touched.
@@ -215,28 +223,28 @@ export class ResponseUsageTap {
         }
         if (this.isSse && this.carry)
             this.feedSse("\n");
-        return { ...(this.usage ? { usage: this.usage } : {}), ...(this.stopReason ? { stopReason: this.stopReason } : {}) };
+        return {
+            ...(this.usage ? { usage: this.usage } : {}),
+            ...(this.stopReason ? { stopReason: this.stopReason } : {}),
+            ...(this.messageId !== undefined ? { messageId: this.messageId } : {}),
+            ...(this.servedTier !== undefined ? { servedTier: this.servedTier } : {}),
+        };
     }
+    // Complete lines are consumed before the cap applies, so an inflated body or one large chunk keeps
+    // its events; only an unfinished line longer than the cap is dropped, along with its later bytes.
     feedSse(text) {
-        this.carry += text;
-        if (this.carry.length > MAX_CARRY) {
-            const newline = this.carry.lastIndexOf("\n");
-            if (newline < 0) {
-                this.carry = "";
-                this.event = "";
-                this.data = [];
-                return;
-            }
-            this.carry = this.carry.slice(newline + 1);
-            this.event = "";
-            this.data = [];
-        }
+        const buffer = this.carry + text;
+        let start = 0;
         for (;;) {
-            const newline = this.carry.indexOf("\n");
+            const newline = buffer.indexOf("\n", start);
             if (newline < 0)
-                return;
-            const raw = this.carry.slice(0, newline);
-            this.carry = this.carry.slice(newline + 1);
+                break;
+            const raw = buffer.slice(start, newline);
+            start = newline + 1;
+            if (this.skipSseLine) {
+                this.skipSseLine = false;
+                continue;
+            }
             const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
             if (line === "") {
                 this.consumeSseEvent();
@@ -250,6 +258,13 @@ export class ResponseUsageTap {
                 this.data.push(line.slice(5).trimStart());
             }
         }
+        this.carry = buffer.slice(start);
+        if (this.carry.length > MAX_CARRY) {
+            this.carry = "";
+            this.skipSseLine = true;
+            this.event = "";
+            this.data = [];
+        }
     }
     consumeSseEvent() {
         if (!this.data.length)
@@ -258,6 +273,8 @@ export class ResponseUsageTap {
             const body = JSON.parse(this.data.join("\n"));
             if (this.event === "message_start" || body.type === "message_start") {
                 const message = body.message;
+                if (typeof message?.id === "string")
+                    this.messageId = message.id;
                 this.setUsage(message?.usage);
             }
             else if (this.event === "message_delta" || body.type === "message_delta") {
@@ -272,6 +289,42 @@ export class ResponseUsageTap {
         }
     }
     feedJson(text) {
+        // Read only the top-level id, never an id quoted in content or a tool input.
+        for (const char of text) {
+            if (this.jsonString !== null) {
+                if (this.jsonString.length < 256)
+                    this.jsonString += char;
+                if (this.jsonEscaped)
+                    this.jsonEscaped = false;
+                else if (char === "\\")
+                    this.jsonEscaped = true;
+                else if (char === '"') {
+                    if (this.jsonDepth === 1) {
+                        try {
+                            const value = JSON.parse(this.jsonString);
+                            if (!this.jsonValue && typeof value === "string")
+                                this.jsonKey = value;
+                            else if (this.jsonKey === "id" && typeof value === "string")
+                                this.messageId = value;
+                        }
+                        catch { /* oversized or malformed string */ }
+                    }
+                    this.jsonString = null;
+                }
+            }
+            else if (char === '"')
+                this.jsonString = '"';
+            else if (char === "{" || char === "[")
+                this.jsonDepth++;
+            else if (char === "}" || char === "]")
+                this.jsonDepth--;
+            else if (this.jsonDepth === 1 && char === ":")
+                this.jsonValue = true;
+            else if (this.jsonDepth === 1 && char === ",") {
+                this.jsonValue = false;
+                this.jsonKey = undefined;
+            }
+        }
         this.carry += text;
         this.stopCarry = (this.stopCarry + text).slice(-MAX_CARRY);
         const stop = /"stop_reason"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/.exec(this.stopCarry);
@@ -303,6 +356,7 @@ export class ResponseUsageTap {
             this.jsonUsageText = "";
             return;
         }
+        this.jsonUsageDepth = 0;
         let quoted = false;
         let escaped = false;
         for (let i = 0; i < this.jsonUsageText.length; i++) {
@@ -335,15 +389,19 @@ export class ResponseUsageTap {
         if (!value || typeof value !== "object")
             return;
         const usage = value;
+        if (typeof usage.service_tier === "string")
+            this.servedTier = usage.service_tier;
         const number = (key) => typeof usage[key] === "number" && Number.isFinite(usage[key]) ? Math.max(0, usage[key]) : 0;
         if (!("input_tokens" in usage || "output_tokens" in usage || "cache_read_input_tokens" in usage || "cache_creation_input_tokens" in usage))
             return;
         const current = this.usage ?? { input: 0, cached: 0, output: 0 };
         const input = "input_tokens" in usage ? number("input_tokens") : current.input;
         const cached = "cache_read_input_tokens" in usage ? number("cache_read_input_tokens") : current.cached;
-        const cacheWrite = "cache_creation_input_tokens" in usage ? number("cache_creation_input_tokens") : current.cacheWrite;
+        const cacheWrite = "cache_creation_input_tokens" in usage
+            ? typeof usage.cache_creation_input_tokens === "number" && Number.isFinite(usage.cache_creation_input_tokens) ? number("cache_creation_input_tokens") : undefined
+            : current.cacheWrite;
         const output = "output_tokens" in usage ? number("output_tokens") : current.output;
-        this.usage = { input, cached, ...(cacheWrite && cacheWrite > 0 ? { cacheWrite } : {}), output };
+        this.usage = { input, cached, ...(cacheWrite !== undefined ? { cacheWrite } : {}), output };
     }
 }
 export function requestId() {

package/dist/router/src/version.js

@@ -5,4 +5,4 @@
 // from the manifests. Until 0.1.1 the router and the CLI each carried their own literal, and both
 // still said "0.1.0" in the 0.1.1 release: after an update nobody could tell which router was
 // running, and the tray app had nothing to compare (2026-09-15, reported from a Windows install).
-export const VERSION = "0.9.0";
+export const VERSION = "0.9.2";