@epoch-agent/plugin-web 0.10.1 → 0.12.0

package/README.md

@@ -1,12 +1,12 @@
 # @epoch-agent/plugin-web
 
 网页抓取与搜索插件。**两个工具**：`web_fetch`（总是有）和 `web_search`
-（**配了搜索后端才注册**）。
+（**有可用后端才注册** —— 缺省状态下就有，见下）。
 
 - ✅ **做**：HTTP GET → HTML→Markdown/Text/HTML、SSRF 校验、逐跳重定向校验、大小限制；
-  web 搜索（tavily / brave / searxng 三个后端）
+  web 搜索（native / tavily / brave / searxng / keyless 五个后端）
 - ❌ **不做**：不执行 JS、不渲染页面、不带浏览器；**不抓搜索引擎的 HTML 结果页**
-  （违反 ToS、随时会碎、要处理验证码 —— 没 key 就诚实地不提供这个工具）
+  （违反 ToS、随时会碎、要处理验证码 —— 要搜就走后端，不走爬虫）
 - **依赖**：只有 node 内置模块。[protocol](../../protocol) 是 peer，
   HTML 转换是手写的（无第三方库）
 
@@ -25,18 +25,33 @@
 **只返回标题 / URL / 摘要，不返回正文。** 一次搜索 5 条结果全抓正文轻松几万 token，
 而其中多半是模型看一眼摘要就丢掉的。分工是：搜 → 模型挑 → `web_fetch` 抓那一条。
 
-### 三个后端，按凭据自动挑
+### 五个后端，按凭据自动挑
 
