clauderipple 0.8.10 → 0.9.1

package/dist/router/src/proxy.js

@@ -18,9 +18,9 @@ import https from "node:https";
 import net from "node:net";
 import tls from "node:tls";
 import zlib from "node:zlib";
-import { UpstreamHealth } from "./health.js";
+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";
@@ -32,7 +32,7 @@ import { OpenAiCompatibleAdapter } from "./providers/openai/index.js";
 import { GoogleAdapter } from "./providers/google/index.js";
 import { conversationKey } from "./providers/chatgpt/translate.js";
 import { providerFor, searchProviderFor, terminateHosts } from "./config.js";
-import { injectPickerModels, isBootstrapPath } from "./picker.js";
+import { chatPickerModels, injectPickerModels, isBootstrapPath } from "./picker.js";
 import { effortLevelsForModel } from "./admin.js";
 import { ResponseUsageTap } from "./requestlog.js";
 import { credentialHeaderValues, redactErrorText, redactHeaders } from "./redact.js";
@@ -198,6 +198,7 @@ export class Proxy {
      * its quarantine again on the first request.
      */
     pool = new CredentialPool();
+    providerHealth = new ProviderHealth();
     /** Latest rate-limit snapshot reported by any chatgpt provider (for the admin GUI). */
     get chatgptRateLimits() {
         const out = {};
@@ -628,6 +629,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);
             }
         };
@@ -638,7 +649,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;
@@ -672,9 +683,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
@@ -693,7 +712,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;
             }
         }
@@ -734,7 +753,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";
@@ -744,7 +763,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;
@@ -754,9 +774,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;
             }
@@ -770,12 +791,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;
@@ -784,7 +804,9 @@ export class Proxy {
                     // The adapter reports each account's outcome to the shared pool itself, so a slot pointing
                     // here fails over once every account is out (chooseTarget asks the adapter).
                     const o = await this.chatgpt(route.provider, provider).handle(req, res, path, json, route.model, effortOf(json));
-                    finish(String(o.status), o.bytes, o.note, o.status >= 400, { ...(o.usage ? { usage: o.usage } : {}), ...(o.stopReason ? { stopReason: o.stopReason } : {}) });
+                    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, ...(searchAttempted ? { upstreamCalled: undefined } : {}) });
                 }
                 catch (e) {
                     finish("-", 0, `chatgpt error ${e.code ?? ""} ${e.message}`);
@@ -800,12 +822,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;
@@ -813,7 +834,9 @@ export class Proxy {
                 try {
                     const o = await this.openai(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 } : {}) });
+                    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, ...(searchAttempted ? { upstreamCalled: undefined } : {}) });
                 }
                 catch (e) {
                     this.recordOutcome(route.provider, 0);
@@ -832,12 +855,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;
@@ -845,7 +867,9 @@ export class Proxy {
                 try {
                     const o = await this.google(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 } : {}) });
+                    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, ...(searchAttempted ? { upstreamCalled: undefined } : {}) });
                 }
                 catch (e) {
                     this.recordOutcome(route.provider, 0);
@@ -869,7 +893,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);
@@ -888,7 +912,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;
@@ -903,7 +926,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;
@@ -954,7 +977,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;
@@ -972,6 +994,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);
@@ -1224,6 +1248,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) {
@@ -1274,7 +1301,7 @@ export class Proxy {
                     else if (status === 200 && isPickerBootstrap) {
                         try {
                             const j = JSON.parse(out.toString("utf8"));
-                            const r = injectPickerModels(j, cfg.cli.extraModels, cfg.cli.autoCompactWindow, (model) => effortLevelsForModel(cfg, model));
+                            const r = injectPickerModels(j, chatPickerModels(cfg), cfg.cli.autoCompactWindow, (model) => effortLevelsForModel(cfg, model));
                             if (r.surfaces.length > 0) {
                                 this.lastPickerInjection = { at: new Date().toISOString(), ...r };
                                 out = Buffer.from(JSON.stringify(j));
@@ -1336,7 +1363,15 @@ 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")) {
+                    this.providerHealth.observe(route.provider, status, providerExhaustion(status, errorBody, retryAfterMs(upRes.headers)));
+                }
                 const note = status >= 400 ? `upstream ${status}: ${errorSnippet(Buffer.concat(errorHead), upRes.headers["content-encoding"], [...errorSecrets], upRes.headers["content-type"])}` : undefined;
                 // Anthropic forgets a conversation's server-side thread after a few idle minutes, and the CLI
                 // answers the 404 by replaying the whole conversation, which hits the prompt cache. From CLI
@@ -1360,7 +1395,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`);
@@ -1411,6 +1446,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;
         }
@@ -1419,6 +1455,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/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.8.10";
+export const VERSION = "0.9.1";