@dcrays/web-search 0.1.0

package/README.md

@@ -0,0 +1,5 @@
+# @dcrays/web-search
+
+书灵墨宝的 DSH 联网搜索插件。加载后注册 `web_search` 工具，把模型搜索请求映射到配置的 HTTP API。
+
+本包对应 `mbh-chat` 环境，端点地址从 Cordis 插件配置读取。

package/cordis.patch.yml

@@ -0,0 +1,5 @@
+- insert:
+    - id: mbh-web-search
+      name: '@dcrays/web-search'
+      config:
+        enabled: true

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@dcrays/web-search",
+  "version": "0.1.0",
+  "description": "DeepSeek Harness web search plugin for Mobook (production)",
+  "type": "module",
+  "main": "plugin/index.js",
+  "types": "plugin/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./plugin/index.d.ts",
+      "default": "./plugin/index.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "plugin/**",
+    "src/**",
+    "cordis.patch.yml",
+    "README.md",
+    "!**/*.map"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-tools": "^0.1.1-rc.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/plugin/index.d.ts

@@ -0,0 +1,30 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { Service } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { type WebSearchRequest, type WebSearchResult } from '../src/index.js';
+export { DEFAULT_BUILD_ENV } from '../src/config/env-config.js';
+export declare const name = "mbh-web-search";
+export declare const inject: string[];
+export interface Config {
+    enabled: boolean;
+    endpointUrl: string;
+    metadataPath: string;
+    timeoutMs: number;
+    maxResponseBytes: number;
+    defaultCount: number;
+    maxCount: number;
+}
+export declare const Config: z<Config>;
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        mbhWebSearch: MbhWebSearchService;
+    }
+}
+export declare class MbhWebSearchService extends Service {
+    private readonly config;
+    private readonly operations;
+    constructor(ctx: Context, config: Config);
+    isEnabled(): boolean;
+    search(request: WebSearchRequest, signal?: AbortSignal): Promise<WebSearchResult>;
+}
+export declare function apply(ctx: Context, config: Config): void;

package/plugin/index.js

