dsh-free-search 0.9.1 → 0.9.2

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、阿里云百炼、火山联网搜索（豆包搜索）、知乎全网/站内（`zhihu_global`/`zhihu_site`，经知乎开放平台 MCP）、OpenAI / Gemini / Claude 模型内置搜索
+- **多引擎可选**：DuckDuckGo（html/lite）、Bing、SearXNG（元搜索，支持自定义实例）、AnySearch、Exa、Tavily、Keenable、Firecrawl、Parallel、Perplexity、SerpBase、Serply、DeepSeek 官方、DeepSeek 原生搜索 API、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 会明确报错）
@@ -71,7 +71,8 @@ dsh 默认的搜索 provider 依赖 DeepSeek 官方 API key（`DEEPSEEK_API_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` |
+| `deepseek-official` | DeepSeek 官方 | 付费 | 需 `DEEPSEEK_API_KEY`；走 Anthropic 兼容的 `web_search` 服务端工具，每次搜索是一整个模型轮次（慢、耗 token） |
+| `deepseek-tools` | DeepSeek 原生搜索 API | 付费 | 需 `DEEPSEEK_API_KEY`（与上一档共用）；直接 `POST /v1/tools/search`，无模型参与，返回结构化 `results[]`（`title`/`url`/`summary`/`date`），同 query 实测 ~0.3s vs 上一档 ~5-6s |
 | `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 的中文结果；**无免费额度**，适合显式选用或作质量升级池，不建议放进默认并发池 |
@@ -109,7 +110,7 @@ dsh 默认的搜索 provider 依赖 DeepSeek 官方 API key（`DEEPSEEK_API_KEY`
 | ① 无限免 key | `ddg` / `ddg-lite` / `bing` / `searxng` / `anysearch` | — |
 | ② 匿名额度（不配 key 也能跑） | `exa` / `tavily` / `keenable` / `firecrawl` / `parallel` | 配 key 提额 |
 | ③ 免费额度（需 key） | `zhihu_global` / `zhihu_site`（每日 5,000 次试用）、`doubao`（每月 500 次）、`baidu`（每日 50 次）、`aliyun`（新用户 200 次包） | 按量后付费 |
-| ④ 付费升级（需 key 才有产出） | `serpbase`（注册送 100 次）/ `serply`（30 天 2,500 次）/ `you` / `perplexity` / `deepseek-official` / `kimi` | 按量 / 按次 |
+| ④ 付费升级（需 key 才有产出） | `serpbase`（注册送 100 次）/ `serply`（30 天 2,500 次）/ `you` / `perplexity` / `deepseek-official` / `deepseek-tools` / `kimi` | 按量 / 按次 |
 | ⑤ 按次计费（模型内置，显式-only） | `openai` / `gemini` / `claude` | 按 token + 每次搜索 |
 
 选默认池的经验：**① 打底 + ③ 打主力**；② 可以进但要知道它在烧匿名额度；④ 只在你确实需要该源时显式选用；⑤ 永不入池。完整的逐引擎额度事实与默认池提案见 [docs/engine-quota-tiers.md](./docs/engine-quota-tiers.md)。
@@ -267,7 +268,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 / serply / deepseek-official / you / baidu / kimi / aliyun / doubao / zhihu_global / zhihu_site / openai / gemini / claude / auto / multi
+provider: bing              # ddg / ddg-lite / bing / searxng / anysearch / exa / tavily / keenable / firecrawl / parallel / perplexity / serpbase / serply / deepseek-official / deepseek-tools / you / baidu / kimi / aliyun / doubao / zhihu_global / zhihu_site / openai / gemini / claude / auto / multi
 fallbackOn: [quota, auth, bot-wall, transient, invalid-response, unknown]   # 允许触发回退的失败类别；[] = 任何失败都立即中止（默认全部）
 lang: zh                    # 设置页界面语言（zh / en）
 bingMarket: zh-CN           # Bing 市场
@@ -326,10 +327,11 @@ Search engine test:
 | SearXNG | `time_range` | ⚠️ 近似 | 同上 |
 | DuckDuckGo / Lite | `df` | ⚠️ 近似 | 同上 |
 | Bing / AnySearch | — | ❌ 忽略 | 无对应参数 |
+| DeepSeek 原生搜索（`deepseek-tools`） | query 语法 `after:` | ✅ 精确 | 端点无独立时间字段，改为把 `after:YYYY-MM-DD` 拼进 query；相对天数按 N 天前折算 |
 
 **"最近似档位"映射规则**：`≤2 天 → day`，`≤14 天 → week`，`≤90 天 → month`，否则 `year`。例如 `3d` 在 Tavily 上按 `day` 处理，`2mo` 按 `month` 处理。
 
-**引擎链优先级**：当带 timeRange 搜索时，支持时间过滤的引擎（tavily / exa / keenable / firecrawl / parallel / searxng / ddg / ddg-lite）会排到引擎链前面，确保过滤真正生效——即使首选引擎是 bing（不支持过滤），也会先尝试支持过滤的引擎。
+**引擎链优先级**：当带 timeRange 搜索时，支持时间过滤的引擎（tavily / exa / keenable / firecrawl / parallel / searxng / ddg / ddg-lite / deepseek-tools）会排到引擎链前面，确保过滤真正生效——即使首选引擎是 bing（不支持过滤），也会先尝试支持过滤的引擎。
 
 示例对话：*"帮我搜最近 3 天关于 DSH 的新闻"* → agent 调用 `advanced_search`，`timeRange: "3d"`。
 
@@ -434,13 +436,13 @@ Search engine test:
 
 #### 离线自检断言（tools/）
 
-仓库自带 **15 个**零依赖断言脚本（合计 **463 项**），**不需要 API key、不联网、不需要测试框架**，Node ≥ 20 即可跑：
+仓库自带 **16 个**零依赖断言脚本（合计 **495 项**），**不需要 API key、不联网、不需要测试框架**，Node ≥ 20 即可跑：
 
 | 脚本 | 覆盖 | 运行（项数） |
 |---|---|---|
-| `assert-engines.mjs` | 引擎清单 / 免费引擎口径 / 语言分池路由 / 池配置字段 / 知乎 URL 剥 utm | `node tools/assert-engines.mjs`（28） |
+| `assert-engines.mjs` | 引擎清单 / 免费引擎口径 / 语言分池路由 / 池配置字段 / 知乎 URL 剥 utm / `deepseek-tools` 接线与 snippetCap 放宽 | `node tools/assert-engines.mjs`（41） |
 | `assert-blocked-domains.mjs` | 域名黑名单：解析、匹配、收口，且前后端清洗同口径 | `node tools/assert-blocked-domains.mjs`（69） |
-| `assert-multi-policy.mjs` | multi 执行策略：并发上限是天花板 / 目标成功源非硬下限 / 凭据资格在上限之前分流 / **Fast·Balanced·Deep 档位** | `node tools/assert-multi-policy.mjs`（142） |
+| `assert-multi-policy.mjs` | multi 执行策略：并发上限是天花板 / 目标成功源非硬下限 / 凭据资格在上限之前分流 / **Fast·Balanced·Deep 档位** | `node tools/assert-multi-policy.mjs`（146） |
 | `assert-result-ranking.mjs` | 合并排序：**eTLD+1 同域判定** / 域名轮转 / `seenIn` 降为末位 / 时效仅带时间过滤时生效 | `node tools/assert-result-ranking.mjs`（31） |
 | `assert-url-norm.mjs` | URL 规范化：只剔已审计的 tracking 参数，保留可能区分资源的参数 | `node tools/assert-url-norm.mjs`（72） |
 | `assert-prompt-contract.mjs` | 系统提示词契约：**检索≠抓取**、不可信边界、模型内置搜索只在显式选中时运行 | `node tools/assert-prompt-contract.mjs`（9） |
@@ -453,6 +455,7 @@ Search engine test:
 | `assert-weather-contract.mjs` | `weather` 工具输出 schema 契约（缺字段裁剪、英文输出、空 geocode 抛错） | `node tools/assert-weather-contract.mjs`（11） |
 | `assert-killtree-win32.mjs` | Windows 子进程树终止（#74）：不再依赖 `taskkill` | `node tools/assert-killtree-win32.mjs`（8） |
 | `assert-killtree-portable.mjs` | 跨平台 `killTree` 便携版契约 | `node tools/assert-killtree-portable.mjs`（5） |
+| `assert-parallel-mcp.mjs` | Parallel MCP 引擎：25 s 超时/调用方取消覆盖**响应体读取**、共享 SSE 解析器（通知/多行帧）、6 类错误路径、REST 精确时间过滤 | `node tools/assert-parallel-mcp.mjs`（15） |
 
 任何一个失败会以非 0 退出码结束并列出失败项；把某个旧版本文件路径作为参数传进去，可以看到修复前必红（用来证明断言不是空转）。改动发布相关逻辑后建议先跑一遍再发版。
 
@@ -543,7 +546,8 @@ If this plugin has been helpful, a ⭐ on [GitHub](https://github.com/DDDMUC/dsh
 | `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` |
+| `deepseek-official` | DeepSeek Official | Paid | Requires `DEEPSEEK_API_KEY`; uses the Anthropic-compatible `web_search` server tool, so every search is a full model turn (slow, token-billed) |
+| `deepseek-tools` | DeepSeek Native Search API | Paid | Requires `DEEPSEEK_API_KEY` (shared with the row above); calls `POST /v1/tools/search` directly, no model involved, returns structured `results[]` (`title`/`url`/`summary`/`date`) — measured ~0.3s vs ~5-6s for the row above on the same query |
 | `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; **no free quota**, so prefer explicit selection or the escalation pool over the default concurrent pool |
