dsh-free-search 0.7.3 → 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、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 会明确报错）
@@ -66,12 +66,15 @@ dsh 默认的搜索 provider 依赖 DeepSeek 官方 API key（`DEEPSEEK_API_KEY`
 | `parallel` | Parallel | 免费 | **无 key 也可用**（官方 MCP 匿名额度），配 key 提升额度并支持精确时间过滤 |
 | `perplexity` | Perplexity | 付费 | 需 `PERPLEXITY_API_KEY` |
 | `serpbase` | SerpBase | 付费 | 需 `SERPBASE_API_KEY`（serpbase.dev，注册送 100 次免费额度） |
+| `serply` | Serply | 付费 | 需 `SERPLY_API_KEY`（serply.io，新账户 30 天内 2,500 次免费额度）；Google 网页结果，按设置页语言本地化 |
 | `deepseek-official` | DeepSeek 官方 | 付费 | 需 `DEEPSEEK_API_KEY` |
 | `you` | You.com | 付费 | 需 `YOUCOM_API_KEY`（you.com/platform/api-keys，注册即送免费额度） |
 | `baidu` | 百度千帆 AI 搜索 | 额度 | 需 `BAIDU_API_KEY`（千帆 AI 搜索，每日赠 50 次，超额按量后付费）；中文全网，支持时间过滤 |
 | `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`） |
@@ -85,6 +88,7 @@ dsh 默认的搜索 provider 依赖 DeepSeek 官方 API key（`DEEPSEEK_API_KEY`
   - Parallel：<https://platform.parallel.ai>
   - Perplexity：<https://www.perplexity.ai/settings/api>
   - SerpBase：<https://serpbase.dev>
+  - Serply：<https://serply.io>（API 文档：<https://serply.io/docs>）
   - DeepSeek：<https://platform.deepseek.com/api_keys>
   - 豆包搜索（火山联网搜索）：<https://console.volcengine.com/search-infinity/web-search>
   - You.com：<https://you.com/platform/api-keys>
@@ -165,7 +169,7 @@ Error: configured web provider "ddg" is not registered
 配置页提供：
 
 - **Search engine**：下拉框切换引擎，保存即生效
-- **API keys**：为 Exa / Tavily / Keenable / Firecrawl / Parallel / Perplexity / DeepSeek / SerpBase / You.com 填写 key（密码框，保存后只显示"已配置"；Exa / Tavily / Keenable / Firecrawl / Parallel 不填也可免 key 使用）
+- **API keys**：为 Exa / Tavily / Keenable / Firecrawl / Parallel / Perplexity / DeepSeek / SerpBase / Serply / You.com 填写 key（密码框，保存后只显示"已配置"；Exa / Tavily / Keenable / Firecrawl / Parallel 不填也可免 key 使用）
   - **推荐**：付费引擎 key 建议写入 harness 凭据中心 `~/.dsh/.credentials.yaml`（如 `DEEPSEEK_API_KEY: sk-...`，与官方 LLM provider 一致，一处管理所有 key）。插件读取优先级：凭据中心 > 设置页 > 环境变量，设置页填的 key 仅作为遗留兼容。
 - **Test engine**：直测当前引擎可用性（不走回退链，付费引擎无 key 会明确报错）
 - **Use Bing default**：把当前搜索引擎切回稳定的免费 Bing；`Discard` 只撤销尚未保存的编辑
@@ -229,7 +233,7 @@ DSH 0.1.7-rc.1 起，配置跟随 profile 的插件条目保存：设置页与 `
 
 ```yaml
 # profiles/<profile>/cordis.patch.yml 中该条目的 config：
-provider: bing              # ddg / ddg-lite / bing / searxng / anysearch / exa / tavily / keenable / firecrawl / parallel / perplexity / serpbase / deepseek-official / you / baidu / kimi / aliyun / doubao / openai / gemini / claude / auto / multi
+provider: bing              # ddg / ddg-lite / bing / searxng / anysearch / exa / tavily / keenable / firecrawl / parallel / perplexity / serpbase / serply / deepseek-official / you / baidu / kimi / aliyun / doubao / openai / gemini / claude / auto / multi
 fallbackOn: [quota, auth, bot-wall, transient, invalid-response, unknown]   # 允许触发回退的失败类别；[] = 任何失败都立即中止（默认全部）
 lang: zh                    # 设置页界面语言（zh / en）
 bingMarket: zh-CN           # Bing 市场