-三家（`tavily` / `brave` / `searxng`）各要什么凭据见
+五档（`native` / `tavily` / `brave` / `searxng` / `keyless`）各要什么凭据见
 [docs/TOOLS.md](../../../docs/TOOLS.md#web_search-要一个搜索后端)。
 
-不配 `search.provider` 时按那张表的顺序探测，第一个有凭据的赢。**显式配了哪家就只认哪家**
+不配 `search.provider` 时按那张表的顺序探测，第一个可用的赢。**显式配了哪家就只认哪家**
 —— 缺 key 时报诊断而不是悄悄换一家：换一家意味着查询发去了另一家公司，
 那是用户没同意的事。
 
-一个后端都没有时 `web_search` **不注册**，启动诊断给 `skipped` 并列出三家各缺什么。
+一个后端都没有时 `web_search` **不注册**，启动诊断给 `skipped` 并逐档列出缺什么。
 注册一个一调就报错的工具比不注册更糟：模型看见工具表里有它就会反复试，每次烧一轮。
 
+#### 两档不用办账号的（2026-09-15）
+
+上面那句「没有后端就不注册」原来的实际效果是**大多数嵌入宿主的用户都没有搜索** ——
+三家老后端全要办账号，而宿主多半不会去配。这一档漏配是静默的：模型不知道自己本该
+有搜索，就改用浏览器去抓搜索引擎结果页（正是本包第一节说「不做」的那件事）。
+
+- **`native`**（`search/native.ts`）借 `provider.apiKey`，让当前 LLM provider 自己的
+  服务端搜索去干活。首版认 `deepseek` / `anthropic`（共用 Anthropic Messages 协议）。
+  它的结果项**没有明文摘要**（正文是 `encrypted_content`），信息走
+  `SearchOutcome.summary`。
+- **`keyless`**（`search/keyless.ts`）打 Exa / Parallel 的匿名 MCP 端点，
+  带游标轮转摊平两家免费额度。**查询词会发给第三方**，所以它排在最后、且能整档关掉。
+
+两个开关缺省开：`search.native: false` / `search.keyless: false`。
+
 > SearXNG **默认没开** JSON 输出，实例的 `settings.yml` 里要有
 > `search: { formats: [html, json] }`。没开时它返回 403，我们把这句话写进了错误里 ——
 > 否则用户会以为是自己地址写错了。
@@ -90,7 +105,10 @@ annotations: { readOnlyHint: true, idempotentHint: false, openWorldHint: true }
 | `tools/web-search.ts`              | 搜索工具：参数钳制 + 会话内缓存 + 失败不炸轮    |
 | `search/provider.ts`               | 后端接口 + 共用的 HTTP / 错误分类               |
 | `search/registry.ts`               | 按配置 + 凭据挑后端（挑不到就不注册）           |
-| `search/{tavily,brave,searxng}.ts` | 三个后端各自的请求 / 响应翻译                   |
+| `search/{tavily,brave,searxng}.ts` | 三个要办账号的后端各自的请求 / 响应翻译         |
+| `search/native.ts`                 | 借当前 LLM provider 的服务端搜索                |
+| `search/keyless.ts`                | Exa / Parallel 免费端点环 + 游标轮转            |
+| `search/mcp.ts`                    | MCP `tools/call`（纯 JSON 和 SSE 两种回法）     |
 | `utils/url-safety.ts`              | 三层 SSRF 校验                                  |
 | `utils/html-to-markdown.ts`        | 手写 HTML→Markdown / →Text                      |
 

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { SearchProviderType, EpochConfig, ToolContext, ToolResult, EpochTool, EpochPlugin } from '@epoch-agent/protocol';
+import { ProviderType, SearchProviderType, EpochConfig, ToolContext, ToolResult, EpochTool, EpochPlugin } from '@epoch-agent/protocol';
 
 /**
  * 搜索后端的接口（方案 37）。
@@ -50,6 +50,26 @@ interface SearchOutcome {
      * 于是会反复重试同一个查询。
      */
     ignored?: string[];
+    /**
+     * 后端自己合成的一段答案，**排在结果列表前面**给模型看。
+     *
+     * ## 为什么要有这一格（2026-09-15）
+     *
+     * `native` 那一档（搜索发生在 LLM provider 的服务端）返回的结果项里
+     * **没有明文摘要**：Anthropic 系的 `web_search_tool_result` 给的是
+     * `{title, url, encrypted_content, page_age}`，正文那一格是**加密的**，
+     * 只有发它的那一方解得开。
+     *
+     * 而本文件开头写着 snippet 的职责是「让模型判断这条值不值得抓正文」——
+     * 没有这一格，native 档交给模型的就是一串裸标题加 URL，它只能盲抓。
+     * 服务端合成的那段话正好补上这个缺口，而且它是**读过正文之后**写的，
+     * 比任何一家的 snippet 都准。
+     *
+     * ⚠️ **不是「摘要的替代品」**：有 snippet 的后端（tavily / brave / searxng /
+     * keyless）照常填 snippet、不填这一格。两者同时存在时都给模型，
+     * 它们回答的是不同的问题（这一格是「答案大概是什么」，snippet 是「这条讲什么」）。
+     */
+    summary?: string;
 }
 interface SearchProvider {
     readonly name: string;
@@ -73,11 +93,11 @@ declare class SearchError extends Error {
 }
 
 /**
- * 按配置 + 凭据挑一个搜索后端（方案 37）。
+ * 按配置 + 凭据挑一个搜索后端（方案 37；2026-09-15 加 native / keyless 两档）。
  *
  * ```
  * 显式配了 provider  → 只认那一家。缺 key 就报出来，**不静默回落到别家**
- * 没配             → 按顺序试 tavily → brave → searxng，第一个能用的赢
+ * 没配             → 按 AUTO_ORDER 顺序试，第一个能用的赢
  * 一个都不能用      → 返回 null，工具**不注册**
  * ```
  *
@@ -87,13 +107,32 @@ declare class SearchError extends Error {
  * 悄悄换成 tavily 意味着他的查询发去了另一家公司 —— 那是他没同意的事。
  * 报出来让他自己选，是唯一诚实的做法。
  *
- * ## 「一个都没有」为什么不注册工具，而不是注册一个会报错的
+ * ## 「一个都没有」这一档 2026-09-15 之后几乎不会出现了
  *
- * 注册一个一调就失败的工具，模型会反复试（它看到工具表里有 `web_search`，
- * 就会认为搜索是可行的），每次都烧一轮。不注册的话它从一开始就知道没这个能力。
- * 诊断走 `skipped` 而不是 `failed` —— 没配搜索不是故障，是没开这个功能。
+ * 原话是「注册一个一调就失败的工具比不注册更糟」，那条判据本身没变。
+ * 变的是**现在几乎总有一家能用**：`native` 跟着已经配好的 LLM provider 走、
+ * `keyless` 连 key 都不要。于是 `null` 这一支退化成「两档都被显式关掉、
+ * 且三家带 key 的也都没配」这种明确的用户选择。
+ *
+ * 这么改的理由是实测到的一次事故（nebular 2026-09-15）：宿主从没配过 `search`，
+ * 于是它的**每一个**用户都没有 `web_search`，而这件事对模型是静默的 ——
+ * 它不知道自己本该有搜索，就改用浏览器去抓搜索引擎结果页，
+ * 把 SEO 广告和 AI 生成的模板文当成行业数据写进了交付物。
  */
 
+/**
+ * `native` 那一档要的东西 —— 它借的是**当前 LLM provider** 的凭据和端点，
+ * 而那几样不在 `EpochConfig['search']` 里。
+ *
+ * 整段缺席时 `native` 会如实报「不知道当前是哪个 provider」然后落到下一档，
+ * 不是报错 —— 这让老的调用点（以及只测搜索配置的用例）不用全改一遍。
+ */
+interface NativeContext {
+    providerType?: ProviderType;
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+}
 /** 一次后端选择的结果 */
 type SearchSelection = {
     provider: SearchProvider;
@@ -104,15 +143,17 @@ type SearchSelection = {
     provider: null;
     detail: string;
 };
-declare function createSearchProvider(type: SearchProviderType, config: EpochConfig['search']): SearchProvider;
+declare function createSearchProvider(type: SearchProviderType, config: EpochConfig['search'], native?: NativeContext): SearchProvider;
 /**
  * 挑一个能用的后端。
  *
  * @param config `EpochConfig.search`。整段缺席 = 用户没开这个功能，
  *   但**仍然会按凭据自动探测** —— 环境里已经有 `TAVILY_API_KEY` 的人
  *   不该被要求再写一行配置才能用上。
+ * @param native 当前 LLM provider 的类型 / 凭据 / 端点。不给的话 `native`
+ *   那一档自动不可用，选择会落到后面几档 —— 老调用点不传也不会崩。
  */
-declare function selectSearchProvider(config: EpochConfig['search']): SearchSelection;
+declare function selectSearchProvider(config: EpochConfig['search'], native?: NativeContext): SearchSelection;
 
 /**
  * SearXNG —— **自托管、无 key** 的那一档（方案 37）。
@@ -166,6 +207,92 @@ interface BraveOptions {
 }
 declare function createBraveProvider(opts?: BraveOptions): SearchProvider;
 
+/**
+ * native —— 让**当前这个 LLM provider 自己**去搜（2026-09-15）。
+ *
+ * codex 和 gemini-cli 走的都是这条路：前者把 `{type:"web_search"}` 交给 OpenAI 的
+ * Responses API，后者读 Gemini grounding 的 `groundingMetadata`。共同点是
+ * **搜索发生在模型那一侧**，于是不需要第二个 API key、也不需要第二个账号。
+ *
+ * ## 为什么排在自动挑选的第一位
+ *
+ * 1. **不要新凭据** —— 用的就是已经配好的那把 provider key。
+ * 2. **隐私暴露面≈0** —— 查询词发给的是本来就持有整段对话的那一方。
+ *    相比之下 tavily / brave / keyless 都是把用户的问题交给一个新的第三方。
+ * 3. **有付费关系就有 SLA** —— 不看免费档的脸色。
+ *
+ * ⚠️ 代价是**一次搜索 = 一个完整的模型轮次**（实测 deepseek-flash：
+ * 5776 in / 583 out token），比纯检索端点慢也贵。要换回检索型后端就显式写
+ * `search.provider: tavily`；整档关掉是 `search.native: false`。
+ *
+ * ## 为什么结果里没有摘要，得靠 `summary`
+ *
+ * Anthropic 系的 `web_search_tool_result` 每一条是
+ * `{title, url, encrypted_content, page_age}` —— 正文那一格**是加密的**，
+ * 只有发它的那一方解得开。所以这一档填的是 `SearchOutcome.summary`
+ * （服务端读完正文之后合成的那段话），判据全文在 `provider.ts` 那一格上。
+ *
+ * ## 覆盖面
+ *
+ * 首版只做 **deepseek + anthropic** —— 两家共用 Anthropic Messages 协议，
+ * 一份实现就够。`openai`（Responses API）和 `google`（grounding）的传输层
+ * 完全不同，是**另外两份实现**，不在这一版里；能力表留着扩展位，
+ * 表里没有的 provider 会如实报原因然后落到下一档，不是报错。
+ */
+
+interface NativeOptions {
+    /** 当前 LLM provider 的类型。不给 = 这一档不可用 */
+    providerType?: ProviderType;
+    /** 已解析好的 provider key（`config.provider.apiKey`） */
+    apiKey?: string;
+    /** 用户自定义的 baseUrl；不给就用能力表里的默认值 */
+    baseUrl?: string;
+    /** 用哪个模型去搜（`config.model`） */
+    model?: string;
+    /** `search.native`。显式 `false` 才关 */
+    enabled?: boolean;
+}
+declare function createNativeProvider(opts?: NativeOptions): SearchProvider;
+
+/**
+ * keyless —— 免费公开端点组成的环，**零 key、零服务器**（2026-09-15）。
+ *
+ * 这一档存在的理由是本仓库原来的一条判据反过来咬了自己：`web_search` 没后端就
+ * 不注册，而三家已有后端**全都要凭据**，于是「什么都没配」的用户拿到的不是
+ * 「一个可能限流的搜索」，是**根本没有搜索**。实测后果（nebular 2026-09-15）：
+ * 模型改去用浏览器抓百度结果页，把 SEO 广告和 AI 模板文当成行业数据写进了交付物。
+ *
+ * ## 为什么可以不要 key
+ *
+ * Exa 和 Parallel 都对外开着**匿名的 MCP 端点**。这不是钻空子：opencode 和
+ * hermes-agent 两个互不相干的项目（一个 TS 一个 Python）各自独立收敛到了
+ * 同一组 URL，说明这是厂商有意留的获客入口。给了 key 就是付费档，不给就是免费档，
+ * 同一个端点。
+ *
+ * ## 为什么要轮转，而不是「排个序、第一家优先」
+ *
+ * 免费档是**按 IP 限流**的。固定先打一家等于把那一家的额度打爆之后才用另一家，
+ * 而限流恢复是有冷却的 —— 结果是两家的额度都没吃满，用户却已经在看「搜索不可用」。
+ * 模块级游标每次调用挪一格，把负载摊平（照 hermes 的 `_ring_cursor`）。
+ *
+ * ## 隐私（照抄 hermes 的分寸，不是可选项）
+ *
+ * - **不发任何用户标识**。
+ * - Parallel 的 `session_id` 是**每进程随机**的一个 hex，它只用于那边的限流关联，
+ *   不落盘、不跨进程复用。
+ * - Parallel 还收一个可选的 `model_name` 分析字段 —— **故意不传**。
+ *
+ * 即便如此，查询词本身仍然会发给第三方。要整档关掉：`search.keyless: false`。
+ */
+
+/** 给用例用：把游标拨回 0，否则用例之间会互相影响 */
+declare function resetKeylessCursor(): void;
+interface KeylessOptions {
+    /** `search.keyless`。显式 `false` 才关 —— 缺省是开着的 */
+    enabled?: boolean;
+}
+declare function createKeylessProvider(opts?: KeylessOptions): SearchProvider;
+
 /**
  * web_search —— 搜一串结果回来，**不抓正文**（方案 37）。
  *
@@ -226,4 +353,4 @@ declare function createWebSearchTool(provider: SearchProvider, opts?: {
     defaultMaxResults?: number;
 }): EpochTool;
 
-export { SearchError, type SearchOptions, type SearchOutcome, type SearchProvider, type SearchResult, type SearchSelection, clearSearchCache, createBraveProvider, createSearchProvider, createSearxngProvider, createTavilyProvider, createWebSearchExec, createWebSearchTool, selectSearchProvider, webPlugin };
+export { type NativeContext, SearchError, type SearchOptions, type SearchOutcome, type SearchProvider, type SearchResult, type SearchSelection, clearSearchCache, createBraveProvider, createKeylessProvider, createNativeProvider, createSearchProvider, createSearxngProvider, createTavilyProvider, createWebSearchExec, createWebSearchTool, resetKeylessCursor, selectSearchProvider, webPlugin };

package/dist/index.js

@@ -11,8 +11,8 @@ function htmlToMarkdown(html) {
   );
   cleaned = cleaned.replace(/<br\s*\/?>/gi, "\n");
   cleaned = cleaned.replace(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, (_, url, text) => {
-    const t5 = stripTags(text).trim();
-    return t5 ? `[${t5}](${url})` : url;
+    const t8 = stripTags(text).trim();
+    return t8 ? `[${t8}](${url})` : url;
   });
   cleaned = cleaned.replace(
     /<img[^>]*src="([^"]*)"[^>]*alt="([^"]*)"[^>]*>/gi,
@@ -338,18 +338,20 @@ function clearSearchCache() {
 function cacheKey(sessionId, query, opts) {
   return `${sessionId}\0${query.trim().toLowerCase()}\0${JSON.stringify(opts)}`;
 }
-function format(results, ignored) {
+function format(results, ignored, summary) {
   const lines = results.map((r, i) => {
     const date = r.publishedAt ? ` \xB7 ${r.publishedAt}` : "";
     const snippet = r.snippet.length > MAX_SNIPPET ? `${r.snippet.slice(0, MAX_SNIPPET)}\u2026` : r.snippet;
-    return `${i + 1}. ${r.title}${date}
+    return snippet ? `${i + 1}. ${r.title}${date}
    ${r.url}
-   ${snippet}`;
+   ${snippet}` : `${i + 1}. ${r.title}${date}
+   ${r.url}`;
   });
   const head = `${results.length} \u6761\u7ED3\u679C\uFF08\u53EA\u6709\u6458\u8981\uFF0C\u8981\u6B63\u6587\u8BF7\u5BF9\u5177\u4F53 URL \u8C03 web_fetch\uFF09`;
+  const lead = summary ? ["", `\u540E\u7AEF\u7EFC\u8FF0\uFF08\u636E\u4E0B\u5217\u6765\u6E90\u5408\u6210\uFF0C\u5F15\u7528\u65F6\u8BF7\u843D\u5230\u5177\u4F53 URL\uFF09\uFF1A`, summary] : [];
   const tail = ignored.length > 0 ? [`
 \u6CE8\u610F\uFF1A${ignored.join("\uFF1B")}`] : [];
-  return [head, "", ...lines, ...tail].join("\n");
+  return [head, ...lead, "", ...lines, ...tail].join("\n");
 }
 function stringArray(value) {
   if (!Array.isArray(value)) return void 0;
@@ -385,7 +387,7 @@ function createWebSearchExec(deps) {
     if (cached) {
       return {
         success: true,
-        output: format(cached, ["\u672C\u6B21\u7ED3\u679C\u6765\u81EA\u672C\u4F1A\u8BDD\u7F13\u5B58\uFF0C\u672A\u91CD\u65B0\u8054\u7F51"]),
+        output: format(cached.results, ["\u672C\u6B21\u7ED3\u679C\u6765\u81EA\u672C\u4F1A\u8BDD\u7F13\u5B58\uFF0C\u672A\u91CD\u65B0\u8054\u7F51"], cached.summary),
         duration: Date.now() - started
       };
     }
@@ -393,7 +395,10 @@ function createWebSearchExec(deps) {
     const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
     try {
       const outcome = await deps.provider.search(query, { ...options, signal: controller.signal });
-      cache.set(key, outcome.results);
+      cache.set(key, {
+        results: outcome.results,
+        ...outcome.summary ? { summary: outcome.summary } : {}
+      });
       if (outcome.results.length === 0) {
         return {
           success: true,
@@ -403,7 +408,7 @@ function createWebSearchExec(deps) {
       }
       return {
         success: true,
-        output: format(outcome.results, outcome.ignored ?? []),
+        output: format(outcome.results, outcome.ignored ?? [], outcome.summary),
         duration: Date.now() - started
       };
     } catch (err) {
@@ -424,7 +429,7 @@ function createWebSearchExec(deps) {
   };
 }
 // src/search/registry.ts
-import { t as t4 } from "@epoch-agent/infra";
+import { t as t7 } from "@epoch-agent/infra";
 // src/search/brave.ts
 import { t } from "@epoch-agent/infra";
 var ENDPOINT = "https://api.search.brave.com/res/v1/web/search";
@@ -489,22 +494,336 @@ function toFreshness(days) {
   if (days <= 366) return "py";
   return void 0;
 }
-// src/search/searxng.ts
+// src/search/keyless.ts
+import { randomUUID } from "crypto";
+import { t as t3 } from "@epoch-agent/infra";
+// src/search/mcp.ts
 import { t as t2 } from "@epoch-agent/infra";
+function pickText(payload) {
+  const trimmed = payload.trim();
+  if (!trimmed.startsWith("{")) return void 0;
+  let data;
+  try {
+    data = JSON.parse(trimmed);
+  } catch {
+    return void 0;
+  }
+  if (data.error && typeof data.error.message === "string") {
+    throw new SearchError(data.error.message);
+  }
+  const content = data.result?.content;
+  if (!Array.isArray(content)) return void 0;
+  for (const item of content) {
+    if (typeof item !== "object" || item === null) continue;
+    const text = item.text;
+    if (typeof text === "string" && text.length > 0) {
+      if (data.result?.isError === true) throw new SearchError(text);
+      return text;
+    }
+  }
+  return void 0;
+}
+function parseMcpResponse(body) {
+  const direct = pickText(body);
+  if (direct !== void 0) return direct;
+  for (const line of body.split("\n")) {
+    if (!line.startsWith("data: ")) continue;
+    const text = pickText(line.slice(6));
+    if (text !== void 0) return text;
+  }
+  return void 0;
+}
+async function mcpCall(init) {
+  let response;
+  try {
+    response = await fetch(init.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+        ...init.headers
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: { name: init.tool, arguments: init.args }
+      }),
+      ...init.signal ? { signal: init.signal } : {}
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new SearchError(t2("web_search_setup.err_timeout", { who: init.who }));
+    }
+    throw new SearchError(
+      t2("web_search_setup.err_unreachable", {
+        who: init.who,
+        detail: err instanceof Error ? err.message : String(err)
+      })
+    );
+  }
+  if (!response.ok) {
+    const hint = response.status === 429 ? t2("web_search_setup.err_rate_limited_hint") : "";
+    throw new SearchError(
+      t2("web_search_setup.err_http", { who: init.who, status: response.status, hint }),
+      response.status
+    );
+  }
+  const text = parseMcpResponse(await response.text());
+  if (text === void 0)
+    throw new SearchError(t2("web_search_setup.err_no_content", { who: init.who }));
+  return text;
+}
+// src/search/keyless.ts
+var EXA_URL = "https://mcp.exa.ai/mcp";
+var PARALLEL_URL = "https://search.parallel.ai/mcp";
+var RATE_LIMIT_ID = randomUUID().replace(/-/gu, "");
+var RING = ["exa", "parallel"];
+var cursor = 0;
+function resetKeylessCursor() {
+  cursor = 0;
+}
+function ringOrder() {
+  const start = cursor % RING.length;
+  cursor = (cursor + 1) % RING.length;
+  return [...RING.slice(start), ...RING.slice(0, start)];
+}
+function parseExa(text, max) {
+  const out = [];
+  let current = null;
+  let inHighlights = false;
+  const flush = () => {
+    if (current && current.url) {
+      out.push({
+        title: current.title || current.url,
+        url: current.url,
+        snippet: current.lines.join(" ").trim(),
+        ...current.date && current.date !== "N/A" ? { publishedAt: current.date } : {}
+      });
+    }
+    current = null;
+    inHighlights = false;
+  };
+  for (const line of text.split("\n")) {
+    if (line.startsWith("Title: ")) {
+      flush();
+      current = { title: line.slice(7).trim(), url: "", date: "", lines: [] };
+    } else if (!current) {
+      continue;
+    } else if (line.startsWith("URL: ")) {
+      current.url = line.slice(5).trim();
+    } else if (line.startsWith("Published: ")) {
+      current.date = line.slice(11).trim();
+    } else if (line.startsWith("Author: ")) {
+    } else if (line.startsWith("Highlights:")) {
+      inHighlights = true;
+    } else if (inHighlights) {
+      const piece = line.trim();
+      if (piece && piece !== "...") current.lines.push(piece);
+    }
+  }
+  flush();
+  return out.slice(0, max);
+}
+function parseParallel(text, max) {
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    throw new SearchError(t3("web_search_setup.err_bad_json", { who: "parallel" }));
+  }
+  if (!Array.isArray(data.results)) return [];
+  const out = [];
+  for (const item of data.results) {
+    if (typeof item !== "object" || item === null) continue;
+    const row = item;
+    if (typeof row.url !== "string" || !row.url) continue;
+    const excerpts = Array.isArray(row.excerpts) ? row.excerpts.filter((e) => typeof e === "string") : [];
+    out.push({
+      title: typeof row.title === "string" && row.title ? row.title : row.url,
+      url: row.url,
+      snippet: excerpts.join(" ").trim(),
+      ...typeof row.publish_date === "string" && row.publish_date ? { publishedAt: row.publish_date } : {}
+    });
+    if (out.length >= max) break;
+  }
+  return out;
+}
+async function searchOne(vendor, query, options) {
+  if (vendor === "exa") {
+    const text2 = await mcpCall({
+      url: EXA_URL,
+      tool: "web_search_exa",
+      args: {
+        query,
+        type: "auto",
+        numResults: options.maxResults,
+        livecrawl: "fallback"
+      },
+      who: "exa",
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    return parseExa(text2, options.maxResults);
+  }
+  const text = await mcpCall({
+    url: PARALLEL_URL,
+    tool: "web_search",
+    args: {
+      objective: query,
+      search_queries: [query],
+      session_id: RATE_LIMIT_ID
+    },
+    who: "parallel",
+    ...options.signal ? { signal: options.signal } : {}
+  });
+  return parseParallel(text, options.maxResults);
+}
+function createKeylessProvider(opts = {}) {
+  return {
+    name: "keyless",
+    unavailableReason() {
+      return opts.enabled === false ? t3("web_search_setup.keyless_disabled") : null;
+    },
+    async search(query, options) {
+      const failures = [];
+      for (const vendor of ringOrder()) {
+        try {
+          const results = await searchOne(vendor, query, options);
+          return {
+            results,
+            ...ignoredOf(options).length > 0 ? { ignored: ignoredOf(options) } : {}
+          };
+        } catch (err) {
+          if (options.signal?.aborted) throw err;
+          failures.push(err instanceof Error ? err.message : String(err));
+        }
+      }
+      throw new SearchError(
+        t3("web_search_setup.keyless_all_failed", {
+          tried: failures.join(t3("web_search_setup.tried_sep"))
+        })
+      );
+    }
+  };
+}
+function ignoredOf(options) {
+  const ignored = [];
+  if (options.recencyDays !== void 0)
+    ignored.push(t3("web_search_setup.ignored_recency_keyless"));
+  if (options.domains?.length) ignored.push(t3("web_search_setup.ignored_domains_keyless"));
+  if (options.excludeDomains?.length) ignored.push(t3("web_search_setup.ignored_exclude_keyless"));
+  return ignored;
+}
+// src/search/native.ts
+import { t as t4 } from "@epoch-agent/infra";
+var ANTHROPIC_STYLE = {
+  deepseek: { defaultBaseUrl: "https://api.deepseek.com", path: "/anthropic/v1/messages" },
+  anthropic: { defaultBaseUrl: "https://api.anthropic.com", path: "/v1/messages" }
+};
+var TOOL_TYPE = "web_search_20250305";
+var MAX_TOKENS = 1500;
+function buildPrompt(query, opts) {
+  const sep = t4("web_search_setup.prompt_domain_sep");
+  const lines = [t4("web_search_setup.prompt_search", { query })];
+  if (opts.domains?.length)
+    lines.push(t4("web_search_setup.prompt_only_domains", { domains: opts.domains.join(sep) }));
+  if (opts.excludeDomains?.length)
+    lines.push(
+      t4("web_search_setup.prompt_avoid_domains", { domains: opts.excludeDomains.join(sep) })
+    );
+  lines.push(t4("web_search_setup.prompt_wrap_up"));
+  return lines.join("\n");
+}
+function collectResults(blocks, max) {
+  const out = [];
+  for (const block of blocks) {
+    if (block.type !== "web_search_tool_result" || !Array.isArray(block.content)) continue;
+    for (const item of block.content) {
+      if (typeof item !== "object" || item === null) continue;
+      const row = item;
+      if (typeof row.url !== "string" || !row.url) continue;
+      out.push({
+        title: typeof row.title === "string" && row.title ? row.title : row.url,
+        snippet: "",
+        url: row.url,
+        ...typeof row.page_age === "string" && row.page_age ? { publishedAt: row.page_age } : {}
+      });
+      if (out.length >= max) return out;
+    }
+  }
+  return out;
+}
+function collectSummary(blocks) {
+  return blocks.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text.trim()).filter((s) => s.length > 0).join("\n\n");
+}
+function createNativeProvider(opts = {}) {
+  const spec = opts.providerType ? ANTHROPIC_STYLE[opts.providerType] : void 0;
+  return {
+    name: "native",
+    unavailableReason() {
+      if (opts.enabled === false) return t4("web_search_setup.native_disabled");
+      if (!opts.providerType) return t4("web_search_setup.native_no_provider");
+      if (!spec) return t4("web_search_setup.native_unsupported", { provider: opts.providerType });
+      if (!opts.apiKey?.trim()) {
+        return t4("web_search_setup.native_need_key", { provider: opts.providerType });
+      }
+      if (!opts.model?.trim()) return t4("web_search_setup.native_no_model");
+      return null;
+    },
+    async search(query, options) {
+      const base = (opts.baseUrl?.trim() || spec.defaultBaseUrl).replace(/\/+$/u, "");
+      const json = await searchFetch(
+        `${base}${spec.path}`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "x-api-key": opts.apiKey,
+            "anthropic-version": "2023-06-01"
+          },
+          body: JSON.stringify({
+            model: opts.model,
+            max_tokens: MAX_TOKENS,
+            tools: [{ type: TOOL_TYPE, name: "web_search", max_uses: 3 }],
+            messages: [{ role: "user", content: buildPrompt(query, options) }]
+          }),
+          ...options.signal ? { signal: options.signal } : {}
+        },
+        "native"
+      );
+      const blocks = Array.isArray(json.content) ? json.content ?? [] : [];
+      const results = collectResults(blocks, options.maxResults);
+      if (results.length === 0) {
+        throw new SearchError(
+          t4("web_search_setup.native_no_search", { provider: opts.providerType })
+        );
+      }
+      const summary = collectSummary(blocks);
+      const ignored = options.recencyDays === void 0 ? [] : [t4("web_search_setup.ignored_recency_native")];
+      return {
+        results,
+        ...summary ? { summary } : {},
+        ...ignored.length > 0 ? { ignored } : {}
+      };
+    }
+  };
+}
+// src/search/searxng.ts
+import { t as t5 } from "@epoch-agent/infra";
 function createSearxngProvider(opts) {
   return {
     name: "searxng",
     unavailableReason() {
       if (!opts.baseUrl?.trim()) {
-        return t2("web_search_setup.searxng_need_base_url");
+        return t5("web_search_setup.searxng_need_base_url");
       }
       try {
         const url = new URL(opts.baseUrl);
         if (url.protocol !== "http:" && url.protocol !== "https:") {
-          return t2("web_search_setup.searxng_bad_protocol", { protocol: url.protocol });
+          return t5("web_search_setup.searxng_bad_protocol", { protocol: url.protocol });
         }
       } catch {
-        return t2("web_search_setup.searxng_bad_url", { url: opts.baseUrl });
+        return t5("web_search_setup.searxng_bad_url", { url: opts.baseUrl });
       }
       return null;
     },
@@ -566,7 +885,7 @@ function timeRange(days) {
   return void 0;
 }
 // src/search/tavily.ts
-import { t as t3 } from "@epoch-agent/infra";
+import { t as t6 } from "@epoch-agent/infra";
 var ENDPOINT2 = "https://api.tavily.com/search";
 var MAX_RESULTS2 = 20;
 function createTavilyProvider(opts = {}) {
@@ -574,7 +893,7 @@ function createTavilyProvider(opts = {}) {
   return {
     name: "tavily",
     unavailableReason() {
-      return key() ? null : t3("web_search_setup.need_tavily_key");
+      return key() ? null : t6("web_search_setup.need_tavily_key");
     },
     async search(query, options) {
       const body = {
@@ -617,34 +936,54 @@ function createTavilyProvider(opts = {}) {
   };
 }
 // src/search/registry.ts
-var AUTO_ORDER = ["tavily", "brave", "searxng"];
-function createSearchProvider(type, config) {
-  if (type === "searxng") {
-    return createSearxngProvider(config?.baseUrl ? { baseUrl: config.baseUrl } : {});
+var AUTO_ORDER = [
+  "native",
+  "tavily",
+  "brave",
+  "searxng",
+  "keyless"
+];
+function createSearchProvider(type, config, native) {
+  switch (type) {
+    case "searxng":
+      return createSearxngProvider(config?.baseUrl ? { baseUrl: config.baseUrl } : {});
+    case "brave":
+      return createBraveProvider();
+    case "keyless":
+      return createKeylessProvider(config?.keyless === false ? { enabled: false } : {});
+    case "native":
+      return createNativeProvider({
+        ...native?.providerType ? { providerType: native.providerType } : {},
+        ...native?.apiKey ? { apiKey: native.apiKey } : {},
+        ...native?.baseUrl ? { baseUrl: native.baseUrl } : {},
+        ...native?.model ? { model: native.model } : {},
+        ...config?.native === false ? { enabled: false } : {}
+      });
+    default:
+      return createTavilyProvider();
   }
-  return type === "brave" ? createBraveProvider() : createTavilyProvider();
 }
-function selectSearchProvider(config) {
+function selectSearchProvider(config, native) {
   const explicit = config?.provider;
   if (explicit) {
-    const provider = createSearchProvider(explicit, config);
+    const provider = createSearchProvider(explicit, config, native);
     const reason = provider.unavailableReason();
     return reason ? {
       provider: null,
-      detail: t4("web_search_setup.explicit_unavailable", { provider: explicit, reason })
-    } : { provider, detail: t4("web_search_setup.explicit_ok", { provider: explicit }) };
+      detail: t7("web_search_setup.explicit_unavailable", { provider: explicit, reason })
+    } : { provider, detail: t7("web_search_setup.explicit_ok", { provider: explicit }) };
   }
   const tried = [];
   for (const type of AUTO_ORDER) {
-    const provider = createSearchProvider(type, config);
+    const provider = createSearchProvider(type, config, native);
     const reason = provider.unavailableReason();
-    if (!reason) return { provider, detail: t4("web_search_setup.auto", { provider: type }) };
+    if (!reason) return { provider, detail: t7("web_search_setup.auto", { provider: type }) };
     tried.push(reason);
   }
   return {
     provider: null,
-    detail: t4("web_search_setup.none", {
-      tried: tried.join(t4("web_search_setup.tried_sep"))
+    detail: t7("web_search_setup.none", {
+      tried: tried.join(t7("web_search_setup.tried_sep"))
     })
   };
 }
@@ -702,11 +1041,14 @@ export {
   SearchError,
   clearSearchCache,
   createBraveProvider,
+  createKeylessProvider,
+  createNativeProvider,
   createSearchProvider,
   createSearxngProvider,
   createTavilyProvider,
   createWebSearchExec,
   createWebSearchTool,
+  resetKeylessCursor,
   selectSearchProvider,
   webPlugin
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epoch-agent/plugin-web",
-  "version": "0.10.1",
+  "version": "0.12.0",
   "private": false,
   "description": "Web 抓取插件 — URL 安全校验 + HTML→Markdown + SSRF 防护",
   "repository": {
@@ -22,8 +22,8 @@
     "dist"
   ],
   "dependencies": {
-    "@epoch-agent/infra": "0.10.1",
-    "@epoch-agent/protocol": "0.10.1"
+    "@epoch-agent/infra": "0.12.0",
+    "@epoch-agent/protocol": "0.12.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",