@@ -0,0 +1,332 @@
+import { createRequire as __mobookCreateRequire } from 'node:module'; const require = __mobookCreateRequire(import.meta.url);
+
+// plugins/web-search/dist-npm/plugin/index.js
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { Service } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+
+// plugins/web-search/dist-npm/src/api-client.js
+import { createHmac, randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+var WebSearchApiError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "WebSearchApiError";
+  }
+};
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function resolveSearchCredentials(metadata, channelId, legacyChannelId) {
+  const root = record(metadata);
+  const plugins = record(root?.plugins);
+  const hardware = record(root?.hardware);
+  const deviceId = nonEmptyString(hardware?.fingerprint);
+  for (const plugin of [record(plugins?.[channelId]), record(plugins?.[legacyChannelId])]) {
+    const userIdValue = plugin?.userId;
+    const userId = typeof userIdValue === "number" && Number.isSafeInteger(userIdValue) ? String(userIdValue) : nonEmptyString(userIdValue);
+    const botToken = nonEmptyString(plugin?.botToken);
+    if (userId && botToken && deviceId)
+      return { userId, botToken, deviceId };
+  }
+  throw new WebSearchApiError("MISSING_CREDENTIALS", `mobook metadata must contain plugins.${channelId}.userId, botToken, and hardware.fingerprint`);
+}
+function requestSignal(signal, timeoutMs) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+async function responseText(response, maxBytes) {
+  const declared = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maxBytes) {
+    await response.body?.cancel().catch(() => void 0);
+    throw new WebSearchApiError("RESPONSE_TOO_LARGE", `web search response exceeds ${maxBytes} bytes`);
+  }
+  if (!response.body)
+    return "";
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let size = 0;
+  let text = "";
+  try {
+    for (; ; ) {
+      const item = await reader.read();
+      if (item.done)
+        break;
+      size += item.value.byteLength;
+      if (size > maxBytes) {
+        await reader.cancel().catch(() => void 0);
+        throw new WebSearchApiError("RESPONSE_TOO_LARGE", `web search response exceeds ${maxBytes} bytes`);
+      }
+      text += decoder.decode(item.value, { stream: true });
+    }
+    return text + decoder.decode();
+  } finally {
+    reader.releaseLock();
+  }
+}
+function parseResponse(text, fallbackQuery) {
+  let payload;
+  try {
+    payload = JSON.parse(text);
+  } catch (error) {
+    throw new WebSearchApiError("INVALID_RESPONSE", "web search API returned invalid JSON", { cause: error });
+  }
+  const wrapper = record(payload);
+  const upstream = record(wrapper?.data);
+  if (wrapper?.success !== true || typeof upstream?.code === "number" && upstream.code !== 200) {
+    throw new WebSearchApiError("API_ERROR", "web search API reported an unsuccessful response");
+  }
+  const searchData = record(upstream?.data);
+  const pages = record(searchData?.webPages);
+  const queryContext = record(searchData?.queryContext);
+  const values = Array.isArray(pages?.value) ? pages.value : [];
+  const results = values.flatMap((value) => {
+    const item = record(value);
+    const url = nonEmptyString(item?.url);
+    if (!item || !url)
+      return [];
+    const result2 = {
+      title: nonEmptyString(item.name) ?? url,
+      url,
+      snippet: nonEmptyString(item.snippet) ?? ""
+    };
+    const siteName = nonEmptyString(item.siteName);
+    const publishedAt = nonEmptyString(item.datePublished);
+    if (siteName)
+      result2.siteName = siteName;
+    if (publishedAt)
+      result2.publishedAt = publishedAt;
+    return [result2];
+  });
+  const result = {
+    query: nonEmptyString(queryContext?.originalQuery) ?? fallbackQuery,
+    results
+  };
+  if (typeof pages?.totalEstimatedMatches === "number" && Number.isFinite(pages.totalEstimatedMatches)) {
+    result.totalEstimatedMatches = pages.totalEstimatedMatches;
+  }
+  return result;
+}
+var WebSearchApiClient = class {
+  config;
+  endpoint;
+  fetchImpl;
+  readFileImpl;
+  nowSeconds;
+  nonce;
+  constructor(config, dependencies = {}) {
+    this.config = config;
+    try {
+      this.endpoint = new URL(config.endpointUrl);
+    } catch (error) {
+      throw new WebSearchApiError("INVALID_CONFIG", "web search endpointUrl is invalid", { cause: error });
+    }
+    if (!["http:", "https:"].includes(this.endpoint.protocol)) {
+      throw new WebSearchApiError("INVALID_CONFIG", "web search endpointUrl must use http or https");
+    }
+    for (const [name2, value] of [
+      ["timeoutMs", config.timeoutMs],
+      ["maxResponseBytes", config.maxResponseBytes],
+      ["defaultCount", config.defaultCount],
+      ["maxCount", config.maxCount]
+    ]) {
+      if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new WebSearchApiError("INVALID_CONFIG", `${name2} must be a positive integer`);
+      }
+    }
+    if (config.defaultCount > config.maxCount) {
+      throw new WebSearchApiError("INVALID_CONFIG", "defaultCount must not exceed maxCount");
+    }
+    this.fetchImpl = dependencies.fetch ?? fetch;
+    this.readFileImpl = dependencies.readFile ?? readFile;
+    this.nowSeconds = dependencies.nowSeconds ?? (() => Math.floor(Date.now() / 1e3));
+    this.nonce = dependencies.nonce ?? (() => randomUUID().replaceAll("-", ""));
+  }
+  async search(request, signal) {
+    const query = request.query.trim();
+    if (!query)
+      throw new WebSearchApiError("INVALID_REQUEST", "web search query must not be empty");
+    const count = request.count ?? this.config.defaultCount;
+    const offset = request.offset ?? 0;
+    if (!Number.isSafeInteger(count) || count < 1 || count > this.config.maxCount) {
+      throw new WebSearchApiError("INVALID_REQUEST", `web search count must be between 1 and ${this.config.maxCount}`);
+    }
+    if (!Number.isSafeInteger(offset) || offset < 0) {
+      throw new WebSearchApiError("INVALID_REQUEST", "web search offset must be a non-negative integer");
+    }
+    let metadata;
+    try {
+      metadata = JSON.parse(await this.readFileImpl(this.config.metadataPath, "utf8"));
+    } catch (error) {
+      throw new WebSearchApiError("MISSING_CREDENTIALS", "unable to read Mobook runtime metadata", { cause: error });
+    }
+    const credentials = resolveSearchCredentials(metadata, this.config.channelId, this.config.legacyChannelId);
+    const timestamp = String(this.nowSeconds());
+    const nonce = this.nonce();
+    const message = `${credentials.userId}
+${credentials.deviceId}
+${timestamp}
+${nonce}`;
+    const signature = createHmac("sha256", credentials.botToken).update(message, "utf8").digest("hex");
+    const body = {
+      user_id: credentials.userId,
+      bot_token: credentials.botToken,
+      device_id: credentials.deviceId,
+      signature,
+      timestamp,
+      nonce,
+      service: "bocha_search",
+      query,
+      count,
+      offset,
+      language: request.language?.trim() || "zh-CN"
+    };
+    if (request.includeDomains?.length)
+      body.include_domains = request.includeDomains;
+    if (request.excludeDomains?.length)
+      body.exclude_domains = request.excludeDomains;
+    const effectiveSignal = requestSignal(signal, this.config.timeoutMs);
+    let response;
+    try {
+      response = await this.fetchImpl(this.endpoint, {
+        method: "POST",
+        headers: { accept: "application/json", "content-type": "application/json" },
+        body: JSON.stringify(body),
+        signal: effectiveSignal
+      });
+    } catch (error) {
+      if (signal?.aborted)
+        throw error;
+      if (effectiveSignal.aborted) {
+        throw new WebSearchApiError("TIMEOUT", `web search request timed out after ${this.config.timeoutMs}ms`, {
+          cause: error
+        });
+      }
+      throw new WebSearchApiError("NETWORK_ERROR", "web search request failed", { cause: error });
+    }
+    const text = await responseText(response, this.config.maxResponseBytes);
+    if (!response.ok)
+      throw new WebSearchApiError("HTTP_ERROR", `web search request failed with HTTP ${response.status}`);
+    return parseResponse(text, query);
+  }
+};
+
+// plugins/web-search/dist-npm/src/tools.js
+import { defineTool } from "@deepseek-ai/dsh-tools";
+function createWebSearchTool(search) {
+  return defineTool({
+    name: "web_search",
+    description: "Search the public web with the configured Mobook Bocha search service. Use this for current information, source discovery, fact verification, news, weather, prices, schedules, or any question that requires internet access. Cite result URLs when answering.",
+    parameters: {
+      query: { type: "string", required: true, description: "A focused web search query." },
+      count: { type: "integer", description: "Number of results to return. Defaults to 5; maximum 20." },
+      offset: { type: "integer", description: "Zero-based result offset for pagination." },
+      language: { type: "string", description: "Search language, for example zh-CN or en-US." },
+      includeDomains: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Optional domains to prefer or restrict, for example ["openai.com"].'
+      },
+      excludeDomains: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional domains to exclude from results."
+      }
+    },
+    output: {
+      schema: { type: "json" },
+      render: (_args, value) => [{ type: "text", text: JSON.stringify(value) }]
+    },
+    timeoutMs: 35e3,
+    async execute(args, exec) {
+      return JSON.parse(JSON.stringify(await search.search(args, exec.signal)));
+    }
+  });
+}
+
+// plugins/web-search/dist-npm/src/index.js
+var MBH_WEB_SEARCH_SERVICE_KEY = "mbhWebSearch";
+
+// plugins/web-search/dist-npm/src/config/env-config.js
+var ENV_CONFIG = {
+  production: {
+    packageName: "@dcrays/web-search",
+    channelId: "mbh-chat",
+    legacyChannelId: "mbhchat",
+    endpointUrl: "https://api-gateway.shuwenda.com/apikey-manage/api/search"
+  },
+  test: {
+    packageName: "@dcrays/web-search-test",
+    channelId: "mbh-chat-test",
+    legacyChannelId: "mbhchat-test",
+    endpointUrl: "https://api-gateway.shuwenda.icu/apikey-manage/api/search"
+  }
+};
+var DEFAULT_BUILD_ENV = "production";
+var ACTIVE_ENV_CONFIG = ENV_CONFIG[DEFAULT_BUILD_ENV];
+
+// plugins/web-search/dist-npm/plugin/index.js
+var name = "@dcrays/web-search";
+var inject = ["tools"];
+var Config = z.object({
+  enabled: z.boolean().default(true),
+  endpointUrl: z.string().default(""),
+  metadataPath: z.string().default(""),
+  timeoutMs: z.natural().min(1).default(3e4),
+  maxResponseBytes: z.natural().min(1).default(1024 * 1024),
+  defaultCount: z.natural().min(1).default(5),
+  maxCount: z.natural().min(1).default(20)
+});
+var MbhWebSearchService = class extends Service {
+  config;
+  operations;
+  constructor(ctx, config) {
+    super(ctx, MBH_WEB_SEARCH_SERVICE_KEY);
+    this.config = config;
+    if (!config.enabled)
+      return;
+    const dshHome = process.env.DSH_HOME?.trim() || resolve(homedir(), ".mobook-harness");
+    this.operations = new WebSearchApiClient({
+      endpointUrl: config.endpointUrl.trim() || ACTIVE_ENV_CONFIG.endpointUrl,
+      metadataPath: config.metadataPath.trim() || resolve(dshHome, "mobook.json"),
+      channelId: ACTIVE_ENV_CONFIG.channelId,
+      legacyChannelId: ACTIVE_ENV_CONFIG.legacyChannelId,
+      timeoutMs: config.timeoutMs,
+      maxResponseBytes: config.maxResponseBytes,
+      defaultCount: config.defaultCount,
+      maxCount: config.maxCount
+    });
+  }
+  isEnabled() {
+    return this.config.enabled;
+  }
+  search(request, signal) {
+    if (!this.operations)
+      return Promise.reject(new Error("mbh-web-search is disabled"));
+    return this.operations.search(request, signal);
+  }
+};
+function apply(ctx, config) {
+  const service = new MbhWebSearchService(ctx, config);
+  ctx.effect(() => {
+    if (!service.isEnabled())
+      return () => void 0;
+    const unregister = ctx.tools.register(createWebSearchTool(service));
+    ctx.logger(name).info("%s plugin loaded with web_search tool for %s", name, DEFAULT_BUILD_ENV);
+    return unregister;
+  }, `${name} lifecycle`);
+}
+export {
+  Config,
+  DEFAULT_BUILD_ENV,
+  MbhWebSearchService,
+  apply,
+  inject,
+  name
+};