@@ -582,7 +586,7 @@ The free/paid binary is not what decides **who belongs in a default pool** — t
 | ① Unlimited, no key | `ddg` / `ddg-lite` / `bing` / `searxng` / `anysearch` | — |
 | ② Anonymous quota (runs without a key) | `exa` / `tavily` / `keenable` / `firecrawl` / `parallel` | key raises the quota |
 | ③ Free quota (key required) | `zhihu_global` / `zhihu_site` (5,000/day trial), `doubao` (500/month), `baidu` (50/day), `aliyun` (200-call starter pack) | pay-as-you-go |
-| ④ Paid upgrade (needs a key to return anything) | `serpbase` (100 free on signup) / `serply` (2,500 for 30 days) / `you` / `perplexity` / `deepseek-official` / `kimi` | per call / per query |
+| ④ Paid upgrade (needs a key to return anything) | `serpbase` (100 free on signup) / `serply` (2,500 for 30 days) / `you` / `perplexity` / `deepseek-official` / `deepseek-tools` / `kimi` | per call / per query |
 | ⑤ Per-call billing (model built-in, explicit-only) | `openai` / `gemini` / `claude` | per token + per search |
 
 Rule of thumb for a default pool: **① as the floor + ③ as the workhorse**; ② is allowed but remember it burns anonymous quota; ④ only when you actually want that source; ⑤ never enters a pool. Per-engine facts and a default-pool proposal live in [docs/engine-quota-tiers.md](./docs/engine-quota-tiers.md).
@@ -740,7 +744,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 / serply / deepseek-official / you / baidu / kimi / aliyun / doubao / zhihu_global / zhihu_site / openai / gemini / claude / auto / multi
+provider: bing              # ddg / ddg-lite / bing / searxng / anysearch / exa / tavily / keenable / firecrawl / parallel / perplexity / serpbase / serply / deepseek-official / deepseek-tools / you / baidu / kimi / aliyun / doubao / zhihu_global / zhihu_site / 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
@@ -799,10 +803,11 @@ Ask the agent for *"news from the last week"*, *"releases this month"*, *"update
 | SearXNG | `time_range` | ⚠️ approximate | same as above |
 | DuckDuckGo / Lite | `df` | ⚠️ approximate | same as above |
 | Bing / AnySearch | — | ❌ ignored | no corresponding parameter |
+| DeepSeek Native Search (`deepseek-tools`) | `after:` query syntax | ✅ precise | the endpoint has no dedicated date field, so `after:YYYY-MM-DD` is appended to the query; relative day counts are converted to an N-days-ago date |
 
 **Nearest-tier mapping rule**: `≤2 days → day`, `≤14 days → week`, `≤90 days → month`, otherwise `year`. For example, `3d` becomes `day` on Tavily, and `2mo` becomes `month`.
 
-**Engine-chain priority**: when a `timeRange` is present, engines that support time filtering (tavily / exa / keenable / firecrawl / parallel / searxng / ddg / ddg-lite) are moved to the front of the fallback chain, so the filter actually takes effect — even if the preferred engine is bing (which does not support filtering), a filtering-capable engine is tried first.
+**Engine-chain priority**: when a `timeRange` is present, engines that support time filtering (tavily / exa / keenable / firecrawl / parallel / searxng / ddg / ddg-lite / deepseek-tools) are moved to the front of the fallback chain, so the filter actually takes effect — even if the preferred engine is bing (which does not support filtering), a filtering-capable engine is tried first.
 
 Example: *"Find DSH news from the last 3 days"* → agent calls `advanced_search` with `timeRange: "3d"`.
 
@@ -907,13 +912,13 @@ Restart `dsh web` after switching to apply changes.
 
 #### Offline self-check assertions (`tools/`)
 
-**Fifteen** zero-dependency assertion scripts ship with the repo (**463 assertions** total): **no API keys, no network, no test framework**, Node ≥ 20:
+**Sixteen** zero-dependency assertion scripts ship with the repo (**495 assertions** total): **no API keys, no network, no test framework**, Node ≥ 20:
 
 | Script | Covers | Run (count) |
 |---|---|---|
-| `assert-engines.mjs` | engine registry / free-engine rule / language-pool routing / pool config fields / Zhihu URL utm stripping | `node tools/assert-engines.mjs` (28) |
+| `assert-engines.mjs` | engine registry / free-engine rule / language-pool routing / pool config fields / Zhihu URL utm stripping / `deepseek-tools` wiring and snippetCap widening | `node tools/assert-engines.mjs` (41) |
 | `assert-blocked-domains.mjs` | domain blocklist: parsing, matching, choke points, and byte-identical front/back-end sanitizing | `node tools/assert-blocked-domains.mjs` (69) |
-| `assert-multi-policy.mjs` | multi execution policy: ceiling semantics / target-is-not-a-hard-minimum / credential eligibility before the ceiling / **Fast·Balanced·Deep presets** | `node tools/assert-multi-policy.mjs` (142) |
+| `assert-multi-policy.mjs` | multi execution policy: ceiling semantics / target-is-not-a-hard-minimum / credential eligibility before the ceiling / **Fast·Balanced·Deep presets** | `node tools/assert-multi-policy.mjs` (146) |
 | `assert-result-ranking.mjs` | merged ranking: **eTLD+1 same-site detection** / domain round-robin / `seenIn` demoted / freshness only under a time filter | `node tools/assert-result-ranking.mjs` (31) |
 | `assert-url-norm.mjs` | URL normalization: strips only audited tracking params, keeps params that may identify different resources | `node tools/assert-url-norm.mjs` (72) |
 | `assert-prompt-contract.mjs` | system-prompt contract: **search ≠ fetch**, untrusted-data boundary, model engines only when explicitly selected | `node tools/assert-prompt-contract.mjs` (9) |
