opencode-search-plugin 2.1.0 → 2.2.0

package/README.md

@@ -4,7 +4,7 @@
 
 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
 
@@ -14,12 +14,12 @@ This repository adds plugins for eleven more of them, taking the pool from five
 
 ## Install
 
-Three equivalent ways to install; pick one. **npm is recommended**: a version published to the registry is immutable, so a pinned `@2.1.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 eleven); 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.2.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 eleven); use the third for one or two files only.
 
 ### 1. From npm (recommended)
 
 ```sh
-# add @2.1.0 to pin
+# add @2.2.0 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.1.0 to pin
+# add #v2.2.0 to pin
 opencode plugin add github:guotree/opencode-search-plugin
 ```
 
@@ -117,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.1.0` on npm, `#v2.1.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.2.0` on npm, `#v2.2.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.
 
 ## Uninstall
 
@@ -153,6 +153,8 @@ Once keys are in place, pick how OpenCode chooses among them:
 
 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 |
@@ -176,6 +178,7 @@ Knobs are environment variables, read once when OpenCode starts — change one a
 | Variable | Default | Meaning |
 | --- | --- | --- |
 | `<PROVIDER>_CACHE_TTL` | `600000` | Milliseconds to reuse a response for the same normalized query. `0` disables caching. |
+| `<PROVIDER>_TIMEOUT` | `25000` | Milliseconds to wait for the provider before failing. `0` removes the deadline but keeps cancellation. |
 
 ### AnySearch
 
@@ -211,6 +214,7 @@ Knobs are environment variables, read once when OpenCode starts — change one a
 | `JINA_INCLUDE_CONTENT` | off | `true` returns each hit's full page markdown — far more context and billed tokens |
 | `JINA_GL` / `JINA_HL` | — | Country / language code |
 | `JINA_LOCATION` | — | City-level origin to simulate, e.g. `Berlin` |
+| `JINA_TIMEOUT` | `25000`, or `60000` with `JINA_INCLUDE_CONTENT` | Only provider whose deadline varies by mode: fetching whole pages is legitimately slower than a snippet search |
 
 ### Keenable
 
@@ -272,7 +276,7 @@ There is deliberately no result-count knob: Google withdrew the `num` parameter,
 1. OpenCode asks the selected provider for the query.
 2. The normalized query (trimmed, whitespace collapsed) is checked against an in-memory cache. A hit returns immediately — repeat queries are free and instant.
 3. On a miss the key is resolved again, so a key rotated in `/connect` applies to the very next search.
-4. The request goes out; failures surface the HTTP status and response body so you can see what the provider actually said.
+4. The request goes out under a deadline (`<PROVIDER>_TIMEOUT`, default 25s). OpenCode applies no timeout of its own around a search, so without this a provider that accepted the connection and then went silent would hang the whole turn. Failures surface the HTTP status and response body, or name the timeout when that is what happened.
 5. The response is schema-decoded, mapped to `{ url, title, content, time }`, and cached.
 
 Dates are parsed from relative phrases (`3 hours ago`, `3小时前`), absolute formats (`Sep 30, 2026`, `31 Mar 2026`), and ISO 8601. Strings whose lenient parsing would invent a wrong year — `Nov 1`, which `Date.parse` reads as 2001 — are dropped rather than reported as a bogus timestamp.
@@ -294,6 +298,7 @@ Also worth checking:
 - **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.
+- **A search fails with `X search timed out after 25000ms`** — the provider accepted the request and never answered within the deadline. Retrying usually works; if a provider is consistently slow for you, raise its `<PROVIDER>_TIMEOUT`. This is a deliberate bound: without one a stalled provider hangs the whole turn, because OpenCode applies no timeout of its own around a search.
 - **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`.
 

package/README.zh-CN.md

@@ -4,7 +4,7 @@
 
 十一个相互独立的 [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/)
 
 ## 为什么做这个插件
 
@@ -14,12 +14,12 @@ OpenCode v2 内置了五个网页搜索 provider：`exa`、`firecrawl`、`parall
 
 ## 安装
 
-三种方式等价，任选其一。**推荐 npm**：已发布到 registry 的版本不可变，固定 `@2.1.0` 后每次安装都拿到同一份字节；GitHub 的 tag 在理论上可以被维护者移动、指向别的 commit。前两种装的是同一个完整包（十一个全有），只想用一两个就用第三种。
+三种方式等价，任选其一。**推荐 npm**：已发布到 registry 的版本不可变，固定 `@2.2.0` 后每次安装都拿到同一份字节；GitHub 的 tag 在理论上可以被维护者移动、指向别的 commit。前两种装的是同一个完整包（十一个全有），只想用一两个就用第三种。
 
 ### 1. 从 npm 安装（推荐）
 
 ```sh
-# 追加 @2.1.0 可固定到该版本
+# 追加 @2.2.0 可固定到该版本
 opencode plugin add opencode-search-plugin
 ```
 
@@ -35,7 +35,7 @@ opencode plugin add opencode-search-plugin
 ### 2. 从 GitHub 安装
 
 ```sh
