clauderipple 0.8.7 → 0.8.8

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 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.8",
   "type": "commonjs"
 }

package/dist/router/src/admin.js

@@ -23,7 +23,7 @@ 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";
@@ -318,6 +318,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) } : {}),

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/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/proxy.js

@@ -31,7 +31,7 @@ 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";
@@ -724,7 +724,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 +1360,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 +1371,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 +1385,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.8";

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); }
 }

package/docs/ARCHITECTURE.md

@@ -506,7 +506,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.8",
   "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": [