clauderipple 0.8.7 → 0.8.9

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.8.9 — 2026-10-08
+
+### Fixed
+
+- **New Claude models appear on their own.** The Claude model list was built into ClaudeRipple,
+  so Opus 5.5, Sonnet 5.5 and Haiku 5.5 never showed up. It now comes from Anthropic's model list
+  for your account, refreshed hourly. When a newer model ships in a family you already use (say
+  Opus 5.5 after Opus 5), it is added to your Claude provider on its own. Untick it and it stays
+  unticked.
+
+## 0.8.8 — 2026-10-07
+
+### Fixed
+
+- **Web search works with OpenCode Go's DeepSeek on the small/fast slot.** With that slot on
+  DeepSeek V4.1 Flash, V4 Flash or V4 Pro through OpenCode Go, every `WebSearch` was refused
+  and the Clients screen marked those models "no web search here". The same plan runs the search on
+  its Anthropic endpoint, so the router now sends searches for these models there. Their other
+  requests are unchanged.
+
 ## 0.8.7 — 2026-10-07
 
 ### Fixed

package/dist/app/package.json

@@ -1,5 +1,5 @@
 {
   "private": true,
-  "version": "0.8.7",
+  "version": "0.8.9",
   "type": "commonjs"
 }

package/dist/router/src/admin.js

@@ -23,13 +23,14 @@ import path from "node:path";
 import http from "node:http";
 import { execFile, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { homeDir, validate } from "./config.js";
+import { homeDir, searchProviderFor, validate } from "./config.js";
 import { PRESETS } from "./presets.js";
 import { resolveCompatibleCaps } from "./compat.js";
 import { CHATGPT_FALLBACK_MODELS } from "./providers/chatgpt/catalog.js";
 import { measureModel, refusedByPlan } from "./capabilities.js";
 import { catalogEntry } from "./catalog.js";
 import { ClaudeCodeAuthStore, nativeAnthropicHeaders } from "./providers/anthropic.js";
+import { fetchClaudeModels, newClaudeReleases } from "./providers/anthropic-models.js";
 import { codexEnabled, codexHome } from "../../cli/src/codex.js";
 import { openBrowser } from "../../cli/src/browser.js";
 import { caTrusted, currentAppProxy } from "../../cli/src/picker.js";
@@ -171,18 +172,27 @@ export function effortLevelsForModel(cfg, modelId) {
     }
     return undefined;
 }
+// Only for when Anthropic's own list cannot be had (no sign-in yet, offline): the live list is
+// `deps.claudeModels`, and a release after this table is cut appears there by itself (2026-10-08).
 const CLAUDE_MODEL_FALLBACK = [
-    { id: "claude-fable-5-1", name: "Fable 5.1" },
+    { id: "claude-haiku-5-5", name: "Haiku 5.5" },
+    { id: "claude-sonnet-5-5", name: "Sonnet 5.5" },
     { id: "claude-opus-5-5", name: "Opus 5.5" },
+    { id: "claude-fable-5-1", name: "Fable 5.1" },
     { id: "claude-opus-5", name: "Opus 5" },
     { id: "claude-sonnet-5", name: "Sonnet 5" },
-    { id: "claude-haiku-4-5", name: "Haiku 4.5" },
     { id: "claude-fable-5", name: "Fable 5" },
     { id: "claude-opus-4-8", name: "Opus 4.8" },
     { id: "claude-opus-4-7", name: "Opus 4.7" },
-    { id: "claude-opus-4-6", name: "Opus 4.6" },
     { id: "claude-sonnet-4-6", name: "Sonnet 4.6" },
+    { id: "claude-opus-4-6", name: "Opus 4.6" },
+    { id: "claude-haiku-4-5", name: "Haiku 4.5" },
 ];
+/** The account's Claude models, or the table above when Anthropic's list cannot be had. */
+async function claudeModelList(deps) {
+    const live = await deps.claudeModels?.().catch(() => null);
+    return live?.length ? live.map(({ line: _line, createdAt: _createdAt, ...model }) => ({ ...model, name: model.name ?? model.id })) : CLAUDE_MODEL_FALLBACK;
+}
 export function adminPort(cfg) {
     return cfg.admin?.port ?? cfg.listen.port + 1;
 }