@@ -243,6 +247,7 @@ firecrawlApiKey: ...        # 或通过设置页填写
 parallelApiKey: ...         # 或通过设置页填写
 perplexityApiKey: ...
 serpbaseApiKey: ...         # 或通过设置页填写
+serplyApiKey: ...           # 或通过设置页填写
 deepseekApiKey: ...
 ```
 
@@ -391,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, 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)
@@ -428,12 +433,15 @@ If this plugin has been helpful, a ⭐ on [GitHub](https://github.com/DDDMUC/dsh
 | `parallel` | Parallel | Free | **Works without a key** (official MCP anonymous quota); a key raises limits and enables precise time filtering |
 | `perplexity` | Perplexity | Paid | Requires `PERPLEXITY_API_KEY` |
 | `serpbase` | SerpBase | Paid | Requires `SERPBASE_API_KEY` (serpbase.dev, 100 free queries on signup) |
+| `serply` | Serply | Paid | Requires `SERPLY_API_KEY` (serply.io, 2,500 free credits for the first 30 days); Google web results localized to the settings language |
 | `deepseek-official` | DeepSeek Official | Paid | Requires `DEEPSEEK_API_KEY` |
 | `you` | You.com | Paid | Requires `YOUCOM_API_KEY` (you.com/platform/api-keys, free tier on signup) |
 | `baidu` | Baidu Qianfan AI Search | Quota | Requires `BAIDU_API_KEY` (Qianfan AI Search, 50 free calls/day then pay-as-you-go); Chinese web-wide, supports time filtering |
 | `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`) |
@@ -447,6 +455,7 @@ If this plugin has been helpful, a ⭐ on [GitHub](https://github.com/DDDMUC/dsh
   - Parallel: <https://platform.parallel.ai>
   - Perplexity: <https://www.perplexity.ai/settings/api>
   - SerpBase: <https://serpbase.dev>
+  - Serply: <https://serply.io> (API docs: <https://serply.io/docs>)
   - DeepSeek: <https://platform.deepseek.com/api_keys>
   - Doubao / Volcano Web Search: <https://console.volcengine.com/search-infinity/web-search>
   - You.com: <https://you.com/platform/api-keys>
@@ -591,7 +600,7 @@ The old `free-search:` section of `~/.dsh/settings.yaml` is **not** imported by
 
 ```yaml
 # config of that entry in profiles/<profile>/cordis.patch.yml:
-provider: bing              # ddg / ddg-lite / bing / searxng / anysearch / exa / tavily / keenable / firecrawl / parallel / perplexity / serpbase / deepseek-official / you / baidu / kimi / aliyun / doubao / openai / gemini / claude / auto / multi
+provider: bing              # ddg / ddg-lite / bing / searxng / anysearch / exa / tavily / keenable / firecrawl / parallel / perplexity / serpbase / serply / deepseek-official / you / baidu / kimi / aliyun / doubao / openai / gemini / claude / auto / multi
 fallbackOn: [quota, auth, bot-wall, transient, invalid-response, unknown]   # failure classes allowed to trigger fallback; [] = abort on any failure (default: all)
 lang: zh                    # settings UI language (zh / en)
 bingMarket: zh-CN           # Bing market
@@ -605,6 +614,7 @@ firecrawlApiKey: ...        # Or configure via the web settings UI
 parallelApiKey: ...         # Or configure via the web settings UI
 perplexityApiKey: ...
 serpbaseApiKey: ...         # Or configure via the web settings UI
