deepseek-web-retrieval 0.4.0 → 0.5.1

package/src/core/domains.ts

@@ -1,30 +1,25 @@
-import { isIP } from "node:net"
-import type { FetchOptions } from "./types"
+import { isIP } from "node:net";
+import type { FetchOptions } from "./types";
 
 export function normalizeDomain(value: string): string | undefined {
-  const trimmed = value.trim()
-  if (!trimmed || /\s/.test(trimmed)) return undefined
-  const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)
-  if (hasScheme && !/^https?:\/\//i.test(trimmed)) return undefined
+  const trimmed = value.trim();
+  if (!trimmed || /\s/.test(trimmed)) return undefined;
+  const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed);
+  if (hasScheme && !/^https?:\/\//i.test(trimmed)) return undefined;
 
-  let hostname: string
+  let hostname: string;
   try {
     // Parsing with a synthetic scheme also strips paths, ports, and userinfo.
-    hostname = new URL(hasScheme ? trimmed : `http://${trimmed}`).hostname
+    hostname = new URL(hasScheme ? trimmed : `http://${trimmed}`).hostname;
   } catch {
-    return undefined
+    return undefined;
   }
-  return normalizeHostname(hostname)
+  return normalizeHostname(hostname);
 }
 
 /** Lowercases a URL hostname and removes brackets and trailing root-label dots. */
 export function normalizeHostname(value: string): string {
-  return value
-    .trim()
-    .toLowerCase()
-    .replace(/^\[/, "")
-    .replace(/\]$/, "")
-    .replace(/\.+$/, "")
+  return value.trim().toLowerCase().replace(/^\[/, "").replace(/\]$/, "").replace(/\.+$/, "");
 }
 
 /**
@@ -32,21 +27,21 @@ export function normalizeHostname(value: string): string {
  * but not `notexample.com` or `example.com.evil.test`.
  */
 export function domainMatches(hostname: string, domain: string): boolean {
-  const host = normalizeHostname(hostname)
-  const target = normalizeHostname(domain)
-  if (!host || !target) return false
-  return host === target || host.endsWith(`.${target}`)
+  const host = normalizeHostname(hostname);
+  const target = normalizeHostname(domain);
+  if (!host || !target) return false;
+  return host === target || host.endsWith(`.${target}`);
 }
 
 export function normalizeDomains(values: unknown): string[] {
-  if (!Array.isArray(values)) return []
-  const domains = new Set<string>()
+  if (!Array.isArray(values)) return [];
+  const domains = new Set<string>();
   for (const value of values) {
-    if (typeof value !== "string") continue
-    const domain = normalizeDomain(value)
-    if (domain) domains.add(domain)
+    if (typeof value !== "string") continue;
+    const domain = normalizeDomain(value);
+    if (domain) domains.add(domain);
   }
-  return [...domains]
+  return [...domains];
 }
 
 /**
@@ -55,9 +50,9 @@ export function normalizeDomains(values: unknown): string[] {
  * to a remote service and fails early instead of producing a confusing 404.
  */
 export function isPrivateHostname(value: string): boolean {
-  const host = normalizeHostname(value)
-  if (!host) return true
-  if (host === "localhost" || host === "local") return true
+  const host = normalizeHostname(value);
+  if (!host) return true;
+  if (host === "localhost" || host === "local") return true;
   if (
     host.endsWith(".localhost") ||
     host.endsWith(".local") ||
@@ -65,48 +60,43 @@ export function isPrivateHostname(value: string): boolean {
     host.endsWith(".lan") ||
     host.endsWith(".home.arpa")
   ) {
-    return true
+    return true;
   }
 
-  const version = isIP(host)
-  if (version === 4) return isPrivateIpv4(host)
-  if (version === 6) return isPrivateIpv6(host)
-  return false
+  const version = isIP(host);
+  if (version === 4) return isPrivateIpv4(host);
+  if (version === 6) return isPrivateIpv6(host);
+  return false;
 }
 
 export function assertFetchHostPolicy(
   url: URL,
   options: Pick<FetchOptions, "allowedDomains" | "blockedDomains" | "blockPrivateHosts">,
 ): void {
-  const host = normalizeHostname(url.hostname)
+  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))
+  const blocked = options.blockedDomains.find((domain) => domainMatches(host, domain));
   if (blocked) {
-    throw new Error(`Fetch blocked for ${host}: matched fetchBlockedDomains entry "${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)`,
-    )
+  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: string): boolean {
-  const parts = host.split(".").map((part) => Number(part))
+  const parts = host.split(".").map((part) => Number(part));
   if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
-    return true
+    return true;
   }
