dsh-free-search 0.7.4 → 0.7.5

package/README.md

@@ -29,7 +29,7 @@ dsh 默认的搜索 provider 依赖 DeepSeek 官方 API key（`DEEPSEEK_API_KEY`
 ### 特性
 
 - **零成本** —— 多个免费引擎，无需 key、无需注册
-- **多引擎可选**：DuckDuckGo（html/lite）、Bing、SearXNG（元搜索，支持自定义实例）、AnySearch、Exa、Tavily、Keenable、Firecrawl、Parallel、Perplexity、SerpBase、Serply、DeepSeek 官方、You.com、百度千帆、Kimi、阿里云百炼、火山联网搜索（豆包搜索）、OpenAI / Gemini / Claude 模型内置搜索
+- **多引擎可选**：DuckDuckGo（html/lite）、Bing、SearXNG（元搜索，支持自定义实例）、AnySearch、Exa、Tavily、Keenable、Firecrawl、Parallel、Perplexity、SerpBase、Serply、DeepSeek 官方、You.com、百度千帆、Kimi、阿里云百炼、火山联网搜索（豆包搜索）、知乎全网/站内（`zhihu_global`/`zhihu_site`，经知乎开放平台 MCP）、OpenAI / Gemini / Claude 模型内置搜索
 - **网页设置页** —— 引擎切换 + API key 配置（UI 中 key 脱敏显示"已配置"）+ 中英文切换；入口在左侧「插件」页的组件行配置（`plugins.row.config`，DSH 0.1.7-rc.1+）
 - **弹出式切换命令** —— 聊天框输入 `/free-search-engine`，弹出引擎选择窗口，点选即切换（等效设置页 + 保存）
 - **引擎测试** —— `free_search_test` 工具让 agent 一键测试所有引擎；设置页也有"测试引擎"按钮（直测当前引擎，不走回退链，付费引擎无 key 会明确报错）
@@ -73,6 +73,8 @@ dsh 默认的搜索 provider 依赖 DeepSeek 官方 API key（`DEEPSEEK_API_KEY`
 | `kimi` | Kimi（Moonshot）联网搜索 | 付费 | 需 `MOONSHOT_API_KEY`（basic 约 ￥0.01/次），返回带正文 chunks 的中文结果 |
 | `aliyun` | 阿里云百炼 EnhancedSearch | 付费 | 需 `DASHSCOPE_API_KEY`（MCP search_pro，约 ￥0.03/次，新用户 200 次免费包）；中文全网带来源 hostname |
 | `doubao` | 火山引擎联网搜索（豆包搜索） | 免费额度 | 需 `DOUBAO_SEARCH_API_KEY`（联网搜索控制台开通，**每月 500 次免费**，超出按量付费）；中文时效内容强，支持时间/站点过滤，返回千字级摘要 |
+| `zhihu_global` | 知乎全网搜索（开放平台 MCP） | 付费 | 需 `ZHIHU_API_KEY`；支持时间过滤（`publish_time`）；无 key 时自动跳过 |
+| `zhihu_site` | 知乎站内搜索（开放平台 MCP） | 付费 | 需 `ZHIHU_API_KEY`；不支持时间过滤 |
 | `openai` | OpenAI 模型内置搜索 | 付费 | 需 `OPENAI_API_KEY`；走 Responses API 的 `web_search` 工具，返回带引用的回答。**按次计费，仅在显式选中时使用**（不参与自动回退/auto）；默认 `gpt-6-luna`，模型与端点可配（`openaiModel` / `openaiBaseUrl`） |
 | `gemini` | Gemini Grounding with Google Search | 付费 | 需 `GEMINI_API_KEY`（兼容 `GOOGLE_API_KEY`）；走官方推荐的 **Interactions API**（`POST /v1beta/interactions`，`tools:[{type:"google_search"}]`），从 `steps[].content[].annotations` 取引用。**按次计费，仅在显式选中时使用**；默认 `gemini-3.8-flash`，模型与端点可配（`geminiModel` / `geminiBaseUrl`） |
 | `claude` | Claude 服务端 web_search | 付费 | 需 `ANTHROPIC_API_KEY`；结果来自 `web_search_tool_result`。**按次计费，仅在显式选中时使用**；默认 `claude-sonnet-5-5`，模型与端点可配（`claudeModel` / `claudeBaseUrl`） |
@@ -394,7 +396,7 @@ This plugin provides multiple free search engines with automatic fallback, compl
 ### Features
 
 - **Zero Cost** — Multiple free engines with no API key or registration required