+serplyApiKey: ...           # Or configure via the web settings UI
 deepseekApiKey: ...
 ```
 

package/lib/client.js

@@ -144,6 +144,7 @@ window.__ModuleLoader__.load({
         perplexityPh: (c) => c ? "Perplexity API 密钥（已配置）" : "Perplexity API 密钥（pplx-...）",
         deepseekPh: (c) => c ? "DeepSeek API 密钥（已配置）" : "DeepSeek API 密钥（sk-...）",
         serpbasePh: (c) => c ? "SerpBase API 密钥（已配置）" : "SerpBase API 密钥（serpbase.dev 获取）",
+        serplyPh: (c) => c ? "Serply API 密钥（已配置）" : "Serply API 密钥（serply.io 获取）",
         youcomPh: (c) => c ? "You.com API 密钥（已配置）" : "You.com API 密钥（you.com/platform/api-keys 获取）",
         baiduPh: (c) => c ? "Baidu API 密钥（已配置）" : "百度千帆 API 密钥（BAIDU_API_KEY）",
         kimiPh: (c) => c ? "Kimi API 密钥（已配置）" : "Kimi API 密钥（MOONSHOT_API_KEY）",
@@ -156,7 +157,7 @@ window.__ModuleLoader__.load({
         keyStorage: "Key 存储位置",
         keyStorageCred: "凭据中心（推荐）",
         keyStorageSettings: "设置页（兼容）",
-        keyStorageCredHint: (c) => `保存后写入 ~/.dsh/.credentials.yaml（最高优先级）。当前已配置：${["anysearch", "exa", "tavily", "keenable", "firecrawl", "parallel", "perplexity", "serpbase", "deepseek", "youcom", "baidu", "kimi", "aliyun", "doubao", "openai", "gemini", "claude"].filter((k) => c[k]).map((k) => k.toUpperCase()).join(", ") || "无"}`,
+        keyStorageCredHint: (c) => `保存后写入 ~/.dsh/.credentials.yaml（最高优先级）。当前已配置：${["anysearch", "exa", "tavily", "keenable", "firecrawl", "parallel", "perplexity", "serpbase", "serply", "deepseek", "youcom", "baidu", "kimi", "aliyun", "doubao", "openai", "gemini", "claude"].filter((k) => c[k]).map((k) => k.toUpperCase()).join(", ") || "无"}`,
         keyStorageSettingsHint: "保存后写入当前 profile 的插件条目 config（cordis.patch.yml，优先级低于凭据中心）。",
         engineEnable: "全局启用的搜索引擎",
         engineEnableHint: "取消勾选后，该引擎会从普通 web_search 回退链、Auto 智能路由、advanced_search、multi_search 和引擎测试中全局排除。至少保留一个引擎。",
@@ -235,6 +236,7 @@ window.__ModuleLoader__.load({
         perplexityPh: (c) => c ? "Perplexity API key (configured)" : "Perplexity API key (pplx-...)",
         deepseekPh: (c) => c ? "DeepSeek API key (configured)" : "DeepSeek API key (sk-...)",
         serpbasePh: (c) => c ? "SerpBase API key (configured)" : "SerpBase API key (from serpbase.dev)",
+        serplyPh: (c) => c ? "Serply API key (configured)" : "Serply API key (from serply.io)",
         youcomPh: (c) => c ? "You.com API key (configured)" : "You.com API key (from you.com/platform/api-keys)",
         baiduPh: (c) => c ? "Baidu API key (configured)" : "Baidu Qianfan API key (BAIDU_API_KEY)",
         kimiPh: (c) => c ? "Kimi API key (configured)" : "Kimi API key (MOONSHOT_API_KEY)",
@@ -247,7 +249,7 @@ window.__ModuleLoader__.load({
         keyStorage: "Key storage",
         keyStorageCred: "Credential center (recommended)",
         keyStorageSettings: "Settings page (legacy)",
-        keyStorageCredHint: (c) => `Saved to ~/.dsh/.credentials.yaml (highest priority). Currently configured: ${["anysearch", "exa", "tavily", "keenable", "firecrawl", "parallel", "perplexity", "serpbase", "deepseek", "youcom", "baidu", "kimi", "aliyun", "doubao", "openai", "gemini", "claude"].filter((k) => c[k]).map((k) => k.toUpperCase()).join(", ") || "none"}`,
+        keyStorageCredHint: (c) => `Saved to ~/.dsh/.credentials.yaml (highest priority). Currently configured: ${["anysearch", "exa", "tavily", "keenable", "firecrawl", "parallel", "perplexity", "serpbase", "serply", "deepseek", "youcom", "baidu", "kimi", "aliyun", "doubao", "openai", "gemini", "claude"].filter((k) => c[k]).map((k) => k.toUpperCase()).join(", ") || "none"}`,
         keyStorageSettingsHint: "Saved to the active profile plugin entry config (cordis.patch.yml; lower priority than the credential center).",
         engineEnable: "Globally enabled search engines",
         engineEnableHint: "Unchecked engines are excluded globally from web_search fallback, Auto routing, advanced_search, multi_search, and engine tests. At least one engine must remain enabled.",
@@ -312,7 +314,7 @@ window.__ModuleLoader__.load({
     };
     const tt = (lang) => I18N[lang === "en" ? "en" : "zh"];
     // 当前插件版本（与 lib/index.js 的 PLUGIN_VERSION 保持一致）
-    const PLUGIN_VERSION = "0.7.3";
+    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 },
@@ -328,6 +330,7 @@ window.__ModuleLoader__.load({
       { id: "parallel", label: "Parallel", badge: "FREE", link: "https://platform.parallel.ai" },
       { id: "perplexity", label: "Perplexity", badge: "API KEY", link: "https://www.perplexity.ai/settings/api" },
       { id: "serpbase", label: "SerpBase · Google", badge: "API KEY", link: "https://serpbase.dev" },
+      { id: "serply", label: "Serply · Google", badge: "API KEY", link: "https://serply.io" },
       { id: "deepseek-official", label: "DeepSeek Official", badge: "API KEY", link: "https://platform.deepseek.com/api_keys" },
       { id: "you", label: "You.com", badge: "API KEY", link: "https://you.com/platform/api-keys" },
       { id: "baidu", label: "Baidu · 百度千帆", badge: "API KEY", link: "https://console.bce.baidu.com/qianfan" },
@@ -339,7 +342,7 @@ window.__ModuleLoader__.load({
       { id: "claude", label: "Claude · 内置搜索", badge: "API KEY", link: "https://console.anthropic.com/settings/keys" },
     ];
     const ENGINE_IDS = ENGINES.filter((engine) => engine.id !== "auto" && engine.id !== "multi").map((engine) => engine.id);
-    const DEFAULT_FALLBACK_ORDER = ["exa", "tavily", "keenable", "firecrawl", "parallel", "perplexity", "serpbase", "deepseek-official", "you", "baidu", "kimi", "aliyun", "doubao", "bing", "anysearch", "ddg", "ddg-lite", "searxng"];
+    const DEFAULT_FALLBACK_ORDER = ["exa", "tavily", "keenable", "firecrawl", "parallel", "perplexity", "serpbase", "serply", "deepseek-official", "you", "baidu", "kimi", "aliyun", "doubao", "bing", "anysearch", "ddg", "ddg-lite", "searxng"];
     const normalizeFallbackOrder = (value) => {
       const configured = Array.isArray(value) ? value.filter((id) => ENGINE_IDS.includes(id)) : [];
       return [...new Set([...configured, ...DEFAULT_FALLBACK_ORDER, ...ENGINE_IDS])];
@@ -469,6 +472,7 @@ window.__ModuleLoader__.load({
       const [perplexityKey, setPerplexityKey] = react.useState("");
       const [deepseekKey, setDeepseekKey] = react.useState("");
       const [serpbaseKey, setSerpbaseKey] = react.useState("");
+      const [serplyKey, setSerplyKey] = react.useState("");
       const [youcomKey, setYoucomKey] = react.useState("");
       const [baiduKey, setBaiduKey] = react.useState("");
       const [kimiKey, setKimiKey] = react.useState("");
@@ -523,6 +527,7 @@ window.__ModuleLoader__.load({
               setPerplexityKey(v.perplexityApiKey ?? "");
               setDeepseekKey(v.deepseekApiKey ?? "");
               setSerpbaseKey(v.serpbaseApiKey ?? "");
+              setSerplyKey(v.serplyApiKey ?? "");
               setYoucomKey(v.youcomApiKey ?? "");
               setBaiduKey(v.baiduApiKey ?? "");
               setKimiKey(v.kimiApiKey ?? "");
@@ -547,6 +552,7 @@ window.__ModuleLoader__.load({
                   if (path === "perplexityApiKey") configured.perplexity = true;
                   if (path === "deepseekApiKey") configured.deepseek = true;
                   if (path === "serpbaseApiKey") configured.serpbase = true;
+                  if (path === "serplyApiKey") configured.serply = true;
                   if (path === "youcomApiKey") configured.youcom = true;
                   if (path === "baiduApiKey") configured.baidu = true;
                   if (path === "kimiApiKey") configured.kimi = true;
@@ -566,7 +572,7 @@ window.__ModuleLoader__.load({
                 const cred = await bridgeCredentialsStatus();
                 if (cred.ok) {
                   const cc = {};
-                  const map = { anysearchApiKey: "anysearch", exaApiKey: "exa", tavilyApiKey: "tavily", keenableApiKey: "keenable", firecrawlApiKey: "firecrawl", parallelApiKey: "parallel", perplexityApiKey: "perplexity", deepseekApiKey: "deepseek", serpbaseApiKey: "serpbase", youcomApiKey: "youcom", baiduApiKey: "baidu", kimiApiKey: "kimi", aliyunApiKey: "aliyun", doubaoApiKey: "doubao", openaiApiKey: "openai", geminiApiKey: "gemini", claudeApiKey: "claude" };
+                  const map = { anysearchApiKey: "anysearch", exaApiKey: "exa", tavilyApiKey: "tavily", keenableApiKey: "keenable", firecrawlApiKey: "firecrawl", parallelApiKey: "parallel", perplexityApiKey: "perplexity", deepseekApiKey: "deepseek", serpbaseApiKey: "serpbase", serplyApiKey: "serply", youcomApiKey: "youcom", baiduApiKey: "baidu", kimiApiKey: "kimi", aliyunApiKey: "aliyun", doubaoApiKey: "doubao", openaiApiKey: "openai", geminiApiKey: "gemini", claudeApiKey: "claude" };
                   for (const [k, v] of Object.entries(cred.value.configured ?? {})) {
                     if (map[k]) cc[map[k]] = v;
                   }
@@ -612,6 +618,7 @@ window.__ModuleLoader__.load({
             ["perplexityApiKey", perplexityKey],
             ["deepseekApiKey", deepseekKey],
             ["serpbaseApiKey", serpbaseKey],
+            ["serplyApiKey", serplyKey],
             ["youcomApiKey", youcomKey],
             ["baiduApiKey", baiduKey],
             ["kimiApiKey", kimiKey],
@@ -1185,6 +1192,19 @@ react_jsx_runtime.jsx("div", {
                           setSaveError("");
                         },
                       }),
+                      react_jsx_runtime.jsx("input", {
+                        className: "dshfs-input",
+                        type: "password",
+                        placeholder: t.serplyPh(keysConfigured.serply),
+                        value: serplyKey,
+                        disabled: !ready || saving,
+                        onChange: (e) => {
+                          setSerplyKey(e.target.value);
+                          setDirty(true);
+                          setFailed(false);
+                          setSaveError("");
+                        },
+                      }),
                       react_jsx_runtime.jsx("input", {
                         className: "dshfs-input",
                         type: "password",

package/lib/index.js

@@ -5,6 +5,29 @@ 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），
+// 它会遮蔽顶层正确的 3.18.4，而旧版没有 .volatile()，导致 import 时报
+// "z.string(...).volatile is not a function" 且完全不知道原因。这里提前检测并给出可操作的修复提示。
+function assertSchemasterySupportsVolatile(schemaLib) {
+  let ok = false;
+  try {
+    ok = typeof schemaLib.string().default("x").volatile === "function";
+  } catch {
+    ok = false;
+  }
+  if (!ok) {
+    throw new Error(
+      "[dsh-free-search] the resolved @deepseek-ai/schemastery has no `.volatile()` (needs >= 3.18.2; this plugin declares ^3.18.4). " +
+        "This usually means a stale nested copy shadows the top-level install - check " +
+        "`node_modules/dsh-free-search/node_modules/@deepseek-ai/schemastery` (often a symlink to an old 3.18.x); " +
+        "delete that stale directory (or reinstall) so the top-level 3.18.4 is used, then fully restart DSH. See issue #55."
+    );
+  }
+}
+assertSchemasterySupportsVolatile(z);
 
 const DDG_HTML_URL = "https://html.duckduckgo.com/html/";
 const DDG_LITE_URL = "https://lite.duckduckgo.com/lite/";
@@ -16,8 +39,10 @@ const PARALLEL_MCP_URL = "https://search.parallel.ai/mcp";
 const KEENABLE_URL = "https://api.keenable.ai/v1/search";
 const KEENABLE_MCP_URL = "https://api.keenable.ai/mcp";
 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";
@@ -55,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", "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"];
@@ -90,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) => {
@@ -109,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 };
@@ -128,13 +155,13 @@ 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"];
 
-const DEFAULT_FALLBACK_ORDER = ["exa", "tavily", "keenable", "firecrawl", "parallel", "perplexity", "serpbase", "deepseek-official", "you", "baidu", "kimi", "aliyun", "doubao", "bing", "anysearch", "ddg", "ddg-lite", "searxng"];
+const DEFAULT_FALLBACK_ORDER = ["exa", "tavily", "keenable", "firecrawl", "parallel", "perplexity", "serpbase", "serply", "deepseek-official", "you", "baidu", "kimi", "aliyun", "doubao", "bing", "anysearch", "ddg", "ddg-lite", "searxng"];
 
 function normalizeDisabledEngines(value) {
   if (!Array.isArray(value)) return [];
@@ -191,7 +218,7 @@ function routeEngines(query, { timeRange, disabledEngines = [], fallbackOrder =
 }
 
 // 当前插件版本（发布时与 package.json 同步）
-const PLUGIN_VERSION = "0.7.3";
+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";
@@ -1784,6 +1811,47 @@ async function searchSerpbase(query, maxResults, apiKey, options, signal) {
   return { sources: uniqueSources(sources, maxResults ?? 10), truncated: false };
 }
 
+// Serply: 必须配置 SERPLY_API_KEY（无 key 跳过，同 serpbase）
+// Google SERP API：GET + X-Api-Key 头，返回 results[]（title/link/description）；num 上限 10。
+// 错误走 HTTP 状态码，401 时 JSON 为 {"detail": "Invalid API key"}。
+async function searchSerply(query, maxResults, apiKey, options, signal) {
+  if (!apiKey) throw new Error("Serply search requires SERPLY_API_KEY");
+  // hl/gl 跟随设置页的 lang，与 SerpBase 同一套 Google 本地化参数，默认 en/us
+  const locale = SERPBASE_LOCALE[options?.lang] ?? SERPBASE_LOCALE.en;
+  const params = new URLSearchParams({
+    q: query,
+    num: String(Math.min(Math.max(maxResults ?? 10, 1), 10)),
+    hl: locale.hl,
+    gl: locale.gl,
+  });
+  const response = await fetch(`${SERPLY_URL}?${params}`, {
+    method: "GET",
+    redirect: "error",
+    headers: {
+      "X-Api-Key": apiKey,
+      accept: "application/json",
+      "user-agent": "deepseek-harness/free-search",
+    },
+    signal: AbortSignal.any([...(signal !== undefined ? [signal] : []), AbortSignal.timeout(15000)]),
+  });
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    if (response.status === 401 || response.status === 403) {
+      throw new Error(`Serply API key is invalid (HTTP ${response.status}) - update it in Settings > Plugins > Free Search`);
+    }
+    throw new Error(`Serply API error (HTTP ${response.status}): ${detail.slice(0, 200)}`);
+  }
+  const data = await response.json();
+  const sources = (data.results ?? [])
+    .filter((r) => r.link)
+    .map((r) => ({
+      url: r.link,
+      ...(r.title ? { title: String(r.title) } : {}),
+      ...(r.description ? { snippet: String(r.description) } : {}),
+    }));
+  return { sources: uniqueSources(sources, maxResults ?? 10), truncated: false };
+}
+
 // You.com: requires YOUCOM_API_KEY (get a free key at https://you.com/platform/api-keys)
 async function searchYoucom(query, maxResults, apiKey, signal) {
   if (!apiKey) throw new Error("You.com search requires YOUCOM_API_KEY");
@@ -2090,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
@@ -2768,12 +2908,14 @@ const KEY_REF_MAP = {
   parallelApiKey: "PARALLEL_API_KEY",
   perplexityApiKey: "PERPLEXITY_API_KEY",
   serpbaseApiKey: "SERPBASE_API_KEY",
+  serplyApiKey: "SERPLY_API_KEY",
   deepseekApiKey: "DEEPSEEK_API_KEY",
   youcomApiKey: "YOUCOM_API_KEY",
   baiduApiKey: "BAIDU_API_KEY",
   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",
@@ -2805,12 +2947,14 @@ const Config = z.object({
   parallelApiKey: z.string().role("secret").volatile(),
   perplexityApiKey: z.string().role("secret").volatile(),
   serpbaseApiKey: z.string().role("secret").volatile(),
+  serplyApiKey: z.string().role("secret").volatile(),
   deepseekApiKey: z.string().role("secret").volatile(),
   youcomApiKey: z.string().role("secret").volatile(),
   baiduApiKey: z.string().role("secret").volatile(),
   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(),
@@ -2852,6 +2996,7 @@ const LEGACY_MIGRATABLE_KEYS = [
   "parallelApiKey",
   "perplexityApiKey",
   "serpbaseApiKey",
+  "serplyApiKey",
   "deepseekApiKey",
   "youcomApiKey",
   "baiduApiKey",
@@ -2997,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 () => {
@@ -3200,6 +3347,16 @@ function apply(ctx, config) {
               continue; // 无 key 跳过
             }
             result = await searchSerpbase(request.query, request.maxResults, key, cfg, effSignal);
+          } else if (engine === "serply") {
+            // serply：必须配置 SERPLY_API_KEY（无 key 跳过）
+            const key = await resolveApiKey("SERPLY_API_KEY", "serplyApiKey");
+            if (!key) {
+              lastError = new Error("Serply requires SERPLY_API_KEY (get one at serply.io)");
+              if (engine === preferred) preferredFailure = "SERPLY_API_KEY is not configured";
+              logger.warn(`free-search: engine "${engine}" skipped (no key), trying next engine`);
+              continue; // 无 key 跳过
+            }
+            result = await searchSerply(request.query, request.maxResults, key, cfg, effSignal);
           } else if (engine === "you") {
             // you.com：必须配置 YOUCOM_API_KEY（无 key 跳过）
             const key = await resolveApiKey("YOUCOM_API_KEY", "youcomApiKey");
@@ -3246,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) {
@@ -3328,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);
@@ -3478,6 +3648,11 @@ function apply(ctx, config) {
           if (!key) return { ok: false, error: "SERPBASE_API_KEY not configured" };
           return await searchSerpbase(q, n, key, cfg);
         }
+        case "serply": {
+          const key = await resolveApiKey("SERPLY_API_KEY", "serplyApiKey");
+          if (!key) return { ok: false, error: "SERPLY_API_KEY not configured" };
+          return await searchSerply(q, n, key, cfg);
+        }
         case "baidu": {
           const key = await resolveApiKey("BAIDU_API_KEY", "baiduApiKey");
           if (!key) return { ok: false, error: "BAIDU_API_KEY not configured" };
@@ -3498,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" };
@@ -3661,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, 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: {
@@ -3983,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, 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: {
@@ -4166,6 +4351,7 @@ function apply(ctx, config) {
 export {
   ALL_ENGINES,
   EXPLICIT_ONLY_ENGINES,
+  assertSchemasterySupportsVolatile,
   COOLDOWN_SESSION_MS,
   engineCooldowns,
   classifyFailure,
@@ -4229,7 +4415,11 @@ export {
   searchReddit,
   searchSearxng,
   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.3",
-  "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": [
@@ -28,6 +29,7 @@
     "parallel",
     "perplexity",
     "serpbase",
+    "serply",
     "search",
     "free",
     "baidu",
@@ -39,7 +41,8 @@
     "auto-routing",
     "doubao",
     "volcengine",
-    "volcano"
+    "volcano",
+    "zhihu"
   ],
   "license": "MIT",
   "publishConfig": {