-  const [a, b] = parts
+  const [a, b] = parts;
   return (
     a === 0 ||
     a === 10 ||
@@ -117,37 +107,36 @@ function isPrivateIpv4(host: string): boolean {
     (a === 192 && b === 168) ||
     (a === 198 && (b === 18 || b === 19)) ||
     a >= 224
-  )
+  );
 }
 
 function isPrivateIpv6(host: string): boolean {
-  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 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;
 
   // IPv4-mapped IPv6, e.g. ::ffff:127.0.0.1. URL parsers normalize the dotted
   // form to hex (`::ffff:7f00:1`), so both representations must be handled.
-  const dottedMapped = value.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/)?.[1]
-  if (dottedMapped) return isPrivateIpv4(dottedMapped)
+  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 mapped = ipv4FromIpv6Hextets(value, /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
+  if (mapped) return isPrivateIpv4(mapped);
 
   // IPv4-compatible IPv6, e.g. ::127.0.0.1, which URL parsers normalize to
   // ::7f00:1.
-  const compatible = ipv4FromIpv6Hextets(value, /^::([0-9a-f]{1,4}):([0-9a-f]{1,4})$/)
-  if (compatible) return isPrivateIpv4(compatible)
+  const compatible = ipv4FromIpv6Hextets(value, /^::([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
+  if (compatible) return isPrivateIpv4(compatible);
 
-  return false
+  return false;
 }
 
 function ipv4FromIpv6Hextets(value: string, pattern: RegExp): string | undefined {
-  const match = value.match(pattern)
-  if (!match) return undefined
-  const high = Number.parseInt(match[1], 16)
-  const low = Number.parseInt(match[2], 16)
-  if (!Number.isFinite(high) || !Number.isFinite(low)) return undefined
-  return `${high >> 8}.${high & 0xff}.${low >> 8}.${low & 0xff}`
+  const match = value.match(pattern);
+  if (!match) return undefined;
+  const high = Number.parseInt(match[1], 16);
+  const low = Number.parseInt(match[2], 16);
+  if (!Number.isFinite(high) || !Number.isFinite(low)) return undefined;
+  return `${high >> 8}.${high & 0xff}.${low >> 8}.${low & 0xff}`;
 }
-

package/src/core/env.ts

@@ -0,0 +1,112 @@
+import { ENABLE_FETCH_ENV, ENABLE_SEARCH_ENV } from "./constants";
+import { resolvePluginOptions } from "./options";
+import type { PluginOptions, ResolvedOptions } from "./types";
+
+/** The environment an adapter reads its key and options from. */
+export type Env = Readonly<Record<string, string | undefined>>;
+
+/** Each supported option mapped onto its DEEPSEEK_* variable, grouped by value type. */
+const NUMBER_ENV = {
+  count: "DEEPSEEK_SEARCH_COUNT",
+  maxResults: "DEEPSEEK_SEARCH_MAX_RESULTS",
+  minRerank: "DEEPSEEK_SEARCH_MIN_RERANK",
+  minAuthority: "DEEPSEEK_SEARCH_MIN_AUTHORITY",
+  maxSummaryChars: "DEEPSEEK_SEARCH_MAX_SUMMARY_CHARS",
+  searchTimeoutMs: "DEEPSEEK_SEARCH_TIMEOUT_MS",
+  fetchMaxChars: "DEEPSEEK_FETCH_MAX_CHARS",
+  fetchTimeoutMs: "DEEPSEEK_FETCH_TIMEOUT_MS",
+  maxRetries: "DEEPSEEK_MAX_RETRIES",
+  retryBaseDelayMs: "DEEPSEEK_RETRY_BASE_DELAY_MS",
+} as const;
+
+const TEXT_ENV = {
+  language: "DEEPSEEK_SEARCH_LANGUAGE",
+} as const;
+
+const DOMAINS_ENV = {
+  blockedDomains: "DEEPSEEK_SEARCH_BLOCKED_DOMAINS",
+  includeDomains: "DEEPSEEK_SEARCH_INCLUDE_DOMAINS",
+  fetchAllowedDomains: "DEEPSEEK_FETCH_ALLOWED_DOMAINS",
+  fetchBlockedDomains: "DEEPSEEK_FETCH_BLOCKED_DOMAINS",
+} as const;
+
+/** Shared defaults are true; only an explicit false value disables them. */
+const FALSE_ONLY_ENV = {
+  allowUnknownAuthority: "DEEPSEEK_SEARCH_ALLOW_UNKNOWN_AUTHORITY",
+  fetchBlockPrivateHosts: "DEEPSEEK_FETCH_BLOCK_PRIVATE_HOSTS",
+  searchEnabled: ENABLE_SEARCH_ENV,
+  fetchEnabled: ENABLE_FETCH_ENV,
+} as const;
+
+/**
+ * Maps `DEEPSEEK_*` environment variables onto the shared plugin option keys and
+ * resolves them through the shared pipeline, so defaults and clamping stay
+ * identical across every adapter. Invalid values are dropped and the shared
+ * default applies.
+ */
+export function resolveEnvOptions(env: Env = process.env): ResolvedOptions {
+  return resolvePluginOptions(pluginOptionsFromEnv(env));
+}
+
+export function pluginOptionsFromEnv(env: Env): PluginOptions {
+  const options: Record<string, unknown> = {};
+
+  putNumber(options, "count", env);
+  putNumber(options, "maxResults", env);
+  putNumber(options, "minRerank", env);
+  putNumber(options, "minAuthority", env);
+  putFalseOnly(options, "allowUnknownAuthority", env);
+  putDomains(options, "blockedDomains", env);
+  putDomains(options, "includeDomains", env);
+  putText(options, "language", env);
+  putNumber(options, "maxSummaryChars", env);
+  putNumber(options, "searchTimeoutMs", env);
+
+  putNumber(options, "fetchMaxChars", env);
+  putDomains(options, "fetchAllowedDomains", env);
+  putDomains(options, "fetchBlockedDomains", env);
+  putNumber(options, "fetchTimeoutMs", env);
+  putFalseOnly(options, "fetchBlockPrivateHosts", env);
+  putFalseOnly(options, "searchEnabled", env);
+  putFalseOnly(options, "fetchEnabled", env);
+
+  putNumber(options, "maxRetries", env);
+  putNumber(options, "retryBaseDelayMs", env);
+
+  return options;
+}
+
+function putNumber(target: Record<string, unknown>, key: keyof typeof NUMBER_ENV, env: Env): void {
+  const value = env[NUMBER_ENV[key]];
+  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: Record<string, unknown>, key: keyof typeof TEXT_ENV, env: Env): void {
+  const value = env[TEXT_ENV[key]];
+  if (value === undefined) return;
+  const trimmed = value.trim();
+  if (trimmed) target[key] = trimmed;
+}
+
+function putFalseOnly(target: Record<string, unknown>, key: keyof typeof FALSE_ONLY_ENV, env: Env): void {
+  if (isFalseValue(env[FALSE_ONLY_ENV[key]])) target[key] = false;
+}
+
+function putDomains(target: Record<string, unknown>, key: keyof typeof DOMAINS_ENV, env: Env): void {
+  const value = env[DOMAINS_ENV[key]];
+  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 isFalseValue(value: string | undefined): boolean {
+  const trimmed = value?.trim().toLowerCase();
+  return trimmed === "false" || trimmed === "0" || trimmed === "no" || trimmed === "off";
+}

package/src/core/format.ts

@@ -1,18 +1,11 @@
-import {
-  FETCH_TRUNCATION_MARKER,
-  MAX_ERROR_BODY_CHARS,
-} from "./constants"
-import type { FormattedFetchContent, SearchResult } from "./types"
+import { FETCH_TRUNCATION_MARKER, MAX_ERROR_BODY_CHARS } from "./constants";
+import type { FormattedFetchContent, SearchResult } from "./types";
 
 /** Truncates by Unicode code points so emoji and surrogate pairs are not split. */
 export function truncate(value: string, maxChars: number): string {
-  if (maxChars <= 0) return ""
-  if (value.length <= maxChars) return value
-  return Array.from(value).slice(0, maxChars).join("")
-}
-
-export function formatFetchContent(title: string, content: string, maxChars: number): string {
-  return truncate(withTitle(title, content), maxChars)
+  if (maxChars <= 0) return "";
+  if (value.length <= maxChars) return value;
+  return Array.from(value).slice(0, maxChars).join("");
 }
 
 /**
@@ -20,40 +13,36 @@ export function formatFetchContent(title: string, content: string, maxChars: num
  * truncation marker counts toward `maxChars`, so the returned content never
  * exceeds the configured budget.
  */
-export function formatFetchedContent(
-  title: string,
-  content: string,
-  maxChars: number,
-): FormattedFetchContent {
-  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 }
+export function formatFetchedContent(title: string, content: string, maxChars: number): FormattedFetchContent {
+  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
+  const markerLength = Array.from(FETCH_TRUNCATION_MARKER).length;
   if (maxChars <= markerLength) {
-    return { content: truncate(document, maxChars), truncated: true }
+    return { content: truncate(document, maxChars), truncated: true };
   }
   return {
     content: `${truncate(document, maxChars - markerLength)}${FETCH_TRUNCATION_MARKER}`,
     truncated: true,
-  }
+  };
 }
 
 function withTitle(title: string, content: string): string {
-  const heading = title.trim()
-  if (!heading) return 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]
+  const body = content.trimStart();
+  const lines = body.split(/\r?\n/);
+  const firstHeading = lines[0]?.match(/^\\?#\s+(.+?)\s*$/)?.[1];
   if (firstHeading && normalizeHeading(firstHeading) === normalizeHeading(heading)) {
     // DeepSeek sometimes escapes the leading "#" as "\#"; normalize it so the
     // result is a real Markdown heading instead of a duplicated literal line.
-    lines[0] = `# ${heading}`
-    return lines.join("\n")
+    lines[0] = `# ${heading}`;
+    return lines.join("\n");
   }
-  return `# ${heading}\n\n${content}`
+  return `# ${heading}\n\n${content}`;
 }
 
 function normalizeHeading(value: string): string {
@@ -61,23 +50,23 @@ function normalizeHeading(value: string): string {
     .trim()
     .replace(/\s+/g, " ")
     .replace(/\s+#+\s*$/, "")
-    .toLowerCase()
+    .toLowerCase();
 }
 
 export function redactSecrets(value: string): string {
   return value
     .replace(/\bsk-[A-Za-z0-9_-]{8,}\b/g, "sk-***")
-    .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, "Bearer ***")
+    .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi, "Bearer ***");
 }
 
 export function formatApiError(operation: string, status: number, body: string): string {
-  const detail = redactSecrets(body.trim())
-  const detailChars = Array.from(detail)
+  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"
+    : "empty response body";
   const hint =
     status === 401
       ? "invalid API key"
@@ -87,13 +76,13 @@ export function formatApiError(operation: string, status: number, body: string):
           ? "permission denied"
           : status === 429
             ? "rate limited"
-            : undefined
-  const label = hint ? `${operation} failed (HTTP ${status}, ${hint})` : `${operation} failed (HTTP ${status})`
-  return `${label}: ${text}`
+            : undefined;
+  const label = hint ? `${operation} failed (HTTP ${status}, ${hint})` : `${operation} failed (HTTP ${status})`;
+  return `${label}: ${text}`;
 }
 
 export function formatTimeoutError(operation: string, timeoutMs: number): string {
-  return `${operation} timed out after ${timeoutMs} ms`
+  return `${operation} timed out after ${timeoutMs} ms`;
 }
 
 /**
@@ -101,27 +90,41 @@ export function formatTimeoutError(operation: string, timeoutMs: number): string
  * Hosts that ignore structured output read this text.
  */
 export function formatSearchResults(results: readonly SearchResult[]): string {
-  if (results.length === 0) return "No results found."
+  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})`]
+      const title = result.title?.trim() || result.url;
+      const lines = [`${index + 1}. [${escapeBrackets(title)}](${result.url})`];
       if (result.content) {
-        lines.push(`   ${result.content.replaceAll("\n", " ")}`)
+        lines.push(`   ${result.content.replaceAll("\n", " ")}`);
       }
       if (result.published !== undefined) {
-        lines.push(`   Published: ${formatPublished(result.published)}`)
+        lines.push(`   Published: ${formatPublished(result.published)}`);
       }
-      return lines.join("\n")
+      return lines.join("\n");
     })
-    .join("\n\n")
+    .join("\n\n");
+}
+
+/**
+ * Renders one search result as the structured mirror of its text form; hosts
+ * that read structuredContent (every JSON-replacing client excepted) get this
+ * shape from both adapters.
+ */
+export function toStructuredResult(result: SearchResult) {
+  return {
+    url: result.url,
+    ...(result.title ? { title: result.title } : {}),
+    ...(result.content ? { content: result.content } : {}),
+    ...(result.published !== undefined ? { published: result.published } : {}),
+  };
 }
 
 function escapeBrackets(value: string): string {
-  return value.replaceAll("[", "\\[").replaceAll("]", "\\]")
+  return value.replaceAll("[", "\\[").replaceAll("]", "\\]");
 }
 
 function formatPublished(epochMs: number): string {
-  return new Date(epochMs).toISOString().slice(0, 10)
+  return new Date(epochMs).toISOString().slice(0, 10);
 }

package/src/core/index.ts

@@ -1,9 +1,9 @@
-export * from "./auth"
-export * from "./client"
-export * from "./constants"
-export * from "./domains"
-export * from "./format"
-export * from "./options"
-export * from "./search"
-export * from "./types"
-export * from "./url"
+export * from "./auth";
+export * from "./client";
+export * from "./constants";
+export * from "./domains";
+export * from "./format";
+export * from "./options";
+export * from "./search";
+export * from "./types";
+export * from "./url";

package/src/core/jsonc.ts

@@ -1,4 +1,4 @@
-import { parse } from "jsonc-parser/lib/esm/main.js"
+import { parse } from "jsonc-parser/lib/esm/main.js";
 
 /**
  * Parses JSONC (JSON with comments and trailing commas) via jsonc-parser,
@@ -6,11 +6,11 @@ import { parse } from "jsonc-parser/lib/esm/main.js"
  * text has errors beyond tolerated comments and trailing commas.
  */
 export function parseJsonc(text: string): unknown {
-  const errors: { error: number; offset: number; length: number }[] = []
-  const value = parse(text, errors, { allowTrailingComma: true })
+  const errors: { error: number; offset: number; length: number }[] = [];
+  const value = parse(text, errors, { allowTrailingComma: true });
   if (errors.length > 0) {
-    const first = errors[0]
-    throw new SyntaxError(`JSONC parse error at offset ${first.offset} (code ${first.error})`)
+    const first = errors[0];
+    throw new SyntaxError(`JSONC parse error at offset ${first.offset} (code ${first.error})`);
   }
-  return value
+  return value;
 }

package/src/core/object.ts

@@ -0,0 +1,4 @@
+/** Shared plain-object guard: core modules and the installer's value helpers agree on one. */
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/core/options.ts

@@ -2,8 +2,8 @@ import {
   DEFAULT_API_KEY_SOURCE,
   DEFAULT_FETCH_MAX_CHARS,
   DEFAULT_MAX_RESULTS,
-  DEFAULT_MAX_SUMMARY_CHARS,
   DEFAULT_MAX_RETRIES,
+  DEFAULT_MAX_SUMMARY_CHARS,
   DEFAULT_MIN_AUTHORITY,
   DEFAULT_MIN_RERANK,
   DEFAULT_RETRY_BASE_DELAY_MS,
@@ -13,8 +13,8 @@ import {
   MAX_RETRY_DELAY_MS,
   MAX_TIMEOUT_MS,
   MIN_TIMEOUT_MS,
-} from "./constants"
-import { normalizeDomains } from "./domains"
+} from "./constants";
+import { normalizeDomains } from "./domains";
 import type {
   ApiKeySource,
   AuthOptions,
@@ -23,7 +23,7 @@ import type {
   ResolvedOptions,
   RetryOptions,
   SearchOptions,
-} from "./types"
+} from "./types";
 
 export function resolvePluginOptions(input?: PluginOptions): ResolvedOptions {
   return {
@@ -31,7 +31,7 @@ export function resolvePluginOptions(input?: PluginOptions): ResolvedOptions {
     fetch: resolveFetchOptions(input),
     auth: resolveAuthOptions(input),
     retry: resolveRetryOptions(input),
-  }
+  };
 }
 
 export function resolveSearchOptions(input?: PluginOptions): SearchOptions {
@@ -47,7 +47,7 @@ export function resolveSearchOptions(input?: PluginOptions): SearchOptions {
     maxSummaryChars: clampInt(input?.maxSummaryChars, DEFAULT_MAX_SUMMARY_CHARS, 0, 1_000_000),
     timeoutMs: clampInt(input?.searchTimeoutMs, DEFAULT_TIMEOUT_MS, MIN_TIMEOUT_MS, MAX_TIMEOUT_MS),
     enabled: input?.searchEnabled !== false,
-  }
+  };
 }
 
 export function resolveFetchOptions(input?: PluginOptions): FetchOptions {
@@ -58,26 +58,21 @@ export function resolveFetchOptions(input?: PluginOptions): FetchOptions {
     timeoutMs: clampInt(input?.fetchTimeoutMs, DEFAULT_TIMEOUT_MS, MIN_TIMEOUT_MS, MAX_TIMEOUT_MS),
     blockPrivateHosts: input?.fetchBlockPrivateHosts !== false,
     enabled: input?.fetchEnabled !== false,
-  }
+  };
 }
 
 export function resolveAuthOptions(input?: PluginOptions): AuthOptions {
-  const value = input?.apiKeySource
+  const value = input?.apiKeySource;
   return {
     source: value === "opencode" || value === "env" ? value : (DEFAULT_API_KEY_SOURCE as ApiKeySource),
-  }
+  };
 }
 
 export function resolveRetryOptions(input?: PluginOptions): RetryOptions {
   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,
-    ),
-  }
+    baseDelayMs: clampInt(input?.retryBaseDelayMs, DEFAULT_RETRY_BASE_DELAY_MS, 0, MAX_RETRY_DELAY_MS),
+  };
 }
 
 /**
@@ -86,23 +81,23 @@ export function resolveRetryOptions(input?: PluginOptions): RetryOptions {
  */
 export function resolveFetchTimeoutMs(configuredMs: number, inputSeconds?: unknown): number {
   if (typeof inputSeconds !== "number" || !Number.isFinite(inputSeconds) || inputSeconds <= 0) {
-    return configuredMs
+    return configuredMs;
   }
-  const inputMs = Math.min(MAX_TIMEOUT_MS, Math.max(1, Math.round(inputSeconds * 1000)))
-  return Math.min(configuredMs, inputMs)
+  const inputMs = Math.min(MAX_TIMEOUT_MS, Math.max(1, Math.round(inputSeconds * 1000)));
+  return Math.min(configuredMs, inputMs);
 }
 
 function optionalText(value: unknown): string | undefined {
-  if (typeof value !== "string") return undefined
-  const trimmed = value.trim()
-  return trimmed ? trimmed : undefined
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : undefined;
 }
 
 function finiteNumber(value: unknown, fallback: number): number {
-  return typeof value === "number" && Number.isFinite(value) ? value : fallback
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
 
 function clampInt(value: unknown, fallback: number, min: number, max: number): number {
-  const number = typeof value === "number" && Number.isFinite(value) ? Math.trunc(value) : fallback
-  return Math.min(max, Math.max(min, number))
+  const number = typeof value === "number" && Number.isFinite(value) ? Math.trunc(value) : fallback;
+  return Math.min(max, Math.max(min, number));
 }