deepseek-web-retrieval 0.0.0-stage → 0.2.0

package/dist/cli.js

@@ -0,0 +1,865 @@
+#!/usr/bin/env node
+
+// src/mcp/cli.ts
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+
+// src/core/auth.ts
+var API_KEY_ENV = "DEEPSEEK_API_KEY";
+function apiKeyFromEnv(env = process.env) {
+  const key = env[API_KEY_ENV]?.trim();
+  return key ? key : undefined;
+}
+
+// src/mcp/auth.ts
+var MISSING_API_KEY_MESSAGE = "DeepSeek API key not found. Set DEEPSEEK_API_KEY in the MCP server's env configuration.";
+function requireApiKey(env) {
+  const apiKey = apiKeyFromEnv(env);
+  if (!apiKey)
+    throw new Error(MISSING_API_KEY_MESSAGE);
+  return apiKey;
+}
+
+// src/core/constants.ts
+var SEARCH_ENDPOINT = "https://api.deepseek.com/v1/tools/search";
+var FETCH_ENDPOINT = "https://api.deepseek.com/v1/tools/fetch";
+var DEFAULT_SEARCH_COUNT = 10;
+var DEFAULT_MAX_RESULTS = 5;
+var DEFAULT_MIN_RERANK = 1.5;
+var DEFAULT_MIN_AUTHORITY = 2;
+var DEFAULT_MAX_SUMMARY_CHARS = 1200;
+var DEFAULT_FETCH_MAX_CHARS = 16000;
+var DEFAULT_TIMEOUT_MS = 30000;
+var MIN_TIMEOUT_MS = 1000;
+var MAX_TIMEOUT_MS = 120000;
+var MAX_QUERY_CHARS = 128;
+var MAX_URL_CHARS = 8192;
+var MAX_ERROR_BODY_CHARS = 2000;
+var MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
+var FETCH_TRUNCATION_MARKER = `
+
+[content truncated]`;
+var DEFAULT_API_KEY_SOURCE = "auto";
+var DEFAULT_MAX_RETRIES = 0;
+var MAX_RETRIES = 5;
+var DEFAULT_RETRY_BASE_DELAY_MS = 250;
+var MAX_RETRY_DELAY_MS = 1e4;
+
+// src/core/domains.ts
+import { isIP } from "node:net";
+function normalizeDomain(value) {
+  const trimmed = value.trim();
+  if (!trimmed || /\s/.test(trimmed))
+    return;
+  const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed);
+  if (hasScheme && !/^https?:\/\//i.test(trimmed))
+    return;
+  let hostname;
+  try {
+    hostname = new URL(hasScheme ? trimmed : `http://${trimmed}`).hostname;
+  } catch {
+    return;
+  }
+  return normalizeHostname(hostname);
+}
+function normalizeHostname(value) {
+  return value.trim().toLowerCase().replace(/^\[/, "").replace(/\]$/, "").replace(/\.+$/, "");
+}
+function domainMatches(hostname, domain) {
+  const host = normalizeHostname(hostname);
+  const target = normalizeHostname(domain);
+  if (!host || !target)
+    return false;
+  return host === target || host.endsWith(`.${target}`);
+}
+function normalizeDomains(values) {
+  if (!Array.isArray(values))
+    return [];
+  const domains = new Set;
+  for (const value of values) {
+    if (typeof value !== "string")
+      continue;
+    const domain = normalizeDomain(value);
+    if (domain)
+      domains.add(domain);
+  }
+  return [...domains];
+}
+function isPrivateHostname(value) {
+  const host = normalizeHostname(value);
+  if (!host)
+    return true;
+  if (host === "localhost" || host === "local")
+    return true;
+  if (host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal") || host.endsWith(".lan") || host.endsWith(".home.arpa")) {
+    return true;
+  }
+  const version = isIP(host);
+  if (version === 4)
+    return isPrivateIpv4(host);
+  if (version === 6)
+    return isPrivateIpv6(host);
+  return false;
+}
+function assertFetchHostPolicy(url, options) {
+  const host = normalizeHostname(url.hostname);
+  if (options.blockPrivateHosts && isPrivateHostname(host)) {
+    throw new Error(`Fetch blocked for ${host}: local/private addresses are not reachable by DeepSeek. ` + "Set fetchBlockPrivateHosts=false only if you really need to send the URL.");
+  }
+  const blocked = options.blockedDomains.find((domain) => domainMatches(host, domain));
+  if (blocked) {
+    throw new Error(`Fetch blocked for ${host}: matched fetchBlockedDomains entry "${blocked}"`);
+  }
+  if (options.allowedDomains.length > 0 && !options.allowedDomains.some((domain) => domainMatches(host, domain))) {
+    throw new Error(`Fetch not allowed for ${host}: add it to fetchAllowedDomains (exact host or subdomain)`);
+  }
+}
+function isPrivateIpv4(host) {
+  const parts = host.split(".").map((part) => Number(part));
+  if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
+    return true;
+  }
+  const [a, b] = parts;
+  return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || a >= 224;
+}
+function isPrivateIpv6(host) {
+  const value = host.toLowerCase();
+  if (value === "::" || value === "::1")
+    return true;
+  if (value.startsWith("fc") || value.startsWith("fd"))
+    return true;
+  if (/^fe[89ab]/.test(value))
+    return true;
+  const dottedMapped = value.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/)?.[1];
+  if (dottedMapped)
+    return isPrivateIpv4(dottedMapped);
+  const mapped = ipv4FromIpv6Hextets(value, /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
+  if (mapped)
+    return isPrivateIpv4(mapped);
+  const compatible = ipv4FromIpv6Hextets(value, /^::([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
+  if (compatible)
+    return isPrivateIpv4(compatible);
+  return false;
+}
+function ipv4FromIpv6Hextets(value, pattern) {
+  const match = value.match(pattern);
+  if (!match)
+    return;
+  const high = Number.parseInt(match[1], 16);
+  const low = Number.parseInt(match[2], 16);
+  if (!Number.isFinite(high) || !Number.isFinite(low))
+    return;
+  return `${high >> 8}.${high & 255}.${low >> 8}.${low & 255}`;
+}
+
+// src/core/options.ts
+function resolvePluginOptions(input) {
+  return {
+    search: resolveSearchOptions(input),
+    fetch: resolveFetchOptions(input),
+    auth: resolveAuthOptions(input),
+    retry: resolveRetryOptions(input)
+  };
+}
+function resolveSearchOptions(input) {
+  return {
+    count: clampInt(input?.count, DEFAULT_SEARCH_COUNT, 1, 50),
+    maxResults: clampInt(input?.maxResults, DEFAULT_MAX_RESULTS, 0, 50),
+    minRerank: finiteNumber(input?.minRerank, DEFAULT_MIN_RERANK),
+    minAuthority: finiteNumber(input?.minAuthority, DEFAULT_MIN_AUTHORITY),
+    allowUnknownAuthority: input?.allowUnknownAuthority === true,
+    blockedDomains: normalizeDomains(input?.blockedDomains),
+    includeDomains: normalizeDomains(input?.includeDomains),
+    language: optionalText(input?.language),
+    maxSummaryChars: clampInt(input?.maxSummaryChars, DEFAULT_MAX_SUMMARY_CHARS, 0, 1e6),
+    timeoutMs: clampInt(input?.searchTimeoutMs, DEFAULT_TIMEOUT_MS, MIN_TIMEOUT_MS, MAX_TIMEOUT_MS),
+    setDefault: input?.setDefaultWebsearch === true
+  };
+}
+function resolveFetchOptions(input) {
+  return {
+    maxChars: clampInt(input?.fetchMaxChars, DEFAULT_FETCH_MAX_CHARS, 0, 1e6),
+    allowedDomains: normalizeDomains(input?.fetchAllowedDomains),
+    blockedDomains: normalizeDomains(input?.fetchBlockedDomains),
+    timeoutMs: clampInt(input?.fetchTimeoutMs, DEFAULT_TIMEOUT_MS, MIN_TIMEOUT_MS, MAX_TIMEOUT_MS),
+    overrideWebfetch: input?.fetchOverrideWebfetch === true,
+    registerTool: input?.fetchRegisterTool !== false,
+    blockPrivateHosts: input?.fetchBlockPrivateHosts !== false
+  };
+}
+function resolveAuthOptions(input) {
+  const value = input?.apiKeySource;
+  return {
+    source: value === "opencode" || value === "env" ? value : DEFAULT_API_KEY_SOURCE
+  };
+}
+function resolveRetryOptions(input) {
+  return {
+    maxRetries: clampInt(input?.maxRetries, DEFAULT_MAX_RETRIES, 0, MAX_RETRIES),
+    baseDelayMs: clampInt(input?.retryBaseDelayMs, DEFAULT_RETRY_BASE_DELAY_MS, 0, MAX_RETRY_DELAY_MS)
+  };
+}
+function optionalText(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : undefined;
+}
+function finiteNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function clampInt(value, fallback, min, max) {
+  const number = typeof value === "number" && Number.isFinite(value) ? Math.trunc(value) : fallback;
+  return Math.min(max, Math.max(min, number));
+}
+
+// src/mcp/config.ts
+function resolveEnvOptions(env = process.env) {
+  return resolvePluginOptions(pluginOptionsFromEnv(env));
+}
+function pluginOptionsFromEnv(env) {
+  const options = {};
+  putNumber(options, "count", env.DEEPSEEK_SEARCH_COUNT);
+  putNumber(options, "maxResults", env.DEEPSEEK_SEARCH_MAX_RESULTS);
+  putNumber(options, "minRerank", env.DEEPSEEK_SEARCH_MIN_RERANK);
+  putNumber(options, "minAuthority", env.DEEPSEEK_SEARCH_MIN_AUTHORITY);
+  putBoolean(options, "allowUnknownAuthority", env.DEEPSEEK_SEARCH_ALLOW_UNKNOWN_AUTHORITY);
+  putDomains(options, "blockedDomains", env.DEEPSEEK_SEARCH_BLOCKED_DOMAINS);
+  putDomains(options, "includeDomains", env.DEEPSEEK_SEARCH_INCLUDE_DOMAINS);
+  putText(options, "language", env.DEEPSEEK_SEARCH_LANGUAGE);
+  putNumber(options, "maxSummaryChars", env.DEEPSEEK_SEARCH_MAX_SUMMARY_CHARS);
+  putNumber(options, "searchTimeoutMs", env.DEEPSEEK_SEARCH_TIMEOUT_MS);
+  putNumber(options, "fetchMaxChars", env.DEEPSEEK_FETCH_MAX_CHARS);
+  putDomains(options, "fetchAllowedDomains", env.DEEPSEEK_FETCH_ALLOWED_DOMAINS);
+  putDomains(options, "fetchBlockedDomains", env.DEEPSEEK_FETCH_BLOCKED_DOMAINS);
+  putNumber(options, "fetchTimeoutMs", env.DEEPSEEK_FETCH_TIMEOUT_MS);
+  if (isFalseValue(env.DEEPSEEK_FETCH_BLOCK_PRIVATE_HOSTS)) {
+    options.fetchBlockPrivateHosts = false;
+  }
+  putNumber(options, "maxRetries", env.DEEPSEEK_MAX_RETRIES);
+  putNumber(options, "retryBaseDelayMs", env.DEEPSEEK_RETRY_BASE_DELAY_MS);
+  return options;
+}
+function putNumber(target, key, value) {
+  if (value === undefined)
+    return;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return;
+  const parsed = Number(trimmed);
+  if (Number.isFinite(parsed))
+    target[key] = parsed;
+}
+function putText(target, key, value) {
+  if (value === undefined)
+    return;
+  const trimmed = value.trim();
+  if (trimmed)
+    target[key] = trimmed;
+}
+function putBoolean(target, key, value) {
+  if (isTrueValue(value))
+    target[key] = true;
+}
+function putDomains(target, key, value) {
+  if (value === undefined || !value.trim())
+    return;
+  const domains = value.split(",").map((domain) => domain.trim()).filter((domain) => domain.length > 0);
+  if (domains.length > 0)
+    target[key] = domains;
+}
+function isTrueValue(value) {
+  const trimmed = value?.trim().toLowerCase();
+  return trimmed === "true" || trimmed === "1" || trimmed === "yes" || trimmed === "on";
+}
+function isFalseValue(value) {
+  const trimmed = value?.trim().toLowerCase();
+  return trimmed === "false" || trimmed === "0" || trimmed === "no" || trimmed === "off";
+}
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/server";
+import * as z from "zod/v4";
+
+// src/core/format.ts
+function truncate(value, maxChars) {
+  if (maxChars <= 0)
+    return "";
+  if (value.length <= maxChars)
+    return value;
+  return Array.from(value).slice(0, maxChars).join("");
+}
+function formatFetchedContent(title, content, maxChars) {
+  const document = withTitle(title, content);
+  const length = Array.from(document).length;
+  if (maxChars <= 0)
+    return { content: "", truncated: length > 0 };
+  if (length <= maxChars)
+    return { content: document, truncated: false };
+  const markerLength = Array.from(FETCH_TRUNCATION_MARKER).length;
+  if (maxChars <= markerLength) {
+    return { content: truncate(document, maxChars), truncated: true };
+  }
+  return {
+    content: `${truncate(document, maxChars - markerLength)}${FETCH_TRUNCATION_MARKER}`,
+    truncated: true
+  };
+}
+function withTitle(title, content) {
+  const heading = title.trim();
+  if (!heading)
+    return content;
+  const body = content.trimStart();
+  const lines = body.split(/\r?\n/);
+  const firstHeading = lines[0]?.match(/^\\?#\s+(.+?)\s*$/)?.[1];
+  if (firstHeading && normalizeHeading(firstHeading) === normalizeHeading(heading)) {
+    lines[0] = `# ${heading}`;
+    return lines.join(`
+`);
+  }
+  return `# ${heading}
+
+${content}`;
+}
+function normalizeHeading(value) {
+  return value.trim().replace(/\s+/g, " ").replace(/\s+#+\s*$/, "").toLowerCase();
+}
+function redactSecrets(value) {
+  return value.replace(/\bsk-[A-Za-z0-9_-]{8,}\b/g, "sk-***").replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, "Bearer ***");
+}
+function formatApiError(operation, status, body) {
+  const detail = redactSecrets(body.trim());
+  const detailChars = Array.from(detail);
+  const text = detail ? detailChars.length > MAX_ERROR_BODY_CHARS ? `${detailChars.slice(0, MAX_ERROR_BODY_CHARS).join("")}…` : detail : "empty response body";
+  const hint = status === 401 ? "invalid API key" : status === 402 ? "insufficient balance" : status === 403 ? "permission denied" : status === 429 ? "rate limited" : undefined;
+  const label = hint ? `${operation} failed (HTTP ${status}, ${hint})` : `${operation} failed (HTTP ${status})`;
+  return `${label}: ${text}`;
+}
+function formatTimeoutError(operation, timeoutMs) {
+  return `${operation} timed out after ${timeoutMs} ms`;
+}
+
+// src/core/url.ts
+function parseFetchUrl(value) {
+  const input = value.trim();
+  if (!input)
+    throw new Error("URL must not be empty");
+  if (input.length > MAX_URL_CHARS) {
+    throw new Error(`URL must be ${MAX_URL_CHARS} characters or fewer`);
+  }
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    throw new Error("URL must be an absolute http:// or https:// URL");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("URL must use http:// or https://");
+  }
+  if (!url.hostname || !normalizeHostname(url.hostname)) {
+    throw new Error("URL must include a host");
+  }
+  if (url.username || url.password) {
+    throw new Error("URL must not contain credentials");
+  }
+  return url;
+}
+function normalizeResultUrl(value) {
+  if (typeof value !== "string")
+    return;
+  const input = value.trim();
+  if (!input || input.length > MAX_URL_CHARS)
+    return;
+  try {
+    const url = new URL(input);
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+      return;
+    if (!url.hostname || url.username || url.password)
+      return;
+    return url.href;
+  } catch {
+    return;
+  }
+}
+
+// src/core/search.ts
+function buildQuery(query, options) {
+  const parts = [query.trim()];
+  for (const domain of normalizeDomains(options.blockedDomains))
+    parts.push(`-site:${domain}`);
+  const include = normalizeDomains(options.includeDomains);
+  if (include.length)
+    parts.push(include.map((domain) => `site:${domain}`).join(" OR "));
+  const language = options.language?.trim().replace(/^lang:/i, "");
+  if (language)
+    parts.push(`lang:${language}`);
+  return parts.filter((part) => part.length > 0).join(" ");
+}
+function parsePublished(value) {
+  if (typeof value !== "string" || !value.trim())
+    return;
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : undefined;
+}
+function processResults(raw, options) {
+  const results = [];
+  const seen = new Set;
+  for (const item of raw) {
+    if (results.length >= options.maxResults)
+      break;
+    if (!item || typeof item !== "object")
+      continue;
+    const url = normalizeResultUrl(item.url);
+    if (!url || seen.has(url))
+      continue;
+    const rerank = item.rerank_score;
+    if (typeof rerank !== "number" || !Number.isFinite(rerank) || rerank < options.minRerank)
+      continue;
+    const authority = item.authority;
+    const knownAuthority = typeof authority === "number" && Number.isFinite(authority) && authority >= 0;
+    if (knownAuthority) {
+      if (authority < options.minAuthority)
+        continue;
+    } else if (!options.allowUnknownAuthority) {
+      continue;
+    }
+    seen.add(url);
+    const content = truncate(optionalText2(item.summary) ?? optionalText2(item.snippet) ?? "", options.maxSummaryChars);
+    const time = {};
+    const published = parsePublished(item.date);
+    if (published !== undefined)
+      time.published = published;
+    const title = optionalText2(item.title);
+    results.push({
+      url,
+      ...title ? { title } : {},
+      ...content ? { content } : {},
+      time
+    });
+  }
+  return results;
+}
+function optionalText2(value) {
+  if (typeof value !== "string")
+    return;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+// src/core/client.ts
+class DeepSeekApiError extends Error {
+  operation;
+  status;
+  body;
+  retryable;
+  retryAfterMs;
+  constructor(input) {
+    const body = redactSecrets(input.body);
+    super(formatApiError(input.operation, input.status, body));
+    this.name = "DeepSeekApiError";
+    this.operation = input.operation;
+    this.status = input.status;
+    this.body = body;
+    this.retryable = input.status === 408 || input.status === 425 || input.status === 429 || input.status >= 500 && input.status <= 599;
+    this.retryAfterMs = input.retryAfterMs;
+  }
+}
+async function searchWeb(query, options, request) {
+  const trimmed = query.trim();
+  if (!trimmed)
+    throw new Error("DeepSeek search query must not be empty");
+  if (Array.from(trimmed).length > MAX_QUERY_CHARS) {
+    throw new Error(`DeepSeek search query must be ${MAX_QUERY_CHARS} characters or fewer`);
+  }
+  const builtQuery = buildQuery(trimmed, options);
+  const builtQueryLength = Array.from(builtQuery).length;
+  if (builtQueryLength > MAX_QUERY_CHARS) {
+    throw new Error(`DeepSeek search query must be ${MAX_QUERY_CHARS} characters or fewer after applying ` + `blockedDomains, includeDomains, and language ` + `(built query is ${builtQueryLength} characters)`);
+  }
+  const payload = await postJson(SEARCH_ENDPOINT, {
+    query: builtQuery,
+    count: options.count,
+    need_content: false
+  }, "DeepSeek Search", request, options.timeoutMs);
+  if (!Array.isArray(payload.results)) {
+    throw new Error("DeepSeek Search returned a response without a results array");
+  }
+  return processResults(payload.results, options);
+}
+async function fetchPage(url, options, request) {
+  assertFetchHostPolicy(url, options);
+  const payload = await postJson(FETCH_ENDPOINT, { url: url.href }, "DeepSeek Fetch", request, options.timeoutMs);
+  const title = typeof payload.title === "string" ? payload.title.trim() : "";
+  const content = typeof payload.content === "string" ? payload.content : "";
+  if (!content.trim()) {
+    throw new Error("DeepSeek Fetch returned no page content (the page may be empty or unavailable)");
+  }
+  return { url: url.href, title, content };
+}
+async function postJson(endpoint, body, operation, options, timeoutMs) {
+  const attempts = options.retry.maxRetries + 1;
+  let lastError;
+  for (let attempt = 0;attempt < attempts; attempt++) {
+    try {
+      return await requestOnce(endpoint, body, operation, options, timeoutMs);
+    } catch (error) {
+      lastError = error;
+      if (!(error instanceof DeepSeekApiError) || !error.retryable || attempt === attempts - 1) {
+        throw error;
+      }
+      await sleep(retryDelay(error.retryAfterMs, options.retry.baseDelayMs, attempt), options.signal);
+    }
+  }
+  throw lastError;
+}
+async function requestOnce(endpoint, body, operation, options, timeoutMs) {
+  return fetchWithTimeout(endpoint, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${options.auth.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  }, options.signal, timeoutMs, operation, async (response) => {
+    if (!response.ok) {
+      const text2 = await readBoundedText(response, MAX_ERROR_BODY_CHARS);
+      throw new DeepSeekApiError({
+        operation,
+        status: response.status,
+        body: text2,
+        retryAfterMs: parseRetryAfter(response.headers.get("retry-after"))
+      });
+    }
+    const text = await readResponseText(response, MAX_RESPONSE_BYTES, operation);
+    if (!text.trim())
+      throw new Error(`${operation} returned an empty response body`);
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new Error(`${operation} returned invalid JSON: ${truncate(redactSecrets(text), 500)}`);
+    }
+  });
+}
+async function fetchWithTimeout(endpoint, init, signal, timeoutMs, operation, handleResponse) {
+  const controller = new AbortController;
+  let timedOut = false;
+  const forwardAbort = () => controller.abort(signal.reason);
+  if (signal.aborted)
+    forwardAbort();
+  else
+    signal.addEventListener("abort", forwardAbort, { once: true });
+  const timer = signal.aborted ? undefined : setTimeout(() => {
+    timedOut = true;
+    controller.abort(new Error("timeout"));
+  }, timeoutMs);
+  try {
+    const response = await fetch(endpoint, { ...init, signal: controller.signal });
+    return await handleResponse(response);
+  } catch (error) {
+    if (timedOut)
+      throw new Error(formatTimeoutError(operation, timeoutMs));
+    if (signal.aborted)
+      throw abortReason(signal, operation);
+    throw error;
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+    signal.removeEventListener("abort", forwardAbort);
+  }
+}
+function parseRetryAfter(value) {
+  if (!value)
+    return;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return;
+  if (/^\d+$/.test(trimmed)) {
+    return Math.min(MAX_RETRY_DELAY_MS, Number(trimmed) * 1000);
+  }
+  const timestamp = Date.parse(trimmed);
+  if (!Number.isFinite(timestamp))
+    return;
+  return Math.min(MAX_RETRY_DELAY_MS, Math.max(0, timestamp - Date.now()));
+}
+function retryDelay(retryAfterMs, baseDelayMs, attempt) {
+  if (retryAfterMs !== undefined)
+    return retryAfterMs;
+  return Math.min(MAX_RETRY_DELAY_MS, baseDelayMs * 2 ** attempt);
+}
+function sleep(ms, signal) {
+  if (ms <= 0)
+    return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortReason(signal, "DeepSeek request"));
+    };
+    if (signal.aborted) {
+      clearTimeout(timer);
+      reject(abortReason(signal, "DeepSeek request"));
+      return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function abortReason(signal, operation) {
+  return signal.reason instanceof Error ? signal.reason : new Error(`${operation} request aborted`);
+}
+async function readBoundedText(response, maxChars) {
+  if (!response.body)
+    return truncate(await response.text(), maxChars + 1);
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  const limit = maxChars + 1;
+  let text = "";
+  let chars = 0;
+  try {
+    while (chars < limit) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      const chunk = decoder.decode(value, { stream: true });
+      text += chunk;
+      chars += Array.from(chunk).length;
+    }
+    text += decoder.decode();
+  } finally {
+    await reader.cancel().catch(() => {
+      return;
+    });
+    reader.releaseLock();
+  }
+  return truncate(text, limit);
+}
+async function readResponseText(response, maxBytes, operation) {
+  if (!response.body) {
+    const text2 = await response.text();
+    if (new TextEncoder().encode(text2).byteLength > maxBytes) {
+      throw new Error(`${operation} response exceeded ${maxBytes} bytes`);
+    }
+    return text2;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let text = "";
+  let bytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      bytes += value.byteLength;
+      if (bytes > maxBytes) {
+        throw new Error(`${operation} response exceeded ${maxBytes} bytes`);
+      }
+      text += decoder.decode(value, { stream: true });
+    }
+    text += decoder.decode();
+  } finally {
+    await reader.cancel().catch(() => {
+      return;
+    });
+    reader.releaseLock();
+  }
+  return text;
+}
+// package.json
+var package_default = {
+  $schema: "https://json.schemastore.org/package.json",
+  name: "deepseek-web-retrieval",
+  version: "0.2.0",
+  description: "Token-efficient DeepSeek Search and Fetch for coding agents, starting with OpenCode v2.",
+  type: "module",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/gwokhou/deepseek-web-retrieval.git"
+  },
+  homepage: "https://github.com/gwokhou/deepseek-web-retrieval#readme",
+  bugs: "https://github.com/gwokhou/deepseek-web-retrieval/issues",
+  keywords: [
+    "opencode",
+    "opencode-plugin",
+    "deepseek",
+    "websearch",
+    "webfetch",
+    "coding-agent",
+    "mcp"
+  ],
+  exports: {
+    ".": "./index.ts",
+    "./core": "./src/core/index.ts",
+    "./mcp": "./src/mcp/server.ts"
+  },
+  bin: {
+    "deepseek-web-retrieval": "./dist/cli.js"
+  },
+  files: [
+    "index.ts",
+    "src",
+    "dist",
+    "docs",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "examples"
+  ],
+  scripts: {
+    typecheck: "tsc --noEmit",
+    build: "bun build src/mcp/cli.ts --target=node --format=esm --outdir=dist --external @modelcontextprotocol/server --external @modelcontextprotocol/server/stdio --external zod --external zod/v4",
+    prepublishOnly: "bun run typecheck && bun run build",
+    test: "bun test",
+    "test:e2e": "bun run test/e2e/run.ts",
+    "docs:matrix": "bun run scripts/render-matrix.ts",
+    "test:coverage": "bun test --coverage",
+    check: "bun run typecheck && bun run build && bun test"
+  },
+  peerDependencies: {
+    "@opencode/plugin": "^2.0.32"
+  },
+  devDependencies: {
+    "@modelcontextprotocol/client": "^2.3.1",
+    "@opencode/plugin": "2.0.32",
+    "@types/bun": "1.4.0",
+    "@types/node": "^26.6.5",
+    typescript: "5.9.3"
+  },
+  engines: {
+    bun: ">=1.3.0",
+    node: ">=20"
+  },
+  dependencies: {
+    "@modelcontextprotocol/server": "^2.3.1",
+    zod: "^4"
+  }
+};
+
+// src/mcp/format.ts
+function formatSearchResults(results) {
+  if (results.length === 0)
+    return "No results found.";
+  return results.map((result, index) => {
+    const title = result.title?.trim() || result.url;
+    const lines = [`${index + 1}. [${escapeBrackets(title)}](${result.url})`];
+    if (result.content) {
+      lines.push(`   ${result.content.replaceAll(`
+`, " ")}`);
+    }
+    if (result.time.published !== undefined) {
+      lines.push(`   Published: ${formatPublished(result.time.published)}`);
+    }
+    return lines.join(`
+`);
+  }).join(`
+
+`);
+}
+function escapeBrackets(value) {
+  return value.replaceAll("[", "\\[").replaceAll("]", "\\]");
+}
+function formatPublished(epochMs) {
+  return new Date(epochMs).toISOString().slice(0, 10);
+}
+
+// src/mcp/server.ts
+var MCP_SERVER_NAME = "deepseek-web-retrieval";
+var SEARCH_INPUT = z.object({
+  query: z.string().min(1).describe("Search query, 128 characters or fewer including operators (site:, -site:, quoted phrases, lang:).")
+});
+var SEARCH_OUTPUT = z.object({
+  results: z.array(z.object({
+    url: z.string(),
+    title: z.string().optional(),
+    content: z.string().optional(),
+    published: z.number().optional()
+  }))
+});
+var FETCH_INPUT = z.object({
+  url: z.string().min(1).describe("Absolute http:// or https:// URL to fetch. Credentials are rejected.")
+});
+var FETCH_OUTPUT = z.object({
+  url: z.string(),
+  title: z.string(),
+  content: z.string(),
+  truncated: z.boolean()
+});
+var SEARCH_DESCRIPTION = "Search the web with DeepSeek's in-house search engine and return a short, filtered result " + "list (title, URL, summary). Results are ranked by relevance and source authority, deduplicated " + "by URL, and capped at the configured maximum. An empty result list is normal, not an error. " + "Use site:/-site: operators in the query to include or exclude domains; the full query must stay " + "within 128 characters. To read a full page, pass a result URL to the deepseek_fetch tool.";
+var FETCH_DESCRIPTION = "Fetch one web page as clean Markdown through DeepSeek's Fetch API. DeepSeek does not render " + "JavaScript and cannot reach private networks; PDFs, images, and other binary files are " + "unsupported. Output is truncated to the configured size.";
+function createDeepSeekServer(config, env = process.env) {
+  const server = new McpServer({ name: MCP_SERVER_NAME, version: package_default.version });
+  server.registerTool("deepseek_web_search", {
+    title: "DeepSeek Web Search",
+    description: SEARCH_DESCRIPTION,
+    inputSchema: SEARCH_INPUT,
+    outputSchema: SEARCH_OUTPUT,
+    annotations: { readOnlyHint: true }
+  }, async ({ query }, ctx) => {
+    try {
+      const request = requestContext(config, env, ctx.mcpReq.signal);
+      const results = await searchWeb(query, config.search, request);
+      return {
+        content: [{ type: "text", text: formatSearchResults(results) }],
+        structuredContent: { results: results.map(toStructuredResult) }
+      };
+    } catch (error) {
+      return toErrorResult(error);
+    }
+  });
+  server.registerTool("deepseek_fetch", {
+    title: "DeepSeek Fetch",
+    description: FETCH_DESCRIPTION,
+    inputSchema: FETCH_INPUT,
+    outputSchema: FETCH_OUTPUT,
+    annotations: { readOnlyHint: true }
+  }, async ({ url }, ctx) => {
+    try {
+      const request = requestContext(config, env, ctx.mcpReq.signal);
+      const target = parseFetchUrl(url);
+      assertFetchHostPolicy(target, config.fetch);
+      const page = await fetchPage(target, config.fetch, request);
+      const formatted = formatFetchedContent(page.title, page.content, config.fetch.maxChars);
+      return {
+        content: [{ type: "text", text: formatted.content }],
+        structuredContent: {
+          url: page.url,
+          title: page.title,
+          content: formatted.content,
+          truncated: formatted.truncated
+        }
+      };
+    } catch (error) {
+      return toErrorResult(error);
+    }
+  });
+  return server;
+}
+function requestContext(config, env, signal) {
+  return { signal, auth: { apiKey: requireApiKey(env) }, retry: config.retry };
+}
+function toStructuredResult(result) {
+  return {
+    url: result.url,
+    ...result.title ? { title: result.title } : {},
+    ...result.content ? { content: result.content } : {},
+    ...result.time.published !== undefined ? { published: result.time.published } : {}
+  };
+}
+function toErrorResult(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+
+// src/mcp/cli.ts
+var env = process.env;
+if (!apiKeyFromEnv(env)) {
+  console.error(MISSING_API_KEY_MESSAGE);
+  process.exit(1);
+}
+var config = resolveEnvOptions(env);
+var handle = serveStdio(() => createDeepSeekServer(config, env));
+console.error(`deepseek-web-retrieval MCP server on stdio ` + `(search: max ${config.search.maxResults} results, fetch: max ${config.fetch.maxChars} chars)`);
+process.on("SIGINT", () => void handle.close());
+process.on("SIGTERM", () => void handle.close());