@@ -926,6 +931,7 @@ Restart `dsh web` after switching to apply changes.
 | `assert-weather-contract.mjs` | `weather` output schema contract (field pruning, English output, empty geocode throws) | `node tools/assert-weather-contract.mjs` (11) |
 | `assert-killtree-win32.mjs` | Windows process-tree termination (#74): no longer relies on `taskkill` | `node tools/assert-killtree-win32.mjs` (8) |
 | `assert-killtree-portable.mjs` | portable `killTree` contract | `node tools/assert-killtree-portable.mjs` (5) |
+| `assert-parallel-mcp.mjs` | Parallel MCP engine: the 25 s timeout / caller abort covers the **body read**, shared SSE parser (notifications, multiline frames), six error paths, REST precise time filtering | `node tools/assert-parallel-mcp.mjs` (15) |
 
 Any failure exits non-zero with the failing items listed. Passing the path of an older file shows the pre-fix failures (proving the assertions are not vacuous). Worth running before a release.
 

package/lib/client.js

@@ -223,7 +223,7 @@ window.__ModuleLoader__.load({
           multiMinSourcesHint: "希望至少几个引擎成功返回。不够时会自动用池外引擎补跑，达标即停。注意这是「尽量达到」而非硬性要求：补跑也达不到时仍会返回已有结果，只在备注里说明，不会让搜索失败。",
           multiPreset: "执行档位",
           multiPresetCustom: "自定义",
-          multiPresetHint: (now) => `一键把上面两个数字设成常用组合（Fast = 1 并发 / 1 目标，Balanced = 3 / 1，Deep = 6 / 2）；手改数字会自动回到「自定义」。当前：${now}。`,
+          multiPresetHint: (now) => `一键把上面两个数字设成常用组合（Fast = 1 并发 / 1 目标，Balanced = 3 / 1，Deep = 6 / 2）；手改数字会自动回到「自定义」。当前：${now}。`,
         blockedDomainsLabel: "域名黑名单（blockedDomains）",
         blockedDomainsHint: "一行一个域名，命中的站点及其所有子域都会从搜索结果里剔除（csdn.net 覆盖 blog.csdn.net）。留空＝不过滤。可以直接粘贴完整网址，scheme、路径和端口会被自动去掉。",
         blockedDomainsWarn: (corrected, dupes, dropped) => `已忽略 ${dupes} 个重复项、${dropped} 行无法识别；${corrected} 行已自动修正为裸域名。规则对下一次搜索生效，旧结果缓存会同步失效。`,
@@ -388,7 +388,7 @@ window.__ModuleLoader__.load({
     };
     const tt = (lang) => I18N[lang === "en" ? "en" : "zh"];
     // 当前插件版本（与 lib/index.js 的 PLUGIN_VERSION 保持一致；跟随上游 v0.7.5）
-    const PLUGIN_VERSION = "0.9.1";
+    const PLUGIN_VERSION = "0.9.2";
     const ENGINES = [
       { id: "auto", label: "Auto · 智能路由", badge: "AUTO", link: null },
       { id: "multi", label: "Multi Search · 多引擎", badge: "MULTI", link: null },
@@ -406,6 +406,7 @@ window.__ModuleLoader__.load({
       { 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: "deepseek-tools", label: "DeepSeek Tools API", badge: "API KEY", link: "https://api-docs.deepseek.com/zh-cn/guides/search" },
       { 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" },
       { id: "kimi", label: "Kimi · Moonshot", badge: "API KEY", link: "https://platform.moonshot.cn" },
@@ -423,7 +424,7 @@ window.__ModuleLoader__.load({
     // 与 lib/index.js 的 EXPLICIT_ONLY_ENGINES 同源：按次计费、只在显式选中时运行，因此不提供入池候选。
     const EXPLICIT_ONLY_ENGINES = ["openai", "gemini", "claude"];
     const MODEL_ENGINES = ENGINES.filter((engine) => EXPLICIT_ONLY_ENGINES.includes(engine.id));
-    const DEFAULT_FALLBACK_ORDER = ["exa", "tavily", "keenable", "firecrawl", "parallel", "perplexity", "serpbase", "serply", "deepseek-official", "you", "baidu", "kimi", "aliyun", "doubao", "tinyfish", "jina", "bing", "anysearch", "ddg", "ddg-lite", "searxng", "zhihu_global", "zhihu_site"];
+    const DEFAULT_FALLBACK_ORDER = ["exa", "tavily", "keenable", "firecrawl", "parallel", "perplexity", "serpbase", "serply", "deepseek-tools", "deepseek-official", "you", "baidu", "kimi", "aliyun", "doubao", "tinyfish", "jina", "bing", "anysearch", "ddg", "ddg-lite", "searxng", "zhihu_global", "zhihu_site"];
     const normalizeFallbackOrder = (value) => {
       const configured = Array.isArray(value) ? value.filter((id) => ENGINE_IDS.includes(id)) : [];
       return [...new Set([...configured, ...DEFAULT_FALLBACK_ORDER, ...ENGINE_IDS.filter((id) => !EXPLICIT_ONLY_ENGINES.includes(id))])].filter((id) => !EXPLICIT_ONLY_ENGINES.includes(id));
@@ -671,6 +672,7 @@ window.__ModuleLoader__.load({
         parallel: [parallelKey, setParallelKey],
         perplexity: [perplexityKey, setPerplexityKey],
         "deepseek-official": [deepseekKey, setDeepseekKey],
+        "deepseek-tools": [deepseekKey, setDeepseekKey],
         serpbase: [serpbaseKey, setSerpbaseKey],
         serply: [serplyKey, setSerplyKey],
         you: [youcomKey, setYoucomKey],
@@ -688,7 +690,7 @@ window.__ModuleLoader__.load({
         claude: [claudeKey, setClaudeKey],
       };
       // #68 密钥状态可视化：引擎 id → 配置中心键名（少数引擎不同名），三态：已配置/可选/缺失
-      const CONFIGURED_KEY_ID = { "deepseek-official": "deepseek", you: "youcom", zhihu_global: "zhihu", zhihu_site: "zhihu" };
+      const CONFIGURED_KEY_ID = { "deepseek-official": "deepseek", "deepseek-tools": "deepseek", you: "youcom", zhihu_global: "zhihu", zhihu_site: "zhihu" };
       const NO_KEY_ENGINES = ["ddg", "ddg-lite", "bing"];
       const OPTIONAL_KEY_ENGINES = ["anysearch", "exa", "tavily", "keenable", "firecrawl", "parallel", "searxng"];
       const hasConfiguredKey = (id) => {

package/lib/index.js

@@ -5,7 +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";
+import { mcpCall, mcpContentText, parseMcpResponseText } from "./mcp_adapter.js";
 import { registerResearchTool } from "./research.js";
 import { registerDomainSearchTool } from "./vertical.js";
 import { createFetchProvider } from "./fetch_provider.js";
@@ -90,7 +90,7 @@ const FREE_SEARCH_NS = "web-search-free";
 const BRIDGE_PREFIX = "/api/dsh-free-search-settings";
 // 意见 A：zhihu_global / zhihu_site 需要 ZHIHU_API_KEY，不属于免 key 引擎（不得进入 FREE_ENGINES）
 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", "tinyfish", "jina", "zhihu_global", "zhihu_site", "openai", "gemini", "claude"];
+const ALL_ENGINES = ["ddg", "ddg-lite", "bing", "searxng", "anysearch", "exa", "tavily", "keenable", "firecrawl", "parallel", "perplexity", "serpbase", "serply", "deepseek-official", "deepseek-tools", "you", "baidu", "kimi", "aliyun", "doubao", "tinyfish", "jina", "zhihu_global", "zhihu_site", "openai", "gemini", "claude"];
 
 // 模型内置搜索（按次计费）：只在你显式选中该引擎时使用；自动回退链与 auto 路由都不会兜底到它们。
 const EXPLICIT_ONLY_ENGINES = ["openai", "gemini", "claude"];
@@ -166,12 +166,13 @@ const FAILURE_CLASS_LABELS = {
 
 
 // 支持 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", "tinyfish", "zhihu_global"];
+// deepseek-tools：原生搜索端点没有独立时间字段，但 query 语法支持 after:/before:，由 deepseekToolsQuery 注入。
+const TIME_ENGINES = ["tavily", "exa", "keenable", "firecrawl", "parallel", "searxng", "ddg", "ddg-lite", "baidu", "doubao", "tinyfish", "deepseek-tools", "zhihu_global"];
 
 // 虚拟搜索模式：不是单个引擎，而是 provider.search 内部的路由/并发策略
 const SEARCH_MODES = ["auto", "multi"];
 
-const DEFAULT_FALLBACK_ORDER = ["exa", "tavily", "keenable", "firecrawl", "parallel", "perplexity", "serpbase", "serply", "deepseek-official", "you", "baidu", "kimi", "aliyun", "doubao", "tinyfish", "jina", "bing", "anysearch", "ddg", "ddg-lite", "searxng", "zhihu_global", "zhihu_site"];
+const DEFAULT_FALLBACK_ORDER = ["exa", "tavily", "keenable", "firecrawl", "parallel", "perplexity", "serpbase", "serply", "deepseek-tools", "deepseek-official", "you", "baidu", "kimi", "aliyun", "doubao", "tinyfish", "jina", "bing", "anysearch", "ddg", "ddg-lite", "searxng", "zhihu_global", "zhihu_site"];
 
 function normalizeDisabledEngines(value) {
   if (!Array.isArray(value)) return [];
@@ -244,7 +245,7 @@ function routeEngines(query, { timeRange, disabledEngines = [], fallbackOrder =
 }
 
 // 当前插件版本（发布时与 package.json 同步；跟随上游 v0.7.5，不在 PR 里 bump）
-const PLUGIN_VERSION = "0.9.1";
+const PLUGIN_VERSION = "0.9.2";
 // 检查更新的 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";
@@ -395,8 +396,10 @@ function cleanSnippet(text, max = 300) {
 }
 
 // 各引擎的摘要展示上限：豆包搜索返回的是千字级 Summary（实测 1300-1800 字），放宽到 2000；
-// 其余引擎维持 300。该上限同时用于 provider 成功后的清洗与 runEngineTest（喂 multi_search）。
-const SNIPPET_MAX_BY_ENGINE = { doubao: 2000 };
+// deepseek-tools 的 summary 官方文档写 600~800 字（实测 530），按 300 截断会把摘要拦腰砍断，
+// 放宽到 2000 与豆包同理；其余引擎维持 300。
+// 该上限同时用于 provider 成功后的清洗与 runEngineTest（喂 multi_search）。
+const SNIPPET_MAX_BY_ENGINE = { doubao: 2000, "deepseek-tools": 2000 };
 function snippetCap(engine) {
   return SNIPPET_MAX_BY_ENGINE[engine] ?? 300;
 }
@@ -1612,15 +1615,20 @@ async function searchParallelMCP(query, maxResults, timeRange, signal) {
   const timer = setTimeout(() => controller.abort(), 25000);
   const onAbort = () => controller.abort();
   signal?.addEventListener("abort", onAbort);
-  let response;
+  if (signal?.aborted) controller.abort();
+  let text;
   try {
     const after = timeRange
       ? timeRange.after ?? (timeRange.days !== undefined ? isoDaysAgo(timeRange.days).slice(0, 10) : undefined)
       : undefined;
     const objective = after ? `${query} (prefer results published after ${after})` : query;
-    response = await fetch(PARALLEL_MCP_URL, {
+    const response = await fetch(PARALLEL_MCP_URL, {
       method: "POST",
-      headers: { "content-type": "application/json", accept: "application/json, text/event-stream" },
+      headers: {
+        "content-type": "application/json",
+        accept: "application/json, text/event-stream",
+        "user-agent": "dsh-free-search (+https://github.com/DDDMUC/dsh-free-search)",
+      },
       body: JSON.stringify({
         jsonrpc: "2.0",
         id: Date.now(),
@@ -1636,6 +1644,9 @@ async function searchParallelMCP(query, maxResults, timeRange, signal) {
       }),
       signal: controller.signal,
     });
+    if (!response.ok) throw new Error(`Parallel MCP error (HTTP ${response.status})`);
+    // Keep the timeout and caller cancellation active while the body is streaming.
+    text = await response.text();
   } catch (error) {
     if (signal?.aborted) throw error;
     throw new Error(`Parallel MCP request failed: ${error?.message ?? String(error)}`);
@@ -1643,33 +1654,25 @@ async function searchParallelMCP(query, maxResults, timeRange, signal) {
     clearTimeout(timer);
     signal?.removeEventListener("abort", onAbort);
   }
-  if (!response.ok) throw new Error(`Parallel MCP error (HTTP ${response.status})`);
-  const text = await response.text();
-  // 兼容 JSON 与 SSE（event: message\ndata: {...}）两种响应形态
-  let json = null;
-  try {
-    json = JSON.parse(text);
-  } catch {
-    for (const line of text.split("\n")) {
-      if (line.startsWith("data: ")) {
-        try {
-          json = JSON.parse(line.slice(6));
-          break;
-        } catch {}
-      }
-    }
-  }
-  if (!json || json.error) throw new Error(`Parallel MCP error: ${json?.error?.message ?? "no data"}`);
-  const blocks = (json.result?.content ?? []).filter((b) => b.type === "text").map((b) => b.text);
+  // The shared parser skips SSE notifications and joins multiline data frames.
+  const json = parseMcpResponseText(text);
+  if (!json) throw new Error("Parallel MCP parse failed: invalid JSON or SSE");
+  if (json.error) throw new Error(`Parallel MCP error: ${json.error.message ?? "unknown error"}`);
+  if (!Array.isArray(json.result?.content)) throw new Error("Parallel MCP malformed content");
+  const blocks = json.result.content.filter((b) => b?.type === "text" && typeof b.text === "string").map((b) => b.text);
   if (json.result?.isError) throw new Error(`Parallel MCP error: ${blocks.join(" ").slice(0, 200) || "tool call failed"}`);
   let payload = null;
   for (const block of blocks) {
     try {
-      payload = JSON.parse(block);
-      break;
+      const parsed = JSON.parse(block);
+      if (Array.isArray(parsed?.results)) {
+        payload = parsed;
+        break;
+      }
     } catch {}
   }
-  const sources = (payload?.results ?? [])
+  if (!payload) throw new Error("Parallel MCP malformed search results");
+  const sources = payload.results
     .filter((r) => r.url)
     .map((r) => {
       const excerpt = (r.excerpts ?? []).find((e) => String(e).trim().length > 0);
@@ -1900,6 +1903,79 @@ async function searchDeepSeekOfficial(query, maxResults, apiKey, signal) {
   return { sources: uniqueSources(sources, maxResults ?? 10), truncated: false };
 }
 
+// DeepSeek 官方原生搜索 API（POST /v1/tools/search）
+// key = DEEPSEEK_API_KEY（与 deepseek-official 共用，接口不同）
+//
+// 与 deepseek-official 的区别：那一档走 Anthropic Messages +
+// `web_search_20250305` 服务端工具，每次搜索是一个完整模型轮次（慢、耗 token、
+// 结果要从 web_search_tool_result 块里再解析）；这一档直接调原生搜索端点，
+// 无模型参与，返回结构化 results[]。实测同 query 下 ~0.3s vs ~5-6s。
+//
+// 计费按「请求次数」而非条数（count 不影响单价），所以这里超额取数不增加成本。
+const DEEPSEEK_TOOLS_SEARCH_URL = "https://api.deepseek.com/v1/tools/search";
+
+// 原生搜索接口没有独立的时间字段，时间过滤写在 query 语法里（after:/before:）。
+// 支持 `after:2025`、`after:2025-01-01`；这里把统一的 timeRange 映射成 after:。
+function deepseekToolsQuery(query, timeRange) {
+  const parsed = parseTimeRange(timeRange);
+  if (!parsed) return query;
+  if (parsed.after) return `${query} after:${parsed.after}`;
+  if (parsed.days) {
+    const since = new Date(Date.now() - parsed.days * 86400000).toISOString().slice(0, 10);
+    return `${query} after:${since}`;
+  }
+  return query;
+}
+
+async function searchDeepSeekTools(query, maxResults, apiKey, timeRange, signal) {
+  if (!apiKey) throw new Error("DeepSeek search requires DEEPSEEK_API_KEY");
+  const limit = Math.min(Math.max(maxResults ?? 5, 1), 50);
+  // 超额取数：按请求计费，且缺 url 的行会被丢弃，多取一些补位成本为零
+  const count = Math.min(50, Math.max(limit, Math.ceil(limit * 1.5)));
+
+  const response = await fetch(DEEPSEEK_TOOLS_SEARCH_URL, {
+    method: "POST",
+    redirect: "error",
+    headers: {
+      authorization: `Bearer ${apiKey}`,
+      "content-type": "application/json",
+      accept: "application/json",
+      "user-agent": "deepseek-harness/free-search",
+    },
+    body: JSON.stringify({ query: deepseekToolsQuery(query, timeRange), count }),
+    signal: AbortSignal.any([...(signal !== undefined ? [signal] : []), AbortSignal.timeout(20000)]),
+  });
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    if (response.status === 401) {
+      throw new Error("DeepSeek API key is invalid (HTTP 401) - update it in Settings > Plugins > Free Search");
+    }
+    // 402 余额不足是终态：不要当成可重试的暂时故障
+    if (response.status === 402) {
+      throw new Error("DeepSeek account balance is insufficient (HTTP 402) - top up at https://platform.deepseek.com");
+    }
+    throw new Error(`DeepSeek API error (HTTP ${response.status}): ${detail.slice(0, 200)}`);
+  }
+
+  const data = await response.json();
+  const rows = Array.isArray(data?.results) ? data.results : [];
+  const sources = rows
+    .filter((r) => r && typeof r.url === "string" && r.url.length > 0)
+    .map((r) => {
+      // summary（600~800 字，面向模型）优先于 snippet（100~200 字，面向渲染）
+      const raw = typeof r.summary === "string" && r.summary.trim() ? r.summary : r.snippet;
+      const snippet = typeof raw === "string" ? raw.trim() : "";
+      return {
+        url: r.url,
+        ...(r.title ? { title: String(r.title) } : {}),
+        ...(snippet ? { snippet: snippet.slice(0, 600) } : {}),
+        // date 是 UTC RFC3339，只保留日期部分与其它引擎的 publishedAt 对齐
+        ...(r.date ? { publishedAt: String(r.date).slice(0, 10) } : {}),
+      };
+    });
+  return { sources: uniqueSources(sources, maxResults ?? 10), truncated: false };
+}
+
 // SerpBase: 必须配置 SERPBASE_API_KEY（无 key 跳过，同 perplexity）
 // Google SERP API：POST + X-API-Key 头，返回 organic[]（title/link/snippet/published_at）。
 // 注意：SerpBase 始终返回 HTTP 200，业务状态放在 JSON 的 status 字段（0=成功，1001=key 无效/缺失，1000=请求非法）。
@@ -3602,6 +3678,15 @@ function apply(ctx, config) {
               continue; // 无 key 跳过
             }
             result = await searchDeepSeekOfficial(request.query, request.maxResults, key, effSignal);
+          } else if (engine === "deepseek-tools") {
+            const key = await resolveApiKey("DEEPSEEK_API_KEY", "deepseekApiKey");
+            if (!key) {
+              lastError = new Error("DeepSeek requires DEEPSEEK_API_KEY");
+              if (engine === preferred) preferredFailure = "DEEPSEEK_API_KEY is not configured";
+              logger.warn(`free-search: engine "${engine}" skipped (no key), trying next engine`);
+              continue; // 无 key 跳过
+            }
+            result = await searchDeepSeekTools(request.query, request.maxResults, key, request.timeRange, effSignal);
           } else if (engine === "serpbase") {
             // serpbase：必须配置 SERPBASE_API_KEY（无 key 跳过，同 perplexity）
             const key = await resolveApiKey("SERPBASE_API_KEY", "serpbaseApiKey");
@@ -3958,6 +4043,11 @@ function apply(ctx, config) {
           if (!key) return { ok: false, error: "DEEPSEEK_API_KEY not configured" };
           return await searchDeepSeekOfficial(q, n, key);
         }
+        case "deepseek-tools": {
+          const key = await resolveApiKey("DEEPSEEK_API_KEY", "deepseekApiKey");
+          if (!key) return { ok: false, error: "DEEPSEEK_API_KEY not configured" };
+          return await searchDeepSeekTools(q, n, key, tr);
+        }
         case "serpbase": {
           const key = await resolveApiKey("SERPBASE_API_KEY", "serpbaseApiKey");
           if (!key) return { ok: false, error: "SERPBASE_API_KEY not configured" };
@@ -4324,7 +4414,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, tinyfish, jina, 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.",
+              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, deepseek-tools, you, baidu, kimi, aliyun, doubao, tinyfish, jina, 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: {
@@ -4702,7 +4792,7 @@ function apply(ctx, config) {
             },
             engine: {
               type: "string",
-              description: "Optional search mode/engine: multi (parallel full language-pool merge), auto, ddg, ddg-lite, bing, searxng, anysearch, exa, tavily, keenable, firecrawl, parallel, perplexity, serpbase, serply, deepseek-official, you, baidu, kimi, aliyun, doubao, tinyfish, jina, zhihu_global, zhihu_site, openai, gemini, claude (model-based; explicit selection only).",
+              description: "Optional search mode/engine: multi (parallel full language-pool merge), auto, ddg, ddg-lite, bing, searxng, anysearch, exa, tavily, keenable, firecrawl, parallel, perplexity, serpbase, serply, deepseek-official (Anthropic-compatible web_search tool), deepseek-tools (DeepSeek native POST /v1/tools/search), you, baidu, kimi, aliyun, doubao, tinyfish, jina, zhihu_global, zhihu_site, openai, gemini, claude (model-based; explicit selection only).",
             },
           },
           output: {
@@ -4950,6 +5040,7 @@ export {
   searchBing,
   searchBilibili,
   searchDeepSeekOfficial,
+  searchDeepSeekTools,
   searchDdgHtml,
   searchDdgLite,
   searchExa,

package/lib/multi_policy.js

@@ -1,270 +1,271 @@
-// #69 Phase 1（第一批）：multi 模式的执行策略——纯函数，便于离线断言。
-//
-// 为什么单独成文件：这几个判断（并发上限怎么取、目标成功数怎么补跑）跑在
-// runMultiSearch 里，而那是 apply() 内的闭包、无法导出单测。抽成纯函数后
-// 既可以直接断言，也符合 reporter「三个预设共用同一条执行管线」的方向
-// （将来加 Fast/Balanced/Deep 时，这里就是预设唯一的作用点）。
-//
-// 两条约束来自 reporter #69，都有断言钉住：
-//   §1 并发上限是「天花板」不是「必须跑满」——候选不够就少跑，不得凑数。
-//   §3 目标成功数（minSources）是「尽量达到」而非硬下限——达不到时返回已有
-//      结果并附提示，绝不丢弃有效证据、绝不因此让整次搜索失败。
-// 另有兼容硬约束：默认值必须让现有行为完全不变，升级对用户透明。
-
-/** 0 / 非数字 / 负数 一律视为「不限制」，保证未配置时行为与今天一致。 */
-export function resolveMaxEngines(value, poolSize) {
-  const n = Number(value);
-  if (!Number.isFinite(n) || n <= 0) return poolSize;
-  return Math.min(Math.floor(n), poolSize);
-}
-
-/**
- * 从候选池里挑出本次实际执行的引擎。
- * 只做「取前 N」，保持池内顺序——池内顺序就是用户在 zhPool/enPool 里配的优先级，
- * 未经用户许可不重排（轮换是后续批次的事）。
- */
-export function selectEngines(engines, configuredMax) {
-  const list = Array.isArray(engines) ? engines.filter((e) => typeof e === "string" && e) : [];
-  if (list.length === 0) return [];
-  return list.slice(0, resolveMaxEngines(configuredMax, list.length));
-}
-
-/** 目标成功源数：至少 1（0/负数/非数字都归 1，因为「0 个成功源」没有意义）。 */
-export function resolveMinSources(value, poolSize) {
-  const n = Number(value);
-  if (!Number.isFinite(n) || n <= 0) return 1;
-  return Math.max(1, Math.floor(n));
-}
-
-/**
- * 主轮结束后，若成功引擎数未达目标，从链路里挑「还没试过」的候选补跑。
- * 已达标时返回空数组——调用方据此一次额外请求都不发（省钱、省限流）。
- */
-export function planTopUp({ attempted = [], succeeded = 0, minSources = 1, chain = [] } = {}) {
-  if (succeeded >= minSources) return [];
-  const tried = new Set(Array.isArray(attempted) ? attempted : []);
-  const candidates = Array.isArray(chain) ? chain : [];
-  return candidates.filter((engine) => engine && !tried.has(engine));
-}
-
-/** 未达标时的说明文字；达标返回 null（不制造噪音）。 */
-export function describeTarget({ minSources = 1, achieved = 0 } = {}) {
-  if (achieved >= minSources) return null;
-  return `sourcesTarget: ${minSources}, achieved: ${achieved}`;
-}
-
-/**
- * 执行档位（#69 §1）。**只复用现有两个旋钮**：并发上限 + 目标成功源数。
- * 不新增后端配置——UI 点档位就是把这两个数字写进去，手改数字即回到「自定义」。
- * 这样零迁移、零缓存键影响，且在 planner 统一之前不改变任何现有语义。
- */
-export const MULTI_PRESETS = {
-  fast: { maxEngines: 1, minSources: 1 },
-  balanced: { maxEngines: 3, minSources: 1 },
-  deep: { maxEngines: 6, minSources: 2 },
-};
-
-/** 由当前 (上限, 目标源数) 反推档位名；不匹配任何档位时返回 "custom"。 */
-export function presetForSettings(maxEngines, minSources) {
-  const max = Number(maxEngines);
-  const min = Number(minSources);
-  const normMax = Number.isFinite(max) && max > 0 ? Math.floor(max) : 0;
-  const normMin = Number.isFinite(min) && min > 0 ? Math.floor(min) : 1;
-  for (const [id, p] of Object.entries(MULTI_PRESETS)) {
-    if (p.maxEngines === normMax && p.minSources === normMin) return id;
-  }
-  return "custom";
-}
-
-/**
- * 常见「两段式」公共后缀（co.uk / com.cn / co.jp …）。不追求完整 PSL——
- * 只覆盖公开搜索里真会撞到的那批；未命中时退化为「最后两段」。
- */
-const MULTI_PART_SUFFIXES = new Set([
-  // 中国 / 港台
-  "com.cn", "net.cn", "org.cn", "gov.cn", "edu.cn", "ac.cn",
-  "com.hk", "org.hk", "net.hk", "edu.hk", "gov.hk",
-  "com.tw", "org.tw", "net.tw", "edu.tw", "gov.tw",
-  // 日韩
-  "co.jp", "or.jp", "ne.jp", "ac.jp", "go.jp",
-  "co.kr", "or.kr", "ne.kr", "go.kr", "re.kr",
-  // 英国 / 英联邦 / 大洋洲
-  "co.uk", "org.uk", "ac.uk", "gov.uk", "me.uk", "net.uk", "sch.uk",
-  "com.au", "net.au", "org.au", "edu.au", "gov.au",
-  "co.nz", "net.nz", "org.nz", "govt.nz", "ac.nz",
-  "co.za", "org.za", "net.za", "gov.za",
-  "co.in", "net.in", "org.in", "gov.in", "ac.in",
-  "com.sg", "com.my", "com.ph", "com.pk", "com.vn", "co.th", "co.id",
-  // 欧洲 / 拉美 / 中东 / 非洲
-  "com.br", "com.mx", "com.ar", "com.tr", "com.ua", "com.pl", "com.ru",
-  "co.il", "com.sa", "com.eg", "com.ng", "co.ke",
-]);
-
-/**
- * 取 URL 的**可注册域**（eTLD+1）用于「同域」判定。
- *
- * 为什么不用主机名：blog.example.com 与 download.example.com 是同一站点的两个子域，
- * 拿主机名分组会把它们当成两个「独立来源」，与 #69 §4 的域名多样性意图正好相反。
- * （这正是 0.8.10 里自认的 known limitation。）
- *
- * IP / 含端口的 IPv6 / localhost / 单标签主机 / 非法 URL 一律原样小写返回，不误判。
- */
-export function domainOf(url) {
-  const raw = String(url ?? "").trim();
-  if (!raw) return "";
-  let host;
-  try {
-    host = new URL(raw).hostname.toLowerCase();
-  } catch {
-    return raw.toLowerCase();
-  }
-  host = host.replace(/\.+$/, "").replace(/^www\./, "");
-  if (!host) return "";
-  if (!host.includes(".") || host.includes(":") || /^\d{1,3}(\.\d{1,3}){3}$/.test(host)) return host;
-  const parts = host.split(".");
-  if (parts.length <= 2) return host;
-  const last2 = parts.slice(-2).join(".");
-  return MULTI_PART_SUFFIXES.has(last2) ? parts.slice(-3).join(".") : last2;
-}
-
-function publishedTs(value) {
-  const ts = Date.parse(String(value ?? ""));
-  return Number.isFinite(ts) ? ts : 0;
-}
-
-/**
- * 合并后的排序（#69 §4）。
- *
- * reporter 的要求：排序信号用「真实可得且有意义」的那些——原始结果顺序、域名多样性、
- * 需要时的时效性；而 `seenIn` **只能当溯源/佐证元数据，不能当主排序键**，理由是
- * "Six matching search results do not necessarily constitute six independent sources"
- * （多个引擎可能共享索引与排序偏见，所以同域堆叠并不等于可信）。
- *
- * 做法（确定性、可离线断言）：
- *   1. 按域名分组；
- *   2. 组内次序：时效性生效时新的优先 → 原始顺序 → 佐证数（仅末位 tiebreak）；
- *   3. 组的次序：按各域「最佳条目」的上述次序；
- *   4. 轮转交错输出：第一轮每域各出一条，再第二轮…… → 前 N 条尽量来自不同域。
- *
- * 刻意只重排、不剔除：多样性是排序信号，不是过滤条件（过滤由 blockedDomains 负责）。
- *
- * 同域判定走 domainOf() 的 eTLD+1：blog.example.com 与 download.example.com 归为同一域。
- * 局限：后缀表是精简版（非完整 PSL），冷门多段后缀仍退化为「最后两段」。
- *
- * @param {{domain?: string, order?: number, corroboration?: number, publishedAt?: string}[]} items
- * @param {{appliesFreshness?: boolean}} [options] appliesFreshness 仅在本次搜索带时间过滤时为 true
- */
-export function rankMergedResults(items, { appliesFreshness = false } = {}) {
-  const list = Array.isArray(items) ? items.slice() : [];
-  if (list.length <= 1) return list;
-
-  const withinKey = (x) => [
-    appliesFreshness ? -publishedTs(x?.publishedAt) : 0,
-    Number(x?.order) || 0,
-    -(Number(x?.corroboration) || 0),
-  ];
-  const cmp = (a, b) => {
-    const ka = withinKey(a);
-    const kb = withinKey(b);
-    for (let i = 0; i < ka.length; i++) {
-      if (ka[i] !== kb[i]) return ka[i] - kb[i];
-    }
-    return 0;
-  };
-
-  const byDomain = new Map();
-  for (const item of list) {
-    const d = String(item?.domain ?? "");
-    if (!byDomain.has(d)) byDomain.set(d, []);
-    byDomain.get(d).push(item);
-  }
-
-  const groups = [...byDomain.values()];
-  for (const group of groups) group.sort(cmp);
-  groups.sort((a, b) => cmp(a[0], b[0]));
-
-  const out = [];
-  const longest = groups.reduce((max, g) => Math.max(max, g.length), 0);
-  for (let round = 0; round < longest; round++) {
-    for (const group of groups) {
-      if (round < group.length) out.push(group[round]);
-    }
-  }
-  return out;
-}
-
-/**
- * 引擎 → 必需凭据描述符（`{ env, settings }`，即 resolveApiKey 的两个参数）。
- * 数组表示「任一命中即算配了」，与 index.js 里 resolveDoubaoKey / resolveGeminiKey
- * 的回退逻辑逐条对应。
- *
- * 为什么需要它：#69 §2 要求引擎资格必须考虑 "Missing credentials"。原状的资格过滤
- * 只看了 disabled / 冷却 / zhihu 预探测，缺 key 的引擎要到 runEngineTest 才发现 ——
- * 而那时它已经占掉了并发上限的名额。本机默认池 [bing, baidu, aliyun, anysearch] 里
- * baidu/aliyun 都没 key，上限设 3 时取走的正是这三个不可用的，唯一能跑的 anysearch
- * 被切掉，整次 multi 直接失败。
- *
- * 收录纪律（有交叉校验断言钉住）：**只收 index.js 里 runEngineTest 显式
- * `if (!key) return { error: "<ENV> not configured" }` 的引擎**，与代码自身对
- * 「缺 key」的声明严格一致。
- *   - 免 key 引擎 ddg/ddg-lite/bing/searxng 不收；
- *   - 有免 key 兜底的 anysearch（key 可空）/ exa、parallel（回落 MCP）不收；
- *   - tavily/keenable/firecrawl 分支没有 not configured 检查（缺 key 时会带着空串去请求，
- *     以鉴权失败收场），暂不收——那属于另一个行为变更，需单独决定。
- * settings 字段必须带上：只在环境变量里找 key 会漏掉「仅填在设置页」的用户。
- */
-export const REQUIRED_CREDENTIALS = {
-  perplexity: [{ env: "PERPLEXITY_API_KEY", settings: "perplexityApiKey" }],
-  "deepseek-official": [{ env: "DEEPSEEK_API_KEY", settings: "deepseekApiKey" }],
-  serpbase: [{ env: "SERPBASE_API_KEY", settings: "serpbaseApiKey" }],
-  serply: [{ env: "SERPLY_API_KEY", settings: "serplyApiKey" }],
-  tinyfish: [{ env: "TINYFISH_API_KEY", settings: "tinyfishApiKey" }],
-  jina: [{ env: "JINA_API_KEY", settings: "jinaApiKey" }],
-  baidu: [{ env: "BAIDU_API_KEY", settings: "baiduApiKey" }],
-  kimi: [{ env: "MOONSHOT_API_KEY", settings: "kimiApiKey" }],
-  aliyun: [{ env: "DASHSCOPE_API_KEY", settings: "aliyunApiKey" }],
-  doubao: [
-    { env: "DOUBAO_SEARCH_API_KEY", settings: "doubaoApiKey" },
-    { env: "WEB_SEARCH_API_KEY", settings: null },
-  ],
-  zhihu_global: [{ env: "ZHIHU_API_KEY", settings: "zhihuApiKey" }],
-  zhihu_site: [{ env: "ZHIHU_API_KEY", settings: "zhihuApiKey" }],
-  openai: [{ env: "OPENAI_API_KEY", settings: "openaiApiKey" }],
-  gemini: [
-    { env: "GEMINI_API_KEY", settings: "geminiApiKey" },
-    { env: "GOOGLE_API_KEY", settings: null },
-  ],
-  claude: [{ env: "ANTHROPIC_API_KEY", settings: "claudeApiKey" }],
-  you: [{ env: "YOUCOM_API_KEY", settings: "youcomApiKey" }],
-};
-
-/** 该引擎需要哪些凭据描述符；不需要凭据（免 key / 有兜底）时返回 null。 */
-export function credentialRequirement(engine) {
-  const req = REQUIRED_CREDENTIALS[engine];
-  if (!req) return null;
-  return req.map((d) => ({ ...d }));
-}
-
-/**
- * 引擎凭据是否齐备。`isAvailable(engine)` 由调用方提供（服务端负责真正解析凭据），
- * 这里只做判定与分流，保持纯函数、可离线断言。
- * 未知引擎一律算合格——宁放过，不误杀未来的新引擎。
- */
-export function isCredentialEligible(engine, isAvailable) {
-  if (!credentialRequirement(engine)) return true;
-  return Boolean(isAvailable && isAvailable(engine));
-}
-
-/**
- * 按凭据把候选池分成「合格」与「缺凭据」两份，顺序均保持原样。
- * 调用方应把 missing 记进 skipped 备注，让用户仍然看得见某引擎为什么没跑。
- */
-export function partitionByCredentials(engines, isAvailable) {
-  const eligible = [];
-  const missing = [];
-  for (const engine of Array.isArray(engines) ? engines : []) {
-    if (isCredentialEligible(engine, isAvailable)) eligible.push(engine);
-    else missing.push(engine);
-  }
-  return { eligible, missing };
-}
+// #69 Phase 1（第一批）：multi 模式的执行策略——纯函数，便于离线断言。
+//
+// 为什么单独成文件：这几个判断（并发上限怎么取、目标成功数怎么补跑）跑在
+// runMultiSearch 里，而那是 apply() 内的闭包、无法导出单测。抽成纯函数后
+// 既可以直接断言，也符合 reporter「三个预设共用同一条执行管线」的方向
+// （将来加 Fast/Balanced/Deep 时，这里就是预设唯一的作用点）。
+//
+// 两条约束来自 reporter #69，都有断言钉住：
+//   §1 并发上限是「天花板」不是「必须跑满」——候选不够就少跑，不得凑数。
+//   §3 目标成功数（minSources）是「尽量达到」而非硬下限——达不到时返回已有
+//      结果并附提示，绝不丢弃有效证据、绝不因此让整次搜索失败。
+// 另有兼容硬约束：默认值必须让现有行为完全不变，升级对用户透明。
+
+/** 0 / 非数字 / 负数 一律视为「不限制」，保证未配置时行为与今天一致。 */
+export function resolveMaxEngines(value, poolSize) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return poolSize;
+  return Math.min(Math.floor(n), poolSize);
+}
+
+/**
+ * 从候选池里挑出本次实际执行的引擎。
+ * 只做「取前 N」，保持池内顺序——池内顺序就是用户在 zhPool/enPool 里配的优先级，
+ * 未经用户许可不重排（轮换是后续批次的事）。
+ */
+export function selectEngines(engines, configuredMax) {
+  const list = Array.isArray(engines) ? engines.filter((e) => typeof e === "string" && e) : [];
+  if (list.length === 0) return [];
+  return list.slice(0, resolveMaxEngines(configuredMax, list.length));
+}
+
+/** 目标成功源数：至少 1（0/负数/非数字都归 1，因为「0 个成功源」没有意义）。 */
+export function resolveMinSources(value, poolSize) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return 1;
+  return Math.max(1, Math.floor(n));
+}
+
+/**
+ * 主轮结束后，若成功引擎数未达目标，从链路里挑「还没试过」的候选补跑。
+ * 已达标时返回空数组——调用方据此一次额外请求都不发（省钱、省限流）。
+ */
+export function planTopUp({ attempted = [], succeeded = 0, minSources = 1, chain = [] } = {}) {
+  if (succeeded >= minSources) return [];
+  const tried = new Set(Array.isArray(attempted) ? attempted : []);
+  const candidates = Array.isArray(chain) ? chain : [];
+  return candidates.filter((engine) => engine && !tried.has(engine));
+}
+
+/** 未达标时的说明文字；达标返回 null（不制造噪音）。 */
+export function describeTarget({ minSources = 1, achieved = 0 } = {}) {
+  if (achieved >= minSources) return null;
+  return `sourcesTarget: ${minSources}, achieved: ${achieved}`;
+}
+
+/**
+ * 执行档位（#69 §1）。**只复用现有两个旋钮**：并发上限 + 目标成功源数。
+ * 不新增后端配置——UI 点档位就是把这两个数字写进去，手改数字即回到「自定义」。
+ * 这样零迁移、零缓存键影响，且在 planner 统一之前不改变任何现有语义。
+ */
+export const MULTI_PRESETS = {
+  fast: { maxEngines: 1, minSources: 1 },
+  balanced: { maxEngines: 3, minSources: 1 },
+  deep: { maxEngines: 6, minSources: 2 },
+};
+
+/** 由当前 (上限, 目标源数) 反推档位名；不匹配任何档位时返回 "custom"。 */
+export function presetForSettings(maxEngines, minSources) {
+  const max = Number(maxEngines);
+  const min = Number(minSources);
+  const normMax = Number.isFinite(max) && max > 0 ? Math.floor(max) : 0;
+  const normMin = Number.isFinite(min) && min > 0 ? Math.floor(min) : 1;
+  for (const [id, p] of Object.entries(MULTI_PRESETS)) {
+    if (p.maxEngines === normMax && p.minSources === normMin) return id;
+  }
+  return "custom";
+}
+
+/**
+ * 常见「两段式」公共后缀（co.uk / com.cn / co.jp …）。不追求完整 PSL——
+ * 只覆盖公开搜索里真会撞到的那批；未命中时退化为「最后两段」。
+ */
+const MULTI_PART_SUFFIXES = new Set([
+  // 中国 / 港台
+  "com.cn", "net.cn", "org.cn", "gov.cn", "edu.cn", "ac.cn",
+  "com.hk", "org.hk", "net.hk", "edu.hk", "gov.hk",
+  "com.tw", "org.tw", "net.tw", "edu.tw", "gov.tw",
+  // 日韩
+  "co.jp", "or.jp", "ne.jp", "ac.jp", "go.jp",
+  "co.kr", "or.kr", "ne.kr", "go.kr", "re.kr",
+  // 英国 / 英联邦 / 大洋洲
+  "co.uk", "org.uk", "ac.uk", "gov.uk", "me.uk", "net.uk", "sch.uk",
+  "com.au", "net.au", "org.au", "edu.au", "gov.au",
+  "co.nz", "net.nz", "org.nz", "govt.nz", "ac.nz",
+  "co.za", "org.za", "net.za", "gov.za",
+  "co.in", "net.in", "org.in", "gov.in", "ac.in",
+  "com.sg", "com.my", "com.ph", "com.pk", "com.vn", "co.th", "co.id",
+  // 欧洲 / 拉美 / 中东 / 非洲
+  "com.br", "com.mx", "com.ar", "com.tr", "com.ua", "com.pl", "com.ru",
+  "co.il", "com.sa", "com.eg", "com.ng", "co.ke",
+]);
+
+/**
+ * 取 URL 的**可注册域**（eTLD+1）用于「同域」判定。
+ *
+ * 为什么不用主机名：blog.example.com 与 download.example.com 是同一站点的两个子域，
+ * 拿主机名分组会把它们当成两个「独立来源」，与 #69 §4 的域名多样性意图正好相反。
+ * （这正是 0.8.10 里自认的 known limitation。）
+ *
+ * IP / 含端口的 IPv6 / localhost / 单标签主机 / 非法 URL 一律原样小写返回，不误判。
+ */
+export function domainOf(url) {
+  const raw = String(url ?? "").trim();
+  if (!raw) return "";
+  let host;
+  try {
+    host = new URL(raw).hostname.toLowerCase();
+  } catch {
+    return raw.toLowerCase();
+  }
+  host = host.replace(/\.+$/, "").replace(/^www\./, "");
+  if (!host) return "";
+  if (!host.includes(".") || host.includes(":") || /^\d{1,3}(\.\d{1,3}){3}$/.test(host)) return host;
+  const parts = host.split(".");
+  if (parts.length <= 2) return host;
+  const last2 = parts.slice(-2).join(".");
+  return MULTI_PART_SUFFIXES.has(last2) ? parts.slice(-3).join(".") : last2;
+}
+
+function publishedTs(value) {
+  const ts = Date.parse(String(value ?? ""));
+  return Number.isFinite(ts) ? ts : 0;
+}
+
+/**
+ * 合并后的排序（#69 §4）。
+ *
+ * reporter 的要求：排序信号用「真实可得且有意义」的那些——原始结果顺序、域名多样性、
+ * 需要时的时效性；而 `seenIn` **只能当溯源/佐证元数据，不能当主排序键**，理由是
+ * "Six matching search results do not necessarily constitute six independent sources"
+ * （多个引擎可能共享索引与排序偏见，所以同域堆叠并不等于可信）。
+ *
+ * 做法（确定性、可离线断言）：
+ *   1. 按域名分组；
+ *   2. 组内次序：时效性生效时新的优先 → 原始顺序 → 佐证数（仅末位 tiebreak）；
+ *   3. 组的次序：按各域「最佳条目」的上述次序；
+ *   4. 轮转交错输出：第一轮每域各出一条，再第二轮…… → 前 N 条尽量来自不同域。
+ *
+ * 刻意只重排、不剔除：多样性是排序信号，不是过滤条件（过滤由 blockedDomains 负责）。
+ *
+ * 同域判定走 domainOf() 的 eTLD+1：blog.example.com 与 download.example.com 归为同一域。
+ * 局限：后缀表是精简版（非完整 PSL），冷门多段后缀仍退化为「最后两段」。
+ *
+ * @param {{domain?: string, order?: number, corroboration?: number, publishedAt?: string}[]} items
+ * @param {{appliesFreshness?: boolean}} [options] appliesFreshness 仅在本次搜索带时间过滤时为 true
+ */
+export function rankMergedResults(items, { appliesFreshness = false } = {}) {
+  const list = Array.isArray(items) ? items.slice() : [];
+  if (list.length <= 1) return list;
+
+  const withinKey = (x) => [
+    appliesFreshness ? -publishedTs(x?.publishedAt) : 0,
+    Number(x?.order) || 0,
+    -(Number(x?.corroboration) || 0),
+  ];
+  const cmp = (a, b) => {
+    const ka = withinKey(a);
+    const kb = withinKey(b);
+    for (let i = 0; i < ka.length; i++) {
+      if (ka[i] !== kb[i]) return ka[i] - kb[i];
+    }
+    return 0;
+  };
+
+  const byDomain = new Map();
+  for (const item of list) {
+    const d = String(item?.domain ?? "");
+    if (!byDomain.has(d)) byDomain.set(d, []);
+    byDomain.get(d).push(item);
+  }
+
+  const groups = [...byDomain.values()];
+  for (const group of groups) group.sort(cmp);
+  groups.sort((a, b) => cmp(a[0], b[0]));
+
+  const out = [];
+  const longest = groups.reduce((max, g) => Math.max(max, g.length), 0);
+  for (let round = 0; round < longest; round++) {
+    for (const group of groups) {
+      if (round < group.length) out.push(group[round]);
+    }
+  }
+  return out;
+}
+
+/**
+ * 引擎 → 必需凭据描述符（`{ env, settings }`，即 resolveApiKey 的两个参数）。
+ * 数组表示「任一命中即算配了」，与 index.js 里 resolveDoubaoKey / resolveGeminiKey
+ * 的回退逻辑逐条对应。
+ *
+ * 为什么需要它：#69 §2 要求引擎资格必须考虑 "Missing credentials"。原状的资格过滤
+ * 只看了 disabled / 冷却 / zhihu 预探测，缺 key 的引擎要到 runEngineTest 才发现 ——
+ * 而那时它已经占掉了并发上限的名额。本机默认池 [bing, baidu, aliyun, anysearch] 里
+ * baidu/aliyun 都没 key，上限设 3 时取走的正是这三个不可用的，唯一能跑的 anysearch
+ * 被切掉，整次 multi 直接失败。
+ *
+ * 收录纪律（有交叉校验断言钉住）：**只收 index.js 里 runEngineTest 显式
+ * `if (!key) return { error: "<ENV> not configured" }` 的引擎**，与代码自身对
+ * 「缺 key」的声明严格一致。
+ *   - 免 key 引擎 ddg/ddg-lite/bing/searxng 不收；
+ *   - 有免 key 兜底的 anysearch（key 可空）/ exa、parallel（回落 MCP）不收；
+ *   - tavily/keenable/firecrawl 分支没有 not configured 检查（缺 key 时会带着空串去请求，
+ *     以鉴权失败收场），暂不收——那属于另一个行为变更，需单独决定。
+ * settings 字段必须带上：只在环境变量里找 key 会漏掉「仅填在设置页」的用户。
+ */
+export const REQUIRED_CREDENTIALS = {
+  perplexity: [{ env: "PERPLEXITY_API_KEY", settings: "perplexityApiKey" }],
+  "deepseek-official": [{ env: "DEEPSEEK_API_KEY", settings: "deepseekApiKey" }],
+  "deepseek-tools": [{ env: "DEEPSEEK_API_KEY", settings: "deepseekApiKey" }],
+  serpbase: [{ env: "SERPBASE_API_KEY", settings: "serpbaseApiKey" }],
+  serply: [{ env: "SERPLY_API_KEY", settings: "serplyApiKey" }],
+  tinyfish: [{ env: "TINYFISH_API_KEY", settings: "tinyfishApiKey" }],
+  jina: [{ env: "JINA_API_KEY", settings: "jinaApiKey" }],
+  baidu: [{ env: "BAIDU_API_KEY", settings: "baiduApiKey" }],
+  kimi: [{ env: "MOONSHOT_API_KEY", settings: "kimiApiKey" }],
+  aliyun: [{ env: "DASHSCOPE_API_KEY", settings: "aliyunApiKey" }],
+  doubao: [
+    { env: "DOUBAO_SEARCH_API_KEY", settings: "doubaoApiKey" },
+    { env: "WEB_SEARCH_API_KEY", settings: null },
+  ],
+  zhihu_global: [{ env: "ZHIHU_API_KEY", settings: "zhihuApiKey" }],
+  zhihu_site: [{ env: "ZHIHU_API_KEY", settings: "zhihuApiKey" }],
+  openai: [{ env: "OPENAI_API_KEY", settings: "openaiApiKey" }],
+  gemini: [
+    { env: "GEMINI_API_KEY", settings: "geminiApiKey" },
+    { env: "GOOGLE_API_KEY", settings: null },
+  ],
+  claude: [{ env: "ANTHROPIC_API_KEY", settings: "claudeApiKey" }],
+  you: [{ env: "YOUCOM_API_KEY", settings: "youcomApiKey" }],
+};
+
+/** 该引擎需要哪些凭据描述符；不需要凭据（免 key / 有兜底）时返回 null。 */
+export function credentialRequirement(engine) {
+  const req = REQUIRED_CREDENTIALS[engine];
+  if (!req) return null;
+  return req.map((d) => ({ ...d }));
+}
+
+/**
+ * 引擎凭据是否齐备。`isAvailable(engine)` 由调用方提供（服务端负责真正解析凭据），
+ * 这里只做判定与分流，保持纯函数、可离线断言。
+ * 未知引擎一律算合格——宁放过，不误杀未来的新引擎。
+ */
+export function isCredentialEligible(engine, isAvailable) {
+  if (!credentialRequirement(engine)) return true;
+  return Boolean(isAvailable && isAvailable(engine));
+}
+
+/**
+ * 按凭据把候选池分成「合格」与「缺凭据」两份，顺序均保持原样。
+ * 调用方应把 missing 记进 skipped 备注，让用户仍然看得见某引擎为什么没跑。
+ */
+export function partitionByCredentials(engines, isAvailable) {
+  const eligible = [];
+  const missing = [];
+  for (const engine of Array.isArray(engines) ? engines : []) {
+    if (isCredentialEligible(engine, isAvailable)) eligible.push(engine);
+    else missing.push(engine);
+  }
+  return { eligible, missing };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-free-search",
-  "version": "0.9.1",
-  "description": "Free web search for DeepSeek Harness: 24 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 + editable zh/en language pools + multi mode (parallel full language-pool merge) + multi_search cross-source tool + failure-aware fallback (quota/auth cooldown, transient retry, fallbackOn) + time filtering + platform search + domain blocklist (blockedDomains) + web_fetch, with web settings UI.",
+  "version": "0.9.2",
+  "description": "Free web search for DeepSeek Harness: 27 engines (Bing/DuckDuckGo/AnySearch/SearXNG/Exa/Tavily/Keenable/Firecrawl/Parallel keyless; Zhihu global/site via MCP and Perplexity/SerpBase/DeepSeek (official + native tools/search)/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 + editable zh/en language pools + multi mode (parallel full language-pool merge) + multi_search cross-source tool + failure-aware fallback (quota/auth cooldown, transient retry, fallbackOn) + time filtering + platform search + domain blocklist (blockedDomains) + web_fetch, with web settings UI.",
   "type": "module",
   "main": "lib/index.js",
   "exports": {