-- **Multi-Engine Support** — DuckDuckGo (HTML / Lite), Bing, AnySearch AI, SearXNG (meta-search with custom instances), Exa, Tavily, Keenable, Firecrawl, Parallel, Perplexity, SerpBase, Serply, DeepSeek Official, You.com, Baidu Qianfan, Kimi, Aliyun Bailian, Volcano Doubao, and the model-based OpenAI / Gemini / Claude searches
+- **Multi-Engine Support** — DuckDuckGo (HTML / Lite), Bing, AnySearch AI, SearXNG (meta-search with custom instances), Exa, Tavily, Keenable, Firecrawl, Parallel, Perplexity, SerpBase, Serply, DeepSeek Official, You.com, Baidu Qianfan, Kimi, Aliyun Bailian, Volcano Doubao, Zhihu web-wide/site search (`zhihu_global`/`zhihu_site`, via the Zhihu open-platform MCP), and the model-based OpenAI / Gemini / Claude searches
 - **Web Settings UI** — Engine switching, API key configuration (keys masked as "configured" in the UI), and a Chinese/English toggle; the entry is the component-row config (`plugins.row.config`) on the sidebar Plugins page (DSH 0.1.7-rc.1+)
 - **Popup Switch Command** — Type `/free-search-engine` in the chat: a picker opens with all engines; click one to switch (equivalent to the settings page + save)
 - **Engine Testing** — `free_search_test` for the agent to check all engines in one call; the settings UI also has a "Test engine" button that tests the selected engine directly (no fallback chain; paid engines without a key report an explicit error)
