clauderipple 0.11.0 → 0.12.0

package/dist/router/src/config.js

@@ -9,15 +9,12 @@ import path from "node:path";
 import { PRESETS } from "./presets.js";
 import { hostProblem, portProblem } from "./remote-host.js";
 /**
- * The provider's own key, re-sent under the header another wire on the same account expects.
+ * The provider's own key wherever its headers carry it, and every header that is not that one.
  *
- * The key is never restated in a model entry, so there is exactly one copy of it to rotate and one
- * to leak. Every other header the provider set is kept: only the auth one is replaced, because
- * sending both conventions at once would hand the endpoint a credential it did not ask for.
+ * Both auth conventions in use are recognised (`x-api-key` and `Authorization: Bearer`), because
+ * one account's headers may describe either depending on the endpoint it was configured for.
  */
-function reauthorized(headers, kind) {
-    if (!headers)
-        return headers;
+function credentialIn(headers) {
     const kept = {};
     let key;
     for (const [name, value] of Object.entries(headers)) {
@@ -32,6 +29,19 @@ function reauthorized(headers, kind) {
         }
         kept[name] = value;
     }
+    return key === undefined ? { kept } : { key, kept };
+}
+/**
+ * The provider's own key, re-sent under the header another wire on the same account expects.
+ *
+ * The key is never restated in a model entry, so there is exactly one copy of it to rotate and one
+ * to leak. Every other header the provider set is kept: only the auth one is replaced, because
+ * sending both conventions at once would hand the endpoint a credential it did not ask for.
+ */
+function reauthorized(headers, kind) {
+    if (!headers)
+        return headers;
+    const { key, kept } = credentialIn(headers);
     // Nothing recognisable to move: leave the headers exactly as they were rather than inventing an
     // empty credential, which would read to the endpoint as a missing key instead of a config error.
     if (key === undefined)
@@ -60,6 +70,28 @@ export function providerFor(provider, model) {
     if (!entry || (entry.wire === undefined && entry.url === undefined && entry.authHeader === undefined))
         return provider;
     const url = entry.url ?? ("url" in provider ? provider.url : undefined);
+    // A Gemini endpoint on the same key and the same provider. The Google adapter is an ordinary
+    // `google` provider now, so the model is folded into one here rather than growing a fourth
+    // adapter: the key moves from the provider's headers to `apiKey` (its convention on this wire is
+    // `x-goog-api-key`, never a bearer), and every header that is not the auth one travels along.
+    if (entry.wire === "google") {
+        const { key, kept } = credentialIn("headers" in provider && provider.headers ? provider.headers : {});
+        const apiKey = "apiKey" in provider && typeof provider.apiKey === "string" ? provider.apiKey : key;
+        const sessionHeader = "sessionHeader" in provider ? provider.sessionHeader : undefined;
+        return {
+            type: "google",
+            auth: "api-key",
+            ...(apiKey !== undefined ? { apiKey } : {}),
+            url: url ?? "",
+            ...(sessionHeader ? { sessionHeader } : {}),
+            ...(Object.keys(kept).length > 0 ? { headers: kept } : {}),
+            ...("models" in provider && provider.models ? { models: provider.models } : {}),
+            ...("identity" in provider && provider.identity !== undefined ? { identity: provider.identity } : {}),
+            ...("instructionsAppend" in provider && provider.instructionsAppend ? { instructionsAppend: provider.instructionsAppend } : {}),
+            ...("limits" in provider && provider.limits !== undefined ? { limits: provider.limits } : {}),
+            ...("preset" in provider && provider.preset ? { preset: provider.preset } : {}),
+        };
+    }
     const headers = entry.authHeader
         ? reauthorized("headers" in provider ? provider.headers : undefined, entry.authHeader)
         : ("headers" in provider ? provider.headers : undefined);
@@ -81,8 +113,9 @@ export function providerFor(provider, model) {
 /**
  * The Anthropic endpoint a web search for `model` runs on, when the provider's preset measured that
  * its plan searches there although the model is spoken to on another wire (`anthropicSearch`).
- * OpenCode Go's DeepSeek models answer on Chat Completions, which has no search, while the same key
- * on the plan's Anthropic endpoint runs the server tool (2026-10-07).
+ * No preset lists a model today: OpenCode Go's, once believed to search for DeepSeek on its
+ * Anthropic endpoint, never did (corrected 2026-10-21), so the search is refused there rather
+ * than fabricated. DeepSeek's search works only on DeepSeek's own API.
  */
 export function searchProviderFor(provider, model) {
     const presetId = provider && "preset" in provider ? provider.preset : undefined;
@@ -224,7 +257,7 @@ export function headerValueProblem(value) {
     return null;
 }
 /** Named once because three provider kinds report it, and a drifting copy would describe the wrong shape. */
-const MODELS_SHAPE = 'models must be entries with a string id and optional name, effortLevels, url, wire ("chat" | "responses" | "anthropic") and authHeader ("x-api-key" | "authorization-bearer")';
+const MODELS_SHAPE = 'models must be entries with a string id and optional name, effortLevels, url, wire ("chat" | "responses" | "anthropic" | "google") and authHeader ("x-api-key" | "authorization-bearer")';
 function validModels(models) {
     return Array.isArray(models) && models.every((model) => {
         if (model === null || typeof model !== "object")
@@ -238,7 +271,7 @@ function validModels(models) {
             return false;
         // A model's own wire, endpoint and auth convention: wrong here and the request goes out in the
         // wrong shape to the wrong path, which reads as a provider that rejects a working key.
-        if (m.wire !== undefined && m.wire !== "chat" && m.wire !== "responses" && m.wire !== "anthropic")
+        if (m.wire !== undefined && m.wire !== "chat" && m.wire !== "responses" && m.wire !== "anthropic" && m.wire !== "google")
             return false;
         if (m.url !== undefined && (typeof m.url !== "string" || !/^https?:\/\//.test(m.url)))
             return false;
@@ -331,6 +364,8 @@ function foldSplitProviders(c) {
 }
 export function validate(c) {
     const errors = [];
+    if (c.autoUpdate !== undefined && typeof c.autoUpdate !== "boolean")
+        errors.push("autoUpdate must be true or false");
     if (c.autoModeClassifier !== undefined) {
         const target = c.autoModeClassifier;
         if (!target || typeof target !== "object")
@@ -347,6 +382,23 @@ export function validate(c) {
                 errors.push("autoModeClassifier: effort must be a string");
         }
     }
+    if (c.webSearch !== undefined) {
+        // Hand-edited config.json reaches here as whatever JSON held, not the declared type.
+        const target = c.webSearch;
+        if (!target || typeof target !== "object" || Array.isArray(target))
+            errors.push("webSearch must be an object");
+        else {
+            if (typeof target.provider !== "string" || !target.provider.trim())
+                errors.push("webSearch: missing provider");
+            else if (!c.providers[target.provider])
+                errors.push(`webSearch: unknown provider "${target.provider}"`);
+            if (typeof target.model !== "string" || !target.model.trim())
+                errors.push("webSearch: missing model");
+            if (target.maxResults !== undefined && (!Number.isInteger(target.maxResults) || target.maxResults <= 0)) {
+                errors.push("webSearch: maxResults must be a positive integer");
+            }
+        }
+    }
     for (const [alias, r] of Object.entries(c.routes)) {
         if (!c.providers[r.provider])
             errors.push(`route ${alias}: unknown provider "${r.provider}"`);
@@ -481,6 +533,13 @@ export function validate(c) {
                 errors.push(`provider ${name}: url must start with http:// or https://`);
             if (p.defaultEffort !== undefined && typeof p.defaultEffort !== "string")
                 errors.push(`provider ${name}: defaultEffort must be a string`);
+            if (p.sessionHeader !== undefined && (typeof p.sessionHeader !== "string" || !p.sessionHeader))
+                errors.push(`provider ${name}: sessionHeader must be a non-empty string`);
+            if (p.headers !== undefined && (!p.headers || typeof p.headers !== "object" || Array.isArray(p.headers) || Object.values(p.headers).some((value) => typeof value !== "string"))) {
+                errors.push(`provider ${name}: headers must be a string record`);
+            }
+            if (p.preset !== undefined && typeof p.preset !== "string")
+                errors.push(`provider ${name}: preset must be a string`);
             if (p.models !== undefined && !validModels(p.models)) {
                 errors.push(`provider ${name}: ${MODELS_SHAPE}`);
             }

package/dist/router/src/index.js

@@ -11,6 +11,8 @@ import { ingressModels } from "./ingress/models.js";
 import { ConfigStore, awakeSettings, configPath, homeDir, terminateHosts, tetherSettings } from "./config.js";
 import { AwakeController, execRunner } from "./awake.js";
 import { TetherController } from "./tether.js";
+import { AutoUpdater } from "./autoupdate.js";
+import { runCli, startCliDetached } from "./cli-control.js";
 import { powerPlatform } from "./power.js";
 import { defaultAgentDir, syncAgentFiles } from "./agents.js";
 import { CertStore } from "./certs.js";
@@ -125,6 +127,10 @@ const activity = () => {
         ...(lastEndedAt !== undefined ? { lastEndedAt } : {}),
     };
 };
+const autoUpdater = new AutoUpdater({
+    home, version: VERSION, enabled: () => store.get().autoUpdate !== false,
+    activity, log, runCli, startCliDetached,
+});
 const awake = new AwakeController({
     platform: process.platform,
     run: powerRunner,
@@ -158,6 +164,7 @@ function beginDrain(reason) {
     if (draining)
         return;
     draining = true;
+    autoUpdater.stop();
     log.info(`${reason}: draining, proxy=${proxy.stats.messagesInFlight} ingress=${ingress.stats.messagesInFlight} model calls`);
     let lastReported = -1;
     // Each drain() closes the shared hold gate first (hold.ts): a call held for a network switch is
@@ -223,6 +230,7 @@ proxy
     // (2026-09-20). Ask once now, after listen(), and never wait for the answer.
     proxy.chatgptRefreshAll();
     const adminDeps = {
+        autoUpdater,
         config: () => store.get(),
         configFile: configPath(),
         log: log,
@@ -253,7 +261,7 @@ proxy
         claudeModels: () => proxy.claudeModels.list(),
         opencodeUsage: (name) => proxy.opencodeLimits(name),
         grokUsage: (name) => proxy.grokLimits(name),
-        image: (req, signal) => proxy.generateImage(req, signal),
+        image: (req, signal, meta) => proxy.generateImage(req, signal, meta),
         modelCatalog: () => loadModelCatalog(),
         shutdown: () => beginDrain("shutdown requested"),
         remote: {
@@ -277,6 +285,8 @@ proxy
     // The first awake tick is the reconcile: a bit a previous process set is kept or cleared now.
     void awake.start().catch((e) => log.warn(`awake: ${e.message}`));
     tether.start();
+    if (!draining)
+        autoUpdater.start();
     setImmediate(premintLeaves);
     // A minute in, once start-up traffic has settled: first the catalogue's context windows are
     // written into models already saved without one (a one-shot pass), then a few one-token requests

package/dist/router/src/picker.js

@@ -52,7 +52,31 @@ function narrowThinking(entry, levels) {
 }
 /** Resolve aliases/routes before advertising an entry; a chat-looking alias can target a judge. */
 export function chatPickerModels(cfg) {
-    return cfg.cli.extraModels.filter(entry => !isJudgeOnlyModel(entry.model) && !isJudgeOnlyModel(resolve(entry.model, {}, cfg)?.model ?? cfg.aliases[entry.model.split("@")[0]] ?? ""));
+    return cfg.cli.extraModels
+        .filter(entry => !isJudgeOnlyModel(entry.model) && !isJudgeOnlyModel(resolve(entry.model, {}, cfg)?.model ?? cfg.aliases[entry.model.split("@")[0]] ?? ""))
+        .map(entry => {
+        if (entry.contextWindow)
+            return entry;
+        const window = providerModelWindow(cfg, entry.model);
+        return window ? { ...entry, contextWindow: window } : entry;
+    });
+}
+/**
+ * The window a provider declared for `model` (its `/models` context length, or one set by hand),
+ * by id without an `@effort` suffix or through an alias. A picker entry saved without a window of
+ * its own used to fall to `cli.autoCompactWindow` although its provider knew better: a 1M MiniMax
+ * subagent compacted twice at ~240K (2026-10-21).
+ */
+export function providerModelWindow(cfg, model) {
+    const base = model.split("@")[0];
+    const ids = new Set([base, cfg.aliases[base] ?? base]);
+    for (const provider of Object.values(cfg.providers)) {
+        for (const entry of ("models" in provider && provider.models) || []) {
+            if (ids.has(entry.id) && typeof entry.contextWindow === "number" && entry.contextWindow > 0)
+                return entry.contextWindow;
+        }
+    }
+    return undefined;
 }
 /**
  * Mutates `json` in place; returns what was done for logging. `effortFor` names the levels a model

package/dist/router/src/presets.js

@@ -176,13 +176,14 @@ export const PRESETS = [
     },
     // Docs: https://opencode.ai/docs/go/
     //
-    // One subscription, one key, one `/models` catalog, three endpoints by which wire each model
+    // One subscription, one key, one `/models` catalog, four endpoint shapes by which wire each model
     // speaks: `/responses` for Muse Spark, Grok and GPT; `/chat/completions` for GLM, Kimi, DeepSeek,
-    // LongCat and MiMo; `/messages` (Anthropic) for MiniMax and Qwen. This used to be three presets
-    // because a provider carried one url and one wire; now a model carries its own wire, url and auth
-    // header (`ProviderModel`), so the account is one preset and `providerFor` folds the override in
-    // when the model is known. The provider-level values below are the Responses base — which is where
-    // Muse Spark lives, and the wire a model with no override gets.
+    // LongCat and MiMo; `/messages` (Anthropic) for MiniMax and Qwen; and Gemini 4 Argon on Google's
+    // `generateContent` under `/inference/go/google`. This used to be three presets because a provider
+    // carried one url and one wire; now a model carries its own wire, url and auth header
+    // (`ProviderModel`), so the account is one preset and `providerFor` folds the override in when the
+    // model is known. The provider-level values below are the Responses base — which is where Muse
+    // Spark lives, and the wire a model with no override gets.
     //
     // `x-opencode-session` is not optional at all: the vendor answers 400 `MissingSessionID` without
     // it — "cannot be routed efficiently" — so it gates the request rather than just the cache.
@@ -255,6 +256,12 @@ export const PRESETS = [
             { id: "qwen3.7-max", name: "Qwen3.7 Max", wire: "anthropic", url: "https://opencode.ai/zen/go", authHeader: "x-api-key" },
             { id: "qwen3.7-plus", name: "Qwen3.7 Plus", wire: "anthropic", url: "https://opencode.ai/zen/go", authHeader: "x-api-key" },
             { id: "qwen3.6-plus", name: "Qwen3.6 Plus", wire: "anthropic", url: "https://opencode.ai/zen/go", authHeader: "x-api-key" },
+            // Gemini, on Google's own generateContent wire rather than either OpenAI one. Its endpoint is
+            // a different origin path and takes the key on `x-goog-api-key`; the docs give the model's
+            // full URL as https://opencode.ai/inference/go/google/v1beta/models/<id> (read 2026-10-21).
+            // `providerFor` folds it into an ordinary google provider, and the transport appends
+            // `/v1beta/models/<id>:generateContent` to this base (providers/google/transport.ts).
+            { id: "gemini-4-argon-contributor", name: "Gemini 4 Argon (Contributor)", wire: "google", url: "https://opencode.ai/inference/go/google" },
         ],
         // Measured 2026-09-18 against the live endpoint, one effort at a time: none, minimal, low,
         // medium, high and xhigh are accepted; **max and ultra are refused** with invalid_request_error.
@@ -263,13 +270,14 @@ export const PRESETS = [
         // to the Responses models above; the Chat and Anthropic ones carry their own empty ladder.
         effortLevels: ["none", "minimal", "low", "medium", "high", "xhigh"],
         thinking: "none",
-        // The DeepSeek models are served on Chat Completions, which ignores every search option, but
-        // the same key on the Anthropic endpoint runs `web_search_20250305` for them: Claude Code's own
-        // side request came back with a `web_search_tool_result` of ten real pages and
-        // `web_search_requests: 1` (measured 2026-10-07; a bearer header there answers "Missing API
-        // key"). Kimi K3, MiniMax M3 and Qwen3.8 Flash take the tool on that endpoint and never search;
-        // GLM and MiMo are not served there at all.
-        anthropicSearch: { url: "https://opencode.ai/zen/go", authHeader: "x-api-key", models: ["deepseek-v4.1-flash", "deepseek-v4-flash", "deepseek-v4-pro"] },
+        // No model on this plan searches. The DeepSeek models are served on Chat Completions, which
+        // ignores every search option, and DeepSeek's search has only ever worked on DeepSeek's own API.
+        // A 2026-10-07 note here claimed the plan's Anthropic endpoint ran `web_search_20250305` for
+        // them; it was wrong — the user reports it never searched, and on 2026-10-21 the relay answered
+        // HTTP 200 with no `web_search_tool_result` hits ("opencode-go web search: no results
+        // returned"). The list stays empty so `/api/status` offers none of them as searchable and a
+        // search routed there is refused instead of fabricated.
+        anthropicSearch: { url: "https://opencode.ai/zen/go", authHeader: "x-api-key", models: [] },
         verified: true,
         notes: "One subscription and key, three endpoints by wire. Measured 2026-09-18. Responses: Muse Spark answers, effort ladder tops out at xhigh, prompt cache reached 96% on a repeated turn. Chat: glm-5.3, glm-5.3-flash, kimi-k3, kimi-k2.7-code, deepseek-v4.1-flash, deepseek-v4-pro, longcat-2.0 and mimo-v2.5-pro all answered. Anthropic: minimax-m3, qwen3.8-max and qwen3.8-flash answered with the prompt cache at 99% on a repeated turn, while union-alpha, the free row, answered \"Model is unavailable\". The Muse Spark Contributor tier is ~90% cheaper because Meta states those interactions improve its products, and OpenCode refuses the model until the workspace opts in (403 DataPolicyError); it is also limited to some regions.",
         docsUrl: "https://opencode.ai/docs/go/",

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

@@ -503,6 +503,7 @@ export class ChatGptAdapter {
         const decoder = new TextDecoder();
         let image;
         let text = "";
+        let usage;
         try {
             for (;;) {
                 const { done, value } = await reader.read();
@@ -516,6 +517,15 @@ export class ChatGptAdapter {
                         if (item?.type === "image_generation_call" && typeof item.result === "string" && item.result)
                             image = item;
                     }
+                    if (event.type === "response.completed") {
+                        // The same conversion the translated turns use: `input_tokens` is what the prompt read,
+                        // `cached_tokens` the part the backend served from its cache.
+                        const u = event.response?.usage;
+                        if (u) {
+                            const cached = u.input_tokens_details?.cached_tokens ?? 0;
+                            usage = { input: (u.input_tokens ?? 0) - cached, cached, output: u.output_tokens ?? 0 };
+                        }
+                    }
                     if (event.type === "error" || event.type === "response.failed") {
                         const error = (event.error ?? event.response?.error);
                         throw new Error(`ChatGPT image generation: ${String(error?.message ?? "backend error")}`);
@@ -539,6 +549,7 @@ export class ChatGptAdapter {
             ...(str(image.size) ? { size: str(image.size) } : {}),
             ...(str(image.quality) ? { quality: str(image.quality) } : {}),
             ...(str(image.revised_prompt) ? { revisedPrompt: str(image.revised_prompt) } : {}),
+            ...(usage ? { usage } : {}),
         };
     }
     /** One in-flight lookup shared by every caller (the status route and the startup refresh). */

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

@@ -407,7 +407,12 @@ export class GoogleAdapter {
         // before usage arrives, so announce an estimate and correct it in message_delta.
         const key = conversationKey(json);
         const startInput = Math.max(estimateTokens(json), this.lastInputByKey.get(key) ?? 0);
-        const transport = createTransport(this.cfg.auth, { ...(this.cfg.apiKey ? { apiKey: this.cfg.apiKey } : {}), ...(this.cfg.url ? { url: this.cfg.url } : {}) });
+        const transport = createTransport(this.cfg.auth, {
+            ...(this.cfg.apiKey ? { apiKey: this.cfg.apiKey } : {}),
+            ...(this.cfg.url ? { url: this.cfg.url } : {}),
+            ...(this.cfg.sessionHeader ? { sessionHeader: this.cfg.sessionHeader } : {}),
+            ...(this.cfg.headers ? { headers: this.cfg.headers } : {}),
+        });
         if (this.cfg.auth === "antigravity") {
             return this.handleAntigravity(res, json, upstreamRequest, transport, model, useEffort, wantStream, key, startInput, host, signatures);
         }
@@ -419,7 +424,7 @@ export class GoogleAdapter {
         }
         let built;
         try {
-            built = transport.build(upstreamRequest, { model, stream: wantStream });
+            built = transport.build(upstreamRequest, { model, stream: wantStream, conversationKey: key });
         }
         catch (error) {
             const out = anthropicError(400, "invalid_request_error", error.message);

package/dist/router/src/providers/google/transport.js

@@ -11,6 +11,7 @@
 // (src/adapters/google.ts:1056-1160, src/adapters/google-antigravity-wire.ts) and is **not measured
 // live** — this environment has no Antigravity subscription. See docs/ARCHITECTURE.md §4d.
 import { antigravityRequestId, antigravitySessionId, antigravityUserAgent, GOOGLE_OAUTH, resolveAntigravityWireModel } from "./antigravity.js";
+import { VERSION } from "../../version.js";
 const DEFAULT_BASE = "https://generativelanguage.googleapis.com";
 /** The AI Studio key: the provider's own, or the environment names Google's own SDKs read. Never logged. */
 export function resolveApiKey(configured) {
@@ -98,6 +99,12 @@ export function createTransport(mode, opts) {
     }
     const base = googleBaseUrl(opts.url);
     const apiKey = resolveApiKey(opts.apiKey);
+    // A provider that asks for a conversation header is not AI Studio; it is a relay such as OpenCode
+    // Go, which also asks clients to name themselves with a distinctive User-Agent rather than an
+    // SDK/library one (https://opencode.ai/docs/go/, read 2026-10-21). Plain AI Studio requests keep
+    // the client's own User-Agent, so nothing about this changes for them.
+    const sessionHeader = opts.sessionHeader?.trim() || undefined;
+    const userAgent = sessionHeader ? `clauderipple/${VERSION}` : undefined;
     return {
         kind: "api-key",
         build(req, o) {
@@ -107,7 +114,15 @@ export function createTransport(mode, opts) {
             const query = o.stream ? "?alt=sse" : "";
             return {
                 url: `${base}/v1beta/models/${encodeURIComponent(o.model)}:${method}${query}`,
-                headers: { "content-type": "application/json", accept: o.stream ? "text/event-stream" : "application/json", "x-goog-api-key": apiKey },
+                headers: {
+                    "content-type": "application/json",
+                    accept: o.stream ? "text/event-stream" : "application/json",
+                    ...(userAgent ? { "user-agent": userAgent } : {}),
+                    ...(sessionHeader && o.conversationKey ? { [sessionHeader]: o.conversationKey } : {}),
+                    ...(opts.headers ?? {}),
+                    // Kept after the vendor's own headers so nothing can shadow the credential on this wire.
+                    "x-goog-api-key": apiKey,
+                },
                 body: JSON.stringify(req),
             };
         },

package/dist/router/src/proxy.js

@@ -36,7 +36,7 @@ import { conversationKey } from "./providers/chatgpt/translate.js";
 import { providerFor, searchProviderFor, terminateHosts } from "./config.js";
 import { chatPickerModels, injectPickerModels, isBootstrapPath } from "./picker.js";
 import { effortLevelsForModel } from "./admin.js";
-import { ResponseUsageTap } from "./requestlog.js";
+import { ResponseUsageTap, requestId } from "./requestlog.js";
 import { credentialHeaderValues, redactErrorText, redactHeaders } from "./redact.js";
 import { ClaudeAccountAuthPool } from "./providers/anthropic-account-pool.js";
 import { ClaudeModelCatalog } from "./providers/anthropic-models.js";
@@ -275,16 +275,56 @@ export class Proxy {
     /**
      * One image for `/api/image`, on the first chatgpt provider and the first model it declares. The
      * model only runs the tool call — the image comes from the backend's own image model — so which
-     * one it is barely matters.
+     * one it is barely matters. The call is recorded like a proxied request, success or failure, so
+     * the dashboard's usage and request list show the subscription's image traffic.
      */
-    generateImage(req, signal) {
+    async generateImage(req, signal, meta) {
         const first = Object.entries(this.deps.config().providers).find(([, p]) => p.type === "chatgpt");
         if (!first || first[1].type !== "chatgpt")
-            return Promise.reject(new Error("image generation needs a ChatGPT provider; add one in the dashboard"));
+            throw new Error("image generation needs a ChatGPT provider; add one in the dashboard");
         const model = first[1].models?.[0]?.id;
         if (!model)
-            return Promise.reject(new Error(`provider ${first[0]} declares no models`));
-        return this.chatgpt(first[0], first[1]).generateImage(model, req, signal);
+            throw new Error(`provider ${first[0]} declares no models`);
+        const at = new Date().toISOString();
+        const started = Date.now();
+        try {
+            const image = await this.chatgpt(first[0], first[1]).generateImage(model, req, signal);
+            const record = {
+                kind: "image",
+                source: model,
+                target: "image",
+                provider: first[0],
+                stream: false,
+                id: requestId(),
+                at,
+                ms: Date.now() - started,
+                ok: true,
+                status: 200,
+                ...(image.usage ? { usage: image.usage } : {}),
+                note: `${image.size ?? "?"} ${image.quality ?? "?"} ${image.format}, ${req.images?.length ?? 0} reference(s)`,
+                ...(meta?.session ? { session: meta.session } : {}),
+            };
+            this.deps.requests.add(record);
+            return image;
+        }
+        catch (e) {
+            const record = {
+                kind: "image",
+                source: model,
+                target: "image",
+                provider: first[0],
+                stream: false,
+                id: requestId(),
+                at,
+                ms: Date.now() - started,
+                ok: false,
+                status: signal?.aborted ? "aborted" : 502,
+                note: e.message.slice(0, 300),
+                ...(meta?.session ? { session: meta.session } : {}),
+            };
+            this.deps.requests.add(record);
+            throw e;
+        }
     }
     /** Dashboard action: put one resting ChatGPT account back into rotation now. */
     chatgptClearCooldown(ownerId) {

package/dist/router/src/requestlog.js

@@ -10,7 +10,7 @@ function isRecord(value) {
         return false;
     const r = value;
     return typeof r.id === "string" && typeof r.at === "string" && typeof r.ms === "number" && typeof r.ok === "boolean" &&
-        (r.kind === "messages" || r.kind === "count_tokens" || r.kind === "other") && typeof r.source === "string" &&
+        (r.kind === "messages" || r.kind === "count_tokens" || r.kind === "other" || r.kind === "image") && typeof r.source === "string" &&
         typeof r.target === "string" && typeof r.provider === "string" && typeof r.stream === "boolean";
 }
 /** Bounded request history, persisted as JSONL so a router restart preserves recent entries. */
@@ -63,12 +63,13 @@ export class RequestLog {
     }
     list(n, filter = {}) {
         const limit = Number.isFinite(n) ? Math.max(0, Math.floor(n)) : 0;
+        const kind = filter.kind === undefined ? undefined : Array.isArray(filter.kind) ? filter.kind : [filter.kind];
         const out = [];
         for (let i = this.records.length - 1; i >= 0 && out.length < limit; i--) {
             const record = this.records[i];
             if (filter.provider && record.provider !== filter.provider)
                 continue;
-            if (filter.kind && record.kind !== filter.kind)
+            if (kind && !kind.includes(record.kind))
                 continue;
             if (filter.session && record.session !== filter.session)
                 continue;

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.11.0";
+export const VERSION = "0.12.0";

package/dist/router/src/websearch.js

@@ -296,8 +296,8 @@ export function anthropicServerToolBackend(opts) {
             // No result blocks means the provider did not run the tool, whatever else it said. A model
             // told to search with no tool it can reach will narrate one instead — an OpenCode Go DeepSeek
             // answered this exact request with its own tool-call markup as plain text and zero searches
-            // (measured 2026-09-18; that same model on the plan's Anthropic endpoint, with its x-api-key
-            // header, does search — 2026-10-07). Treat that as the failure it is.
+            // (measured 2026-09-18; its Anthropic endpoint returns no hits either — 2026-10-21). Treat
+            // that as the failure it is.
             const deduped = dedupeHits(hits).slice(0, opts.maxResults ?? 10);
             if (deduped.length === 0)
                 throw new Error(`${opts.name} web search: no results returned`);