package/src/api-client.d.ts

@@ -0,0 +1,62 @@
+export interface WebSearchRequest {
+    query: string;
+    count?: number;
+    offset?: number;
+    language?: string;
+    includeDomains?: string[];
+    excludeDomains?: string[];
+}
+export interface WebSearchItem {
+    title: string;
+    url: string;
+    snippet: string;
+    siteName?: string;
+    publishedAt?: string;
+}
+export interface WebSearchResult {
+    query: string;
+    totalEstimatedMatches?: number;
+    results: WebSearchItem[];
+}
+export interface WebSearchOperations {
+    search(request: WebSearchRequest, signal?: AbortSignal): Promise<WebSearchResult>;
+}
+export interface WebSearchApiClientConfig {
+    endpointUrl: string;
+    metadataPath: string;
+    channelId: string;
+    legacyChannelId: string;
+    timeoutMs: number;
+    maxResponseBytes: number;
+    defaultCount: number;
+    maxCount: number;
+}
+export declare class WebSearchApiError extends Error {
+    readonly code: 'INVALID_CONFIG' | 'INVALID_REQUEST' | 'MISSING_CREDENTIALS' | 'HTTP_ERROR' | 'API_ERROR' | 'INVALID_RESPONSE' | 'RESPONSE_TOO_LARGE' | 'NETWORK_ERROR' | 'TIMEOUT';
+    constructor(code: 'INVALID_CONFIG' | 'INVALID_REQUEST' | 'MISSING_CREDENTIALS' | 'HTTP_ERROR' | 'API_ERROR' | 'INVALID_RESPONSE' | 'RESPONSE_TOO_LARGE' | 'NETWORK_ERROR' | 'TIMEOUT', message: string, options?: ErrorOptions);
+}
+type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+type ReadFile = (path: string, encoding: BufferEncoding) => Promise<string>;
+interface Dependencies {
+    fetch?: Fetch;
+    readFile?: ReadFile;
+    nowSeconds?: () => number;
+    nonce?: () => string;
+}
+interface SearchCredentials {
+    userId: string;
+    botToken: string;
+    deviceId: string;
+}
+export declare function resolveSearchCredentials(metadata: unknown, channelId: string, legacyChannelId: string): SearchCredentials;
+export declare class WebSearchApiClient implements WebSearchOperations {
+    private readonly config;
+    private readonly endpoint;
+    private readonly fetchImpl;
+    private readonly readFileImpl;
+    private readonly nowSeconds;
+    private readonly nonce;
+    constructor(config: WebSearchApiClientConfig, dependencies?: Dependencies);
+    search(request: WebSearchRequest, signal?: AbortSignal): Promise<WebSearchResult>;
+}
+export {};

