opencode-search-plugin 2.0.0 → 2.1.1

package/README.md

@@ -2,24 +2,24 @@
 
 **English** · [简体中文](README.zh-CN.md)
 
-Ten self-contained [OpenCode](https://opencode.ai) v2 plugins that register web search providers. Each file stands on its own: copy one into your plugins directory, or install the package to get all ten.
+Eleven self-contained [OpenCode](https://opencode.ai) v2 plugins that register web search providers. Each file stands on its own: copy one into your plugins directory, or install the package to get all eleven.
 
-[AnySearch](https://www.anysearch.com/) · [Brave Search](https://brave.com/search/api/) · [Jina](https://jina.ai/) · [Keenable](https://keenable.ai/) · [Linkup](https://www.linkup.so/) · [Metaso](https://metaso.cn/) · [Querit](https://querit.ai/) · [SerpApi](https://serpapi.com/) · [Serper](https://serper.dev/) · [You.com](https://you.com/)
+[AnySearch](https://www.anysearch.com/) · [Brave Search](https://brave.com/search/api/) · [DeepSeek](https://api-docs.deepseek.com/guides/search/) · [Jina](https://jina.ai/) · [Keenable](https://keenable.ai/) · [Linkup](https://www.linkup.so/) · [Metaso](https://metaso.cn/) · [Querit](https://querit.ai/) · [SerpApi](https://serpapi.com/) · [Serper](https://serper.dev/) · [You.com](https://you.com/)
 
 ## Why this exists
 
 OpenCode v2 ships with five web search providers built in: `exa`, `firecrawl`, `parallel`, `tavily` and `tinyfish`. Outside that set, a much wider field of search APIs offers free quotas or free tiers — enough to run an agent's searches without paying for the privilege.
 
-This repository adds plugins for ten more of them, taking the pool from five providers to fifteen. AnySearch and Keenable run without a key at all; the other eight bind only when you supply one, so installing this package never routes a query to a provider that would immediately fail. Which of them are worth your time depends on the free tier each one currently offers, so check a provider's pricing before you rely on it.
+This repository adds plugins for eleven more of them, taking the pool from five providers to sixteen. AnySearch and Keenable run without a key at all; the other nine bind only when you supply one, so installing this package never routes a query to a provider that would immediately fail. Which of them are worth your time depends on the free tier each one currently offers, so check a provider's pricing before you rely on it.
 
 ## Install
 
-Three equivalent ways to install; pick one. **npm is recommended**: a version published to the registry is immutable, so a pinned `@2.0.0` always installs the same bytes, whereas a GitHub tag can in principle be moved by a maintainer to point at a different commit. The first two install the same complete package (all ten); use the third for one or two files only.
+Three equivalent ways to install; pick one. **npm is recommended**: a version published to the registry is immutable, so a pinned `@2.1.1` always installs the same bytes, whereas a GitHub tag can in principle be moved by a maintainer to point at a different commit. The first two install the same complete package (all eleven); use the third for one or two files only.
 
 ### 1. From npm (recommended)
 
 ```sh
-# add @2.0.0 to pin
+# add @2.1.1 to pin
 opencode plugin add opencode-search-plugin
 ```
 
@@ -35,7 +35,7 @@ or declare it in `opencode.json(c)`:
 ### 2. From GitHub
 
 ```sh
-# add #v2.0.0 to pin
+# add #v2.1.1 to pin
 opencode plugin add github:guotree/opencode-search-plugin
 ```
 
@@ -67,7 +67,7 @@ For a location that is not auto-discovered, list it explicitly:
 
 ### Skip the services you have no key for
 
-Loading the package registers all ten, but a provider without a key never joins the search pool — see [Keys](#keys). To keep them out of the registry entirely:
+Loading the package registers all eleven, but a provider without a key never joins the search pool — see [Keys](#keys). To keep some out of the registry entirely, use either or both of these optional options:
 
 ```jsonc
 {
@@ -80,7 +80,31 @@ Loading the package registers all ten, but a provider without a key never joins
 }
 ```
 
-`disable` takes the provider IDs listed in the table below. AnySearch and Keenable need no key, so `disable` is the only way to keep those two out of the pool.
+- `disable` is a deny-list: it never registers the IDs it names — the provider IDs in the table below. AnySearch and Keenable need no key, so `disable` is the only way to keep those two out of the pool.
+- `enable` is an allow-list: only the IDs it names are registered, and everything else is skipped — `"enable": ["osp-brave", "osp-jina"]` runs those two alone.
+
+When both are set, **`disable` wins on any overlap**. A per-provider exclusion is never overridden by a bulk allow-list:
+
+```jsonc
+{
+  "options": {
+    "enable": ["osp-brave", "osp-jina", "osp-serper"],
+    "disable": ["osp-serper", "osp-youcom"]
+    // osp-serper stays out: disable overrides enable.
+    // osp-youcom was never allowed in; that entry is inert.
+  }
+}
+```
+
+Read as set arithmetic, the registered pool is `enable − disable`. The overlap drops out; a `disable` ID the allow-list never contained was never a candidate to begin with — redundant, but harmless and unreported. The overlap is the only redundancy that earns a warning, and the log names the IDs in it.
+
+```text
+enable  = {osp-brave, osp-jina, osp-serper, osp-keenable, osp-linkup}
+disable = {osp-keenable, osp-linkup, osp-youcom}
+pool    =  osp-brave, osp-jina          -- enable minus disable
+```
+
+Configuration that cannot take effect is reported in the log rather than silently dropped: an ID this package does not register (a typo) is named, as is an option that is not an array. An `enable` list that ends up naming no known provider leaves the pool empty — the log says so.
 
 ## Upgrade
 
@@ -93,7 +117,7 @@ opencode plugin update github:guotree/opencode-search-plugin
 opencode plugin update
 ```
 
-The target is the specifier that was configured: an npm install is named by its package name, a GitHub install answers only to its `github:` form — naming it by its bare package name fails with `Plugin is not configured`. Run `opencode plugin check` first to see what is outdated. An install without a pinned version follows new releases; a pinned one — `@2.0.0` on npm, `#v2.0.0` on GitHub — stays on its pin until you re-run `plugin add` with a newer pin or edit the specifier in `opencode.json(c)`. A locally copied file is upgraded by copying the new version over the old one.
+The target is the specifier that was configured: an npm install is named by its package name, a GitHub install answers only to its `github:` form — naming it by its bare package name fails with `Plugin is not configured`. Run `opencode plugin check` first to see what is outdated. An install without a pinned version follows new releases; a pinned one — `@2.1.1` on npm, `#v2.1.1` on GitHub — stays on its pin until you re-run `plugin add` with a newer pin or edit the specifier in `opencode.json(c)`. A locally copied file is upgraded by copying the new version over the old one.
 
 ## Uninstall
 
@@ -104,7 +128,7 @@ opencode plugin remove opencode-search-plugin
 opencode plugin remove github:guotree/opencode-search-plugin
 ```
 
-The same rule: pass the specifier you installed with. The command edits the global configuration; if the plugin is instead a `plugins` entry in `opencode.json(c)` or a locally copied file, delete the entry or the copied `.ts` file. Saved `/connect` credentials are untouched — a reinstall finds them again — and to turn off a few providers instead of the whole plugin, use `disable` above.
+The same rule: pass the specifier you installed with. The command edits the global configuration; if the plugin is instead a `plugins` entry in `opencode.json(c)` or a locally copied file, delete the entry or the copied `.ts` file. Saved `/connect` credentials are untouched — a reinstall finds them again — and to turn off a few providers instead of the whole plugin, use `enable`/`disable` above.
 
 ## Keys
 
@@ -127,12 +151,15 @@ Once keys are in place, pick how OpenCode chooses among them:
 
 ## Providers
 
-Every ID below carries an `osp-` prefix — this package's namespace. OpenCode's own providers register bare vendor names (`exa`, `tavily`), and a vendor's official plugin would do the same, so the prefix is what keeps those entries from colliding with ours — both in the websearch pool and in the `/connect` table, where credentials are keyed by integration ID. Use the prefixed form verbatim in `websearch.provider` and in `disable`.
+Every ID below carries an `osp-` prefix — this package's namespace. OpenCode's own providers register bare vendor names (`exa`, `tavily`), and a vendor's official plugin would do the same, so the prefix is what keeps those entries from colliding with ours — both in the websearch pool and in the `/connect` table, where credentials are keyed by integration ID. Use the prefixed form verbatim in `websearch.provider` and in `enable`/`disable`.
+
+The namespace also shows on the display name: `/connect` lists each of this package's entries with an `(osp)` marker — `DeepSeek (osp)` beside a built-in `DeepSeek` — so a key saved here cannot be mistaken for a built-in provider's. The websearch pool keeps the plain provider name, since the pool holds only search providers and the collision does not exist there.
 
 | Provider | ID | Key (env / `/connect`) | Anonymous | Notes |
 | --- | --- | --- | --- | --- |
 | AnySearch | `osp-anysearch` | `ANYSEARCH_API_KEY` | yes | Free tier per IP; intent router, `cn`/`intl` zones |
 | Brave Search | `osp-brave` | `BRAVE_SEARCH_API_KEY` | no | Independent index, 20 results max |
+| DeepSeek | `osp-deepseek` | `DEEPSEEK_API_KEY` | no | In-house index; $0.75 per 1,000 successful requests; 5 QPS cap |
 | Jina | `osp-jina` | `JINA_API_KEY` | no | Page content is opt-in because it is token-billed |
 | Keenable | `osp-keenable` | `KEENABLE_API_KEY` | yes | 100,000 requests a month with a key; keyless tier is per IP |
 | Linkup | `osp-linkup` | `LINKUP_API_KEY` | no | `flash`/`fast`/`standard`/`deep` reasoning depth |
@@ -146,7 +173,7 @@ Every ID below carries an `osp-` prefix — this package's namespace. OpenCode's
 
 Knobs are environment variables, read once when OpenCode starts — change one and restart. Defaults match what each API documents, so leaving them unset is the right starting point.
 
-### Shared by all ten
+### Shared by all eleven
 
 | Variable | Default | Meaning |
 | --- | --- | --- |
@@ -172,6 +199,12 @@ Knobs are environment variables, read once when OpenCode starts — change one a
 | `BRAVE_LANG` | — | Result language, e.g. `en`, `zh-hans`, `pt-br` |
 | `BRAVE_FRESHNESS` | — | `pd` (24h), `pw` (7d), `pm` (31d), `py` (365d), or `YYYY-MM-DDtoYYYY-MM-DD` |
 
+### DeepSeek
+
+| Variable | Default | Meaning |
+| --- | --- | --- |
+| `DEEPSEEK_COUNT` | `10` | Results per search, clamped to 1–50 (DeepSeek's maximum). Price is per request, so more results cost nothing extra |
+
 ### Jina
 
 | Variable | Default | Meaning |
@@ -253,20 +286,20 @@ Dates are parsed from relative phrases (`3 hours ago`, `3小时前`), absolute f
 opencode plugin list
 
 # Which providers are actually in the pool?
-# A provider missing here has no key, or is listed in `disable`.
-# AnySearch and Keenable are always present, since neither needs one.
+# A provider missing here has no key, or `enable`/`disable` kept it out.
+# AnySearch and Keenable are always present, since neither needs a key.
 opencode api get "/api/websearch/provider"
 ```
 
 Also worth checking:
 
-- **A provider is missing from the pool** — it has no key. Run `/connect` or export its variable, then restart; credential changes made in `/connect` rebind without one.
+- **A provider is missing from the pool** — it has no key, or `disable` (or a narrow `enable`) filtered it out. Run `/connect` or export its variable, then restart; credential changes made in `/connect` rebind without one. A name that should be there but is not is often a typo: the log flags unknown IDs and any `enable`/`disable` overlap.
 - **A search fails with `Keenable rate limited the request (HTTP 429)`** — the keyless pool is capped at 1,000 requests an hour and 10 a second per IP, shared with the rest of your egress address. Set `KEENABLE_API_KEY` to draw on your own allowance instead.
 - **A search fails with `Connect X in /connect, or set X_API_KEY`** — the key disappeared between binding and searching. Reconnect or re-export.
 - **Everything is slow or burning credits** — leave `*_CACHE_TTL` at its default. Repeated queries within the window are served from memory.
 - **Nothing happens after editing a plugin file** — OpenCode watches plugins and reloads them; if it does not, `opencode service restart`.
 
-Logs live at `~/.local/share/opencode/log/opencode.log`; filter for `loading plugin` to see every plugin OpenCode resolved, with its entrypoint.
+Logs live at `~/.local/share/opencode/log/opencode.log`; filter for `loading plugin` to see every plugin OpenCode resolved, with its entrypoint. Warnings this plugin emits about `enable`/`disable` land in the same file, carrying a `[opencode-search-plugin]` prefix.
 
 ## Development
 

package/README.zh-CN.md

@@ -2,24 +2,24 @@
 
 # opencode-search-plugin
 
-十个相互独立的 [OpenCode](https://opencode.ai) v2 插件，各自注册一个网页搜索 provider。每个文件都能单独使用：复制一个进你的插件目录，或者安装这个包一次拿全十个。
+十一个相互独立的 [OpenCode](https://opencode.ai) v2 插件，各自注册一个网页搜索 provider。每个文件都能单独使用：复制一个进你的插件目录，或者安装这个包一次拿全十一个。
 
-[AnySearch](https://www.anysearch.com/) · [Brave Search](https://brave.com/search/api/) · [Jina](https://jina.ai/) · [Keenable](https://keenable.ai/) · [Linkup](https://www.linkup.so/) · [Metaso](https://metaso.cn/) · [Querit](https://querit.ai/) · [SerpApi](https://serpapi.com/) · [Serper](https://serper.dev/) · [You.com](https://you.com/)
+[AnySearch](https://www.anysearch.com/) · [Brave Search](https://brave.com/search/api/) · [DeepSeek](https://api-docs.deepseek.com/guides/search/) · [Jina](https://jina.ai/) · [Keenable](https://keenable.ai/) · [Linkup](https://www.linkup.so/) · [Metaso](https://metaso.cn/) · [Querit](https://querit.ai/) · [SerpApi](https://serpapi.com/) · [Serper](https://serper.dev/) · [You.com](https://you.com/)
 
 ## 为什么做这个插件
 
 OpenCode v2 内置了五个网页搜索 provider：`exa`、`firecrawl`、`parallel`、`tavily`、`tinyfish`。在这个范围之外，还有大量搜索 API 提供免费额度或免费层级，足以支撑 agent 的日常检索而不必为此付费。
 
-本仓库为其中十家补上了插件，把可用池从五个 provider 扩到十五个。AnySearch 和 Keenable 无需任何 key 即可使用；其余八家只在你提供 key 之后才会绑定，因此装上这个包也不会把查询路由到一个注定失败的服务上。至于哪几家值得用，取决于它们各自当前的免费额度，长期依赖某家之前建议先确认它的定价。
+本仓库为其中十一家补上了插件，把可用池从五个 provider 扩到十六个。AnySearch 和 Keenable 无需任何 key 即可使用；其余九家只在你提供 key 之后才会绑定，因此装上这个包也不会把查询路由到一个注定失败的服务上。至于哪几家值得用，取决于它们各自当前的免费额度，长期依赖某家之前建议先确认它的定价。
 
 ## 安装
 
-三种方式等价，任选其一。**推荐 npm**：已发布到 registry 的版本不可变，固定 `@2.0.0` 后每次安装都拿到同一份字节；GitHub 的 tag 在理论上可以被维护者移动、指向别的 commit。前两种装的是同一个完整包（十个全有），只想用一两个就用第三种。
+三种方式等价，任选其一。**推荐 npm**：已发布到 registry 的版本不可变，固定 `@2.1.1` 后每次安装都拿到同一份字节；GitHub 的 tag 在理论上可以被维护者移动、指向别的 commit。前两种装的是同一个完整包（十一个全有），只想用一两个就用第三种。
 
 ### 1. 从 npm 安装（推荐）
 
 ```sh
-# 追加 @2.0.0 可固定到该版本
+# 追加 @2.1.1 可固定到该版本
 opencode plugin add opencode-search-plugin
 ```
 
@@ -35,7 +35,7 @@ opencode plugin add opencode-search-plugin
 ### 2. 从 GitHub 安装
 
 ```sh
-# 追加 #v2.0.0 可固定到该 tag
+# 追加 #v2.1.1 可固定到该 tag
 opencode plugin add github:guotree/opencode-search-plugin
 ```
 
@@ -67,7 +67,7 @@ opencode plugin add github:guotree/opencode-search-plugin
 
 ### 跳过你没有 key 的服务
 
-装包会注册全部十家，但没有 key 的 provider 永远不会进入搜索池——见下文[密钥](#密钥)。想让它们连注册表都不出现：
+装包会注册全部十一家，但没有 key 的 provider 永远不会进入搜索池——见下文[密钥](#密钥)。想让它们连注册表都不出现，可以单独或同时使用下面两个可选选项：
 
 ```jsonc
 {
@@ -80,7 +80,31 @@ opencode plugin add github:guotree/opencode-search-plugin
 }
 ```
 
-`disable` 填的是下表中的 provider ID。AnySearch 和 Keenable 不需要 key，想把这两家也排除在搜索池之外，只能用 `disable`。
+- `disable` 是黑名单：它列出的 provider ID（见下文[支持的服务](#支持的服务)的表格）永远不会注册。AnySearch 和 Keenable 不需要 key，想把这两家也排除在搜索池之外，只能用 `disable`。
+- `enable` 是白名单：只注册列出的 ID，其余一律跳过——`"enable": ["osp-brave", "osp-jina"]` 表示只跑这两家。
+
+两者同时配置时，**交集由 `disable` 胜出**：逐家的排除绝不会被批量白名单覆盖。
+
+```jsonc
+{
+  "options": {
+    "enable": ["osp-brave", "osp-jina", "osp-serper"],
+    "disable": ["osp-serper", "osp-youcom"]
+    // osp-serper 仍然不注册：disable 压过 enable。
+    // osp-youcom 本来就不在白名单里，这条是冗余的。
+  }
+}
+```
+
+用集合运算来读：实际注册的池 = `enable − disable`。交集被剔除；`disable` 里不在 `enable` 中的 ID 从一开始就不在候选内——属于无害的冗余，不会被报告。唯一会触发警告的冗余是交集，日志会点出其中的 ID。
+
+```text
+enable  = {osp-brave, osp-jina, osp-serper, osp-keenable, osp-linkup}
+disable = {osp-keenable, osp-linkup, osp-youcom}
+pool    =  osp-brave, osp-jina          -- enable 减 disable
+```
+
+无法生效的配置会在日志里提示，而不是被悄悄丢弃：写错的 ID（本包没注册的名字）会被点名，选项不是数组也会被点名。`enable` 如果最终一个已知 provider 都没匹配上，搜索池会是空的——日志里会写明这一点。
 
 ## 升级
 
@@ -93,7 +117,7 @@ opencode plugin update github:guotree/opencode-search-plugin
 opencode plugin update
 ```
 
-升级目标用的是配置时的说明符：npm 安装用包名，GitHub 安装只认自己的 `github:` 形式——用裸包名会报 `Plugin is not configured`。先跑 `opencode plugin check` 查看有哪些过期。未固定版本的安装会跟上新版本；固定过的——npm 形式的 `@2.0.0`、GitHub 形式的 `#v2.0.0`——会停在原地，直到你用新 pin 重新执行 `plugin add`，或直接修改 `opencode.json(c)` 里的说明符。本地复制的文件则用新版本覆盖旧文件来升级。
+升级目标用的是配置时的说明符：npm 安装用包名，GitHub 安装只认自己的 `github:` 形式——用裸包名会报 `Plugin is not configured`。先跑 `opencode plugin check` 查看有哪些过期。未固定版本的安装会跟上新版本；固定过的——npm 形式的 `@2.1.1`、GitHub 形式的 `#v2.1.1`——会停在原地，直到你用新 pin 重新执行 `plugin add`，或直接修改 `opencode.json(c)` 里的说明符。本地复制的文件则用新版本覆盖旧文件来升级。
 
 ## 卸载
 
@@ -104,7 +128,7 @@ opencode plugin remove opencode-search-plugin
 opencode plugin remove github:guotree/opencode-search-plugin
 ```
 
-同上：传入安装时使用的说明符。该命令修改的是全局配置；若插件是写在 `opencode.json(c)` 的 `plugins` 条目里或本地复制的文件，删掉对应条目、或删掉复制的 `.ts` 文件即可。`/connect` 里保存的密钥不受影响——重新装回就能继续用——只想关掉其中几家而不是整个插件，用上文的 `disable`。
+同上：传入安装时使用的说明符。该命令修改的是全局配置；若插件是写在 `opencode.json(c)` 的 `plugins` 条目里或本地复制的文件，删掉对应条目、或删掉复制的 `.ts` 文件即可。`/connect` 里保存的密钥不受影响——重新装回就能继续用——只想关掉其中几家而不是整个插件，用上文的 `enable`/`disable`。
 
 ## 密钥
 
@@ -127,12 +151,15 @@ AnySearch 和 Keenable 是例外。两家都有匿名层级，因此始终注册
 
 ## 支持的服务
 
-下表每个 ID 都带 `osp-` 前缀——这是本包的命名空间。OpenCode 内置 provider 用的是裸厂商名（`exa`、`tavily`），厂商自己的插件也会注册裸名（Keenable 就已经有一个），所以前缀是避免撞名的唯一保障：既避开搜索池里的重复，也避开 `/connect` 里按 integration ID 存凭据的那张表。在 `websearch.provider` 和 `disable` 里请原样使用带前缀的 ID。
+下表每个 ID 都带 `osp-` 前缀——这是本包的命名空间。OpenCode 内置 provider 用的是裸厂商名（`exa`、`tavily`），厂商自己的插件也会注册裸名（Keenable 就已经有一个），所以前缀是避免撞名的唯一保障：既避开搜索池里的重复，也避开 `/connect` 里按 integration ID 存凭据的那张表。在 `websearch.provider` 和 `enable`/`disable` 里请原样使用带前缀的 ID。
+
+命名空间同样体现在显示名上：`/connect` 里本包的每个条目都带 `(osp)` 标记——内置的 `DeepSeek` 旁边是 `DeepSeek (osp)`——存在这里的 key 不会和内置 provider 的混淆。搜索池里仍用纯品牌名，因为池中只有搜索 provider，不存在撞名问题。
 
 | 服务 | ID | 密钥（环境变量 / `/connect`） | 匿名可用 | 说明 |
 | --- | --- | --- | --- | --- |
 | AnySearch | `osp-anysearch` | `ANYSEARCH_API_KEY` | 是 | 按 IP 的免费额度；意图路由，`cn` / `intl` 分区 |
 | Brave Search | `osp-brave` | `BRAVE_SEARCH_API_KEY` | 否 | 独立索引，最多 20 条结果 |
+| DeepSeek | `osp-deepseek` | `DEEPSEEK_API_KEY` | 否 | 自研搜索引擎；每千次成功请求 5 元；限速 5 QPS |
 | Jina | `osp-jina` | `JINA_API_KEY` | 否 | 页面正文按 token 计费，因此默认不取 |
 | Keenable | `osp-keenable` | `KEENABLE_API_KEY` | 是 | 有 key 每月 100,000 次免费请求；无 key 层级按 IP 限速 |
 | Linkup | `osp-linkup` | `LINKUP_API_KEY` | 否 | `flash` / `fast` / `standard` / `deep` 四档推理深度 |
@@ -146,7 +173,7 @@ AnySearch 和 Keenable 是例外。两家都有匿名层级，因此始终注册
 
 所有配置项都是环境变量，OpenCode 启动时读取一次——改了要重启。默认值取自各家 API 文档，所以一开始什么都不设就是合理的起点。
 
-### 十家通用
+### 十一家通用
 
 | 变量 | 默认值 | 含义 |
 | --- | --- | --- |
@@ -172,6 +199,12 @@ AnySearch 和 Keenable 是例外。两家都有匿名层级，因此始终注册
 | `BRAVE_LANG` | — | 结果语言，例如 `en`、`zh-hans`、`pt-br` |
 | `BRAVE_FRESHNESS` | — | `pd`（24 小时）、`pw`（7 天）、`pm`（31 天）、`py`（365 天），或 `YYYY-MM-DDtoYYYY-MM-DD` |
 
+### DeepSeek
+
+| 变量 | 默认值 | 含义 |
+| --- | --- | --- |
+| `DEEPSEEK_COUNT` | `10` | 每次搜索的结果数，限制在 1–50（DeepSeek 的上限）。按请求计费，条数增多不加价 |
+
 ### Jina
 
 | 变量 | 默认值 | 含义 |
@@ -253,20 +286,20 @@ AnySearch 和 Keenable 是例外。两家都有匿名层级，因此始终注册
 opencode plugin list
 
 # 搜索池里到底有哪些 provider？
-# 这里少了一家，说明它没有 key，或者被写进了 `disable`。
+# 这里少了一家，说明它没有 key，或者被 `enable`/`disable` 排除了。
 # AnySearch 和 Keenable 永远在列，因为它们都不需要 key。
 opencode api get "/api/websearch/provider"
 ```
 
 另外几个值得检查的地方：
 
-- **某家 provider 不在池里** —— 它没有 key。执行 `/connect` 或导出对应环境变量，然后重启；在 `/connect` 里做的凭据变更会自动重绑，不需要重启。
+- **某家 provider 不在池里** —— 它没有 key，或者被 `disable`（或收窄后的 `enable`）过滤掉了。执行 `/connect` 或导出对应环境变量，然后重启；在 `/connect` 里做的凭据变更会自动重绑，不需要重启。本该在却不在的名字多半是拼写错误：日志会点出无法识别的 ID 和 `enable`/`disable` 的交集。
 - **搜索报错 `Keenable rate limited the request (HTTP 429)`** —— 无 key 层级每个 IP 每小时 1,000 次、每秒 10 次，且与同一出口地址上的其他人共用。改用 `KEENABLE_API_KEY` 就会记到你自己的额度上。
 - **搜索报错 `Connect X in /connect, or set X_API_KEY`** —— key 在绑定和搜索之间消失了。重新连接或重新导出。
 - **一切都很慢、或者积分烧得飞快** —— 把 `*_CACHE_TTL` 保持在默认值。时间窗内的重复查询由内存直接返回。
 - **改了插件文件却没反应** —— OpenCode 会监视插件并自动重载；如果没有，执行 `opencode service restart`。
 
-日志在 `~/.local/share/opencode/log/opencode.log`；过滤 `loading plugin` 可以看到 OpenCode 解析到的每个插件及其入口文件。
+日志在 `~/.local/share/opencode/log/opencode.log`；过滤 `loading plugin` 可以看到 OpenCode 解析到的每个插件及其入口文件。本插件关于 `enable`/`disable` 的警告也落在同一个文件里，带 `[opencode-search-plugin]` 前缀。
 
 ## 开发
 

package/index.ts

@@ -4,6 +4,7 @@ import type { Scope } from "effect"
 
 import { effect as anysearch } from "./plugins/anysearch-search"
 import { effect as brave } from "./plugins/brave-search"
+import { effect as deepseek } from "./plugins/deepseek-search"
 import { effect as jina } from "./plugins/jina-search"
 import { effect as keenable } from "./plugins/keenable-search"
 import { effect as linkup } from "./plugins/linkup-search"
@@ -16,18 +17,19 @@ import { effect as youcom } from "./plugins/youcom-search"
 type ProviderEffect = (ctx: Plugin.Context) => Effect.Effect<void, never, Scope.Scope>
 
 /**
- * The ten providers this package registers, in alphabetical order. Each entry
+ * The eleven providers this package registers, in alphabetical order. Each entry
  * is the same effect its standalone file uses as a default export, so a file
  * copied out of this repository behaves exactly as it does here.
  *
  * The key of each entry is the websearch provider ID -- the one that appears in
- * `/api/websearch/provider`, in `websearch.provider`, and in the `disable`
- * option below. Renaming one would strand existing configuration. Each is
- * prefixed `osp-` to namespace it to this package; see CONTRIBUTING.md.
+ * `/api/websearch/provider`, in `websearch.provider`, and in the `enable` and
+ * `disable` options below. Renaming one would strand existing configuration.
+ * Each is prefixed `osp-` to namespace it to this package; see CONTRIBUTING.md.
  */
 const PROVIDERS: ReadonlyArray<readonly [id: string, run: ProviderEffect]> = [
   ["osp-anysearch", anysearch],
   ["osp-brave", brave],
+  ["osp-deepseek", deepseek],
   ["osp-jina", jina],
   ["osp-keenable", keenable],
   ["osp-linkup", linkup],
@@ -38,24 +40,82 @@ const PROVIDERS: ReadonlyArray<readonly [id: string, run: ProviderEffect]> = [
   ["osp-youcom", youcom],
 ]
 
+/** Every ID this package registers, so a typo in an option can be named. */
+const KNOWN_IDS: ReadonlySet<string> = new Set(PROVIDERS.map(([id]) => id))
+
+const WARNING = "[opencode-search-plugin]"
+
 /**
- * Reads the `disable` plugin option. A key-requiring provider that is disabled
- * here is never registered, which is how a user trims the pool down to the
- * services they actually hold keys for.
+ * Reads the `enable` or `disable` plugin option: an array of provider IDs.
+ * Anything that cannot take effect is reported on stderr rather than acted on
+ * -- a wrong shape is ignored outright, and an ID naming no provider here is
+ * dropped. A typo in a knob must not cost the user every provider, but it must
+ * not vanish silently either: `disable` shrinks the pool by one entry when an
+ * ID misses, while `enable` can shrink it to nothing.
  */
-function disabledProviders(ctx: Plugin.Context): ReadonlySet<string> {
-  const requested: unknown = ctx.options["disable"]
-  if (!Array.isArray(requested)) return new Set()
-  return new Set(requested.filter((entry): entry is string => typeof entry === "string"))
+function readOption(
+  ctx: Plugin.Context,
+  option: "enable" | "disable",
+): ReadonlySet<string> | undefined {
+  const requested: unknown = ctx.options[option]
+  if (requested === undefined) return undefined
+  if (!Array.isArray(requested)) {
+    console.warn(`${WARNING} ${option} must be an array of provider IDs; ignoring it`)
+    return undefined
+  }
+  const ids = new Set(requested.filter((entry): entry is string => typeof entry === "string"))
+  const unknown = [...ids].filter((id) => !KNOWN_IDS.has(id))
+  if (unknown.length > 0) {
+    console.warn(
+      `${WARNING} ${option} names no provider this package registers: ${unknown.join(", ")}`,
+    )
+  }
+  return ids
+}
+
+/**
+ * Resolves both options into the sets the registration loop reads. `undefined`
+ * from `readOption` means "no opinion": without `enable` every provider is a
+ * candidate, and without `disable` nothing is vetoed, so each option on its
+ * own behaves exactly as it did before the other existed.
+ */
+function registrationOptions(ctx: Plugin.Context): {
+  readonly allowed: ReadonlySet<string> | undefined
+  readonly disabled: ReadonlySet<string>
+} {
+  const allowed = readOption(ctx, "enable")
+  const disabled = readOption(ctx, "disable") ?? new Set<string>()
+
+  // Deny wins on the overlap: a provider `disable` names stays out even when
+  // `enable` lists it, so a per-provider exclusion is never overridden by a
+  // bulk allow-list. The overlap is named because the config is redundant,
+  // not fatal -- loading continues under the deny.
+  const overlap = allowed ? [...allowed].filter((id) => disabled.has(id)) : []
+  if (overlap.length > 0) {
+    console.warn(
+      `${WARNING} disable overrides enable for: ${overlap.join(", ")} -- those providers stay out`,
+    )
+  }
+
+  // An allow-list that reaches no known provider registers nothing at all. The
+  // registration loop stays faithful to that, but the reason belongs in the
+  // log: an empty search pool is otherwise indistinguishable from a loaded
+  // plugin that silently did nothing.
+  if (allowed !== undefined && ![...allowed].some((id) => KNOWN_IDS.has(id))) {
+    console.warn(`${WARNING} enable lists no known provider; the search pool will be empty`)
+  }
+
+  return { allowed, disabled }
 }
 
 export default Plugin.define({
   id: "opencode-search-plugin",
   effect: (ctx) =>
     Effect.gen(function* () {
-      const disabled = disabledProviders(ctx)
+      const { allowed, disabled } = registrationOptions(ctx)
       for (const [id, run] of PROVIDERS) {
         if (disabled.has(id)) continue
+        if (allowed !== undefined && !allowed.has(id)) continue
         yield* run(ctx)
       }
     }),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-search-plugin",
-  "version": "2.0.0",
-  "description": "Ten self-contained websearch provider plugins for OpenCode v2: AnySearch, Brave, Jina, Keenable, Linkup, Metaso, Querit, SerpApi, Serper and You.com.",
+  "version": "2.1.1",
+  "description": "Eleven self-contained websearch provider plugins for OpenCode v2: AnySearch, Brave, DeepSeek, Jina, Keenable, Linkup, Metaso, Querit, SerpApi, Serper and You.com.",
   "type": "module",
   "license": "MIT",
   "keywords": [

package/plugins/anysearch-search.ts

@@ -113,7 +113,7 @@ export const effect = (ctx: Plugin.Context) =>
     // Make "AnySearch" show up in /connect with an API-key method.
     yield* ctx.integration.transform((editor) => {
       editor.update(ID, (integration) => {
-        integration.name = "AnySearch"
+        integration.name = "AnySearch (osp)"
       })
       editor.method.update({
         integrationID: ID,

package/plugins/brave-search.ts

@@ -148,7 +148,7 @@ export const effect = (ctx: Plugin.Context) =>
     // Make "Brave Search" show up in /connect with an API-key method.
     yield* ctx.integration.transform((editor) => {
       editor.update(ID, (integration) => {
-        integration.name = "Brave Search"
+        integration.name = "Brave Search (osp)"
       })
       editor.method.update({
         integrationID: ID,

package/plugins/deepseek-search.ts

@@ -0,0 +1,270 @@
+import { Plugin } from "@opencode/plugin/effect"
+import { Effect, Schema, Stream } from "effect"
+
+// DeepSeek opened the search engine behind its own app to developers on
+// 2026-10-17. Billing is per successful request -- not per token, not per
+// returned result -- so `count` costs nothing extra and every repeat query the
+// cache answers is a request not billed at all. The content field is
+// `summary`: the API documents it as 600-800 characters "intended to be read
+// by a model", which is exactly what an agent consumes. `content` would only
+// fill with whole-page text under `need_content`, which bloats the agent's
+// context for no gain. Fields absent from a hit map the way the other
+// providers map them: a missing title falls back to the URL, a missing
+// summary to an empty string.
+const DeepSeekResponse = Schema.Struct({
+  results: Schema.optional(
+    Schema.Array(
+      Schema.Struct({
+        title: Schema.optional(Schema.String),
+        url: Schema.String,
+        summary: Schema.optional(Schema.String),
+        // RFC 3339 in UTC, or null when the publication time is unknown.
+        date: Schema.optional(Schema.NullOr(Schema.String)),
+      }),
+    ),
+  ),
+})
+
+// The /connect integration ID, and the websearch provider ID it binds to.
+// The `osp-` prefix is this package's namespace: OpenCode's built-ins and a
+// vendor plugin's own entry are bare vendor names, so `deepseek` would collide
+// with them, and with the opencode.db row keyed by integration ID.
+const ID = "osp-deepseek"
+
+function envInt(name: string, fallback: number): number {
+  const raw = (process.env[name] ?? "").trim()
+  if (raw === "") return fallback
+  const value = Number(raw)
+  return Number.isFinite(value) && value >= 0 ? value : fallback
+}
+
+// Search engines hand out dates in three flavours: relative ("28 minutes ago"),
+// absolute ("Sep 30, 2026" in the US, "31 Mar 2026" elsewhere), and non-English
+// relative ("4天前"). Relative values are rounded upstream, so month/year use
+// 30/365 days. ISO 8601 timestamps are accepted as-is -- DeepSeek emits only
+// that shape, RFC 3339 with a time component.
+// See https://serpapi.com/blog/how-to-parse-dates-from-google-search/
+const RELATIVE_MS: Record<string, number> = {
+  minute: 60_000,
+  hour: 3_600_000,
+  day: 86_400_000,
+  week: 604_800_000,
+  month: 2_592_000_000,
+  year: 31_536_000_000,
+  分钟: 60_000,
+  小时: 3_600_000,
+  天: 86_400_000,
+  周: 604_800_000,
+  个月: 2_592_000_000,
+  月: 2_592_000_000,
+  年: 31_536_000_000,
+}
+
+const RELATIVE_DATE =
+  /^(\d+)\s*(minute|hour|day|week|month|year|分钟|小时|天|周|个月|月|年)s?\s*(?:ago|前)$/i
+
+const ABSOLUTE_DATE = [
+  /^\d{1,2}\s+[A-Za-z]{3,9}\s+\d{4}$/, // "3 Jan 2022", "31 Mar 2026"
+  /^[A-Za-z]{3,9}\s+\d{1,2},?\s+\d{4}$/, // "Sep 30, 2026", "Jan 27, 2025"
+  /^\d{4}-\d{2}-\d{2}$/, // "2026-10-16"
+  // ISO 8601 with a time component, which some providers return verbatim.
+  /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?$/,
+]
+
+function parseSearchDate(value: string | undefined): number {
+  const text = value?.trim()
+  if (!text) return NaN
+
+  const relative = RELATIVE_DATE.exec(text)
+  if (relative) {
+    const unit = relative[2] !== undefined ? RELATIVE_MS[relative[2].toLowerCase()] : undefined
+    const amount = Number(relative[1])
+    if (unit === undefined || !Number.isFinite(amount)) return NaN
+    return Date.now() - amount * unit
+  }
+
+  // Only trust Date.parse on shapes these providers actually emit -- its lenient
+  // parser invents a year for strings like "Nov 1", which would date the result
+  // to 2001.
+  return ABSOLUTE_DATE.some((shape) => shape.test(text)) ? Date.parse(text) : NaN
+}
+
+function toResult(item: {
+  title?: string | undefined
+  url: string
+  summary?: string | undefined
+  date?: string | null | undefined
+}) {
+  const published = parseSearchDate(item.date ?? undefined)
+  return {
+    url: item.url,
+    title: item.title || item.url,
+    content: item.summary ?? "",
+    time: Number.isFinite(published) ? { published } : {},
+  }
+}
+
+type SearchResult = ReturnType<typeof toResult>
+
+// DeepSeek charges per successful search and has no anonymous tier. A repeat
+// query is a fresh billed dispatch, so responses are cached per normalized
+// query. Knobs are read once at load time, restart after changing them.
+//
+//   DEEPSEEK_CACHE_TTL   ms to reuse a response for the same query (0 disables)
+//   DEEPSEEK_COUNT       results per search, clamped to 1-50
+//   DEEPSEEK_API_KEY     required; from https://platform.deepseek.com
+const CACHE_TTL = envInt("DEEPSEEK_CACHE_TTL", 600_000)
+const COUNT = Math.min(Math.max(envInt("DEEPSEEK_COUNT", 10), 1), 50)
+
+const CACHE_LIMIT = 200
+const cache = new Map<string, { at: number; results: SearchResult[] }>()
+
+function cacheKey(query: string): string {
+  return query.trim().replace(/\s+/g, " ")
+}
+
+function readCache(queryKey: string): SearchResult[] | undefined {
+  if (CACHE_TTL <= 0) return undefined
+  const hit = cache.get(queryKey)
+  return hit && Date.now() - hit.at < CACHE_TTL ? hit.results : undefined
+}
+
+function writeCache(queryKey: string, results: SearchResult[]): void {
+  if (CACHE_TTL <= 0) return
+  cache.set(queryKey, { at: Date.now(), results })
+  if (cache.size > CACHE_LIMIT) {
+    const oldest = cache.keys().next().value
+    if (oldest !== undefined) cache.delete(oldest)
+  }
+}
+
+export const effect = (ctx: Plugin.Context) =>
+  Effect.gen(function* () {
+    // Make "DeepSeek" show up in /connect with an API-key method.
+    yield* ctx.integration.transform((editor) => {
+      editor.update(ID, (integration) => {
+        integration.name = "DeepSeek (osp)"
+      })
+      editor.method.update({
+        integrationID: ID,
+        method: { type: "key", label: "DeepSeek API key" },
+      })
+      editor.method.update({
+        integrationID: ID,
+        method: { type: "env", names: ["DEEPSEEK_API_KEY"] },
+      })
+    })
+
+    // The host instantiates this API's failure channel as `unknown`, which would
+    // make the whole plugin effect unrunnable. A credential read must never take
+    // the plugin down: a failed read degrades to "no stored key", and the
+    // environment fallback below applies exactly as it does when the credential
+    // simply does not exist.
+    const soften = <A>(read: Effect.Effect<A, unknown>): Effect.Effect<A | undefined, never> =>
+      read.pipe(Effect.catch(() => Effect.succeed(undefined)))
+
+    // The key comes from the /connect credential, falling back to the
+    // environment. Resolved per call so a rotated key needs no restart.
+    const resolveKey = () =>
+      Effect.gen(function* () {
+        const connection = yield* soften(ctx.integration.connection.active(ID))
+        const credential = connection
+          ? yield* soften(ctx.integration.connection.resolve(connection))
+          : undefined
+        return credential?.type === "key" ? credential.key : process.env.DEEPSEEK_API_KEY
+      })
+
+    // DeepSeek is bound to websearch only while a key exists. Deleting the key
+    // unbinds the provider, so `random` can never pick a keyless DeepSeek.
+    // The transform replays on reload and reads `bound` as it stands then.
+    let bound = Boolean(yield* resolveKey())
+
+    yield* ctx.websearch.transform((editor) => {
+      if (!bound) return
+      editor.add({
+        id: ID,
+        name: "DeepSeek",
+        execute: ({ query }) =>
+          Effect.gen(function* () {
+            const queryKey = cacheKey(query)
+            const cached = readCache(queryKey)
+            if (cached) return cached
+
+            // Rechecked per call: binding can lag a key deletion by the
+            // event round-trip, so this keeps that window explicit.
+            const key = yield* resolveKey()
+            if (!key) {
+              return yield* Effect.fail(
+                new Error("Connect DeepSeek in /connect, or set DEEPSEEK_API_KEY"),
+              )
+            }
+
+            const response = yield* Effect.tryPromise({
+              try: () =>
+                fetch("https://api.deepseek.com/v1/tools/search", {
+                  method: "POST",
+                  headers: {
+                    Accept: "application/json",
+                    "Content-Type": "application/json",
+                    Authorization: "Bearer " + key,
+                  },
+                  body: JSON.stringify({
+                    query: queryKey,
+                    count: COUNT,
+                  }),
+                }),
+              catch: (error) => new Error("DeepSeek request failed: " + String(error)),
+            })
+
+            if (!response.ok) {
+              const detail = yield* Effect.tryPromise({
+                try: () => response.text(),
+                catch: () => new Error("response body unavailable"),
+              })
+              return yield* Effect.fail(
+                new Error("DeepSeek API error " + response.status + ": " + detail),
+              )
+            }
+
+            const json = yield* Effect.tryPromise({
+              try: () => response.json(),
+              catch: (error) => new Error("Invalid DeepSeek response: " + String(error)),
+            })
+
+            const body = yield* Schema.decodeUnknownEffect(DeepSeekResponse)(json)
+            const results = (body.results ?? []).map(toResult)
+
+            // DeepSeek charges per dispatch and does not bill failures or empty
+            // results, so a hit that never enters the cache is a query paid for
+            // again on every repeat.
+            writeCache(queryKey, results)
+            return results
+          }),
+      })
+    })
+
+    // Rebind on credential changes: connect, delete, or rotate a key and the
+    // provider joins or leaves the websearch pool without a restart. Env-var
+    // keys cannot change under a running process, so they bind at startup.
+    yield* Effect.forkScoped(
+      ctx.event.subscribe().pipe(
+        Stream.filter(
+          (event) =>
+            event.type === "credential.updated" ||
+            event.type === "credential.switched" ||
+            event.type === "integration.updated",
+        ),
+        Stream.mapEffect(() =>
+          Effect.gen(function* () {
+            const next = Boolean(yield* resolveKey())
+            if (next === bound) return
+            bound = next
+            yield* ctx.websearch.reload()
+          }),
+        ),
+        Stream.runDrain,
+      ),
+    )
+  })
+
+export default Plugin.define({ id: "deepseek-search", effect })

package/plugins/jina-search.ts

@@ -112,7 +112,7 @@ export const effect = (ctx: Plugin.Context) =>
     // Make "Jina" show up in /connect with an API-key method.
     yield* ctx.integration.transform((editor) => {
       editor.update(ID, (integration) => {
-        integration.name = "Jina"
+        integration.name = "Jina (osp)"
       })
       editor.method.update({
         integrationID: ID,

package/plugins/keenable-search.ts

@@ -163,7 +163,7 @@ export const effect = (ctx: Plugin.Context) =>
     // Make "Keenable" show up in /connect with an API-key method.
     yield* ctx.integration.transform((editor) => {
       editor.update(ID, (integration) => {
-        integration.name = "Keenable"
+        integration.name = "Keenable (osp)"
       })
       editor.method.update({
         integrationID: ID,

package/plugins/linkup-search.ts

@@ -88,7 +88,7 @@ export const effect = (ctx: Plugin.Context) =>
     // Make "Linkup" show up in /connect with an API-key method.
     yield* ctx.integration.transform((editor) => {
       editor.update(ID, (integration) => {
-        integration.name = "Linkup"
+        integration.name = "Linkup (osp)"
       })
       editor.method.update({
         integrationID: ID,

package/plugins/metaso-search.ts

@@ -143,7 +143,7 @@ export const effect = (ctx: Plugin.Context) =>
     // Make "Metaso" show up in /connect with an API-key method.
     yield* ctx.integration.transform((editor) => {
       editor.update(ID, (integration) => {
-        integration.name = "Metaso Search"
+        integration.name = "Metaso Search (osp)"
       })
       editor.method.update({
         integrationID: ID,

package/plugins/querit-search.ts

@@ -153,7 +153,7 @@ export const effect = (ctx: Plugin.Context) =>
     // Make "Querit" show up in /connect with an API-key method.
     yield* ctx.integration.transform((editor) => {
       editor.update(ID, (integration) => {
-        integration.name = "Querit"
+        integration.name = "Querit (osp)"
       })
       editor.method.update({
         integrationID: ID,

package/plugins/serpapi-search.ts

@@ -147,7 +147,7 @@ export const effect = (ctx: Plugin.Context) =>
     // Make "SerpApi" show up in /connect with an API-key method.
     yield* ctx.integration.transform((editor) => {
       editor.update(ID, (integration) => {
-        integration.name = "SerpApi"
+        integration.name = "SerpApi (osp)"
       })
       editor.method.update({
         integrationID: ID,

package/plugins/serper-search.ts

@@ -146,7 +146,7 @@ export const effect = (ctx: Plugin.Context) =>
     // Make "Serper" show up in /connect with an API-key method.
     yield* ctx.integration.transform((editor) => {
       editor.update(ID, (integration) => {
-        integration.name = "Serper"
+        integration.name = "Serper (osp)"
       })
       editor.method.update({
         integrationID: ID,

package/plugins/youcom-search.ts

@@ -177,7 +177,7 @@ export const effect = (ctx: Plugin.Context) =>
     // Make "You.com" show up in /connect with an API-key method.
     yield* ctx.integration.transform((editor) => {
       editor.update(ID, (integration) => {
-        integration.name = "You.com"
+        integration.name = "You.com (osp)"
       })
       editor.method.update({
         integrationID: ID,