@@ -318,6 +328,11 @@ async function buildStatus(deps, opts = {}) {
                 // events — a backend the router does not have, so a search still cannot go through it.
                 // Naming the provider's own capability instead would be a promise the router cannot keep.
                 ...(providerCanSearch(name, cfg) ? { webSearch: true } : {}),
+                // A provider whose plan searches on another endpoint does so for some models only.
+                ...(() => {
+                    const models = (("models" in p && p.models) || []).map((m) => typeof m === "string" ? m : m.id).filter((id) => searchProviderFor(p, id));
+                    return models.length ? { webSearchModels: models } : {};
+                })(),
                 // Reaching the host says nothing about being able to use it: a chatgpt provider with no
                 // credentials is not "connected", and calling it that sends the user off believing it works.
                 ...(p.type === "chatgpt" ? { needsLogin: !chatgptSignedIn(p.auth) } : {}),
@@ -633,7 +648,9 @@ function claudeAuthStore(deps) {
     return new ClaudeCodeAuthStore(undefined, { home: homeDir(), ...(deps.observedClaudeCodeAuth ? { observed: deps.observedClaudeCodeAuth } : {}) });
 }
 async function probeAnthropicApiKey(apiKey, probeFetch = fetchWithTimeout) {
-    const models = CLAUDE_MODEL_FALLBACK;
+    // The key's own model list where it answers; a key that cannot list is still tested below.
+    const listed = await fetchClaudeModels("https://api.anthropic.com", { "x-api-key": apiKey }, probeFetch).catch(() => []);
+    const models = listed.length ? listed.map(({ line: _line, createdAt: _createdAt, ...model }) => model) : CLAUDE_MODEL_FALLBACK;
     const label = "messages endpoint";
     try {
         const response = await probeFetch("https://api.anthropic.com/v1/messages", {
@@ -656,14 +673,14 @@ async function probeAnthropicApiKey(apiKey, probeFetch = fetchWithTimeout) {
         return { ok: false, auth: "unreachable", models, error: `${label}: ${errorText(e)}` };
     }
 }
-function probeClaudeCodeAuth(deps) {
+async function probeClaudeCodeAuth(deps) {
     const source = claudeAuthStore(deps).describeSource();
     // Our own accounts are reported separately: a Claude Desktop session can outrank them, and without
     // this the screen would answer a finished sign-in with the source it was already showing.
     const accounts = listClaudeAccounts(homeDir());
     const hasUsableAccount = accounts.some((account) => !account.needsReauth && account.expiresAt > Date.now());
     const signedIn = accounts.length > 0 ? "oauth" : readClaudeAuthFile(homeDir())?.source ?? null;
-    return { ok: source !== null || hasUsableAccount, auth: source !== null || hasUsableAccount ? "ok" : "missing", source, signedIn, accountCount: accounts.length, models: CLAUDE_MODEL_FALLBACK };
+    return { ok: source !== null || hasUsableAccount, auth: source !== null || hasUsableAccount ? "ok" : "missing", source, signedIn, accountCount: accounts.length, models: await claudeModelList(deps) };
 }
 /** The reasoning levels a `GET /v1beta/models` entry says the model takes, or none to offer. */
 function googleEffortLevels(entry) {
@@ -1084,6 +1101,55 @@ export function measureUnsettledModels(deps) {
     }
     return started;
 }
+/**
+ * Declare each Claude release the account has gained on every native Anthropic provider that
+ * declares an older model of the same family (`newClaudeReleases`). The declared list was whatever
+ * was ticked when the provider was saved, so Opus 5.5, Sonnet 5.5 and Haiku 5.5 stayed off it for
+ * weeks while Claude Code had them (2026-10-08). A model offered once is remembered in
+ * `claude-models-offered.json` and never offered again, so unticking a new model sticks.
+ * Returns the `provider/model` ids it declared.
+ */
+export async function adoptNewClaudeModels(deps) {
+    const live = await deps.claudeModels?.().catch(() => null);
+    if (!live?.length)
+        return [];
+    const stateFile = path.join(homeDir(), "claude-models-offered.json");
+    let offered = new Set();
+    try {
+        const saved = JSON.parse(fs.readFileSync(stateFile, "utf8"));
+        if (Array.isArray(saved.offered))
+            offered = new Set(saved.offered.filter((id) => typeof id === "string"));
+    }
+    catch { /* first run: nothing offered yet */ }
+    let current;
+    try {
+        current = JSON.parse(fs.readFileSync(deps.configFile, "utf8"));
+    }
+    catch (e) {
+        deps.log.warn(`admin: claude models not adopted: could not read config: ${errorText(e)}`);
+        return [];
+    }
+    const added = [];
+    for (const [name, provider] of Object.entries(current.providers)) {
+        if (provider.type !== "anthropic" || !provider.models?.length)
+            continue;
+        for (const model of newClaudeReleases(live, provider.models.map((entry) => entry.id), offered)) {
+            provider.models.push({ id: model.id, name: model.name ?? model.id });
+            added.push(`${name}/${model.id}`);
+        }
+    }
+    if (added.length) {
+        const errors = validate(current);
+        if (errors.length > 0) {
+            deps.log.warn(`admin: claude models not adopted: config did not validate: ${errors[0]}`);
+            return [];
+        }
+        writeConfigFile(deps.configFile, current);
+        deps.log.info(`admin: declared new Claude model(s): ${added.join(", ")}`);
+    }
+    fs.writeFileSync(stateFile, JSON.stringify({ offered: [...new Set([...offered, ...live.map((model) => model.id)])].sort() }, null, 2) + "\n");
+    return added;
+}
 /** Run one provider measurement job to completion. Detached: the request that started it has already answered. */
 async function runMeasureJob(jobId, providerName, models, deps) {
     const job = MEASURE_JOBS.get(jobId);
@@ -1140,7 +1206,7 @@ async function runMeasureJob(jobId, providerName, models, deps) {
         MEASURE_JOBS.set(jobId, { ...job, state: "failed", error: errorText(e), finishedAt: Date.now() });
     }
 }
-function pickerModels(deps) {
+async function pickerModels(deps) {
     const last = deps.picker?.().last;
     if (last && typeof last === "object" && Array.isArray(last.surfaces)) {
         const entries = last.surfaces
@@ -1166,7 +1232,7 @@ function pickerModels(deps) {
         if (models.length > 0)
             return { models, source: "picker" };
     }
-    return { models: CLAUDE_MODEL_FALLBACK, source: "fallback" };
+    return { models: await claudeModelList(deps), source: "fallback" };
 }
 function tailLines(file, n) {
     if (!fs.existsSync(file))
@@ -1288,7 +1354,7 @@ export function startAdmin(deps) {
                 return;
             }
             if (pathname === "/api/claude-models" && method === "GET") {
-                sendJson(res, 200, pickerModels(deps));
+                sendJson(res, 200, await pickerModels(deps));
                 return;
             }
             if (pathname === "/api/effort-levels" && method === "GET") {
@@ -1319,7 +1385,7 @@ export function startAdmin(deps) {
                 const probe = parsed;
                 if (probe.type === "anthropic") {
                     if (probe.auth === "claude-code") {
-                        sendJson(res, 200, probeClaudeCodeAuth(deps));
+                        sendJson(res, 200, await probeClaudeCodeAuth(deps));
                         return;
                     }
                     if (probe.auth === "api-key") {

package/dist/router/src/config.js

@@ -6,6 +6,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { PRESETS } from "./presets.js";
 /**
  * The provider's own key, re-sent under the header another wire on the same account expects.
  *
@@ -76,6 +77,27 @@ export function providerFor(provider, model) {
     }
     return { ...shared, type: "openai-compatible", url: url ?? "", ...(entry.wire ? { wire: entry.wire } : {}) };
 }
+/**
+ * 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).
+ */
+export function searchProviderFor(provider, model) {
+    const presetId = provider && "preset" in provider ? provider.preset : undefined;
+    const search = presetId ? PRESETS.find((entry) => entry.id === presetId)?.anthropicSearch : undefined;
+    if (!provider || !search || !search.models.includes(model))
+        return undefined;
+    const headers = reauthorized("headers" in provider ? provider.headers : undefined, search.authHeader);
+    const sessionHeader = "sessionHeader" in provider ? provider.sessionHeader : undefined;
+    return {
+        type: "anthropic-compatible",
+        url: search.url,
+        ...(headers ? { headers } : {}),
+        ...(sessionHeader ? { sessionHeader } : {}),
+        ...(presetId ? { preset: presetId } : {}),
+    };
+}
 export const PICKER_HOSTS_DEFAULT = ["claude.ai"];
 export function terminateHosts(c) {
     const hosts = [c.upstream];

package/dist/router/src/index.js

@@ -14,7 +14,7 @@ import { CertStore } from "./certs.js";
 import { Logger } from "./log.js";
 import { UpstreamHealth, EXIT_UPSTREAM_UNREACHABLE } from "./health.js";
 import { Proxy } from "./proxy.js";
-import { measureUnsettledModels, startAdmin } from "./admin.js";
+import { adoptNewClaudeModels, measureUnsettledModels, startAdmin } from "./admin.js";
 import { loadModelCatalog } from "./catalog.js";
 import { RequestLog } from "./requestlog.js";
 import { OpenAiIngress } from "./ingress/server.js";
@@ -164,6 +164,7 @@ proxy
         picker: () => ({ enabled: !!store.get().picker?.enabled, hosts: terminateHosts(store.get()).slice(1), last: proxy.lastPickerInjection }),
         observedClaudeCodeAuth,
         claudeUsage: () => proxy.claudeUsage.snapshot(),
+        claudeModels: () => proxy.claudeModels.list(),
         image: (req, signal) => proxy.generateImage(req, signal),
         modelCatalog: () => loadModelCatalog(),
         shutdown: () => beginDrain("shutdown requested"),
@@ -174,6 +175,11 @@ proxy
     // A minute in, once start-up traffic has settled: a few one-token requests per model whose
     // effort nobody has measured yet, so effort works without the owner re-saving the provider.
     setTimeout(() => measureUnsettledModels(adminDeps), 60_000).unref();
+    // Claude releases reach the declared models without a ClaudeRipple release: checked a minute in,
+    // then every six hours (the catalogue itself is cached for an hour).
+    const adopt = () => void adoptNewClaudeModels(adminDeps).catch((e) => log.warn(`claude models: ${e.message}`));
+    setTimeout(adopt, 60_000).unref();
+    setInterval(adopt, 6 * 60 * 60_000).unref();
 })
     .catch((e) => {
     log.error(`listen failed: ${e.message}`);

package/dist/router/src/presets.js

@@ -260,6 +260,13 @@ 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"] },
         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/anthropic-models.js

@@ -0,0 +1,125 @@
+const EFFORT_ORDER = ["low", "medium", "high", "xhigh", "max"];
+/**
+ * The active models in a `/v1/models` body. A dated id (`claude-haiku-4-5-20251001`) is folded to
+ * its alias, which the API takes as well and which is the id the rest of ClaudeRipple and Claude
+ * Code's own aliases use.
+ */
+export function claudeModelsFromBody(body) {
+    const data = body?.data;
+    if (!Array.isArray(data))
+        return [];
+    const out = [];
+    for (const raw of data) {
+        if (!raw || typeof raw !== "object")
+            continue;
+        const m = raw;
+        if (typeof m.id !== "string" || !m.id.startsWith("claude-"))
+            continue;
+        if (m.lifecycle !== undefined && m.lifecycle !== "active")
+            continue;
+        const id = m.id.replace(/-\d{8}$/, "");
+        if (out.some((entry) => entry.id === id))
+            continue;
+        const name = typeof m.display_name === "string" ? m.display_name.replace(/^Claude\s+/, "") : id;
+        const effort = m.capabilities?.effort;
+        const supported = (key) => {
+            const value = effort?.[key];
+            return typeof value === "object" && value !== null && value.supported === true;
+        };
+        const entry = { id, name };
+        // Haiku 4.5 reports the effort block with every level unsupported: it takes no effort at all.
+        if (effort && typeof effort === "object")
+            entry.effortLevels = effort.supported === true ? EFFORT_ORDER.filter(supported) : [];
+        if (typeof m.max_input_tokens === "number" && m.max_input_tokens > 0)
+            entry.contextWindow = m.max_input_tokens;
+        if (typeof m.line === "string")
+            entry.line = m.line;
+        const created = typeof m.created_at === "string" ? Date.parse(m.created_at) : NaN;
+        if (Number.isFinite(created))
+            entry.createdAt = created;
+        out.push(entry);
+    }
+    return out;
+}
+/**
+ * The account's model list, fetched at most once per `ttlMs` (an hour by default: Anthropic ships a
+ * model every few weeks). A failed lookup keeps the last good list, and null means none was ever
+ * had, so a caller falls back to its own.
+ */
+export class ClaudeModelCatalog {
+    last = null;
+    fetchedAt = Number.NEGATIVE_INFINITY;
+    inFlight = null;
+    source;
+    opts;
+    constructor(source, opts) {
+        this.source = source;
+        this.opts = opts;
+    }
+    list() {
+        const now = (this.opts.now ?? Date.now)();
+        if (now - this.fetchedAt < (this.opts.ttlMs ?? 60 * 60_000))
+            return Promise.resolve(this.last);
+        this.inFlight ??= this.fetch().finally(() => {
+            this.fetchedAt = (this.opts.now ?? Date.now)();
+            this.inFlight = null;
+        });
+        return this.inFlight;
+    }
+    async fetch() {
+        let credential;
+        try {
+            credential = (await this.source.credentials())[0];
+        }
+        catch (e) {
+            this.opts.warn?.(`claude models: no credentials: ${e.message}`);
+            return this.last;
+        }
+        if (!credential)
+            return this.last;
+        try {
+            const models = await fetchClaudeModels(`https://${this.opts.upstream()}`, credential.headers, this.opts.fetch, this.opts.timeoutMs);
+            if (models.length)
+                this.last = models;
+        }
+        catch (e) {
+            this.opts.warn?.(`claude models: ${e.message}`);
+        }
+        return this.last;
+    }
+}
+/** One `GET /v1/models` with the given credentials. Throws on anything but a usable answer. */
+export async function fetchClaudeModels(origin, headers, fetchImpl = fetch, timeoutMs = 8000) {
+    const res = await fetchImpl(`${origin}/v1/models?limit=100`, {
+        method: "GET",
+        headers: { "anthropic-version": "2023-06-01", ...headers, accept: "application/json" },
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    // The status alone: the body of an auth failure is not worth the risk of echoing.
+    if (!res.ok)
+        throw new Error(`HTTP ${res.status}`);
+    return claudeModelsFromBody(await res.json());
+}
+/**
+ * The models to add to a provider's declared list: each one released after the newest model it
+ * already declares in the same family, and not offered before. A family the provider does not
+ * declare at all is left out — someone who unticked every Sonnet did not ask for the next one — and
+ * so is anything in `offered`, so a model unticked after it arrived does not come back.
+ */
+export function newClaudeReleases(live, declared, offered) {
+    const byId = new Map(live.map((model) => [model.id, model]));
+    const newest = new Map();
+    for (const id of declared) {
+        const model = byId.get(id.replace(/-\d{8}$/, ""));
+        if (!model?.line || model.createdAt === undefined)
+            continue;
+        newest.set(model.line, Math.max(newest.get(model.line) ?? Number.NEGATIVE_INFINITY, model.createdAt));
+    }
+    const declaredIds = new Set(declared.map((id) => id.replace(/-\d{8}$/, "")));
+    return live.filter((model) => {
+        if (declaredIds.has(model.id) || offered.has(model.id) || !model.line || model.createdAt === undefined)
+            return false;
+        const floor = newest.get(model.line);
+        return floor !== undefined && model.createdAt > floor;
+    });
+}

package/dist/router/src/proxy.js

@@ -31,12 +31,13 @@ import { ChatGptAdapter } from "./providers/chatgpt/index.js";
 import { OpenAiCompatibleAdapter } from "./providers/openai/index.js";
 import { GoogleAdapter } from "./providers/google/index.js";
 import { conversationKey } from "./providers/chatgpt/translate.js";
-import { providerFor, terminateHosts } from "./config.js";
+import { providerFor, searchProviderFor, terminateHosts } from "./config.js";
 import { injectPickerModels, isBootstrapPath } from "./picker.js";
 import { effortLevelsForModel } from "./admin.js";
 import { ResponseUsageTap } 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";
 import { ClaudeUsage } from "./providers/anthropic-usage.js";
 import { dropForeignThinking } from "./thinking.js";
 const MAX_BODY = 64 * 1024 * 1024;
@@ -188,6 +189,8 @@ export class Proxy {
     claudeAccounts;
     /** Each Claude subscription account's usage, for the admin status (never a token). */
     claudeUsage;
+    /** The Claude models the signed-in account can use, from Anthropic's own list. */
+    claudeModels;
     deps;
     /**
      * Cooldowns, quarantines and conversation stickiness for provider credentials. In memory: a
@@ -357,6 +360,10 @@ export class Proxy {
             upstream: () => this.deps.config().upstream,
             warn: (message) => deps.log.warn(message),
         });
+        this.claudeModels = new ClaudeModelCatalog(this.claudeAccounts, {
+            upstream: () => this.deps.config().upstream,
+            warn: (message) => deps.log.warn(message),
+        });
         this.httpServer = http.createServer({ maxHeaderSize: 64 * 1024 }, (req, res) => {
             void this.handle(req, res);
         });
@@ -724,7 +731,9 @@ export class Proxy {
             // search of a `smallFast` slot pointed at Luna while the Clients screen called that provider
             // searchable (2026-10-07: 41 searches failed with nothing on screen to say why). A configured
             // backend on this same provider has already had its try above.
-            const own = cfg.providers[route.provider]?.type === "chatgpt" && cfg.webSearch?.provider !== route.provider;
+            // 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)))
                 return;
             const blocks = webSearchErrorBlocks(search, "unavailable");
@@ -1358,8 +1367,9 @@ export class Proxy {
             return false;
         }
         // Which backend is chosen below depends on the wire the search model speaks, which may not be
-        // the provider's own.
-        const provider = providerFor(configured, settings.model);
+        // the provider's own — or on the endpoint its plan searches on, which may not be the model's.
+        const searchVia = searchProviderFor(configured, settings.model);
+        const provider = searchVia ?? providerFor(configured, settings.model);
         const url = "url" in provider && typeof provider.url === "string" ? provider.url : undefined;
         if (!url && provider.type !== "chatgpt") {
             this.deps.log.warn(`web search: provider ${settings.provider} has no url; leaving the request alone`);
@@ -1368,10 +1378,12 @@ export class Proxy {
         // Which backend depends on how the provider is spoken to, not on the vendor. An
         // anthropic-compatible one is asked in Anthropic's own shape and hands back the blocks the CLI
         // already parses; an openai-compatible one is asked through its chat web plugin.
+        // OpenCode Go refuses a request without its session header outright (400 MissingSessionID).
+        const sessionHeader = "sessionHeader" in provider ? provider.sessionHeader : undefined;
         const common = {
             name: settings.provider,
             url: url ?? "",
-            headers: ("headers" in provider && provider.headers) || {},
+            headers: { ...(("headers" in provider && provider.headers) || {}), ...(sessionHeader ? { [sessionHeader]: crypto.randomUUID() } : {}) },
             model: settings.model,
             ...(settings.maxResults ? { maxResults: settings.maxResults } : {}),
         };
@@ -1380,7 +1392,7 @@ export class Proxy {
             // Refuse before sending rather than after. A provider that cannot run the server tool is sent
             // "perform a web search" with no tool attached, and a model told to search with nothing to
             // search with narrates a tool call instead — an answer shaped like success, holding nothing.
-            if (!this.canRunServerTools(settings.provider, this.deps.config())) {
+            if (!searchVia && !this.canRunServerTools(settings.provider, this.deps.config())) {
                 this.deps.log.warn(`web search: provider ${settings.provider} does not run server tools; leaving the request alone`);
                 return false;
             }

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

package/dist/router/src/websearch.js

@@ -296,7 +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). Treat that as the failure it is.
+            // (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.
             const deduped = dedupeHits(hits).slice(0, opts.maxResults ?? 10);
             if (deduped.length === 0)
                 throw new Error(`${opts.name} web search: no results returned`);

package/dist/ui/app.js

@@ -519,8 +519,12 @@ const MODEL_SLOTS = ["smallFast", "subagent", "main"];
 // A provider the router measured as unable to search. Only the router can know this — it comes from
 // the status snapshot, never from the model's name — and the `smallFast` slot is exactly where it
 // matters, because a search sent to such a model comes back as invented prose or a visible failure.
-function providerCannotSearch(name) {
-  return Boolean(status && status.providers && status.providers[name] && status.providers[name].webSearch !== true);
+// A plan that searches on another of its endpoints does so for the models it names only.
+function providerCannotSearch(name, model) {
+  const entry = status && status.providers && status.providers[name];
+  if (!entry || entry.webSearch === true) return false;
+  const id = String(model || "").replace(/@[^@]*$/, "");
+  return !(Array.isArray(entry.webSearchModels) && entry.webSearchModels.includes(id));
 }
 
 function renderModelSlots() {
@@ -535,7 +539,7 @@ function renderModelSlots() {
       if (chosen[slot] === model.id) option.selected = true;
       // `smallFast` is what a WebSearch runs on, so an inability to search is fatal there and
       // merely worth knowing everywhere else.
-      if (slot === "smallFast" && providerCannotSearch(group.name)) {
+      if (slot === "smallFast" && providerCannotSearch(group.name, model.id)) {
         option.textContent += ` — ${t("slots.noWebSearch")}`;
       }
       select.appendChild(option);
@@ -572,7 +576,7 @@ async function saveModelSlots() {
     // screen was already guilty of once. The label on the option warns before the fact; this catches
     // a session that already had it selected.
     const owners = models.smallFast ? providersOffering(next, models.smallFast) : [];
-    if (owners.length && providerCannotSearch(owners[0])) toast(t("slots.noWebSearchWarn"), true);
+    if (owners.length && providerCannotSearch(owners[0], models.smallFast)) toast(t("slots.noWebSearchWarn"), true);
     else toast(t("slots.slotSaved"));
   } catch (error) { toast(t("common.saveFailed"), true, error.message); }
 }
@@ -1791,7 +1795,10 @@ function openAnthropicProviderForm(options) {
         response.error ? el("div", { class: "small", text: response.error.replace(/^no-credits:\s*/, "") }) : null,
       ].filter(Boolean));
       if (Array.isArray(response.models) && response.models.length) {
-        foundModels = response.models;
+        // Anthropic's own list, so a release shows up here without a ClaudeRipple update. A saved
+        // model the list no longer carries stays visible and ticked rather than dropped on save.
+        const listed = new Set(response.models.map((model) => model.id));
+        foundModels = [...response.models, ...modelsOf(existing).filter((model) => !listed.has(model.id))];
         selected = new Set(existing ? modelsOf(existing).map((model) => model.id) : foundModels.map((model) => model.id));
         renderModels();
       }
@@ -1799,6 +1806,9 @@ function openAnthropicProviderForm(options) {
     finally { if (formActive) probeButton.disabled = false; }
   }
   probeButton.addEventListener("click", () => void runProbe());
+  // The Claude login needs nothing typed, so fetch the account's model list as soon as the form
+  // opens: a saved provider otherwise showed only what was ticked when it was first saved.
+  if (auth.value === "claude-code") setTimeout(() => void runProbe(), 0);
   const modeHint = hint("");
   function syncModeHint() { modeHint.textContent = auth.value === "claude-code" && accountPool ? t("providers.anthropicPoolRouting") : t("providers.anthropicIngressOnly"); }
   auth.addEventListener("change", syncModeHint);

package/dist/ui/presets-fallback.js

@@ -3,15 +3,18 @@
 // Used only while the router is starting up or an older router does not yet expose
 // /api/presets and /api/claude-models. The API response replaces these lists.
 const FALLBACK_CLAUDE_MODELS = [
+  { id: "claude-haiku-5-5", name: "Haiku 5.5" },
+  { id: "claude-sonnet-5-5", name: "Sonnet 5.5" },
+  { id: "claude-opus-5-5", name: "Opus 5.5" },
   { id: "claude-fable-5-1", name: "Fable 5.1" },
   { id: "claude-opus-5", name: "Opus 5" },
   { id: "claude-sonnet-5", name: "Sonnet 5" },
-  { id: "claude-haiku-4-5", name: "Haiku 4.5" },
   { id: "claude-fable-5", name: "Fable 5" },
   { id: "claude-opus-4-8", name: "Opus 4.8" },
   { id: "claude-opus-4-7", name: "Opus 4.7" },
-  { id: "claude-opus-4-6", name: "Opus 4.6" },
   { id: "claude-sonnet-4-6", name: "Sonnet 4.6" },
+  { id: "claude-opus-4-6", name: "Opus 4.6" },
+  { id: "claude-haiku-4-5", name: "Haiku 4.5" },
 ];
 
 const CHATGPT_MODELS = [

package/docs/ARCHITECTURE.md

@@ -208,6 +208,18 @@ request went, and a `Pane` holds the request log.
 
 ## 4. Provider adapters
 
+- **The Claude model list is Anthropic's own (2026-10-08).** The native `anthropic`
+  provider's models came from a constant in admin.ts, so each release after it was cut
+  was missing from the provider form, the mapping table and the declared list until a
+  ClaudeRipple release caught up — Opus 5.5 (Sep 21), Sonnet 5.5 (Sep 28) and Haiku 5.5
+  (Oct 7) all were, while Claude Code itself had them. `GET /v1/models` answers the Claude
+  Code login (the observed headers) as well as an API key, newest first, with each model's
+  effort ladder, context window and lifecycle (measured: 14 active models). The router
+  caches it for an hour (`ClaudeModelCatalog`); the constant is only the fallback when no
+  sign-in answers. A release is also **declared** on its own, every six hours: added to a
+  native provider that already declares an older model of the same family, and remembered
+  in `claude-models-offered.json` so a model unticked afterwards is not added again.
+
 - **Declared models route themselves (2026-09-19).** A provider's `models` list —
   filled by the probe from the vendor's `/models`, ticked in the GUI — now decides
   routing when no rule matched: a model exactly one provider carries goes there,
@@ -506,7 +518,16 @@ request went, and a `Pane` holds the request log.
         runs OpenAI's hosted `web_search` and cites real pages, but its wire is OpenAI-shaped while
         its hits arrive as Responses events (`web_search_call`, `url_citation`), a backend the router
         does not have. DeepSeek's own endpoint and the ChatGPT provider run Anthropic's server tool;
-        OpenCode Go's chat and Anthropic endpoints, and every `openai-compatible` provider, do not.
+        OpenCode Go's chat endpoint, and every `openai-compatible` provider, do not.
+      - **OpenCode Go's Anthropic endpoint does, for DeepSeek only** (corrected 2026-10-07). The
+        line above once said it did not. Re-measured with the key in `x-api-key` (a bearer there
+        answers "Missing API key"), Claude Code's own side request to `/zen/go/v1/messages` came back
+        with ten real hits and `web_search_requests: 1` for deepseek-v4.1-flash, deepseek-v4-flash
+        and deepseek-v4-pro; Kimi K3, MiniMax M3 and Qwen3.8 Flash took the tool and never searched;
+        GLM and MiMo are not served there. The preset lists those three as `anthropicSearch`, and a
+        search routed to one of them (a `smallFast` slot on OpenCode Go's DeepSeek) is relayed there
+        by `anthropicServerToolBackend`, though the model's turns stay on Chat Completions. The
+        Clients screen reads `webSearchModels` from `/api/status` to stop calling them unsearchable.
     - **A model that cannot search does not merely decline — it invents.** Measured 2026-09-21
       against OpenCode Go's chat endpoint: `plugins: [{id: "web"}]` is accepted and ignored (HTTP
       200, no `annotations`, cache reporting no lookup), and the model answers a search-shaped

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clauderipple",
-  "version": "0.8.7",
+  "version": "0.8.9",
   "description": "Use GPT (any ChatGPT plan with Codex), DeepSeek and 400+ other models in the Claude Desktop Code tab and Claude Code while staying signed in to your Claude subscription — no third-party gateway mode. Several ChatGPT accounts that take over when one runs out, in Codex too.",
   "license": "GPL-3.0-only",
   "workspaces": [