package/src/api-client.js

@@ -0,0 +1,211 @@
+import { createHmac, randomUUID } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+export class WebSearchApiError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = 'WebSearchApiError';
+    }
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+export function resolveSearchCredentials(metadata, channelId, legacyChannelId) {
+    const root = record(metadata);
+    const plugins = record(root?.plugins);
+    const hardware = record(root?.hardware);
+    const deviceId = nonEmptyString(hardware?.fingerprint);
+    for (const plugin of [record(plugins?.[channelId]), record(plugins?.[legacyChannelId])]) {
+        const userIdValue = plugin?.userId;
+        const userId = typeof userIdValue === 'number' && Number.isSafeInteger(userIdValue) ? String(userIdValue) : nonEmptyString(userIdValue);
+        const botToken = nonEmptyString(plugin?.botToken);
+        if (userId && botToken && deviceId)
+            return { userId, botToken, deviceId };
+    }
+    throw new WebSearchApiError('MISSING_CREDENTIALS', `mobook metadata must contain plugins.${channelId}.userId, botToken, and hardware.fingerprint`);
+}
+function requestSignal(signal, timeoutMs) {
+    const timeout = AbortSignal.timeout(timeoutMs);
+    return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+async function responseText(response, maxBytes) {
+    const declared = Number(response.headers.get('content-length'));
+    if (Number.isFinite(declared) && declared > maxBytes) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new WebSearchApiError('RESPONSE_TOO_LARGE', `web search response exceeds ${maxBytes} bytes`);
+    }
+    if (!response.body)
+        return '';
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let size = 0;
+    let text = '';
+    try {
+        for (;;) {
+            const item = await reader.read();
+            if (item.done)
+                break;
+            size += item.value.byteLength;
+            if (size > maxBytes) {
+                await reader.cancel().catch(() => undefined);
+                throw new WebSearchApiError('RESPONSE_TOO_LARGE', `web search response exceeds ${maxBytes} bytes`);
+            }
+            text += decoder.decode(item.value, { stream: true });
+        }
+        return text + decoder.decode();
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function parseResponse(text, fallbackQuery) {
+    let payload;
+    try {
+        payload = JSON.parse(text);
+    }
+    catch (error) {
+        throw new WebSearchApiError('INVALID_RESPONSE', 'web search API returned invalid JSON', { cause: error });
+    }
+    const wrapper = record(payload);
+    const upstream = record(wrapper?.data);
+    if (wrapper?.success !== true || (typeof upstream?.code === 'number' && upstream.code !== 200)) {
+        throw new WebSearchApiError('API_ERROR', 'web search API reported an unsuccessful response');
+    }
+    const searchData = record(upstream?.data);
+    const pages = record(searchData?.webPages);
+    const queryContext = record(searchData?.queryContext);
+    const values = Array.isArray(pages?.value) ? pages.value : [];
+    const results = values.flatMap((value) => {
+        const item = record(value);
+        const url = nonEmptyString(item?.url);
+        if (!item || !url)
+            return [];
+        const result = {
+            title: nonEmptyString(item.name) ?? url,
+            url,
+            snippet: nonEmptyString(item.snippet) ?? ''
+        };
+        const siteName = nonEmptyString(item.siteName);
+        const publishedAt = nonEmptyString(item.datePublished);
+        if (siteName)
+            result.siteName = siteName;
+        if (publishedAt)
+            result.publishedAt = publishedAt;
+        return [result];
+    });
+    const result = {
+        query: nonEmptyString(queryContext?.originalQuery) ?? fallbackQuery,
+        results
+    };
+    if (typeof pages?.totalEstimatedMatches === 'number' && Number.isFinite(pages.totalEstimatedMatches)) {
+        result.totalEstimatedMatches = pages.totalEstimatedMatches;
+    }
+    return result;
+}
+export class WebSearchApiClient {
+    config;
+    endpoint;
+    fetchImpl;
+    readFileImpl;
+    nowSeconds;
+    nonce;
+    constructor(config, dependencies = {}) {
+        this.config = config;
+        try {
+            this.endpoint = new URL(config.endpointUrl);
+        }
+        catch (error) {
+            throw new WebSearchApiError('INVALID_CONFIG', 'web search endpointUrl is invalid', { cause: error });
+        }
+        if (!['http:', 'https:'].includes(this.endpoint.protocol)) {
+            throw new WebSearchApiError('INVALID_CONFIG', 'web search endpointUrl must use http or https');
+        }
+        for (const [name, value] of [
+            ['timeoutMs', config.timeoutMs],
+            ['maxResponseBytes', config.maxResponseBytes],
+            ['defaultCount', config.defaultCount],
+            ['maxCount', config.maxCount]
+        ]) {
+            if (!Number.isSafeInteger(value) || value <= 0) {
+                throw new WebSearchApiError('INVALID_CONFIG', `${name} must be a positive integer`);
+            }
+        }
+        if (config.defaultCount > config.maxCount) {
+            throw new WebSearchApiError('INVALID_CONFIG', 'defaultCount must not exceed maxCount');
+        }
+        this.fetchImpl = dependencies.fetch ?? fetch;
+        this.readFileImpl = dependencies.readFile ?? readFile;
+        this.nowSeconds = dependencies.nowSeconds ?? (() => Math.floor(Date.now() / 1000));
+        this.nonce = dependencies.nonce ?? (() => randomUUID().replaceAll('-', ''));
+    }
+    async search(request, signal) {
+        const query = request.query.trim();
+        if (!query)
+            throw new WebSearchApiError('INVALID_REQUEST', 'web search query must not be empty');
+        const count = request.count ?? this.config.defaultCount;
+        const offset = request.offset ?? 0;
+        if (!Number.isSafeInteger(count) || count < 1 || count > this.config.maxCount) {
+            throw new WebSearchApiError('INVALID_REQUEST', `web search count must be between 1 and ${this.config.maxCount}`);
+        }
+        if (!Number.isSafeInteger(offset) || offset < 0) {
+            throw new WebSearchApiError('INVALID_REQUEST', 'web search offset must be a non-negative integer');
+        }
+        let metadata;
+        try {
+            metadata = JSON.parse(await this.readFileImpl(this.config.metadataPath, 'utf8'));
+        }
+        catch (error) {
+            throw new WebSearchApiError('MISSING_CREDENTIALS', 'unable to read Mobook runtime metadata', { cause: error });
+        }
+        const credentials = resolveSearchCredentials(metadata, this.config.channelId, this.config.legacyChannelId);
+        const timestamp = String(this.nowSeconds());
+        const nonce = this.nonce();
+        const message = `${credentials.userId}\n${credentials.deviceId}\n${timestamp}\n${nonce}`;
+        const signature = createHmac('sha256', credentials.botToken).update(message, 'utf8').digest('hex');
+        const body = {
+            user_id: credentials.userId,
+            bot_token: credentials.botToken,
+            device_id: credentials.deviceId,
+            signature,
+            timestamp,
+            nonce,
+            service: 'bocha_search',
+            query,
+            count,
+            offset,
+            language: request.language?.trim() || 'zh-CN'
+        };
+        if (request.includeDomains?.length)
+            body.include_domains = request.includeDomains;
+        if (request.excludeDomains?.length)
+            body.exclude_domains = request.excludeDomains;
+        const effectiveSignal = requestSignal(signal, this.config.timeoutMs);
+        let response;
+        try {
+            response = await this.fetchImpl(this.endpoint, {
+                method: 'POST',
+                headers: { accept: 'application/json', 'content-type': 'application/json' },
+                body: JSON.stringify(body),
+                signal: effectiveSignal
+            });
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
+            if (effectiveSignal.aborted) {
+                throw new WebSearchApiError('TIMEOUT', `web search request timed out after ${this.config.timeoutMs}ms`, {
+                    cause: error
+                });
+            }
+            throw new WebSearchApiError('NETWORK_ERROR', 'web search request failed', { cause: error });
+        }
+        const text = await responseText(response, this.config.maxResponseBytes);
+        if (!response.ok)
+            throw new WebSearchApiError('HTTP_ERROR', `web search request failed with HTTP ${response.status}`);
+        return parseResponse(text, query);
+    }
+}

package/src/config/env-config.d.ts

@@ -0,0 +1,10 @@
+export type BuildEnv = 'production' | 'test';
+export interface EnvConfig {
+    packageName: string;
+    channelId: string;
+    legacyChannelId: string;
+    endpointUrl: string;
+}
+export declare const ENV_CONFIG: Record<BuildEnv, EnvConfig>;
+export declare const DEFAULT_BUILD_ENV: BuildEnv;
+export declare const ACTIVE_ENV_CONFIG: EnvConfig;

package/src/config/env-config.js

@@ -0,0 +1,16 @@
+export const ENV_CONFIG = {
+    production: {
+        packageName: '@dcrays/web-search',
+        channelId: 'mbh-chat',
+        legacyChannelId: 'mbhchat',
+        endpointUrl: 'https://api-gateway.shuwenda.com/apikey-manage/api/search'
+    },
+    test: {
+        packageName: '@dcrays/web-search-test',
+        channelId: 'mbh-chat-test',
+        legacyChannelId: 'mbhchat-test',
+        endpointUrl: 'https://api-gateway.shuwenda.icu/apikey-manage/api/search'
+    }
+};
+export const DEFAULT_BUILD_ENV = 'production';
+export const ACTIVE_ENV_CONFIG = ENV_CONFIG[DEFAULT_BUILD_ENV];

package/src/index.d.ts

@@ -0,0 +1,4 @@
+export declare const MBH_WEB_SEARCH_PLUGIN_NAME = "mbh-web-search";
+export declare const MBH_WEB_SEARCH_SERVICE_KEY = "mbhWebSearch";
+export * from './api-client.js';
+export * from './tools.js';

package/src/index.js

@@ -0,0 +1,4 @@
+export const MBH_WEB_SEARCH_PLUGIN_NAME = 'mbh-web-search';
+export const MBH_WEB_SEARCH_SERVICE_KEY = 'mbhWebSearch';
+export * from './api-client.js';
+export * from './tools.js';

package/src/tools.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from '@deepseek-ai/dsh-tools';
+import type { WebSearchOperations } from './api-client.js';
+export declare function createWebSearchTool(search: WebSearchOperations): ToolDefinition;

package/src/tools.js

@@ -0,0 +1,31 @@
+import { defineTool } from '@deepseek-ai/dsh-tools';
+export function createWebSearchTool(search) {
+    return defineTool({
+        name: 'web_search',
+        description: 'Search the public web with the configured Mobook Bocha search service. Use this for current information, source discovery, fact verification, news, weather, prices, schedules, or any question that requires internet access. Cite result URLs when answering.',
+        parameters: {
+            query: { type: 'string', required: true, description: 'A focused web search query.' },
+            count: { type: 'integer', description: 'Number of results to return. Defaults to 5; maximum 20.' },
+            offset: { type: 'integer', description: 'Zero-based result offset for pagination.' },
+            language: { type: 'string', description: 'Search language, for example zh-CN or en-US.' },
+            includeDomains: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Optional domains to prefer or restrict, for example ["openai.com"].'
+            },
+            excludeDomains: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Optional domains to exclude from results.'
+            }
+        },
+        output: {
+            schema: { type: 'json' },
+            render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }]
+        },
+        timeoutMs: 35_000,
+        async execute(args, exec) {
+            return JSON.parse(JSON.stringify(await search.search(args, exec.signal)));
+        }
+    });
+}