dsh-web-search-plugin 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,54 @@
+# Changelog
+
+All notable changes to this project are documented here. The format is based
+on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
+adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.1] - 2026-08-19
+
+### Added
+
+- **GitHub Actions publishing** (`.github/workflows/publish.yml`): pushing a
+  `v*` tag publishes to npm with provenance; `ci.yml` runs the syntax checks
+  and a pack dry-run on every push/PR.
+
+### Fixed
+
+- **Client bundle: missing `exports.inject`** (`lib/client.js`). The browser
+  plugin only exported `apply`, so cordis had an empty `fiber.inject` and any
+  `ctx.*` service access (e.g. `ctx.locale`) threw
+  `cannot get property "locale" without inject`. Now exports
+  `inject = ["slots", "locale", "connection", "remote", "settingsScope"]`.
+- **Plugin-card slot registration** (`lib/client.js`). The card registered into
+  `settings.plugin.item` with the rc.6 `id`/`order` shape; the slot is keyed
+  since rc.6+ and requires `key: "dsh-web-search-plugin"`.
+- **`CardForm.field("apiKey")` crash** (`lib/client.js`). The write-only
+  credential field has no section spec; `spec.format(...)` on `undefined`
+  threw `Cannot read properties of undefined (reading 'format')` during the
+  card projection. Added the secret-field branch (mirroring the official
+  `CardForm`).
+- **`dsh.client.inject` now includes `@deepseek-ai/dsh-client-ui-slots`**
+  (`package.json`), matching the load set used by community plugins.
+
+### Changed
+
+- No longer requires the `dsh-host-apiproxy` settings-namespace allowlist
+  patch that rc.6 needed: rc.7's `settings.describe()` exposes registered
+  namespaces dynamically.
+- **Renamed to `dsh-web-search-plugin`**: the package name (matching the
+  repository name); the plugin id, settings namespace and card key were
+  renamed in lockstep so a single identity is used everywhere. No version
+  has shipped yet, so the rename carries no migration cost.
+
+## [0.1.0] - 2026-08-19
+
+### Added
+
+- Initial release: `TavilySearchProvider` (`id: "tavily"`) registered into
+  `ctx.web`, with `dsh-web-search-plugin` settings section.
+- Keyless mode (`X-Tavily-Access-Mode: keyless`) and keyed mode
+  (Bearer token via `TAVILY_API_KEY` credential reference).
+- Browser configuration card for the DSH plugin configuration surface.
+
+[0.1.1]: https://github.com/X-C1811/dsh-web-search-plugin/compare/v0.1.0...v0.1.1
+[0.1.0]: https://github.com/X-C1811/dsh-web-search-plugin/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dsh-web-search-plugin contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,119 @@
+# dsh-web-search-plugin
+
+A [Tavily](https://tavily.com)-backed web search provider for the [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) web capability seam (`ctx.web`). It registers a `WebSearchProvider` under the stable id `tavily`, so the model-facing `web_search` tool runs against Tavily instead of the built-in DeepSeek search endpoint — with or without an API key.
+
+- **Keyless mode (default)** — free and rate-limited; no account or API key required. Activated by a single `X-Tavily-Access-Mode: keyless` request header.
+- **Keyed mode** — uses a Tavily API key resolved from the `TAVILY_API_KEY` credential / launch-environment reference (or a literal `apiKey`), sent as a Bearer token.
+- **UI-configurable** — ships a configuration card in the DSH web settings (Settings → Plugins → Plugin configuration → Web search (Tavily)) to switch modes and edit options live.
+
+## Features
+
+- Implements the same provider contract as the official `@deepseek-ai/dsh-web-search-deepseek` plugin: `inject: ['web']` + `installSettingsSection` + `ctx.web.registerSearchProvider`.
+- Zero-config keyless search works out of the box; switch to an API key in one click for higher limits.
+- Normalizes Tavily's `answer` into the result `content` and `results[]` into citeable `sources[]` (url, title, snippet, published date), deduplicated by URL.
+- Settings section `dsh-web-search-plugin` is exposed dynamically through rc.7's `settings.describe()` — no host allowlist patch required.
+- Maps provider errors and caller cancellation to the seam's `WEB_PROVIDER_ERROR` / `WEB_ABORTED` codes; credentials are resolved per search, so a key stored or rotated in the web credentials domain applies to the next search without a restart.
+
+## Requirements
+
+- DeepSeek Harness `0.1.0-rc.7` or newer (keyed plugin slots and dynamic settings exposure)
+- pnpm, for installing plugins into a profile via `dsh plugin`
+
+## Install
+
+### From npm
+
+```powershell
+dsh plugin --profile web add dsh-web-search-plugin
+```
+
+### From a local checkout
+
+```powershell
+dsh plugin --profile web add "path/to/dsh-web-search-plugin"
+```
+
+Then route the web seam to the Tavily provider and enable the plugin in `%USERPROFILE%\.dsh\profiles\web\cordis.patch.yml`:
+
+```yaml
+# Replaces the base `web` config, which pins `searchProvider: deepseek-official`.
+- id: web
+  name: '@deepseek-ai/dsh-web'
+  config:
+    searchProvider: tavily
+
+- insert:
+    - id: dsh-web-search-plugin
+      name: dsh-web-search-plugin
+      config:
+        mode: keyless
+```
+
+Restart the DSH web process; the browser picks up the plugin's client bundle on the next page refresh.
+
+> **Note on `file:` (local) installs** — pnpm treats a `file:path` dependency as a snapshot: changes made to the source directory are **not** propagated into the profile's `node_modules` automatically. After editing the plugin, re-run `dsh plugin --profile web add "path/to/dsh-web-search-plugin"` (or copy the files over) and restart.
+
+## Configuration
+
+The settings card (Settings → Plugins → Plugin configuration → Web search (Tavily)) edits the `dsh-web-search-plugin` namespace:
+
+| Key | Default | Meaning |
+|---|---|---|
+| `mode` | `keyless` | `keyless` (free, rate-limited) or `keyed` (Tavily API key) |
+| `apiKey` | — | Literal Tavily API key (never echoed back; stored via the credentials domain) |
+| `apiKeyEnv` | `TAVILY_API_KEY` | Credential/env reference resolved on each keyed search |
+| `baseURL` | `https://api.tavily.com` | Tavily REST base URL; `/search` is appended |
+| `maxResults` | `8` | Sources per search (1–20) |
+| `searchDepth` | `basic` | `basic` (faster) or `advanced` (deeper) |
+| `includeAnswer` | `true` | Request Tavily's generated answer; surfaced as the result `content` |
+| `topic` | `general` | `general` or `news` |
+
+Environment overrides: `DSH_WEB_SEARCH_PROVIDER=tavily` selects this provider at boot; the plugin's base URL falls back to `$TAVILY_BASE_URL` when `baseURL` is unset.
+
+## Switching back to the built-in search
+
+Change `searchProvider` back to `deepseek-official` in the profile patch. The plugin may stay registered; it is then simply not selected.
+
+## How it works
+
+- One `POST https://api.tavily.com/search` per search; keyless requests send `x-tavily-access-mode: keyless`, keyed requests send `authorization: Bearer <key>`.
+- Non-2xx responses become `WEB_PROVIDER_ERROR` (Tavily's `detail.error` text is preserved); caller cancellation becomes `WEB_ABORTED`.
+
+## Repository layout
+
+```
+lib/index.js    Host plugin: schemastery Config, TavilySearchProvider, settings section
+lib/client.js   Browser bundle (window.__ModuleLoader__.load): the configuration card
+```
+
+## Development
+
+```powershell
+node --check lib/index.js
+node --check lib/client.js
+```
+
+The client bundle must stay in the `window.__ModuleLoader__.load({ id, factory })` wire format — it is loaded by `dsh-client-modules`, not by a bundler. It must export **both** `apply` and `inject` (the array of cordis service names it reads: `slots`, `locale`, `connection`, `remote`, `settingsScope`) and register its card into the keyed `settings.plugin.item` slot with a `key`.
+
+## Publishing
+
+Releases are published automatically by GitHub Actions (`.github/workflows/publish.yml`): **pushing a `v*` tag** (e.g. `v0.1.1`) publishes the package to npm with provenance. Plain pushes to `main` never publish.
+
+1. Make sure `package.json` `version` matches the tag you are about to push (e.g. `0.1.1` → `v0.1.1`).
+2. On GitHub, set an npm automation token (publish permission) as the `NPM_TOKEN` repository secret under **Settings → Secrets and variables → Actions**, and allow workflow runs under **Settings → Actions**.
+3. Tag and push:
+
+   ```powershell
+   git tag v0.1.1
+   git push origin v0.1.1
+   ```
+
+The workflow verifies the tag against `package.json` `version` before publishing (`npm publish --provenance --access public`), so an accidental mismatch fails fast instead of shipping the wrong version. Users can then install with `dsh plugin --profile web add dsh-web-search-plugin`.
+
+## Contributing
+
+Issues and pull requests are welcome. See the [issue tracker](https://github.com/X-C1811/dsh-web-search-plugin/issues) for known limitations and the roadmap; the provider is shaped so additional search APIs can be added beside Tavily.
+
+## License
+
+[MIT](LICENSE)

package/lib/client.js

@@ -0,0 +1,451 @@
+/**
+ * Browser half of `dsh-web-search-plugin`: a plugin card under the
+ * "settings → Plugins → Plugin configuration" surface that edits the
+ * `dsh-web-search-plugin` settings namespace and its `TAVILY_API_KEY` credential.
+ *
+ * This bundle is a self-contained hand-written module in the exact wire format
+ * the client module system expects: one `window.__ModuleLoader__.load` call
+ * whose factory registers a Cordis plugin through `exports.apply`. It mirrors
+ * the official `dsh-client-ui-settings-plugins` cards (staged edits, save
+ * writes once, credential written through the credentials domain) without
+ * depending on that package's internal `CardForm`.
+ *
+ * @module dsh-web-search-plugin/client
+ */
+window.__ModuleLoader__.load({
+	id: "dsh-web-search-plugin",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let react = require("react");
+		let _deepseek_ai_dsh_client_runtime_client = require("@deepseek-ai/dsh-client-runtime/client");
+
+		/** Settings namespace of the Tavily search provider. */
+		const NS = "dsh-web-search-plugin";
+		/** Credential reference the provider resolves when the section names none. */
+		const DEFAULT_API_KEY_REF = "TAVILY_API_KEY";
+		/** Form field the credential control stages under. */
+		const API_KEY_FIELD = "apiKey";
+
+		/** Locale bundles for the card. */
+		const en = {
+			nav: "Web search (Tavily)",
+			description: "The Tavily search provider. Keyless by default; switch to keyed and add a Tavily API key for higher limits.",
+			mode: "Auth mode",
+			modeKeyless: "Keyless (free, rate-limited)",
+			modeKeyed: "API key",
+			apiKey: "API key",
+			apiKeyHint: "Stored outside the settings file. Leave blank to keep the current key.",
+			apiKeySet: "A key is configured.",
+			apiKeyUnset: "No key is configured; keyed search is unavailable until one is.",
+			apiKeyEnv: "Credential reference",
+			apiKeyEnvHint: "Name of the credential/env var resolved for keyed search.",
+			baseURL: "Endpoint",
+			baseURLHint: "Leave blank to use the provider default.",
+			maxResults: "Max results",
+			maxResultsHint: "Sources returned per search (1-20).",
+			searchDepth: "Search depth",
+			searchDepthBasic: "Basic (faster)",
+			searchDepthAdvanced: "Advanced (slower, deeper)",
+			includeAnswer: "Include answer",
+			includeAnswerHint: "Request Tavily's generated answer text shown above the sources.",
+			topic: "Topic",
+			topicGeneral: "General",
+			topicNews: "News",
+			expand: "Show settings",
+			collapse: "Hide settings",
+			save: "Save",
+			saving: "Saving…",
+			discard: "Discard",
+			unsaved: "Unsaved",
+			saveFailed: "The deployment did not accept these values; they were left for you to correct.",
+			readOnly: "This deployment stores settings read-only.",
+			invalidNumber: "Enter a number, or leave blank to use the default."
+		};
+		/** Simplified Chinese copy. */
+		const zh = {
+			nav: "网页搜索（Tavily）",
+			description: "Tavily 搜索提供方。默认 keyless 免费使用；切换到 API key 并填入 Tavily key 可提高限额。",
+			mode: "认证模式",
+			modeKeyless: "Keyless（免费、限流）",
+			modeKeyed: "API key",
+			apiKey: "API Key",
+			apiKeyHint: "不写入设置文件。留空表示保持当前密钥。",
+			apiKeySet: "已配置密钥。",
+			apiKeyUnset: "未配置密钥；keyed 模式下搜索不可用。",
+			apiKeyEnv: "凭据引用名",
+			apiKeyEnvHint: "keyed 模式解析的凭据/环境变量名。",
+			baseURL: "接口地址",
+			baseURLHint: "留空则使用提供方默认地址。",
+			maxResults: "结果数量",
+			maxResultsHint: "每次搜索返回的源数量（1-20）。",
+			searchDepth: "搜索深度",
+			searchDepthBasic: "Basic（较快）",
+			searchDepthAdvanced: "Advanced（较慢、更深）",
+			includeAnswer: "包含摘要回答",
+			includeAnswerHint: "请求 Tavily 生成摘要回答，显示在结果上方。",
+			topic: "主题",
+			topicGeneral: "通用",
+			topicNews: "新闻",
+			expand: "展开设置",
+			collapse: "收起设置",
+			save: "保存",
+			saving: "保存中…",
+			discard: "放弃修改",
+			unsaved: "未保存",
+			saveFailed: "本部署没有接受这些值，已保留供你修改。",
+			readOnly: "本部署的设置为只读。",
+			invalidNumber: "请填数字；留空表示使用默认值。"
+		};
+
+		/** A whole-number field spec: empty draft clears, any other invalid draft blocks save. */
+		function numberField(field) {
+			return {
+				field,
+				format: (value) => typeof value === "number" ? String(value) : "",
+				parse: (text) => {
+					const trimmed = text.trim();
+					if (trimmed === "") return { kind: "clear" };
+					const parsed = Number(trimmed);
+					return Number.isFinite(parsed) ? { kind: "set", value: parsed } : void 0;
+				}
+			};
+		}
+		/** A free-text field spec: empty draft clears. */
+		function textField(field) {
+			return {
+				field,
+				format: (value) => typeof value === "string" ? value : "",
+				parse: (text) => {
+					const trimmed = text.trim();
+					return trimmed === "" ? { kind: "clear" } : { kind: "set", value: trimmed };
+				}
+			};
+		}
+		/** A choice field spec (mode/searchDepth/topic): staged as its raw string. */
+		function choiceField(field) {
+			return {
+				field,
+				format: (value) => typeof value === "string" ? value : "",
+				parse: (text) => text.trim() === "" ? { kind: "clear" } : { kind: "set", value: text.trim() }
+			};
+		}
+		/** A boolean field spec: a checkbox draft sets or clears. */
+		function booleanField(field) {
+			return {
+				field,
+				format: (value) => value === true ? "true" : "",
+				parse: (text) => text === "true" ? { kind: "set", value: true } : { kind: "clear" }
+			};
+		}
+
+		/**
+		 * Staged form over the `dsh-web-search-plugin` settings namespace. Modeled on
+		 * the official cards' `CardForm` contract: a draft map, save writes every
+		 * staged edit once, and the API key is written through the credentials
+		 * domain addressed by the reference the section names.
+		 */
+		var TavilyCardForm = class {
+			constructor(scope, api) {
+				this.scope = scope;
+				this.api = api;
+				this.specs = new Map([numberField("maxResults"), textField("apiKeyEnv"), textField("baseURL"), choiceField("mode"), choiceField("searchDepth"), choiceField("topic"), booleanField("includeAnswer")].map((spec) => [spec.field, spec]));
+				this.staged = new Map();
+				this.saving = false;
+				this.failed = false;
+				this.credential = { ref: "", configured: false, writable: true };
+				this.listeners = new Set();
+				scope.subscribe(() => {
+					this.publish();
+				});
+				this.readCredential();
+			}
+			bind(project) {
+				const store = (0, _deepseek_ai_dsh_client_runtime_client.createSnapshotStore)(project());
+				this.listeners.add(() => {
+					store.set(project());
+				});
+				return store;
+			}
+			shell() {
+				const snapshot = this.scope.getSnapshot();
+				const plan = this.plan();
+				return {
+					available: snapshot.status === "ready",
+					writable: snapshot.writable,
+					dirty: plan.length > 0,
+					invalid: plan.some((item) => item.run === void 0),
+					saving: this.saving,
+					failed: this.failed
+				};
+			}
+			field(field) {
+				const staged = this.staged.get(field);
+				// Write-only credential controls have no section spec; they
+				// report only their staged draft (mirroring the official
+				// cards' secret-field branch in CardForm.field).
+				if (field === API_KEY_FIELD) return {
+					text: staged?.text ?? "",
+					overridden: false,
+					invalid: false
+				};
+				const spec = this.specs.get(field);
+				if (staged === void 0) return {
+					text: spec.format(this.sectionValue(field)),
+					overridden: this.stored(field),
+					invalid: false
+				};
+				const write = staged.clear ? { kind: "clear" } : spec.parse(staged.text);
+				return {
+					text: staged.text,
+					overridden: write?.kind === "set",
+					invalid: write === void 0
+				};
+			}
+			plan() {
+				const plan = [];
+				for (const [field, staged] of this.staged) {
+					if (field === API_KEY_FIELD) {
+						const value = staged.text.trim();
+						if (value !== "") plan.push({ field, run: () => this.writeKey(value) });
+						continue;
+					}
+					const spec = this.specs.get(field);
+					if (staged.clear) {
+						if (this.stored(field)) plan.push({ field, run: () => this.clear(field) });
+						continue;
+					}
+					if (staged.text === spec.format(this.sectionValue(field))) continue;
+					const write = spec.parse(staged.text);
+					if (write === void 0) plan.push({ field, run: void 0 });
+					else if (write.kind === "clear") plan.push({ field, run: () => this.clear(field) });
+					else plan.push({ field, run: () => this.store(field, write.value) });
+				}
+				return plan;
+			}
+			async save() {
+				const plan = this.plan();
+				const writes = plan.flatMap((item) => item.run === void 0 ? [] : [item.run]);
+				if (plan.length === 0 || this.saving || writes.length !== plan.length) return;
+				this.saving = true;
+				this.failed = false;
+				this.publish();
+				let landed = true;
+				for (const write of writes) landed = await write() && landed;
+				if (landed) this.staged.clear();
+				this.saving = false;
+				this.failed = !landed;
+				this.publish();
+			}
+			actions() {
+				return {
+					edit: (field, text) => {
+						this.stage(field, { text, clear: false });
+					},
+					resetField: (field) => {
+						this.stage(field, { text: this.baseText(field), clear: true });
+					},
+					save: () => {
+						this.save();
+					},
+					discard: () => {
+						if (this.staged.size === 0 && !this.failed) return;
+						this.staged.clear();
+						this.failed = false;
+						this.publish();
+					}
+				};
+			}
+			async clear(field) {
+				await this.scope.unset(field);
+				return !this.stored(field);
+			}
+			async store(field, value) {
+				await this.scope.set(field, value);
+				return this.userLayer()?.[field] === value;
+			}
+			stage(field, edit) {
+				this.staged.set(field, edit);
+				this.failed = false;
+				this.publish();
+			}
+			snapshotOf() {
+				return this.scope.getSnapshot();
+			}
+			sectionValue(field) {
+				return this.snapshotOf().value?.[field];
+			}
+			baseText(field) {
+				return this.specs.get(field).format(this.snapshotOf().base?.[field]);
+			}
+			userLayer() {
+				return this.snapshotOf().user;
+			}
+			stored(field) {
+				const user = this.userLayer();
+				return user !== void 0 && Object.hasOwn(user, field);
+			}
+			publish() {
+				for (const listener of this.listeners) listener();
+			}
+			/** The credential reference the section names, or the provider default. */
+			refOf() {
+				const declared = this.sectionValue("apiKeyEnv");
+				return declared !== void 0 && declared.length > 0 ? declared : DEFAULT_API_KEY_REF;
+			}
+			/** Ask the credentials domain about the reference the section currently names. */
+			async readCredential() {
+				const ref = this.refOf();
+				if (ref !== this.credential.ref) {
+					this.credential = { ref, configured: false, writable: true };
+					this.publish();
+				}
+				let response;
+				try {
+					response = await this.api.credentials.describe({ refs: [ref] });
+				} catch (_credentialReadFailure) {
+					return;
+				}
+				if (!response.result.ok || ref !== this.refOf()) return;
+				const view = response.result.value.credentials[ref];
+				const next = {
+					ref,
+					configured: view?.configured ?? false,
+					writable: view?.writable ?? true
+				};
+				if (next.configured === this.credential.configured && next.writable === this.credential.writable) return;
+				this.credential = next;
+				this.publish();
+			}
+			/** Re-read after the Host reports a change to the reference this card watches. */
+			refreshCredential(ref) {
+				if (ref !== this.credential.ref) return;
+				this.readCredential();
+			}
+			/** Write the staged key, then re-read whether the Host now holds one. */
+			async writeKey(value) {
+				try {
+					await this.api.credentials.set({ ref: this.refOf(), value });
+				} catch (_credentialWriteFailure) {}
+				await this.readCredential();
+				return this.credential.configured;
+			}
+		};
+
+		/** Bridges the `dsh-web-search-plugin` scope and the credentials domain onto the card. */
+		var TavilyCardController = class {
+			constructor(scope, api) {
+				this.scope = scope;
+				this.api = api;
+				this.form = new TavilyCardForm(scope, api);
+				this.store = this.form.bind(() => this.projection());
+				scope.subscribe(() => {
+					this.form.readCredential();
+				});
+			}
+			projection() {
+				return {
+					...this.form.shell(),
+					mode: this.form.field("mode"),
+					apiKey: this.form.field(API_KEY_FIELD),
+					apiKeyEnv: this.form.field("apiKeyEnv"),
+					baseURL: this.form.field("baseURL"),
+					maxResults: this.form.field("maxResults"),
+					searchDepth: this.form.field("searchDepth"),
+					includeAnswer: this.form.field("includeAnswer"),
+					topic: this.form.field("topic"),
+					apiKeyConfigured: this.form.credential.configured,
+					apiKeyWritable: this.form.credential.writable
+				};
+			}
+			inject() {
+				return {
+					hooks: { tavilySearchCard: this.store },
+					...this.form.actions()
+				};
+			}
+		};
+
+		/** Row style: one labelled field with label, hint, and staged input. */
+		const fieldRow = (label, hint, children) => react.createElement("div", { style: { display: "flex", flexDirection: "column", gap: "4px", padding: "12px 0", borderTop: "1px solid var(--dsw-alias-border-l2)" } },
+			react.createElement("label", { style: { color: "var(--dsw-alias-label-primary)", fontSize: "13px", fontWeight: 500, lineHeight: "1.5" } }, label),
+			children,
+			hint ? react.createElement("p", { style: { color: "var(--dsw-alias-label-tertiary)", margin: 0, fontSize: "12px", lineHeight: "1.5" } }, hint) : null);
+		/** Text/number input. */
+		const textInput = (props) => react.createElement("input", { style: { border: "1px solid var(--dsw-alias-border-l2)", background: "var(--dsw-alias-bg-layer-3)", height: "34px", font: "inherit", color: "var(--dsw-alias-label-primary)", borderRadius: "8px", padding: "0 12px", fontSize: "13px", lineHeight: "1.5" }, type: "text", ...props.numeric ? { inputMode: "numeric" } : {}, ...props });
+		/** Password input for the write-only credential. */
+		const secretInput = (props) => react.createElement("input", { style: { border: "1px solid var(--dsw-alias-border-l2)", background: "var(--dsw-alias-bg-layer-3)", height: "34px", font: "inherit", color: "var(--dsw-alias-label-primary)", borderRadius: "8px", padding: "0 12px", fontSize: "13px", lineHeight: "1.5" }, type: "password", autoComplete: "off", ...props });
+		/** Choice select. */
+		const selectInput = (props) => react.createElement("select", { style: { border: "1px solid var(--dsw-alias-border-l2)", background: "var(--dsw-alias-bg-layer-3)", height: "34px", font: "inherit", color: "var(--dsw-alias-label-primary)", borderRadius: "8px", padding: "0 12px", fontSize: "13px", lineHeight: "1.5" }, ...props });
+		/** Checkbox for booleans. */
+		const checkboxInput = (props) => react.createElement("input", { type: "checkbox", style: { width: "16px", height: "16px", accentColor: "var(--dsw-alias-brand-primary)" }, ...props });
+
+		/** Render one plugin card: header disclosure plus the staged form. */
+		function TavilyCard(props) {
+			const { t } = props;
+			const state = props.useTavilySearchCard((snapshot) => snapshot);
+			const [open, setOpen] = react.useState(false);
+			if (!state.available) return null;
+			const disabled = !state.writable;
+			const blocked = !state.dirty || state.invalid || state.saving;
+			return react.createElement("li", { style: { border: "1px solid var(--dsw-alias-border-l2)", background: "var(--dsw-alias-bg-layer-3)", borderRadius: "12px", listStyle: "none" } },
+				react.createElement("button", { type: "button", "aria-expanded": open, onClick: () => setOpen(!open), style: { appearance: "none", width: "100%", font: "inherit", color: "inherit", textAlign: "left", cursor: "pointer", background: "0 0", border: "0", borderRadius: "12px", alignItems: "center", gap: "12px", padding: "14px 16px", display: "flex" } },
+					react.createElement("span", { style: { flexDirection: "column", flex: 1, gap: "4px", minWidth: 0, display: "flex" } },
+						react.createElement("span", { style: { color: "var(--dsw-alias-label-primary)", fontSize: "15px", fontWeight: 600, lineHeight: "1.4" } }, t("nav")),
+						react.createElement("span", { style: { color: "var(--dsw-alias-label-tertiary)", fontSize: "13px", lineHeight: "1.5" } }, t("description"))),
+					state.dirty ? react.createElement("span", { style: { whiteSpace: "nowrap", background: "var(--dsw-alias-bg-module-platform)", color: "var(--dsw-alias-label-secondary)", borderRadius: "999px", flex: "none", padding: "1px 8px", fontSize: "11px", fontWeight: 500, lineHeight: "17px" } }, t("unsaved")) : null,
+					react.createElement("span", { style: { color: "var(--dsw-alias-label-tertiary)", flex: "none" } }, open ? "▾" : "▸")),
+				open ? react.createElement("div", { style: { borderTop: "1px solid var(--dsw-alias-border-l2)", margin: "0 16px", paddingBottom: "8px" } },
+					!state.writable ? react.createElement("p", { style: { color: "var(--dsw-alias-label-tertiary)", margin: "12px 0 0", fontSize: "12px", lineHeight: "1.5" } }, t("readOnly")) : null,
+					fieldRow(t("mode"), null, selectInput({ id: "plugin-config-web-search-mode", value: state.mode.text, disabled, onChange: (e) => props.edit("mode", e.target.value), children: [
+						react.createElement("option", { value: "keyless", key: "keyless" }, t("modeKeyless")),
+						react.createElement("option", { value: "keyed", key: "keyed" }, t("modeKeyed"))
+					] })),
+					state.mode.text === "keyed" ? fieldRow(t("apiKey"), t("apiKeyHint"), secretInput({ id: "plugin-config-web-search-key", value: state.apiKey.text, disabled: !state.apiKeyWritable, placeholder: state.apiKeyConfigured ? t("apiKeySet") : t("apiKeyUnset"), onChange: (e) => props.edit("apiKey", e.target.value) })) : null,
+					state.mode.text === "keyed" ? fieldRow(t("apiKeyEnv"), t("apiKeyEnvHint"), textInput({ id: "plugin-config-web-search-keyref", value: state.apiKeyEnv.text, disabled, onChange: (e) => props.edit("apiKeyEnv", e.target.value), onReset: () => props.resetField("apiKeyEnv") })) : null,
+					fieldRow(t("baseURL"), t("baseURLHint"), textInput({ id: "plugin-config-web-search-base", value: state.baseURL.text, disabled, onChange: (e) => props.edit("baseURL", e.target.value), onReset: () => props.resetField("baseURL") })),
+					fieldRow(t("searchDepth"), null, selectInput({ id: "plugin-config-web-search-depth", value: state.searchDepth.text, disabled, onChange: (e) => props.edit("searchDepth", e.target.value), children: [
+						react.createElement("option", { value: "basic", key: "basic" }, t("searchDepthBasic")),
+						react.createElement("option", { value: "advanced", key: "advanced" }, t("searchDepthAdvanced"))
+					] })),
+					fieldRow(t("topic"), null, selectInput({ id: "plugin-config-web-search-topic", value: state.topic.text, disabled, onChange: (e) => props.edit("topic", e.target.value), children: [
+						react.createElement("option", { value: "general", key: "general" }, t("topicGeneral")),
+						react.createElement("option", { value: "news", key: "news" }, t("topicNews"))
+					] })),
+					fieldRow(t("includeAnswer"), t("includeAnswerHint"), checkboxInput({ id: "plugin-config-web-search-answer", checked: state.includeAnswer.text === "true", disabled, onChange: (e) => props.edit("includeAnswer", e.target.checked ? "true" : "") })),
+					fieldRow(t("maxResults"), t("maxResultsHint"), textInput({ id: "plugin-config-web-search-max", numeric: true, value: state.maxResults.text, disabled, onChange: (e) => props.edit("maxResults", e.target.value), onReset: () => props.resetField("maxResults") })),
+					react.createElement("div", { style: { borderTop: "1px solid var(--dsw-alias-border-l2)", justifyContent: "flex-end", alignItems: "center", gap: "8px", padding: "12px 0 4px", display: "flex" } },
+						state.failed ? react.createElement("p", { role: "status", style: { minWidth: 0, color: "var(--dsw-alias-label-error)", flex: 1, margin: 0, fontSize: "12px", lineHeight: "1.5" } }, t("saveFailed")) : null,
+						react.createElement("button", { type: "button", disabled: !state.dirty || state.saving, onClick: props.discard, style: { appearance: "none", font: "inherit", cursor: "pointer", border: "1px solid var(--dsw-alias-border-l2)", borderRadius: "8px", padding: "5px 14px", fontSize: "13px", lineHeight: "1.5", color: "var(--dsw-alias-label-secondary)", background: "0 0" } }, t("discard")),
+						react.createElement("button", { type: "button", disabled: blocked, onClick: props.save, style: { appearance: "none", font: "inherit", cursor: "pointer", border: "1px solid transparent", borderRadius: "8px", padding: "5px 14px", fontSize: "13px", lineHeight: "1.5", color: "var(--dsw-alias-label-on-brand)", background: "var(--dsw-alias-bg-brand-solid)" } }, t(state.saving ? "saving" : "save")))) : null);
+		}
+
+		/** Mount the Tavily card into the plugin configuration surface. */
+		function apply(ctx) {
+			const { api } = ctx.get("connection");
+			const t = ctx.locale.bind(NS);
+			ctx.effect(() => ctx.locale.register(NS, { zh, en }), "dsh-web-search-plugin: card dictionaries");
+			const controller = new TavilyCardController(ctx.settingsScope.bind({ namespace: NS }), api);
+			ctx.effect(() => ctx.remote.$on("credentials/updated", (ref) => {
+				controller.form.refreshCredential(ref);
+			}), "dsh-web-search-plugin: credential invalidations");
+			ctx.slots.inject("settings.plugin.item", function* () {
+				yield ctx.slots.register({
+					name: "settings.plugin.item",
+					key: "dsh-web-search-plugin",
+					locale: NS,
+					inject: () => controller.inject()
+				}, TavilyCard);
+			});
+		}
+
+		/** Cordis service names this browser plugin's apply reads (fiber inject). */
+		const inject = ["slots", "locale", "connection", "remote", "settingsScope"];
+
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});
+//# sourceMappingURL=client.js.map

package/lib/index.js

@@ -0,0 +1,279 @@
+/**
+ * Tavily-backed search provider for the DeepSeek Harness web capability seam
+ * (`ctx.web`). Registers a `WebSearchProvider` under the stable id `tavily`
+ * that calls the Tavily REST API (`POST {baseURL}/search`).
+ *
+ * Two authentication modes are supported, switchable through this plugin's
+ * settings section (`dsh-web-search-plugin`):
+ * - `keyless`: free rate-limited access, no account or key. A single
+ *   `X-Tavily-Access-Mode: keyless` header activates it.
+ * - `keyed`: a Tavily API key resolved through the credentials service
+ *   (`TAVILY_API_KEY` by default), the launching environment, or a literal
+ *   `apiKey` in the config; sent as a Bearer token.
+ *
+ * Responses follow the standard Tavily schema and are normalized into the
+ * seam's `WebSearchResult` (`answer` -> `content`, `results[]` -> `sources[]`).
+ *
+ * The plugin mirrors the structure of `@deepseek-ai/dsh-web-search-deepseek`:
+ * a function/namespace Cordis plugin (`inject: ['web']`) that registers its
+ * own settings section and never registers a model-facing tool.
+ *
+ * @module dsh-web-search-plugin
+ */
+import z from "@deepseek-ai/schemastery";
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+import { launchEnvironmentOf } from "@deepseek-ai/dsh-launch-environment";
+import { WebError } from "@deepseek-ai/dsh-web";
+
+/** Stable id this provider registers under. */
+const TAVILY_PROVIDER_ID = "tavily";
+/** Default Tavily REST API base; `/search` is appended. */
+const TAVILY_DEFAULT_BASE_URL = "https://api.tavily.com";
+/** Default credential reference resolved for every keyed search. */
+const DEFAULT_API_KEY_ENV = "TAVILY_API_KEY";
+/** Attribution header sent on every request. */
+const USER_AGENT = "dsh-web-search-plugin/0.1.1";
+/** Tavily's hard cap on `max_results`. */
+const TAVILY_MAX_RESULTS_CAP = 20;
+
+/** Cordis plugin name used by loader diagnostics. */
+const name = "dsh-web-search-plugin";
+/** The web seam this provider registers into. */
+const inject = ["web"];
+
+/** Plugin config (all optional — `apply` fills defaults). */
+const Config = z.object({
+	/** Authentication mode: `keyless` (default, free rate-limited) or `keyed`. */
+	mode: z.string().default("keyless"),
+	/** Literal Tavily API key; prefer {@link apiKeyEnv} so no secret enters configuration files. */
+	apiKey: z.string().role("secret").default(""),
+	/** Credential reference resolved for each keyed search; defaults to `TAVILY_API_KEY`. */
+	apiKeyEnv: z.string().role("credential-ref").default(DEFAULT_API_KEY_ENV),
+	/** Tavily REST API base. Defaults to `https://api.tavily.com`. */
+	baseURL: z.string().default(TAVILY_DEFAULT_BASE_URL),
+	/** Upper bound on returned sources; Tavily accepts 1..20. */
+	maxResults: z.number().step(1).min(1).max(TAVILY_MAX_RESULTS_CAP).default(8),
+	/** Search depth: `basic` (default) or `advanced`. */
+	searchDepth: z.string().default("basic"),
+	/** Request Tavily's generated answer text; surfaced as the result `content`. */
+	includeAnswer: z.boolean().default(true),
+	/** Search topic: `general` (default) or `news`. */
+	topic: z.string().default("general"),
+	/** Settings namespace carrying this provider's mode, endpoint, and key reference. */
+});
+/** Settings namespace carrying this provider's mode, endpoint, and key reference. */
+const WEB_SEARCH_TAVILY_SETTINGS_NAMESPACE = settingsNamespace("dsh-web-search-plugin");
+/** Environment variable naming this provider's endpoint override. */
+const TAVILY_BASE_URL_ENV = "TAVILY_BASE_URL";
+
+/**
+ * Normalize a standard Tavily search response into the seam's
+ * `WebSearchResult`. Sources are deduped by `url` (Tavily can surface the same
+ * page twice); the provider-generated `answer` becomes `content` only when the
+ * `includeAnswer` option asked for it. The seam owns the final `maxResults`
+ * truncation, so `truncated` is always `false` here.
+ *
+ * @param json - the parsed Tavily response body.
+ * @param includeAnswer - whether the request requested `include_answer`.
+ * @returns the normalized search result.
+ * @throws {@link WebError} when the body is not a usable object.
+ */
+function mapTavilyResponse(json, includeAnswer) {
+	if (json === null || typeof json !== "object") throw new WebError("Tavily returned a non-object response body", "WEB_PROVIDER_ERROR");
+	const results = Array.isArray(json.results) ? json.results : [];
+	if (results.length === 0) throw new WebError("Tavily returned no results", "WEB_PROVIDER_ERROR");
+	const seen = /* @__PURE__ */ new Set();
+	const sources = [];
+	for (const item of results) {
+		if (item === null || typeof item !== "object") continue;
+		if (typeof item.url !== "string" || item.url.length === 0 || seen.has(item.url)) continue;
+		seen.add(item.url);
+		sources.push({
+			url: item.url,
+			...typeof item.title === "string" && item.title.length > 0 ? { title: item.title } : {},
+			...typeof item.content === "string" && item.content.length > 0 ? { snippet: item.content } : {},
+			...typeof item.published_date === "string" && item.published_date.length > 0 ? { publishedAt: item.published_date } : {}
+		});
+	}
+	return {
+		...includeAnswer === true && typeof json.answer === "string" && json.answer.length > 0 ? { content: json.answer } : {},
+		sources,
+		truncated: false
+	};
+}
+
+/** The Tavily-backed search provider; HTTP redirects fail as `WEB_PROVIDER_ERROR`. */
+class TavilySearchProvider {
+	/**
+	 * @param resolveOptions - the options for the NEXT operation, snapshotted
+	 * once at each operation's entry so one search never mixes two sections.
+	 */
+	constructor(resolveOptions) {
+		this.resolveOptions = resolveOptions;
+	}
+
+	id = TAVILY_PROVIDER_ID;
+
+	/** Cheap local usability check; must not make network calls. */
+	available() {
+		const options = this.resolveOptions();
+		if (!URL.canParse(options.baseURL)) return false;
+		if (options.mode !== "keyed") return true;
+		return ((options.apiKey?.length ?? 0) > 0 || options.resolveApiKey !== void 0);
+	}
+
+	/** Run one search through the Tavily REST API. */
+	async search(request, signal) {
+		const options = this.resolveOptions();
+		throwIfSearchAborted(signal);
+		let apiKey;
+		if (options.mode === "keyed") {
+			apiKey = await this.apiKey(options, signal);
+			throwIfSearchAborted(signal);
+		}
+		const endpoint = `${options.baseURL.replace(/\/+$/u, "")}/search`;
+		const body = {
+			query: request.query,
+			max_results: Math.min(request.maxResults ?? options.maxResults, TAVILY_MAX_RESULTS_CAP),
+			search_depth: options.searchDepth,
+			topic: options.topic,
+			include_answer: options.includeAnswer === true,
+			include_images: false
+		};
+		const headers = {
+			"content-type": "application/json",
+			"accept": "application/json",
+			"user-agent": USER_AGENT,
+			...options.mode === "keyless" ? { "x-tavily-access-mode": "keyless" } : { "authorization": `Bearer ${apiKey}` }
+		};
+		let response;
+		try {
+			response = await fetch(endpoint, {
+				method: "POST",
+				redirect: "error",
+				headers,
+				body: JSON.stringify(body),
+				...signal !== void 0 ? { signal } : {}
+			});
+		} catch (error) {
+			if (signal?.aborted === true || isAbortError(error)) throw searchAborted(signal, error);
+			throw new WebError(`Tavily search request failed: ${String(error)}`, "WEB_PROVIDER_ERROR", { cause: error });
+		}
+		if (!response.ok) {
+			let message = `Tavily API error (HTTP ${response.status})`;
+			try {
+				const parsed = await response.json();
+				const detail = parsed?.detail?.error ?? parsed?.error ?? parsed?.message;
+				if (typeof detail === "string" && detail.length > 0) message = detail;
+			} catch {
+				/* non-JSON error body — keep the status-line message */
+			}
+			throw new WebError(message, "WEB_PROVIDER_ERROR");
+		}
+		try {
+			return mapTavilyResponse(await response.json(), options.includeAnswer === true);
+		} catch (error) {
+			if (signal?.aborted === true || isAbortError(error)) throw searchAborted(signal, error);
+			if (error instanceof WebError) throw error;
+			throw new WebError(`Tavily returned an unprocessable response body: ${String(error)}`, "WEB_PROVIDER_ERROR", { cause: error });
+		}
+	}
+
+	/**
+	 * Resolve one operation's credential without retaining it on the provider.
+	 * @param options - the caller's snapshot; the certificate and the endpoint it is sent to come from one section.
+	 * @param signal - abort signal for the surrounding search.
+	 * @returns the resolved key.
+	 */
+	async apiKey(options, signal) {
+		throwIfSearchAborted(signal);
+		if (options.apiKey !== void 0 && options.apiKey.length > 0) return options.apiKey;
+		let resolved;
+		try {
+			resolved = await abortable(options.resolveApiKey?.() ?? Promise.resolve(void 0), signal);
+		} catch (error) {
+			if (signal?.aborted === true || isAbortError(error)) throw searchAborted(signal, error);
+			throw new WebError(`Tavily search credential resolution failed: ${String(error)}`, "WEB_PROVIDER_ERROR", { cause: error });
+		}
+		if (resolved !== void 0 && resolved.length > 0) return resolved;
+		throw new WebError(`Tavily search has no API key for "${options.apiKeyEnv ?? DEFAULT_API_KEY_ENV}"; store it through the credentials service, export it in the launching environment, or set a literal "apiKey" in the dsh-web-search-plugin config`, "WEB_PROVIDER_CREDENTIAL_MISSING");
+	}
+}
+
+/** Race a same-process asynchronous preflight against caller cancellation. */
+function abortable(operation, signal) {
+	if (signal === void 0) return operation;
+	if (signal.aborted) return Promise.reject(searchAborted(signal));
+	return new Promise((resolve, reject) => {
+		const onAbort = () => {
+			reject(searchAborted(signal));
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+		operation.then((value) => {
+			signal.removeEventListener("abort", onAbort);
+			resolve(value);
+		}, (error) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(new Error(String(error).replace(/^Error: /u, ""), { cause: error }));
+		});
+	});
+}
+
+/** Throw the provider's stable cancellation error when the caller already aborted. */
+function throwIfSearchAborted(signal) {
+	if (signal?.aborted === true) throw searchAborted(signal);
+}
+
+/** Build the provider's stable cancellation error while retaining the caller's reason. */
+function searchAborted(signal, fallback) {
+	return new WebError("Tavily search aborted", "WEB_ABORTED", { cause: signal?.aborted === true ? signal.reason : fallback });
+}
+
+/** True for a fetch/`AbortSignal` abort, surfaced as `WEB_ABORTED`. */
+function isAbortError(error) {
+	return error instanceof DOMException && error.name === "AbortError";
+}
+
+/**
+ * Project one resolved section into the options the provider serves its next
+ * search with. Environment fallbacks stay here rather than in the provider:
+ * every value it reads is already fully defaulted.
+ * @param ctx - plugin context supplying the credential and environment planes.
+ * @param config - the currently authoritative section.
+ * @returns options for one search.
+ */
+function resolveOptions(ctx, config) {
+	const apiKeyEnv = credentialRef(config.apiKeyEnv ?? DEFAULT_API_KEY_ENV);
+	const literalApiKey = config.apiKey !== void 0 && config.apiKey.length > 0 ? config.apiKey : void 0;
+	return {
+		mode: config.mode ?? "keyless",
+		...literalApiKey === void 0 ? {} : { apiKey: literalApiKey },
+		resolveApiKey: async () => {
+			const credentials = ctx.get("credentials");
+			if (credentials !== void 0) return (await credentials.resolve(apiKeyEnv))?.value;
+			const ambient = launchEnvironmentOf(ctx).get(apiKeyEnv);
+			return ambient !== void 0 && ambient.value.length > 0 ? ambient.value : void 0;
+		},
+		apiKeyEnv,
+		baseURL: config.baseURL ?? launchEnvironmentOf(ctx).get(TAVILY_BASE_URL_ENV)?.value ?? TAVILY_DEFAULT_BASE_URL,
+		maxResults: config.maxResults ?? 8,
+		searchDepth: config.searchDepth ?? "basic",
+		includeAnswer: config.includeAnswer ?? true,
+		topic: config.topic ?? "general"
+	};
+}
+
+/** Register the Tavily search provider with `ctx.web`. */
+function apply(ctx, config) {
+	let current = () => config;
+	installSettingsSection(ctx, WEB_SEARCH_TAVILY_SETTINGS_NAMESPACE, Config, config, {
+		setSource: (source) => {
+			current = source;
+		},
+		onChange: () => {}
+	});
+	ctx.web.registerSearchProvider(new TavilySearchProvider(() => resolveOptions(ctx, current())));
+}
+
+export { Config, TAVILY_DEFAULT_BASE_URL, TAVILY_PROVIDER_ID, TavilySearchProvider, WEB_SEARCH_TAVILY_SETTINGS_NAMESPACE, apply, inject, name };

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "dsh-web-search-plugin",
+  "version": "0.1.1",
+  "description": "Tavily web-search provider for the DeepSeek Harness web capability seam (ctx.web): keyless or API-key modes with a UI config card; provider framework extensible to more search APIs",
+  "keywords": [
+    "dsh-plugin",
+    "deepseek-harness",
+    "dsh",
+    "tavily",
+    "web-search",
+    "websearch",
+    "search",
+    "plugin"
+  ],
+  "type": "module",
+  "main": "lib/index.js",
+  "files": [
+    "lib",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "exports": {
+    ".": {
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "default": "./lib/client.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-slots",
+        "@deepseek-ai/dsh-api-remotes"
+      ]
+    }
+  },
+  "scripts": {
+    "check": "node --check lib/index.js && node --check lib/client.js"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-web": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-credentials": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-settings": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-launch-environment": "^0.1.0-rc.7",
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "@deepseek-ai/cordis": "^4.0.1"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/X-C1811/dsh-web-search-plugin.git"
+  },
+  "homepage": "https://github.com/X-C1811/dsh-web-search-plugin",
+  "bugs": {
+    "url": "https://github.com/X-C1811/dsh-web-search-plugin/issues"
+  }
+}