@@ -438,6 +440,8 @@ If this plugin has been helpful, a ⭐ on [GitHub](https://github.com/DDDMUC/dsh
 | `kimi` | Kimi (Moonshot) Web Search | Paid | Requires `MOONSHOT_API_KEY` (basic ~¥0.01/call); returns Chinese results with body chunks |
 | `aliyun` | Aliyun Bailian EnhancedSearch | Paid | Requires `DASHSCOPE_API_KEY` (MCP search_pro, ~¥0.03/call, 200 free calls for new users); Chinese web-wide with source hostnames |
 | `doubao` | Volcano Web Search (Doubao) | Free quota | Requires `DOUBAO_SEARCH_API_KEY` (open it in the Web Search console; **500 free queries/month**, pay-as-you-go beyond); strong for fresh Chinese content, supports time/site filters, returns long summaries |
+| `zhihu_global` | Zhihu web-wide search (open-platform MCP) | Paid | Requires `ZHIHU_API_KEY`; supports the time filter (`publish_time`); skipped automatically when no key is set |
+| `zhihu_site` | Zhihu site search (open-platform MCP) | Paid | Requires `ZHIHU_API_KEY`; time filtering not verified, so it is not offered |
 | `openai` | OpenAI built-in web search | Paid | Requires `OPENAI_API_KEY`; uses the Responses API `web_search` tool and returns a cited answer. **Billed per search, explicit selection only** (never picked by the fallback chain or Auto); default `gpt-6-luna`, model/endpoint configurable (`openaiModel` / `openaiBaseUrl`) |
 | `gemini` | Gemini grounding with Google Search | Paid | Requires `GEMINI_API_KEY` (falls back to `GOOGLE_API_KEY`); uses the recommended **Interactions API** (`POST /v1beta/interactions`, `tools:[{type:"google_search"}]`) and reads citations from `steps[].content[].annotations`. **Billed per search, explicit selection only**; default `gemini-3.8-flash`, model/endpoint configurable (`geminiModel` / `geminiBaseUrl`) |
 | `claude` | Claude server-side web_search | Paid | Requires `ANTHROPIC_API_KEY`; results come from `web_search_tool_result`. **Billed per search, explicit selection only**; default `claude-sonnet-5-5`, model/endpoint configurable (`claudeModel` / `claudeBaseUrl`) |

package/lib/client.js

@@ -314,7 +314,7 @@ window.__ModuleLoader__.load({
     };
     const tt = (lang) => I18N[lang === "en" ? "en" : "zh"];
     // 当前插件版本（与 lib/index.js 的 PLUGIN_VERSION 保持一致）
-    const PLUGIN_VERSION = "0.7.4";
+    const PLUGIN_VERSION = "0.7.5";
     const ENGINES = [
       { id: "auto", label: "Auto · 智能路由", badge: "AUTO", link: null },
       { id: "multi", label: "Multi Search · 多引擎", badge: "MULTI", link: null },

package/lib/index.js

@@ -5,6 +5,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { exec } from "node:child_process";
+import { mcpCall, mcpContentText } from "./mcp_adapter.js";
 
 // 兼容 guard（#55）：Node 会优先解析插件目录下的嵌套依赖，若那里残留旧的
 // @deepseek-ai/schemastery（如 node_modules/dsh-free-search/node_modules/... -> 3.18.1），
@@ -41,6 +42,7 @@ const SERPBASE_URL = "https://api.serpbase.dev/google/search";
 const SERPLY_URL = "https://api.serply.io/v1/search";
 const YOUCOM_URL = "https://ydc-index.io/v1/search";
 const DOUBAO_SEARCH_URL = "https://open.feedcoopapi.com/search_api/web_search";
+const ZHIHU_MCP_URL = "https://developer.zhihu.com/api/mcp/v1";
 const USER_AGENT =
   "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0 Safari/537.36";
 const ACCEPT_LANG = "zh-CN,zh;q=0.9,en;q=0.8";
@@ -78,7 +80,7 @@ const MARKET_TO_LANG = {
 const FREE_SEARCH_NS = "web-search-free";
 const BRIDGE_PREFIX = "/api/dsh-free-search-settings";
 const FREE_ENGINES = ["ddg", "ddg-lite", "bing", "searxng", "anysearch"];
-const ALL_ENGINES = ["ddg", "ddg-lite", "bing", "searxng", "anysearch", "exa", "tavily", "keenable", "firecrawl", "parallel", "perplexity", "serpbase", "serply", "deepseek-official", "you", "baidu", "kimi", "aliyun", "doubao", "openai", "gemini", "claude"];
+const ALL_ENGINES = ["ddg", "ddg-lite", "bing", "searxng", "anysearch", "exa", "tavily", "keenable", "firecrawl", "parallel", "perplexity", "serpbase", "serply", "deepseek-official", "you", "baidu", "kimi", "aliyun", "doubao", "zhihu_global", "zhihu_site", "openai", "gemini", "claude"];
 
 // 模型内置搜索（按次计费）：只在你显式选中该引擎时使用；自动回退链与 auto 路由都不会兜底到它们。
 const EXPLICIT_ONLY_ENGINES = ["openai", "gemini", "claude"];
@@ -113,9 +115,11 @@ const clearCooldown = (engine) => engineCooldowns.delete(engine);
 const setCooldown = (engine, ms) => {
   engineCooldowns.set(engine, ms === COOLDOWN_SESSION_MS ? COOLDOWN_SESSION_MS : Date.now() + ms);
 };
-const applyFailureCooldown = (engine, cls) => {
+const applyFailureCooldown = (engine, cls, rateLimited = false) => {
   if (cls === "quota" || cls === "auth") setCooldown(engine, COOLDOWN_SESSION_MS);
   else if (cls === "bot-wall") setCooldown(engine, BOT_WALL_COOLDOWN_MS);
+  // 短窗限流（429/rate limit）：60 秒退避，避免下一次搜索立刻再撞（知乎 MCP 等实测存在 RPM 级限流）
+  else if (rateLimited) setCooldown(engine, BOT_WALL_COOLDOWN_MS);
 };
 
 const classifyFailure = (error) => {
@@ -132,7 +136,7 @@ const classifyFailure = (error) => {
     return { class: "bot-wall", message };
   }
   if (rateLimited || /http 5\d\d|timeout|timed out|aborted|abort|fetch failed|econn|network|socket/.test(m)) {
-    return { class: "transient", message };
+    return { class: "transient", message, rateLimited };
   }
   if (/invalid json|unexpected|parse|empty response|returned 0 results|schema|missing .*field|malformed/.test(m)) {
     return { class: "invalid-response", message };
@@ -151,8 +155,8 @@ const FAILURE_CLASS_LABELS = {
 };
 
 
-// 支持 time_range 过滤的引擎
-const TIME_ENGINES = ["tavily", "exa", "keenable", "firecrawl", "parallel", "searxng", "ddg", "ddg-lite", "baidu", "doubao"];
+// 支持 time_range 过滤的引擎（zhihu_global：global_search 的 filter 支持 publish_time>=unix秒，已实测；zhihu_site 未验证，不加）
+const TIME_ENGINES = ["tavily", "exa", "keenable", "firecrawl", "parallel", "searxng", "ddg", "ddg-lite", "baidu", "doubao", "zhihu_global"];
 
 // 虚拟搜索模式：不是单个引擎，而是 provider.search 内部的路由/并发策略
 const SEARCH_MODES = ["auto", "multi"];
@@ -214,7 +218,7 @@ function routeEngines(query, { timeRange, disabledEngines = [], fallbackOrder =
 }
 
 // 当前插件版本（发布时与 package.json 同步）
-const PLUGIN_VERSION = "0.7.4";
+const PLUGIN_VERSION = "0.7.5";
 // 检查更新的 npm registry 元数据地址（dsh-free-search 是 npmjs 上的公开包）
 const NPM_REGISTRY_URL = "https://registry.npmjs.org/dsh-free-search/latest";
 const PLUGIN_NPM_URL = "https://www.npmjs.com/package/dsh-free-search";
@@ -2154,6 +2158,78 @@ async function searchAliyun(query, maxResults, apiKey, timeRange, signal) {
 }
 
 
+// ── 知乎开放平台 MCP（developer.zhihu.com/api/mcp/v1）─────────────────────────
+// 两个引擎共用一套 MCP 适配器（lib/mcp_adapter.js，方案 v4.3 §2.7）：
+//   zhihu_global → tools/call global_search（全网，filter 支持 publish_time>=unix秒 → 入 TIME_ENGINES）
+//   zhihu_site   → tools/call zhihu_search（站内，未验证时间过滤 → 不入 TIME_ENGINES）
+// 服务端为无状态 streamable-http：实测直连 tools/call 即可（initialize 非必需，也无 session 头），
+// 响应可能是纯 JSON 或 SSE 帧——两种格式由适配器统一解析。
+// key = ZHIHU_API_KEY（凭据中心 → 本条目 config zhihuApiKey → 环境变量，三级解析；无 key 时引擎跳过不阻断回退链）
+function zhihuMcpHeaders(apiKey) {
+  return {
+    authorization: `Bearer ${apiKey}`,
+    "user-agent": "deepseek-harness/free-search",
+  };
+}
+
+// CallToolResult.content[0].text 内层 JSON → sources；{code:!=0} 与解析失败都算失败（不当搜索结果）
+function zhihuToSources(result, maxResults) {
+  const text = mcpContentText(result);
+  if (!text) return { sources: [], truncated: false };
+  let inner;
+  try {
+    inner = JSON.parse(text);
+  } catch {
+    throw new Error(`Zhihu inner content JSON parse error: ${text.slice(0, 200)}`);
+  }
+  if (inner && typeof inner.code === "number" && inner.code !== 0) {
+    throw new Error(`Zhihu API error ${inner.code}: ${inner.message ?? JSON.stringify(inner).slice(0, 200)}`);
+  }
+  const items = inner?.data?.items;
+  if (!Array.isArray(items)) return { sources: [], truncated: false };
+  const sources = items
+    .filter((it) => it && it.url)
+    .map((it) => ({
+      url: String(it.url),
+      ...(it.title ? { title: String(it.title) } : {}),
+      ...(it.summary ? { snippet: String(it.summary) } : {}),
+      ...(Number.isFinite(it.edit_time) && it.edit_time > 0
+        ? { publishedAt: new Date(it.edit_time * 1000).toISOString().replace(/\.\d{3}Z$/, "Z") }
+        : {}),
+      ...(it.author_name ? { author: String(it.author_name) } : {}),
+    }));
+  return { sources: uniqueSources(sources, maxResults ?? 10), truncated: false };
+}
+
+async function searchZhihuGlobal(query, maxResults, apiKey, timeRange, signal) {
+  if (!apiKey) throw new Error("Zhihu search requires ZHIHU_API_KEY");
+  const count = Math.min(Math.max(maxResults ?? 10, 1), 20);
+  const arguments_ = { query: String(query).slice(0, 100), count, search_db: "all" };
+  if (timeRange) {
+    // 已验证原生时间过滤：filter 表达式 publish_time>=<unix秒>；{days} 相对 / {after} 绝对日期都折算成秒
+    const afterMs = timeRange.after
+      ? Date.parse(`${timeRange.after}T00:00:00Z`)
+      : Date.now() - (timeRange.days ?? 1) * 86_400_000;
+    if (Number.isFinite(afterMs)) arguments_.filter = `publish_time>=${Math.floor(afterMs / 1000)}`;
+  }
+  const result = await mcpCall(ZHIHU_MCP_URL, zhihuMcpHeaders(apiKey), "tools/call", {
+    name: "global_search",
+    arguments: arguments_,
+  }, { timeoutMs: 20000, signal, label: "Zhihu" });
+  return zhihuToSources(result, maxResults);
+}
+
+async function searchZhihuSite(query, maxResults, apiKey, signal) {
+  if (!apiKey) throw new Error("Zhihu search requires ZHIHU_API_KEY");
+  const count = Math.min(Math.max(maxResults ?? 10, 1), 20);
+  const result = await mcpCall(ZHIHU_MCP_URL, zhihuMcpHeaders(apiKey), "tools/call", {
+    name: "zhihu_search",
+    arguments: { query: String(query).slice(0, 100), count },
+  }, { timeoutMs: 20000, signal, label: "Zhihu" });
+  return zhihuToSources(result, maxResults);
+}
+
+
 // ── 模型内置联网搜索（OpenAI / Gemini / Claude）──────────────────────────────
 // 这三个走"模型 + 服务端搜索工具"：由模型执行搜索并返回引用，按次/按 token 计费，
 // 因此只在用户显式选中该引擎时运行（见 EXPLICIT_ONLY_ENGINES）。模型名与 Base URL
@@ -2839,6 +2915,7 @@ const KEY_REF_MAP = {
   kimiApiKey: "MOONSHOT_API_KEY",
   aliyunApiKey: "DASHSCOPE_API_KEY",
   doubaoApiKey: "DOUBAO_SEARCH_API_KEY",
+  zhihuApiKey: "ZHIHU_API_KEY",
   openaiApiKey: "OPENAI_API_KEY",
   geminiApiKey: "GEMINI_API_KEY",
   claudeApiKey: "ANTHROPIC_API_KEY",
@@ -2877,6 +2954,7 @@ const Config = z.object({
   kimiApiKey: z.string().role("secret").volatile(),
   aliyunApiKey: z.string().role("secret").volatile(),
   doubaoApiKey: z.string().role("secret").volatile(),
+  zhihuApiKey: z.string().role("secret").volatile(),
   // 模型内置搜索：key + 模型名 + Base URL（后两者留空用默认，便于走兼容网关）
   openaiApiKey: z.string().role("secret").volatile(),
   geminiApiKey: z.string().role("secret").volatile(),
@@ -3064,6 +3142,8 @@ function apply(ctx, config) {
     if (primary) return primary;
     return resolveApiKey("WEB_SEARCH_API_KEY", undefined);
   };
+  // 知乎：凭据中心 ZHIHU_API_KEY → 本条目 config zhihuApiKey → 环境变量（三级解析；无 key 时引擎跳过）
+  const resolveZhihuKey = () => resolveApiKey("ZHIHU_API_KEY", "zhihuApiKey");
   // 模型内置搜索：主 key 名 + 常见别名回退
   const resolveOpenaiKey = () => resolveApiKey("OPENAI_API_KEY", "openaiApiKey");
   const resolveGeminiKey = async () => {
@@ -3323,6 +3403,18 @@ function apply(ctx, config) {
               continue;
             }
             result = await searchDoubao(request.query, request.maxResults, key, timeRange, effSignal);
+          } else if (engine === "zhihu_global" || engine === "zhihu_site") {
+            // 知乎 MCP 双引擎：无 key 跳过（不阻断回退链）；global 带时间过滤，site 不带
+            const key = await resolveZhihuKey();
+            if (!key) {
+              lastError = new Error("Zhihu requires ZHIHU_API_KEY");
+              if (engine === preferred) preferredFailure = "ZHIHU_API_KEY is not configured";
+              logger.warn(`free-search: engine "${engine}" skipped (no key), trying next engine`);
+              continue;
+            }
+            result = engine === "zhihu_global"
+              ? await searchZhihuGlobal(request.query, request.maxResults, key, timeRange, effSignal)
+              : await searchZhihuSite(request.query, request.maxResults, key, effSignal);
           } else if (engine === "openai") {
             const key = await resolveOpenaiKey();
             if (!key) {
@@ -3405,9 +3497,10 @@ function apply(ctx, config) {
           const failure = classifyFailure(error);
           const message = failure.message;
           if (engine === preferred) { preferredFailure = message; preferredFailureClass = failure.class; }
-          applyFailureCooldown(engine, failure.class);
-          // transient（超时/5xx/网络/限流）：同引擎重试一次再回退，避免一次抖动丢掉好引擎
-          if (failure.class === "transient" && !retriedEngines.has(engine)) {
+          applyFailureCooldown(engine, failure.class, failure.rateLimited);
+          // transient（超时/5xx/网络）：同引擎重试一次再回退，避免一次抖动丢掉好引擎；
+          // 限流（rateLimited）不重试——短窗内再发必再撞，已设 60s 冷却
+          if (failure.class === "transient" && !failure.rateLimited && !retriedEngines.has(engine)) {
             retriedEngines.add(engine);
             logger.warn(`free-search: engine "${engine}" failed [transient] (${message}), retrying once`);
             chain.splice(qi + 1, 0, engine);
@@ -3580,6 +3673,16 @@ function apply(ctx, config) {
           if (!key) return { ok: false, error: "DOUBAO_SEARCH_API_KEY not configured" };
           return await searchDoubao(q, n, key, tr);
         }
+        case "zhihu_global": {
+          const key = await resolveZhihuKey();
+          if (!key) return { ok: false, error: "ZHIHU_API_KEY not configured" };
+          return await searchZhihuGlobal(q, n, key, tr);
+        }
+        case "zhihu_site": {
+          const key = await resolveZhihuKey();
+          if (!key) return { ok: false, error: "ZHIHU_API_KEY not configured" };
+          return await searchZhihuSite(q, n, key);
+        }
         case "openai": {
           const key = await resolveOpenaiKey();
           if (!key) return { ok: false, error: "OPENAI_API_KEY not configured" };
@@ -3743,7 +3846,7 @@ function apply(ctx, config) {
           parameters: {
             engines: {
               type: "array",
-              description: "Which engines to test (default: all enabled engines). Options: ddg, ddg-lite, bing, searxng, anysearch, exa, tavily, keenable, firecrawl, parallel, perplexity, serpbase, serply, deepseek-official, you, baidu, kimi, aliyun, doubao, openai, gemini, claude; the virtual modes auto and multi are also accepted and run the real routing/concurrent path. openai/gemini/claude are model-based and bill per search, so they are only used when explicitly named.",
+              description: "Which engines to test (default: all enabled engines). Options: ddg, ddg-lite, bing, searxng, anysearch, exa, tavily, keenable, firecrawl, parallel, perplexity, serpbase, serply, deepseek-official, you, baidu, kimi, aliyun, doubao, zhihu_global, zhihu_site, openai, gemini, claude; zhihu_global (web-wide, supports time filter) and zhihu_site (Zhihu-only) need ZHIHU_API_KEY. The virtual modes auto and multi are also accepted and run the real routing/concurrent path. openai/gemini/claude are model-based and bill per search, so they are only used when explicitly named.",
               items: { type: "string" },
             },
             query: {
@@ -4065,7 +4168,7 @@ function apply(ctx, config) {
             },
             engine: {
               type: "string",
-              description: "Optional search mode/engine: multi (parallel top-3 merge), auto, ddg, ddg-lite, bing, searxng, anysearch, exa, tavily, keenable, firecrawl, parallel, perplexity, serpbase, serply, deepseek-official, you, baidu, kimi, aliyun, doubao, openai, gemini, claude (model-based; explicit selection only).",
+              description: "Optional search mode/engine: multi (parallel top-3 merge), auto, ddg, ddg-lite, bing, searxng, anysearch, exa, tavily, keenable, firecrawl, parallel, perplexity, serpbase, serply, deepseek-official, you, baidu, kimi, aliyun, doubao, zhihu_global, zhihu_site, openai, gemini, claude (model-based; explicit selection only).",
             },
           },
           output: {
@@ -4314,6 +4417,9 @@ export {
   searchSerpbase,
   searchSerply,
   searchYoucom,
+  searchZhihuGlobal,
+  searchZhihuSite,
+  ZHIHU_MCP_URL,
   searchStackOverflow,
   searchTavily,
   searchV2ex,

package/lib/mcp_adapter.js

@@ -0,0 +1,193 @@
+// MCP JSON-RPC 适配器（方案 v4.3 §2.7）：知乎开放平台等 streamable-http MCP 引擎共用。
+// 零新依赖：网络只用 node 标准库（node:https；http:// 端点仅为本地单测保留——
+// 不用 undici/fetch，部分网关按指纹拦 undici，见 research.js #crawl4ai 注记）。
+// 协议要求全部落地：
+//  - JSON 与 SSE（text/event-stream 的 data: 行）双响应格式解析；
+//  - JSON-RPC error（envelope.error）与工具级 isError（result.isError）区分并各自抛错；
+//  - 认证失败（HTTP 401/403）与超时/网络错误给出可被 classifyFailure 归类的消息；
+//  - 不假定 HTTP 200 + JSON 解析成功即调用成功：envelope/result/content 逐层校验。
+//
+// 错误消息与 free-search 失败分类（classifyFailure）的约定：
+//   认证 → "authentication failed (HTTP 401/403)" → auth（会话级冷却）
+//   超时/网络 → "timed out"/"aborted"/"ECONN…" → transient（同引擎重试一次）
+//   协议/解析 → "invalid JSON"/"unexpected"/"parse" → invalid-response
+
+import https from "node:https";
+import http from "node:http";
+
+/**
+ * 解析 MCP 响应体：先按纯 JSON 解析，失败再按 SSE 帧提取。
+ * SSE 帧：多个 `data:` 行（同一事件内按规范以 \n 拼接）；这里同时兼容
+ * “每行独立一个完整 JSON-RPC envelope”的服务端实现——两种都取能解析出的 envelope，
+ * 优先带 result/error 字段的那条，否则取最后一条可解析的。
+ * @param {string} rawText
+ * @returns {object|null} JSON-RPC envelope，无法解析返回 null
+ */
+export function parseMcpResponseText(rawText) {
+  if (typeof rawText !== "string" || rawText.length === 0) return null;
+  const direct = tryJson(rawText);
+  if (direct) return direct;
+
+  // SSE：按空行切事件；事件内拼接 data: 行负载
+  const events = rawText.split(/\r?\n\r?\n/);
+  const payloads = [];
+  for (const event of events) {
+    const dataLines = [];
+    for (const line of event.split(/\r?\n/)) {
+      if (line.startsWith("data:")) dataLines.push(line.slice(5).replace(/^ /, ""));
+    }
+    if (dataLines.length > 0) payloads.push(dataLines.join("\n"));
+  }
+  // 兼容没有空行分隔、每行一个 data: 的实现
+  if (payloads.length === 0) {
+    for (const line of rawText.split(/\r?\n/)) {
+      if (line.startsWith("data:")) payloads.push(line.slice(5).replace(/^ /, ""));
+    }
+  }
+  let fallback = null;
+  for (const payload of payloads) {
+    const parsed = tryJson(payload);
+    if (!parsed || typeof parsed !== "object") continue;
+    if (parsed.result !== undefined || parsed.error !== undefined) return parsed;
+    fallback = fallback ?? parsed;
+  }
+  return fallback;
+}
+
+function tryJson(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 发送一次 JSON-RPC 2.0 请求并返回 envelope.result（工具调用的 CallToolResult）。
+ * 任何失败路径都以 Error 抛出（消息见文件头分类约定），不返回部分结果。
+ *
+ * @param {string} endpoint MCP HTTP 端点（如 https://developer.zhihu.com/api/mcp/v1）
+ * @param {object} headers 额外请求头（Authorization / 自定义 UA 等；Content-Type/Accept 内置可覆盖）
+ * @param {string} method JSON-RPC 方法（"tools/call" / "initialize" / …）
+ * @param {object|undefined} params JSON-RPC params
+ * @param {{timeoutMs?: number, signal?: AbortSignal, id?: number|string, label?: string}} [options]
+ *   timeoutMs 默认 30000，<=0 表示不限；label 用于错误消息前缀（默认取端点 hostname）
+ * @returns {Promise<object>} JSON-RPC result 对象（tools/call 时为 {content, isError?}）
+ */
+export async function mcpCall(endpoint, headers = {}, method, params, options = {}) {
+  const { timeoutMs = 30000, signal, id = 1 } = options;
+  const label = options.label ?? safeHost(endpoint);
+  const body = JSON.stringify({
+    jsonrpc: "2.0",
+    id,
+    method,
+    ...(params !== undefined ? { params } : {}),
+  });
+
+  const rawText = await httpsPost(endpoint, body, {
+    "content-type": "application/json",
+    accept: "application/json, text/event-stream",
+    ...headers,
+  }, { timeoutMs, signal, label });
+
+  const envelope = parseMcpResponseText(rawText);
+  if (!envelope) {
+    throw new Error(`${label} MCP response is not valid JSON or SSE (parse failed): ${rawText.slice(0, 200)}`);
+  }
+  if (envelope.error) {
+    const { code, message } = envelope.error;
+    throw new Error(`${label} MCP error ${code ?? "?"}: ${message ?? JSON.stringify(envelope.error)}`);
+  }
+  const result = envelope.result;
+  if (result === null || result === undefined || typeof result !== "object" || Array.isArray(result)) {
+    throw new Error(`${label} MCP result missing or malformed: ${JSON.stringify(envelope).slice(0, 200)}`);
+  }
+  if (method === "tools/call" && result.isError) {
+    // 工具级错误：isError=true，正文在 content 里，不能当搜索结果
+    const errText = mcpContentText(result);
+    throw new Error(`${label} MCP tool error (isError): ${errText.slice(0, 200) || JSON.stringify(result).slice(0, 200)}`);
+  }
+  return result;
+}
+
+/** 从 CallToolResult.content 里取第一条 text 类型的文本（无则返回空串）。 */
+export function mcpContentText(result) {
+  if (!result || !Array.isArray(result.content)) return "";
+  const item = result.content.find((c) => c && c.type === "text" && typeof c.text === "string");
+  return item ? item.text : "";
+}
+
+function safeHost(endpoint) {
+  try {
+    return new URL(endpoint).hostname;
+  } catch {
+    return "MCP";
+  }
+}
+
+// 真实引擎端点都是 https；http 仅为本地错误路径单测保留（同一套 node 标准库实现）
+function transportFor(endpoint) {
+  try {
+    return new URL(endpoint).protocol === "http:" ? http : https;
+  } catch {
+    return https;
+  }
+}
+
+function httpsPost(endpoint, body, headers, { timeoutMs, signal, label }) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timer = null;
+    const onAbort = () => {
+      req.destroy(new Error(`${label} MCP request aborted`));
+    };
+    const req = transportFor(endpoint).request(endpoint, {
+      method: "POST",
+      headers: { ...headers, "content-length": Buffer.byteLength(body) },
+    }, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        const status = res.statusCode ?? 0;
+        const text = Buffer.concat(chunks).toString("utf8");
+        if (settled) return;
+        settled = true;
+        cleanup();
+        if (status === 401 || status === 403) {
+          reject(new Error(`${label} MCP authentication failed (HTTP ${status}) - check the API key`));
+          return;
+        }
+        if (status < 200 || status >= 300) {
+          reject(new Error(`${label} MCP HTTP ${status}: ${text.slice(0, 200)}`));
+          return;
+        }
+        resolve(text);
+      });
+    });
+    const cleanup = () => {
+      if (timer !== null) clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    req.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      // destroy(err) 的 err 带上下文直接透传；网络栈错误补前缀
+      reject(error instanceof Error && /MCP/.test(error.message ?? "")
+        ? error
+        : new Error(`${label} MCP request failed: ${error?.message ?? String(error)}`));
+    });
+    if (timeoutMs > 0) {
+      timer = setTimeout(() => {
+        req.destroy(new Error(`${label} MCP request timed out after ${timeoutMs}ms (timeout)`));
+      }, timeoutMs);
+    }
+    if (signal?.aborted) {
+      req.destroy(new Error(`${label} MCP request aborted`));
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    req.end(body);
+  });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-free-search",
-  "version": "0.7.4",
-  "description": "Free web search for DeepSeek Harness: 21 engines (Bing/DuckDuckGo/AnySearch/SearXNG/Exa/Tavily/Keenable/Firecrawl/Parallel keyless; Perplexity/SerpBase/DeepSeek/You.com/Baidu/Kimi/Aliyun/Doubao with key; OpenAI/Gemini/Claude model built-in search, explicit-only) + auto smart routing + global engine enable/disable & fallback priority + multi mode (parallel top-3 merge) + multi_search cross-source tool + failure-aware fallback (quota/auth cooldown, transient retry, fallbackOn) + time filtering + platform search + web_fetch, with web settings UI.",
+  "version": "0.7.5",
+  "description": "Free web search for DeepSeek Harness: 23 engines (Bing/DuckDuckGo/AnySearch/SearXNG/Exa/Tavily/Keenable/Firecrawl/Parallel keyless; Zhihu global/site via MCP and Perplexity/SerpBase/DeepSeek/You.com/Baidu/Kimi/Aliyun/Doubao with key; OpenAI/Gemini/Claude model built-in search, explicit-only) + auto smart routing + global engine enable/disable & fallback priority + multi mode (parallel top-3 merge) + multi_search cross-source tool + failure-aware fallback (quota/auth cooldown, transient retry, fallbackOn) + time filtering + platform search + web_fetch, with web settings UI.",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -12,6 +12,7 @@
   "files": [
     "lib/index.js",
     "lib/client.js",
+    "lib/mcp_adapter.js",
     "cordis.patch.yml"
   ],
   "keywords": [
@@ -40,7 +41,8 @@
     "auto-routing",
     "doubao",
     "volcengine",
-    "volcano"
+    "volcano",
+    "zhihu"
   ],
   "license": "MIT",
   "publishConfig": {