-# 追加 #v2.1.0 可固定到该 tag
+# 追加 #v2.2.0 可固定到该 tag
 opencode plugin add github:guotree/opencode-search-plugin
 ```
 
@@ -117,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.1.0`、GitHub 形式的 `#v2.1.0`——会停在原地，直到你用新 pin 重新执行 `plugin add`，或直接修改 `opencode.json(c)` 里的说明符。本地复制的文件则用新版本覆盖旧文件来升级。
+升级目标用的是配置时的说明符：npm 安装用包名，GitHub 安装只认自己的 `github:` 形式——用裸包名会报 `Plugin is not configured`。先跑 `opencode plugin check` 查看有哪些过期。未固定版本的安装会跟上新版本；固定过的——npm 形式的 `@2.2.0`、GitHub 形式的 `#v2.2.0`——会停在原地，直到你用新 pin 重新执行 `plugin add`，或直接修改 `opencode.json(c)` 里的说明符。本地复制的文件则用新版本覆盖旧文件来升级。
 
 ## 卸载
 
@@ -153,6 +153,8 @@ AnySearch 和 Keenable 是例外。两家都有匿名层级，因此始终注册
 
 下表每个 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` 分区 |
@@ -176,6 +178,7 @@ AnySearch 和 Keenable 是例外。两家都有匿名层级，因此始终注册
 | 变量 | 默认值 | 含义 |
 | --- | --- | --- |
 | `<PROVIDER>_CACHE_TTL` | `600000` | 同一条归一化查询可复用响应的毫秒数。`0` 关闭缓存。 |
+| `<PROVIDER>_TIMEOUT` | `25000` | 等待 provider 返回的毫秒数，超时即失败。`0` 取消该期限，但保留取消能力。 |
 
 ### AnySearch
 
@@ -211,6 +214,7 @@ AnySearch 和 Keenable 是例外。两家都有匿名层级，因此始终注册
 | `JINA_INCLUDE_CONTENT` | 关 | `true` 返回每条命中的整页 markdown——上下文和计费 token 都会大幅增加 |
 | `JINA_GL` / `JINA_HL` | — | 国家 / 语言代码 |
 | `JINA_LOCATION` | — | 模拟的城市级来源，例如 `Berlin` |
+| `JINA_TIMEOUT` | `25000`；开启 `JINA_INCLUDE_CONTENT` 时为 `60000` | 唯一一个默认值随模式变化的 provider：抓取整页本来就比取摘要慢得多 |
 
 ### Keenable
 
@@ -272,7 +276,7 @@ AnySearch 和 Keenable 是例外。两家都有匿名层级，因此始终注册
 1. OpenCode 向选定的 provider 发起查询。
 2. 归一化后的查询（去首尾、压缩空白）先查内存缓存；命中则直接返回——重复查询免费且即时。
 3. 未命中时重新解析密钥，因此在 `/connect` 里轮换的 key 立即对下一次搜索生效。
-4. 发出请求；失败时会带上 HTTP 状态码和响应体，让你看到服务方到底说了什么。
+4. 发出请求，且带期限（`<PROVIDER>_TIMEOUT`，默认 25 秒）。OpenCode 自身并不给搜索加任何超时，所以没有这道期限的话，一个接受了连接却不再应答的 provider 会挂住整轮对话。失败时会带上 HTTP 状态码和响应体；如果是超时，报错会直接点明是超时。
 5. 响应经 schema 解码，映射为 `{ url, title, content, time }`，然后写入缓存。
 
 日期解析支持相对表述（`3 hours ago`、`3小时前`）、绝对格式（`Sep 30, 2026`、`31 Mar 2026`）和 ISO 8601。凡是宽松解析会凭空造出错误年份的字符串——比如 `Nov 1`，`Date.parse` 会读成 2001 年——一律丢弃，而不是返回一个错误的时间戳。
@@ -294,6 +298,7 @@ opencode api get "/api/websearch/provider"
 - **某家 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 在绑定和搜索之间消失了。重新连接或重新导出。
+- **搜索报错 `X search timed out after 25000ms`** —— provider 接受了请求，但在期限内没有返回。重试通常就好；如果某家 provider 在你这边一贯偏慢，调大它的 `<PROVIDER>_TIMEOUT`。这道期限是刻意加的：没有它，一个卡住的 provider 会挂住整轮对话，因为 OpenCode 自身并不给搜索设置任何超时。
 - **一切都很慢、或者积分烧得飞快** —— 把 `*_CACHE_TTL` 保持在默认值。时间窗内的重复查询由内存直接返回。
 - **改了插件文件却没反应** —— OpenCode 会监视插件并自动重载；如果没有，执行 `opencode service restart`。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-search-plugin",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "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",

package/plugins/anysearch-search.ts

@@ -73,8 +73,12 @@ function envStr(name: string): string {
 //   ANYSEARCH_ZONE          "cn" or "intl"
 //   ANYSEARCH_LANGUAGE      preferred result language, e.g. "zh-CN"
 //   ANYSEARCH_FORMAT        "markdown" (default) or "json" for the content field
+//   ANYSEARCH_TIMEOUT       ms to wait before failing (0 removes the deadline)
 //   ANYSEARCH_API_KEY       optional; anonymous access works without it
 const CACHE_TTL = envInt("ANYSEARCH_CACHE_TTL", 600_000)
+// OpenCode's own providers each bounded themselves at 25s, and the host adds
+// no deadline of its own around `execute`, so this is the only one that exists.
+const SEARCH_TIMEOUT = envInt("ANYSEARCH_TIMEOUT", 25_000)
 const SEARCH_SIZE = Math.min(Math.max(envInt("ANYSEARCH_MAX_RESULTS", 10), 1), 10)
 const TAG = envStr("ANYSEARCH_TAG")
 const ZONE = envStr("ANYSEARCH_ZONE")
@@ -103,6 +107,14 @@ function writeCache(queryKey: string, results: SearchResult[]): void {
   }
 }
 
+// A hung upstream must not hang the agent: the deadline bounds it, and the
+// thunk's signal carries host cancellation into the socket. `timeout <= 0`
+// removes the deadline but never the cancellation, because
+// `AbortSignal.timeout(0)` aborts instantly rather than "never".
+function timedSignal(signal: AbortSignal, timeout: number): AbortSignal {
+  return timeout > 0 ? AbortSignal.any([signal, AbortSignal.timeout(timeout)]) : signal
+}
+
 // Unlike the other providers in this repo, AnySearch never gates on `bound`:
 // anonymous access is a first-class mode, so the provider is always in the
 // pool. The key is still read per call, which is why no credential-event
@@ -113,7 +125,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,
@@ -159,7 +171,7 @@ export const effect = (ctx: Plugin.Context) =>
             if (key) headers.Authorization = "Bearer " + key
 
             const response = yield* Effect.tryPromise({
-              try: () =>
+              try: (signal) =>
                 fetch("https://api.anysearch.com/v1/search", {
                   method: "POST",
                   headers,
@@ -171,8 +183,14 @@ export const effect = (ctx: Plugin.Context) =>
                     ...(LANGUAGE ? { language: LANGUAGE } : {}),
                     format: FORMAT,
                   }),
+                  signal: timedSignal(signal, SEARCH_TIMEOUT),
                 }),
-              catch: (error) => new Error("AnySearch request failed: " + String(error)),
+              // A timeout is its own failure: naming it stops the user hunting
+              // for a key problem that was never there.
+              catch: (error) =>
+                error instanceof Error && error.name === "TimeoutError"
+                  ? new Error("AnySearch search timed out after " + SEARCH_TIMEOUT + "ms")
+                  : new Error("AnySearch request failed: " + String(error)),
             })
 
             if (!response.ok) {

package/plugins/brave-search.ts

@@ -114,12 +114,17 @@ type SearchResult = ReturnType<typeof toResult>
 //   BRAVE_LANG            result language code, e.g. "en", "zh-hans", "pt-br"
 //   BRAVE_FRESHNESS       "pd" (24h) "pw" (7d) "pm" (31d) "py" (365d) or a
 //                         "YYYY-MM-DDtoYYYY-MM-DD" range
+//   BRAVE_TIMEOUT         ms to wait for Brave before failing (0 removes the
+//                         deadline; cancellation still applies)
 //   BRAVE_SEARCH_API_KEY  required; from https://brave.com/search/api/
 const CACHE_TTL = envInt("BRAVE_CACHE_TTL", 600_000)
 const SEARCH_SIZE = Math.min(Math.max(envInt("BRAVE_NUM", 8), 1), 20)
 const COUNTRY = envStr("BRAVE_COUNTRY")
 const SEARCH_LANG = envStr("BRAVE_LANG")
 const FRESHNESS = envStr("BRAVE_FRESHNESS")
+// OpenCode's own providers each bound themselves at 25s, and the host adds no
+// deadline of its own around `execute`, so this is the only one that exists.
+const SEARCH_TIMEOUT = envInt("BRAVE_TIMEOUT", 25_000)
 
 const CACHE_LIMIT = 200
 const cache = new Map<string, { at: number; results: SearchResult[] }>()
@@ -143,12 +148,20 @@ function writeCache(queryKey: string, results: SearchResult[]): void {
   }
 }
 
+// A hung upstream must not hang the agent: the deadline bounds it, and the
+// thunk's signal carries host cancellation into the socket. `timeout <= 0`
+// removes the deadline but never the cancellation, because
+// `AbortSignal.timeout(0)` aborts instantly rather than "never".
+function timedSignal(signal: AbortSignal, timeout: number): AbortSignal {
+  return timeout > 0 ? AbortSignal.any([signal, AbortSignal.timeout(timeout)]) : signal
+}
+
 export const effect = (ctx: Plugin.Context) =>
   Effect.gen(function* () {
     // 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,
@@ -212,14 +225,20 @@ export const effect = (ctx: Plugin.Context) =>
             if (FRESHNESS) url.searchParams.set("freshness", FRESHNESS)
 
             const response = yield* Effect.tryPromise({
-              try: () =>
+              try: (signal) =>
                 fetch(url, {
                   headers: {
                     Accept: "application/json",
                     "X-Subscription-Token": key,
                   },
+                  signal: timedSignal(signal, SEARCH_TIMEOUT),
                 }),
-              catch: (error) => new Error("Brave request failed: " + String(error)),
+              // A timeout is its own failure: naming it stops the user hunting
+              // for a key problem that was never there.
+              catch: (error) =>
+                error instanceof Error && error.name === "TimeoutError"
+                  ? new Error("Brave search timed out after " + SEARCH_TIMEOUT + "ms")
+                  : new Error("Brave request failed: " + String(error)),
             })
 
             if (!response.ok) {

package/plugins/deepseek-search.ts

@@ -112,8 +112,12 @@ type SearchResult = ReturnType<typeof toResult>
 //
 //   DEEPSEEK_CACHE_TTL   ms to reuse a response for the same query (0 disables)
 //   DEEPSEEK_COUNT       results per search, clamped to 1-50
+//   DEEPSEEK_TIMEOUT     ms to wait before failing (0 removes the deadline)
 //   DEEPSEEK_API_KEY     required; from https://platform.deepseek.com
 const CACHE_TTL = envInt("DEEPSEEK_CACHE_TTL", 600_000)
+// OpenCode's own providers each bounded themselves at 25s, and the host adds
+// no deadline of its own around `execute`, so this is the only one that exists.
+const SEARCH_TIMEOUT = envInt("DEEPSEEK_TIMEOUT", 25_000)
 const COUNT = Math.min(Math.max(envInt("DEEPSEEK_COUNT", 10), 1), 50)
 
 const CACHE_LIMIT = 200
@@ -138,12 +142,20 @@ function writeCache(queryKey: string, results: SearchResult[]): void {
   }
 }
 
+// A hung upstream must not hang the agent: the deadline bounds it, and the
+// thunk's signal carries host cancellation into the socket. `timeout <= 0`
+// removes the deadline but never the cancellation, because
+// `AbortSignal.timeout(0)` aborts instantly rather than "never".
+function timedSignal(signal: AbortSignal, timeout: number): AbortSignal {
+  return timeout > 0 ? AbortSignal.any([signal, AbortSignal.timeout(timeout)]) : signal
+}
+
 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"
+        integration.name = "DeepSeek (osp)"
       })
       editor.method.update({
         integrationID: ID,
@@ -200,7 +212,7 @@ export const effect = (ctx: Plugin.Context) =>
             }
 
             const response = yield* Effect.tryPromise({
-              try: () =>
+              try: (signal) =>
                 fetch("https://api.deepseek.com/v1/tools/search", {
                   method: "POST",
                   headers: {
@@ -212,8 +224,14 @@ export const effect = (ctx: Plugin.Context) =>
                     query: queryKey,
                     count: COUNT,
                   }),
+                  signal: timedSignal(signal, SEARCH_TIMEOUT),
                 }),
-              catch: (error) => new Error("DeepSeek request failed: " + String(error)),
+              // A timeout is its own failure: naming it stops the user hunting
+              // for a key problem that was never there.
+              catch: (error) =>
+                error instanceof Error && error.name === "TimeoutError"
+                  ? new Error("DeepSeek search timed out after " + SEARCH_TIMEOUT + "ms")
+                  : new Error("DeepSeek request failed: " + String(error)),
             })
 
             if (!response.ok) {

package/plugins/jina-search.ts

@@ -77,6 +77,10 @@ function envStr(name: string): string {
 //   JINA_GL              country code for results, e.g. "us", "cn"
 //   JINA_HL              language code for results, e.g. "en", "zh-cn"
 //   JINA_LOCATION        city-level origin to simulate, e.g. "Berlin"
+//   JINA_TIMEOUT         ms to wait before failing (0 removes the deadline).
+//                        Defaults to 25000, or 60000 when JINA_INCLUDE_CONTENT
+//                        is on, because whole-page fetches legitimately take
+//                        far longer than a snippet search
 //   JINA_API_KEY         required; free key at https://jina.ai/?sui=apikey
 const CACHE_TTL = envInt("JINA_CACHE_TTL", 600_000)
 const INCLUDE_CONTENT = envStr("JINA_INCLUDE_CONTENT") === "true"
@@ -84,6 +88,13 @@ const SEARCH_SIZE = Math.min(Math.max(envInt("JINA_NUM", 0), 0), 100)
 const GL = envStr("JINA_GL")
 const HL = envStr("JINA_HL")
 const LOCATION = envStr("JINA_LOCATION")
+// OpenCode's own providers each bounded themselves at 25s, and the host adds
+// no deadline of its own around `execute`, so this is the only one that exists.
+// Jina is the one provider whose default has to vary: asking for page content
+// turns a snippet search into a crawl, and a shared budget would either cut
+// that off or be padded so high that a genuine hang takes a minute to surface.
+const DEFAULT_TIMEOUT = INCLUDE_CONTENT ? 60_000 : 25_000
+const SEARCH_TIMEOUT = envInt("JINA_TIMEOUT", DEFAULT_TIMEOUT)
 
 const CACHE_LIMIT = 200
 const cache = new Map<string, { at: number; results: SearchResult[] }>()
@@ -107,12 +118,20 @@ function writeCache(queryKey: string, results: SearchResult[]): void {
   }
 }
 
+// A hung upstream must not hang the agent: the deadline bounds it, and the
+// thunk's signal carries host cancellation into the socket. `timeout <= 0`
+// removes the deadline but never the cancellation, because
+// `AbortSignal.timeout(0)` aborts instantly rather than "never".
+function timedSignal(signal: AbortSignal, timeout: number): AbortSignal {
+  return timeout > 0 ? AbortSignal.any([signal, AbortSignal.timeout(timeout)]) : signal
+}
+
 export const effect = (ctx: Plugin.Context) =>
   Effect.gen(function* () {
     // 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,
@@ -169,7 +188,7 @@ export const effect = (ctx: Plugin.Context) =>
             }
 
             const response = yield* Effect.tryPromise({
-              try: () =>
+              try: (signal) =>
                 fetch("https://s.jina.ai/", {
                   method: "POST",
                   headers: {
@@ -188,8 +207,14 @@ export const effect = (ctx: Plugin.Context) =>
                     ...(HL ? { hl: HL } : {}),
                     ...(LOCATION ? { location: LOCATION } : {}),
                   }),
+                  signal: timedSignal(signal, SEARCH_TIMEOUT),
                 }),
-              catch: (error) => new Error("Jina request failed: " + String(error)),
+              // A timeout is its own failure: naming it stops the user hunting
+              // for a key problem that was never there.
+              catch: (error) =>
+                error instanceof Error && error.name === "TimeoutError"
+                  ? new Error("Jina search timed out after " + SEARCH_TIMEOUT + "ms")
+                  : new Error("Jina request failed: " + String(error)),
             })
 
             if (!response.ok) {

package/plugins/keenable-search.ts

@@ -122,8 +122,12 @@ function envStr(name: string): string {
 //                         leave unset and the organization's default applies
 //   KEENABLE_TITLE        app name sent as X-Keenable-Title, which the keyless
 //                         endpoint requires to attribute traffic (max 256 chars)
+//   KEENABLE_TIMEOUT      ms to wait before failing (0 removes the deadline)
 //   KEENABLE_API_KEY      optional; keyless access works without it
 const CACHE_TTL = envInt("KEENABLE_CACHE_TTL", 600_000)
+// OpenCode's own providers each bounded themselves at 25s, and the host adds
+// no deadline of its own around `execute`, so this is the only one that exists.
+const SEARCH_TIMEOUT = envInt("KEENABLE_TIMEOUT", 25_000)
 const SEARCH_SIZE = Math.min(Math.max(envInt("KEENABLE_MAX_RESULTS", 10), 1), 50)
 const MODE = envStr("KEENABLE_MODE")
 const TITLE = (envStr("KEENABLE_TITLE") || "opencode-search-plugin").slice(0, 256)
@@ -153,6 +157,14 @@ function writeCache(queryKey: string, results: SearchResult[]): void {
   }
 }
 
+// A hung upstream must not hang the agent: the deadline bounds it, and the
+// thunk's signal carries host cancellation into the socket. `timeout <= 0`
+// removes the deadline but never the cancellation, because
+// `AbortSignal.timeout(0)` aborts instantly rather than "never".
+function timedSignal(signal: AbortSignal, timeout: number): AbortSignal {
+  return timeout > 0 ? AbortSignal.any([signal, AbortSignal.timeout(timeout)]) : signal
+}
+
 // Unlike the key-requiring providers in this repo, Keenable never gates on
 // `bound`: keyless access is a first-class mode, so the provider is always in
 // the pool. The key is still read per call, which is why no credential-event
@@ -163,7 +175,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,
@@ -213,7 +225,7 @@ export const effect = (ctx: Plugin.Context) =>
             if (key) headers["X-API-Key"] = key
 
             const response = yield* Effect.tryPromise({
-              try: () =>
+              try: (signal) =>
                 fetch(key ? SEARCH_URL : PUBLIC_URL, {
                   method: "POST",
                   headers,
@@ -222,8 +234,14 @@ export const effect = (ctx: Plugin.Context) =>
                     max_results: SEARCH_SIZE,
                     ...(MODE ? { mode: MODE } : {}),
                   }),
+                  signal: timedSignal(signal, SEARCH_TIMEOUT),
                 }),
-              catch: (error) => new Error("Keenable request failed: " + String(error)),
+              // A timeout is its own failure: naming it stops the user hunting
+              // for a key problem that was never there.
+              catch: (error) =>
+                error instanceof Error && error.name === "TimeoutError"
+                  ? new Error("Keenable search timed out after " + SEARCH_TIMEOUT + "ms")
+                  : new Error("Keenable request failed: " + String(error)),
             })
 
             if (!response.ok) {

package/plugins/linkup-search.ts

@@ -54,8 +54,12 @@ function envStr(name: string): string {
 //                        vendor's recommended default for agents), "standard"
 //                        (single agentic pass) or "deep" (several iterations)
 //   LINKUP_MAX_RESULTS   results per search, clamped to 1-100
+//   LINKUP_TIMEOUT       ms to wait before failing (0 removes the deadline)
 //   LINKUP_API_KEY       required; from https://app.linkup.so
 const CACHE_TTL = envInt("LINKUP_CACHE_TTL", 600_000)
+// OpenCode's own providers each bounded themselves at 25s, and the host adds
+// no deadline of its own around `execute`, so this is the only one that exists.
+const SEARCH_TIMEOUT = envInt("LINKUP_TIMEOUT", 25_000)
 const SEARCH_SIZE = Math.min(Math.max(envInt("LINKUP_MAX_RESULTS", 10), 1), 100)
 const DEPTH = ["flash", "fast", "standard", "deep"].includes(envStr("LINKUP_DEPTH"))
   ? envStr("LINKUP_DEPTH")
@@ -83,12 +87,20 @@ function writeCache(queryKey: string, results: SearchResult[]): void {
   }
 }
 
+// A hung upstream must not hang the agent: the deadline bounds it, and the
+// thunk's signal carries host cancellation into the socket. `timeout <= 0`
+// removes the deadline but never the cancellation, because
+// `AbortSignal.timeout(0)` aborts instantly rather than "never".
+function timedSignal(signal: AbortSignal, timeout: number): AbortSignal {
+  return timeout > 0 ? AbortSignal.any([signal, AbortSignal.timeout(timeout)]) : signal
+}
+
 export const effect = (ctx: Plugin.Context) =>
   Effect.gen(function* () {
     // 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,
@@ -145,7 +157,7 @@ export const effect = (ctx: Plugin.Context) =>
             }
 
             const response = yield* Effect.tryPromise({
-              try: () =>
+              try: (signal) =>
                 fetch("https://api.linkup.so/v1/search", {
                   method: "POST",
                   headers: {
@@ -159,8 +171,14 @@ export const effect = (ctx: Plugin.Context) =>
                     outputType: "searchResults",
                     maxResults: SEARCH_SIZE,
                   }),
+                  signal: timedSignal(signal, SEARCH_TIMEOUT),
                 }),
-              catch: (error) => new Error("Linkup request failed: " + String(error)),
+              // A timeout is its own failure: naming it stops the user hunting
+              // for a key problem that was never there.
+              catch: (error) =>
+                error instanceof Error && error.name === "TimeoutError"
+                  ? new Error("Linkup search timed out after " + SEARCH_TIMEOUT + "ms")
+                  : new Error("Linkup request failed: " + String(error)),
             })
 
             if (!response.ok) {

package/plugins/metaso-search.ts

@@ -111,8 +111,12 @@ type SearchResult = ReturnType<typeof toResult>
 //   METASO_INCLUDE_RAW_CONTENT  true returns the full source text of every hit: same
 //                               search cost, far more context tokens. Only worth it
 //                               when you would otherwise webfetch those hits anyway.
+//   METASO_TIMEOUT              ms to wait before failing (0 removes the deadline)
 //   METASO_API_KEY              required; from https://metaso.cn
 const CACHE_TTL = envInt("METASO_CACHE_TTL", 600_000)
+// OpenCode's own providers each bounded themselves at 25s, and the host adds
+// no deadline of its own around `execute`, so this is the only one that exists.
+const SEARCH_TIMEOUT = envInt("METASO_TIMEOUT", 25_000)
 const SEARCH_SIZE = Math.min(Math.max(envInt("METASO_SEARCH_SIZE", 20), 1), 100)
 const INCLUDE_RAW_CONTENT = envStr("METASO_INCLUDE_RAW_CONTENT") === "true"
 
@@ -138,12 +142,20 @@ function writeCache(queryKey: string, results: SearchResult[]): void {
   }
 }
 
+// A hung upstream must not hang the agent: the deadline bounds it, and the
+// thunk's signal carries host cancellation into the socket. `timeout <= 0`
+// removes the deadline but never the cancellation, because
+// `AbortSignal.timeout(0)` aborts instantly rather than "never".
+function timedSignal(signal: AbortSignal, timeout: number): AbortSignal {
+  return timeout > 0 ? AbortSignal.any([signal, AbortSignal.timeout(timeout)]) : signal
+}
+
 export const effect = (ctx: Plugin.Context) =>
   Effect.gen(function* () {
     // 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,
@@ -200,7 +212,7 @@ export const effect = (ctx: Plugin.Context) =>
             }
 
             const response = yield* Effect.tryPromise({
-              try: () =>
+              try: (signal) =>
                 fetch("https://metaso.cn/api/v1/search", {
                   method: "POST",
                   headers: {
@@ -216,8 +228,14 @@ export const effect = (ctx: Plugin.Context) =>
                     includeRawContent: INCLUDE_RAW_CONTENT,
                     conciseSnippet: true,
                   }),
+                  signal: timedSignal(signal, SEARCH_TIMEOUT),
                 }),
-              catch: (error) => new Error("Metaso request failed: " + String(error)),
+              // A timeout is its own failure: naming it stops the user hunting
+              // for a key problem that was never there.
+              catch: (error) =>
+                error instanceof Error && error.name === "TimeoutError"
+                  ? new Error("Metaso search timed out after " + SEARCH_TIMEOUT + "ms")
+                  : new Error("Metaso request failed: " + String(error)),
             })
 
             if (!response.ok) {

package/plugins/querit-search.ts

@@ -122,8 +122,12 @@ type SearchResult = ReturnType<typeof toResult>
 //
 //   QUERIT_CACHE_TTL   ms to reuse a response for the same query (0 disables)
 //   QUERIT_COUNT       results per search; Querit's own limit applies
+//   QUERIT_TIMEOUT     ms to wait before failing (0 removes the deadline)
 //   QUERIT_API_KEY     required; from https://querit.ai
 const CACHE_TTL = envInt("QUERIT_CACHE_TTL", 600_000)
+// OpenCode's own providers each bounded themselves at 25s, and the host adds
+// no deadline of its own around `execute`, so this is the only one that exists.
+const SEARCH_TIMEOUT = envInt("QUERIT_TIMEOUT", 25_000)
 const SEARCH_SIZE = envInt("QUERIT_COUNT", 8)
 
 const CACHE_LIMIT = 200
@@ -148,12 +152,20 @@ function writeCache(queryKey: string, results: SearchResult[]): void {
   }
 }
 
+// A hung upstream must not hang the agent: the deadline bounds it, and the
+// thunk's signal carries host cancellation into the socket. `timeout <= 0`
+// removes the deadline but never the cancellation, because
+// `AbortSignal.timeout(0)` aborts instantly rather than "never".
+function timedSignal(signal: AbortSignal, timeout: number): AbortSignal {
+  return timeout > 0 ? AbortSignal.any([signal, AbortSignal.timeout(timeout)]) : signal
+}
+
 export const effect = (ctx: Plugin.Context) =>
   Effect.gen(function* () {
     // 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,
@@ -210,7 +222,7 @@ export const effect = (ctx: Plugin.Context) =>
             }
 
             const response = yield* Effect.tryPromise({
-              try: () =>
+              try: (signal) =>
                 fetch("https://api.querit.ai/v1/search", {
                   method: "POST",
                   headers: {
@@ -219,8 +231,14 @@ export const effect = (ctx: Plugin.Context) =>
                     Authorization: "Bearer " + key,
                   },
                   body: JSON.stringify({ query: queryKey, count: SEARCH_SIZE }),
+                  signal: timedSignal(signal, SEARCH_TIMEOUT),
                 }),
-              catch: (error) => new Error("Querit request failed: " + String(error)),
+              // A timeout is its own failure: naming it stops the user hunting
+              // for a key problem that was never there.
+              catch: (error) =>
+                error instanceof Error && error.name === "TimeoutError"
+                  ? new Error("Querit search timed out after " + SEARCH_TIMEOUT + "ms")
+                  : new Error("Querit request failed: " + String(error)),
             })
 
             if (!response.ok) {

package/plugins/serpapi-search.ts

@@ -111,11 +111,15 @@ type SearchResult = ReturnType<typeof toResult>
 //   SERPAPI_GL         country code for results, e.g. "us", "cn"
 //   SERPAPI_HL         language code for results, e.g. "en", "zh-cn"
 //   SERPAPI_TBS        advanced filters, e.g. "qdr:d" (past day), "qdr:y"
+//   SERPAPI_TIMEOUT    ms to wait before failing (0 removes the deadline)
 //   SERPAPI_API_KEY    required; from https://serpapi.com
 //
 // There is deliberately no result-count knob: Google withdrew the `num`
 // parameter, so SerpApi cannot honour one and a count would be a lie.
 const CACHE_TTL = envInt("SERPAPI_CACHE_TTL", 600_000)
+// OpenCode's own providers each bounded themselves at 25s, and the host adds
+// no deadline of its own around `execute`, so this is the only one that exists.
+const SEARCH_TIMEOUT = envInt("SERPAPI_TIMEOUT", 25_000)
 const GL = envStr("SERPAPI_GL")
 const HL = envStr("SERPAPI_HL")
 const TBS = envStr("SERPAPI_TBS")
@@ -142,12 +146,20 @@ function writeCache(queryKey: string, results: SearchResult[]): void {
   }
 }
 
+// A hung upstream must not hang the agent: the deadline bounds it, and the
+// thunk's signal carries host cancellation into the socket. `timeout <= 0`
+// removes the deadline but never the cancellation, because
+// `AbortSignal.timeout(0)` aborts instantly rather than "never".
+function timedSignal(signal: AbortSignal, timeout: number): AbortSignal {
+  return timeout > 0 ? AbortSignal.any([signal, AbortSignal.timeout(timeout)]) : signal
+}
+
 export const effect = (ctx: Plugin.Context) =>
   Effect.gen(function* () {
     // 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,
@@ -212,13 +224,19 @@ export const effect = (ctx: Plugin.Context) =>
             if (TBS) url.searchParams.set("tbs", TBS)
 
             const response = yield* Effect.tryPromise({
-              try: () =>
+              try: (signal) =>
                 fetch(url, {
                   headers: {
                     Accept: "application/json",
                   },
+                  signal: timedSignal(signal, SEARCH_TIMEOUT),
                 }),
-              catch: (error) => new Error("SerpApi request failed: " + String(error)),
+              // A timeout is its own failure: naming it stops the user hunting
+              // for a key problem that was never there.
+              catch: (error) =>
+                error instanceof Error && error.name === "TimeoutError"
+                  ? new Error("SerpApi search timed out after " + SEARCH_TIMEOUT + "ms")
+                  : new Error("SerpApi request failed: " + String(error)),
             })
 
             if (!response.ok) {

package/plugins/serper-search.ts

@@ -112,8 +112,12 @@ type SearchResult = ReturnType<typeof toResult>
 //   SERPER_HL          language code for results, e.g. "en", "zh-cn"
 //   SERPER_TBS         time filter: "qdr:h" (hour) "qdr:d" (day) "qdr:w" (week)
 //                      "qdr:m" (month) "qdr:y" (year)
+//   SERPER_TIMEOUT     ms to wait before failing (0 removes the deadline)
 //   SERPER_API_KEY     required; from https://serper.dev
 const CACHE_TTL = envInt("SERPER_CACHE_TTL", 600_000)
+// OpenCode's own providers each bounded themselves at 25s, and the host adds
+// no deadline of its own around `execute`, so this is the only one that exists.
+const SEARCH_TIMEOUT = envInt("SERPER_TIMEOUT", 25_000)
 const SEARCH_SIZE = Math.min(Math.max(envInt("SERPER_NUM", 10), 1), 100)
 const GL = envStr("SERPER_GL")
 const HL = envStr("SERPER_HL")
@@ -141,12 +145,20 @@ function writeCache(queryKey: string, results: SearchResult[]): void {
   }
 }
 
+// A hung upstream must not hang the agent: the deadline bounds it, and the
+// thunk's signal carries host cancellation into the socket. `timeout <= 0`
+// removes the deadline but never the cancellation, because
+// `AbortSignal.timeout(0)` aborts instantly rather than "never".
+function timedSignal(signal: AbortSignal, timeout: number): AbortSignal {
+  return timeout > 0 ? AbortSignal.any([signal, AbortSignal.timeout(timeout)]) : signal
+}
+
 export const effect = (ctx: Plugin.Context) =>
   Effect.gen(function* () {
     // 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,
@@ -203,7 +215,7 @@ export const effect = (ctx: Plugin.Context) =>
             }
 
             const response = yield* Effect.tryPromise({
-              try: () =>
+              try: (signal) =>
                 fetch("https://google.serper.dev/search", {
                   method: "POST",
                   headers: {
@@ -218,8 +230,14 @@ export const effect = (ctx: Plugin.Context) =>
                     ...(HL ? { hl: HL } : {}),
                     ...(TBS ? { tbs: TBS } : {}),
                   }),
+                  signal: timedSignal(signal, SEARCH_TIMEOUT),
                 }),
-              catch: (error) => new Error("Serper request failed: " + String(error)),
+              // A timeout is its own failure: naming it stops the user hunting
+              // for a key problem that was never there.
+              catch: (error) =>
+                error instanceof Error && error.name === "TimeoutError"
+                  ? new Error("Serper search timed out after " + SEARCH_TIMEOUT + "ms")
+                  : new Error("Serper request failed: " + String(error)),
             })
 
             if (!response.ok) {

package/plugins/youcom-search.ts

@@ -140,8 +140,12 @@ type SearchResult = ReturnType<typeof toResult>
 //   YOUCOM_LANGUAGE      result language, e.g. "EN", "ZH-HANS"
 //   YOUCOM_COUNTRY       geographic focus, e.g. "US", "CN"
 //   YOUCOM_FRESHNESS     "day" | "week" | "month" | "year" or "YYYY-MM-DDtoYYYY-MM-DD"
+//   YOUCOM_TIMEOUT       ms to wait before failing (0 removes the deadline)
 //   YDC_API_KEY          required; You.com's canonical env var, shared with its SDKs
 const CACHE_TTL = envInt("YOUCOM_CACHE_TTL", 600_000)
+// OpenCode's own providers each bounded themselves at 25s, and the host adds
+// no deadline of its own around `execute`, so this is the only one that exists.
+const SEARCH_TIMEOUT = envInt("YOUCOM_TIMEOUT", 25_000)
 const SEARCH_SIZE = Math.min(Math.max(envInt("YOUCOM_COUNT", 10), 1), 100)
 const EXTRACTION = ["none", "highlights", "full_page"].includes(envStr("YOUCOM_EXTRACTION"))
   ? envStr("YOUCOM_EXTRACTION")
@@ -172,12 +176,20 @@ function writeCache(queryKey: string, results: SearchResult[]): void {
   }
 }
 
+// A hung upstream must not hang the agent: the deadline bounds it, and the
+// thunk's signal carries host cancellation into the socket. `timeout <= 0`
+// removes the deadline but never the cancellation, because
+// `AbortSignal.timeout(0)` aborts instantly rather than "never".
+function timedSignal(signal: AbortSignal, timeout: number): AbortSignal {
+  return timeout > 0 ? AbortSignal.any([signal, AbortSignal.timeout(timeout)]) : signal
+}
+
 export const effect = (ctx: Plugin.Context) =>
   Effect.gen(function* () {
     // 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,
@@ -244,7 +256,7 @@ export const effect = (ctx: Plugin.Context) =>
                   : undefined
 
             const response = yield* Effect.tryPromise({
-              try: () =>
+              try: (signal) =>
                 fetch("https://ydc-index.io/v1/search", {
                   method: "POST",
                   headers: {
@@ -260,8 +272,14 @@ export const effect = (ctx: Plugin.Context) =>
                     ...(FRESHNESS ? { freshness: FRESHNESS } : {}),
                     ...(extraction ? { extraction } : {}),
                   }),
+                  signal: timedSignal(signal, SEARCH_TIMEOUT),
                 }),
-              catch: (error) => new Error("You.com request failed: " + String(error)),
+              // A timeout is its own failure: naming it stops the user hunting
+              // for a key problem that was never there.
+              catch: (error) =>
+                error instanceof Error && error.name === "TimeoutError"
+                  ? new Error("You.com search timed out after " + SEARCH_TIMEOUT + "ms")
+                  : new Error("You.com request failed: " + String(error)),
             })
 
             if (!response.ok) {