@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-web-access/web-tool-core.js

@@ -0,0 +1,1312 @@
+import { existsSync, readFileSync } from "node:fs";
+import pLimit from "p-limit";
+import { normalizeFetchContentParams } from "./fetch-params.js";
+import { resolveAuthFetchProfile } from "./auth-fetch.js";
+import { findContent } from "./content-find.js";
+import {
+  assertSearchProviderSelectionAllowed,
+  normalizeSearchProviderSelection,
+  search
+} from "./gemini-search.js";
+import { isOpenAISearchAvailable } from "./openai-search.js";
+import { getWebSearchConfigPath, runWithProxy } from "./utils.js";
+import { deleteResult, generateId, getResult, storeResult } from "./storage.js";
+import {
+  buildResearchArtifact,
+  getResearchArtifact,
+  storeResearchArtifact,
+  withClaimAssessment
+} from "./source-check.js";
+export const WEB_SEARCH_CONFIG_PATH = getWebSearchConfigPath();
+export function parseConfigRoot(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse ${WEB_SEARCH_CONFIG_PATH}: ${message}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Invalid config in ${WEB_SEARCH_CONFIG_PATH}: expected a JSON object`);
+  }
+  return parsed;
+}
+export function loadConfig() {
+  if (!existsSync(WEB_SEARCH_CONFIG_PATH))
+    return {};
+  return parseConfigRoot(readFileSync(WEB_SEARCH_CONFIG_PATH, "utf-8"));
+}
+export const DEFAULT_TOOL_NAMES = {
+  webSearch: "web_search",
+  sourceCheck: "source_check",
+  fetchContent: "fetch_content",
+  getSearchContent: "get_search_content"
+};
+const SEARCH_QUERY_CONCURRENCY = 3;
+const FETCH_MODES = ["readable", "raw", "answer"];
+export function resolveFetchModeConfig(config) {
+  const configuredModes = config.fetch?.allowedModes ?? FETCH_MODES;
+  if (!Array.isArray(configuredModes) || configuredModes.length === 0 || configuredModes.some((mode) => !FETCH_MODES.includes(mode))) {
+    throw new Error(`fetch.allowedModes in ${WEB_SEARCH_CONFIG_PATH} must be a non-empty array containing only "readable", "raw", or "answer"`);
+  }
+  const allowedModes = configuredModes;
+  const duplicateMode = allowedModes.find((mode, index) => allowedModes.indexOf(mode) !== index);
+  if (duplicateMode) {
+    throw new Error(`fetch.allowedModes in ${WEB_SEARCH_CONFIG_PATH} must not contain duplicates: "${duplicateMode}"`);
+  }
+  const defaultMode = config.fetch?.defaultMode ?? "readable";
+  if (!allowedModes.includes(defaultMode)) {
+    throw new Error(`fetch.defaultMode in ${WEB_SEARCH_CONFIG_PATH} must be one of fetch.allowedModes`);
+  }
+  return { defaultMode, allowedModes };
+}
+export function runSearchQueries(queries, run) {
+  const limit = pLimit(SEARCH_QUERY_CONCURRENCY);
+  return Promise.all(queries.map((query, index) => limit(() => run(query, index))));
+}
+export function isToolEnabled(config, key) {
+  const override = config.tools?.[key]?.enabled;
+  if (typeof override === "boolean")
+    return override;
+  return key !== "webSearch" && key !== "sourceCheck" || config.webSearch?.enabled !== false;
+}
+function joinToolNames(names) {
+  if (names.length === 0)
+    return "stored content";
+  if (names.length === 1)
+    return names[0];
+  if (names.length === 2)
+    return `${names[0]} or ${names[1]}`;
+  return `${names.slice(0, -1).join(", ")}, or ${names[names.length - 1]}`;
+}
+export function normalizeProviderInput(value, label = "provider") {
+  if (value === undefined)
+    return;
+  return normalizeSearchProviderSelection(value, label);
+}
+export function resolveRequestedProvider(requested) {
+  const normalizedRequested = normalizeProviderInput(requested);
+  if (normalizedRequested && normalizedRequested !== "auto") {
+    assertSearchProviderSelectionAllowed(normalizedRequested, "Requested provider");
+    return normalizedRequested;
+  }
+  const config = loadConfig();
+  const provider = normalizeProviderInput(config.searchProvider ?? config.provider, `provider in ${WEB_SEARCH_CONFIG_PATH}`) ?? "auto";
+  assertSearchProviderSelectionAllowed(provider, `configured provider in ${WEB_SEARCH_CONFIG_PATH}`);
+  return provider;
+}
+export function toCuratorProvider(provider) {
+  if (Array.isArray(provider))
+    return "all";
+  return provider === "auto" ? undefined : provider;
+}
+export function normalizeRecencyFilter(value) {
+  return value === "day" || value === "week" || value === "month" || value === "year" ? value : undefined;
+}
+export function normalizeQueryList(queryList) {
+  const normalized = [];
+  for (const query of queryList) {
+    if (typeof query !== "string")
+      continue;
+    const trimmed = query.trim();
+    if (trimmed.length > 0)
+      normalized.push(trimmed);
+  }
+  return normalized;
+}
+export function expandQueryString(query) {
+  if (typeof query !== "string")
+    return [];
+  const trimmed = query.trim();
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed) && parsed.every((entry) => typeof entry === "string")) {
+        return parsed.map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+      }
+    } catch {}
+  }
+  return [query];
+}
+let extractModulePromise;
+export async function fetchAllContent(urls, signal, options) {
+  const extractModule = await (extractModulePromise ??= import("./extract.js"));
+  return extractModule.fetchAllContent(urls, signal, options);
+}
+export async function fetchUncoveredContent(urls, provided, fetchPages) {
+  const providedByUrl = new Map;
+  for (const content of provided ?? []) {
+    if (!providedByUrl.has(content.url))
+      providedByUrl.set(content.url, content);
+  }
+  const missing = urls.filter((url) => !providedByUrl.has(url));
+  const fetched = missing.length > 0 ? await fetchPages(missing) : [];
+  let next = 0;
+  return urls.map((url) => providedByUrl.get(url) ?? fetched[next++]);
+}
+export function withRegisteredFetchOptions(options, toolNames, proxy) {
+  return {
+    ...options ?? {},
+    toolNames,
+    ...proxy !== undefined ? { proxy } : {}
+  };
+}
+function isAbortError(err) {
+  return (err instanceof Error ? err.message : String(err)).toLowerCase().includes("abort");
+}
+const DEFAULT_MAX_INLINE_CONTENT_CHARS = 30000;
+const MIN_INLINE_CONTENT_CHARS = 1000;
+const MAX_INLINE_CONTENT_CHARS = 200000;
+export function getMaxInlineContentChars(config = loadConfig()) {
+  const value = config.maxInlineContentChars;
+  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value < MIN_INLINE_CONTENT_CHARS) {
+    return DEFAULT_MAX_INLINE_CONTENT_CHARS;
+  }
+  return Math.min(value, MAX_INLINE_CONTENT_CHARS);
+}
+export function stripThumbnails(results) {
+  return results.map(({ thumbnail, frames, ...rest }) => rest);
+}
+function searchStructuredContent(responseId, fetchId, results) {
+  return {
+    responseId,
+    fetchId,
+    queries: results.map(({ query, answer, error, provider, providers, results }) => ({
+      query,
+      answer,
+      error,
+      provider,
+      providers,
+      results: results.map(({ title, url, snippet }) => ({ title, url, snippet }))
+    }))
+  };
+}
+function fetchStructuredContent(responseId, results) {
+  return {
+    responseId,
+    urls: results.map(({ url, title, content, error, mimeType, status, duration }) => ({ url, title, content, error, mimeType, status, duration }))
+  };
+}
+function initialContentSlice(content, maxChars) {
+  let endOffset = Math.min(content.length, maxChars);
+  if (endOffset < content.length) {
+    const lineBreak = content.lastIndexOf(`
+`, endOffset);
+    if (lineBreak >= Math.floor(maxChars * 0.8))
+      endOffset = lineBreak + 1;
+  }
+  const text = content.slice(0, endOffset);
+  return {
+    text,
+    endOffset,
+    totalBytes: Buffer.byteLength(content),
+    totalLines: content.length === 0 ? 0 : content.split(`
+`).length,
+    shownBytes: Buffer.byteLength(text),
+    shownLines: text.length === 0 ? 0 : text.split(`
+`).length
+  };
+}
+function normalizeFindQueries(value) {
+  const queries = (Array.isArray(value) ? value : [value]).map((query) => query.trim()).filter(Boolean);
+  if (queries.length === 0)
+    throw new Error("findText must contain at least one non-empty string");
+  return queries;
+}
+function normalizeFindMode(value) {
+  if (value === undefined)
+    return;
+  if (value === "exact" || value === "case-insensitive" || value === "fuzzy")
+    return value;
+  throw new Error('findMode must be "exact", "case-insensitive", or "fuzzy"');
+}
+function normalizeGetSearchContentParams(params) {
+  const normalized = { ...params, findMode: normalizeFindMode(params.findMode) };
+  if (normalized.query?.trim() === "")
+    delete normalized.query;
+  if (normalized.url?.trim() === "")
+    delete normalized.url;
+  if (normalized.findText !== undefined) {
+    delete normalized.offset;
+    delete normalized.limit;
+  }
+  return normalized;
+}
+function formatInputValue(value) {
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (typeof value === "number")
+    return Number.isNaN(value) ? "NaN" : String(value);
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized === undefined ? String(value) : serialized;
+  } catch {
+    return String(value);
+  }
+}
+function formatSearchSummary(results, answer) {
+  if (results.length === 0) {
+    return answer ? `${answer}
+
+---
+
+**Sources:**
+No sources returned.` : "No results found.";
+  }
+  let output = answer ? `${answer}
+
+---
+
+**Sources:**
+` : "";
+  output += results.map((r, i) => `${i + 1}. ${r.title}
+   ${r.url}`).join(`
+
+`);
+  return output;
+}
+function formatSourceCheckResult(artifact, getSearchContentTool = DEFAULT_TOOL_NAMES.getSearchContent) {
+  const assessment = artifact.claims?.[0];
+  const lines = [`# Source check: ${artifact.query}`, ""];
+  if (assessment) {
+    lines.push(`**Status:** ${assessment.status} (confidence ${assessment.confidence.toFixed(2)})`);
+    lines.push(`**Rationale:** ${assessment.rationale}`);
+    if (assessment.supporting_passages.length > 0)
+      lines.push(`**Supporting passages:** ${assessment.supporting_passages.join(", ")}`);
+    if (assessment.contradicting_passages.length > 0)
+      lines.push(`**Contradicting passages:** ${assessment.contradicting_passages.join(", ")}`);
+    lines.push("");
+  }
+  if (artifact.sources.length > 0) {
+    lines.push("## Sources");
+    for (const source of artifact.sources)
+      lines.push(`${source.rank}. [${source.quality}] ${source.title}
+   ${source.url}`);
+    lines.push("");
+  }
+  if (artifact.errors?.length)
+    lines.push(`Search errors: ${artifact.errors.map((entry) => `${entry.query}: ${entry.error}`).join("; ")}`);
+  lines.push(getSearchContentTool ? `Artifact responseId: ${artifact.id} (retrievable via ${getSearchContentTool}).` : `Artifact responseId: ${artifact.id}. Content retrieval is not registered.`);
+  return lines.join(`
+`);
+}
+function duplicateQuerySet(results) {
+  const counts = new Map;
+  for (const result of results) {
+    counts.set(result.query, (counts.get(result.query) ?? 0) + 1);
+  }
+  const duplicates = new Set;
+  for (const [query, count] of counts) {
+    if (count > 1)
+      duplicates.add(query);
+  }
+  return duplicates;
+}
+function formatQueryHeader(query, provider, duplicateQueries) {
+  const suffix = duplicateQueries.has(query) && provider ? ` (${provider})` : "";
+  return `## Query: "${query}"${suffix}
+
+`;
+}
+function hasFullInlineCoverage(urls, inlineContent) {
+  if (!inlineContent || inlineContent.length === 0)
+    return false;
+  const coveredUrls = new Set(inlineContent.map((c) => c.url));
+  return urls.every((url) => coveredUrls.has(url));
+}
+function formatFullResults(queryData) {
+  let output = `## Results for: "${queryData.query}"
+
+`;
+  const providers = queryData.providers ?? (queryData.provider ? [queryData.provider] : []);
+  if (providers.length > 0)
+    output += `**Provider${providers.length === 1 ? "" : "s"}:** ${providers.join(", ")}
+
+`;
+  if (queryData.answer) {
+    output += `${queryData.answer}
+
+---
+
+`;
+  }
+  for (const r of queryData.results) {
+    output += `### ${r.title}
+${r.url}${r.snippet ? `
+
+${r.snippet}` : ""}
+
+`;
+  }
+  return output;
+}
+function boundSearchPresentation(text, guidance, truncationGuidance, maxChars) {
+  const fullText = `${text}${guidance}`;
+  if (fullText.length <= maxChars) {
+    return { text: fullText, truncated: false, originalChars: text.length, returnedChars: text.length, omittedChars: 0 };
+  }
+  const marker = `
+
+---
+[Output truncated.]${truncationGuidance}`;
+  const prefixLength = maxChars - marker.length;
+  const bounded = `${text.slice(0, prefixLength)}${marker}`;
+  return {
+    text: bounded,
+    truncated: true,
+    originalChars: text.length,
+    returnedChars: prefixLength,
+    omittedChars: text.length - prefixLength
+  };
+}
+export function registeredFetchToolNames(settings) {
+  return {
+    ...settings.enabledTools.webSearch ? { webSearch: settings.toolNames.webSearch } : {},
+    ...settings.enabledTools.fetchContent ? { fetchContent: settings.toolNames.fetchContent } : {},
+    ...settings.enabledTools.getSearchContent ? { getSearchContent: settings.toolNames.getSearchContent } : {}
+  };
+}
+export function storedContentSourceNames(settings) {
+  return joinToolNames([
+    ...settings.enabledTools.webSearch ? [settings.toolNames.webSearch] : [],
+    ...settings.enabledTools.sourceCheck ? [settings.toolNames.sourceCheck] : [],
+    ...settings.enabledTools.fetchContent ? [settings.toolNames.fetchContent] : []
+  ]);
+}
+function sliceWithContinuation(content, offset, limit, maxChars, continuationAt) {
+  let endOffset = offset + Math.min(limit, content.length - offset);
+  let continuation = "";
+  while (endOffset < content.length) {
+    continuation = continuationAt(endOffset);
+    const overflow = endOffset - offset + continuation.length - maxChars;
+    if (overflow <= 0)
+      break;
+    endOffset -= overflow;
+  }
+  return { endOffset, text: content.slice(offset, endOffset) + (endOffset < content.length ? continuation : "") };
+}
+export function createWebToolCore(host) {
+  const { settings } = host;
+  const toolNames = settings.toolNames;
+  const getSearchContentEnabled = settings.enabledTools.getSearchContent;
+  const fetchModeConfig = settings.fetchModes;
+  const registeredToolNames = registeredFetchToolNames(settings);
+  const storedContentSources = storedContentSourceNames(settings);
+  function fetchOptions(options, proxy) {
+    const merged = host.extractOptions ? { ...options ?? {}, ...host.extractOptions } : options;
+    return withRegisteredFetchOptions(merged, registeredToolNames, proxy);
+  }
+  function storeFetchResult(responseId, data, authProfile) {
+    if (authProfile?.cache === "off")
+      return false;
+    host.storeFetchedContent(responseId, data);
+    return true;
+  }
+  function storeAndPublishSearch(results) {
+    const id = generateId();
+    const data = {
+      id,
+      type: "search",
+      timestamp: Date.now(),
+      queries: results
+    };
+    storeResult(id, data);
+    host.publishResult?.(data);
+    return id;
+  }
+  function buildSearchReturn(opts) {
+    const sc = opts.results.filter((r) => !r.error).length;
+    const tr = opts.results.reduce((sum, r) => sum + r.results.length, 0);
+    const hasApprovedSummary = typeof opts.approvedSummary === "string" && opts.approvedSummary.trim().length > 0;
+    const maxInlineContentChars = settings.maxInlineContentChars;
+    let output = "";
+    if (hasApprovedSummary) {
+      output = opts.approvedSummary.trim();
+    } else {
+      if (opts.curated) {
+        output += `[These results were manually curated by the user in the browser. Use them as-is — do not re-search or discard.]
+
+`;
+      }
+      const providerNames = opts.results.map((result) => {
+        const providers = result.providers ?? (result.provider ? [result.provider] : []);
+        return providers.join(", ") || "unknown";
+      });
+      output += opts.results.length === 1 ? `**Provider:** ${providerNames[0]}
+
+` : `**Providers used:** ${providerNames.map((name, index) => `Query ${index + 1}: ${name}`).join("; ")}
+
+`;
+      const duplicateQueries = opts.curated ? duplicateQuerySet(opts.results) : new Set;
+      for (const { query, answer, results, error, provider } of opts.results) {
+        if (opts.queryList.length > 1) {
+          output += opts.curated ? formatQueryHeader(query, provider, duplicateQueries) : `## Query: "${query}"
+
+`;
+        }
+        if (error)
+          output += `Error: ${error}
+
+`;
+        else
+          output += formatSearchSummary(results, answer) + `
+
+`;
+      }
+    }
+    const hasInlineReady = hasFullInlineCoverage(opts.urls, opts.inlineContent);
+    let fetchId = null;
+    if (hasInlineReady && opts.inlineContent) {
+      fetchId = generateId();
+      const data = {
+        id: fetchId,
+        type: "fetch",
+        timestamp: Date.now(),
+        urls: opts.inlineContent
+      };
+      host.storeFetchedContent(fetchId, data);
+    } else if (opts.includeContent) {
+      fetchId = host.startBackgroundFetch?.(opts.urls, opts.proxy, opts.inlineContent) ?? null;
+    }
+    const searchId = storeAndPublishSearch(opts.results);
+    const isBackgroundFetch = fetchId !== null && !hasInlineReady;
+    const unboundedPresentation = output.trim();
+    const buildGuidance = (forTruncation) => {
+      let value = "";
+      if (hasInlineReady && opts.inlineContent && fetchId) {
+        value += `
+---
+Full content for ${opts.inlineContent.length} sources is ready as responseId "${fetchId}". `;
+        value += getSearchContentEnabled ? `Use ${toolNames.getSearchContent}({ responseId: "${fetchId}", urlIndex: 0, offset: 0, limit: ${maxInlineContentChars} }) to retrieve the first bounded page.` : forTruncation ? `Enable ${toolNames.getSearchContent} to retrieve the full stored content.` : "";
+      } else if (isBackgroundFetch && fetchId) {
+        value += `
+---
+Content fetching in background as responseId "${fetchId}". Will notify when ready.`;
+      }
+      if (getSearchContentEnabled || forTruncation) {
+        value += `
+---
+Full search results are stored as responseId "${searchId}". `;
+        value += getSearchContentEnabled ? `Use ${toolNames.getSearchContent}({ responseId: "${searchId}", queryIndex: 0, offset: 0, limit: ${maxInlineContentChars} }) to retrieve the first bounded page${opts.results.length > 1 ? `; repeat with queryIndex 1 through ${opts.results.length - 1}` : ""}.` : `Enable ${toolNames.getSearchContent} to retrieve the full stored results.`;
+      }
+      return value;
+    };
+    const presentation = hasApprovedSummary ? { text: unboundedPresentation, truncated: false, originalChars: unboundedPresentation.length, returnedChars: unboundedPresentation.length, omittedChars: 0 } : boundSearchPresentation(unboundedPresentation, buildGuidance(false), buildGuidance(true), maxInlineContentChars);
+    const summaryGuidance = hasApprovedSummary ? buildGuidance(false) : "";
+    return {
+      content: [
+        { type: "text", text: presentation.text },
+        ...summaryGuidance ? [{ type: "text", text: summaryGuidance }] : []
+      ],
+      structuredContent: searchStructuredContent(searchId, fetchId, opts.results),
+      details: {
+        queries: opts.queryList,
+        queryCount: opts.queryList.length,
+        successfulQueries: sc,
+        totalResults: tr,
+        includeContent: opts.includeContent,
+        fetchId,
+        fetchUrls: isBackgroundFetch ? opts.urls : undefined,
+        searchId,
+        queryProviders: opts.results.map((result) => ({
+          query: result.query,
+          providers: result.providers ?? (result.provider ? [result.provider] : [])
+        })),
+        truncated: presentation.truncated,
+        originalChars: presentation.originalChars,
+        returnedChars: presentation.returnedChars,
+        omittedChars: presentation.omittedChars,
+        ...opts.curated ? {
+          curated: true,
+          curatedFrom: opts.curatedFrom,
+          curatedQueries: opts.results.map((r) => ({
+            query: r.query,
+            provider: r.provider || null,
+            answer: r.answer || null,
+            sources: r.results.map((s) => ({ title: s.title, url: s.url })),
+            error: r.error
+          }))
+        } : {},
+        ...opts.workflow && hasApprovedSummary ? {
+          summary: {
+            text: opts.approvedSummary.trim(),
+            workflow: opts.workflow,
+            model: opts.summaryMeta?.model ?? null,
+            durationMs: opts.summaryMeta?.durationMs ?? 0,
+            tokenEstimate: opts.summaryMeta?.tokenEstimate ?? 0,
+            fallbackUsed: opts.summaryMeta?.fallbackUsed === true,
+            fallbackReason: opts.summaryMeta?.fallbackReason,
+            phase: opts.summaryMeta?.phase,
+            edited: opts.summaryMeta?.edited === true
+          }
+        } : {}
+      }
+    };
+  }
+  async function webSearch(params, signal, call = {}) {
+    const { extensionContext: ctx, onUpdate } = call;
+    return runWithProxy(typeof params.proxy === "string" ? params.proxy : undefined, async () => {
+      const rawQueryList = Array.isArray(params.queries) ? params.queries : params.query !== undefined ? expandQueryString(params.query) : [];
+      const queryList = normalizeQueryList(rawQueryList);
+      const recencyFilter = normalizeRecencyFilter(params.recencyFilter);
+      if (queryList.length === 0) {
+        return {
+          content: [{ type: "text", text: "Error: No query provided. Use 'query' or 'queries' parameter." }],
+          details: { error: "No query provided" }
+        };
+      }
+      let completedSearches = 0;
+      const allUrls = [];
+      const allInlineContent = [];
+      const resolvedProvider = resolveRequestedProvider(params.provider);
+      const queryResponses = await runSearchQueries(queryList, async (query) => {
+        signal?.throwIfAborted();
+        onUpdate?.({
+          content: [{ type: "text", text: `Searching "${query}" (${completedSearches}/${queryList.length} complete)...` }],
+          details: { phase: "search", progress: completedSearches / queryList.length, currentQuery: query }
+        });
+        try {
+          const { answer, results, inlineContent, provider, providerResponses } = await search(query, {
+            provider: resolvedProvider,
+            numResults: params.numResults,
+            recencyFilter,
+            domainFilter: params.domainFilter,
+            includeContent: params.includeContent,
+            category: params.category,
+            signal,
+            extensionContext: ctx
+          });
+          const providers = providerResponses?.map((response) => response.provider) ?? [provider];
+          return { result: { query, answer, results, error: null, provider, providers }, inlineContent };
+        } catch (err) {
+          if (signal?.aborted || isAbortError(err))
+            throw err;
+          const message = err instanceof Error ? err.message : String(err);
+          const requestedProvider = toCuratorProvider(resolvedProvider);
+          return {
+            result: { query, answer: "", results: [], error: message, provider: requestedProvider },
+            inlineContent: undefined
+          };
+        } finally {
+          completedSearches++;
+          if (!signal?.aborted) {
+            onUpdate?.({
+              content: [{ type: "text", text: `Completed ${completedSearches}/${queryList.length} searches.` }],
+              details: { phase: "search", progress: completedSearches / queryList.length, currentQuery: query }
+            });
+          }
+        }
+      });
+      const searchResults = queryResponses.map((response) => response.result);
+      for (const response of queryResponses) {
+        for (const result of response.result.results) {
+          if (!allUrls.includes(result.url))
+            allUrls.push(result.url);
+        }
+        if (response.inlineContent)
+          allInlineContent.push(...response.inlineContent);
+      }
+      let approvedSummary;
+      let summaryMeta;
+      if (call.summarize) {
+        const summary = await call.summarize(searchResults);
+        if ("content" in summary)
+          return summary;
+        approvedSummary = summary.approvedSummary;
+        summaryMeta = summary.summaryMeta;
+      }
+      let inlineContent = allInlineContent.length > 0 ? allInlineContent : undefined;
+      if (params.includeContent && (call.awaitContent || !host.startBackgroundFetch) && allUrls.length > 0 && !hasFullInlineCoverage(allUrls, inlineContent)) {
+        const proxy = typeof params.proxy === "string" ? params.proxy : undefined;
+        const fetched = await fetchUncoveredContent(allUrls, inlineContent, (urls) => fetchAllContent(urls, signal, fetchOptions(undefined, proxy)));
+        signal?.throwIfAborted();
+        inlineContent = stripThumbnails(fetched);
+      }
+      return buildSearchReturn({
+        queryList,
+        results: searchResults,
+        urls: allUrls,
+        includeContent: params.includeContent ?? false,
+        inlineContent,
+        workflow: call.summarize ? "auto-summary" : undefined,
+        approvedSummary,
+        summaryMeta,
+        proxy: typeof params.proxy === "string" ? params.proxy : undefined
+      });
+    });
+  }
+  async function sourceCheck(params, signal, call = {}) {
+    const ctx = call.extensionContext;
+    return runWithProxy(typeof params.proxy === "string" ? params.proxy : undefined, async () => {
+      const claim = typeof params.claim === "string" ? params.claim.trim() : "";
+      if (!claim) {
+        return { content: [{ type: "text", text: "Error: 'claim' is required." }], details: { error: "Missing claim" } };
+      }
+      const requestedQueries = Array.isArray(params.queries) ? params.queries.filter((query) => typeof query === "string").map((query) => query.trim()).filter(Boolean) : [];
+      const queries = (requestedQueries.length > 0 ? requestedQueries : [claim]).slice(0, 8);
+      const numResults = typeof params.numResults === "number" && Number.isFinite(params.numResults) ? Math.min(20, Math.max(1, Math.floor(params.numResults))) : 5;
+      const domainFilter = Array.isArray(params.domainFilter) ? params.domainFilter.filter((domain) => typeof domain === "string") : undefined;
+      const recencyFilter = normalizeRecencyFilter(params.recencyFilter);
+      const resultsByUrl = new Map;
+      const summaries = [];
+      const errors = [];
+      let provider;
+      for (const query of queries) {
+        if (signal?.aborted)
+          break;
+        try {
+          const response = await search(query, {
+            provider: resolveRequestedProvider(params.provider),
+            numResults,
+            recencyFilter,
+            domainFilter,
+            signal,
+            extensionContext: ctx
+          });
+          if (signal?.aborted)
+            break;
+          provider ??= response.provider;
+          if (response.answer)
+            summaries.push(`${query}: ${response.answer}`);
+          for (const result of response.results) {
+            if (!resultsByUrl.has(result.url))
+              resultsByUrl.set(result.url, result);
+          }
+        } catch (err) {
+          if (signal?.aborted || isAbortError(err))
+            break;
+          errors.push({ query, error: err instanceof Error ? err.message : String(err) });
+        }
+      }
+      const results = [...resultsByUrl.values()].slice(0, 20).map((result, index) => ({ ...result, rank: index + 1 }));
+      let fetched = [];
+      if (params.fetchContent && results.length > 0) {
+        const urls = results.slice(0, 5).map((result) => result.url);
+        try {
+          fetched = await fetchAllContent(urls, signal, fetchOptions(undefined, typeof params.proxy === "string" ? params.proxy : undefined));
+        } catch (err) {
+          if (signal?.aborted || isAbortError(err))
+            throw err;
+          fetched = urls.map((url) => ({ url, title: "", content: "", error: err instanceof Error ? err.message : String(err) }));
+        }
+      }
+      const artifact = withClaimAssessment(buildResearchArtifact({
+        query: claim,
+        provider,
+        summary: summaries.length > 0 ? summaries.join(`
+
+`) : undefined,
+        results,
+        fetched,
+        recency: recencyFilter,
+        domainFilter
+      }), [claim]);
+      if (errors.length > 0)
+        artifact.errors = errors;
+      storeResearchArtifact(artifact);
+      host.publishResult?.({
+        id: artifact.id,
+        type: "research",
+        timestamp: artifact.timestamp,
+        artifact
+      });
+      return {
+        content: [{ type: "text", text: formatSourceCheckResult(artifact, getSearchContentEnabled ? toolNames.getSearchContent : null) }],
+        details: { responseId: artifact.id, artifact, sourceCount: artifact.sources.length, passageCount: artifact.passages.length, searchCount: queries.length }
+      };
+    });
+  }
+  async function fetchContent(params, signal, call = {}) {
+    const { extensionContext: ctx, onUpdate } = call;
+    let normalized;
+    try {
+      normalized = normalizeFetchContentParams(params);
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      return { content: [{ type: "text", text: `Error: ${error}` }], details: { error } };
+    }
+    const { urlList, options } = normalized;
+    const mode = options.mode ?? fetchModeConfig.defaultMode;
+    if (!fetchModeConfig.allowedModes.includes(mode)) {
+      const error = `Fetch mode "${mode}" is disabled by fetch.allowedModes.`;
+      return { content: [{ type: "text", text: `Error: ${error}` }], details: { error } };
+    }
+    return runWithProxy(options.proxy, async () => {
+      if (mode === "answer" && !options.prompt) {
+        return { content: [{ type: "text", text: "Error: mode answer requires prompt." }], details: { error: "mode answer requires prompt" } };
+      }
+      if (mode === "raw" && (options.forceClone === true || options.timestamp || options.frames || options.prompt || options.model || options.answerModel)) {
+        return { content: [{ type: "text", text: "Error: mode raw cannot be combined with forceClone, prompt, timestamp, frames, model, or answerModel." }], details: { error: "Incompatible raw mode options" } };
+      }
+      if (mode !== "answer" && options.answerModel) {
+        return { content: [{ type: "text", text: "Error: answerModel requires mode answer." }], details: { error: "answerModel requires mode answer" } };
+      }
+      if (mode === "answer" && options.model) {
+        return { content: [{ type: "text", text: "Error: use answerModel, not model, with mode answer." }], details: { error: "model is incompatible with mode answer" } };
+      }
+      if (mode === "answer" && options.auth !== undefined) {
+        return { content: [{ type: "text", text: "Error: auth cannot be combined with mode answer." }], details: { error: "auth cannot be combined with mode answer" } };
+      }
+      let authFetchProfile;
+      if (options.auth !== undefined) {
+        try {
+          authFetchProfile = resolveAuthFetchProfile(options.auth);
+        } catch (err) {
+          const error = err instanceof Error ? err.message : String(err);
+          return { content: [{ type: "text", text: `Error: ${error}` }], details: { error } };
+        }
+      }
+      if (urlList.length === 0) {
+        return {
+          content: [{ type: "text", text: "Error: No URL provided. Use the 'url' parameter, or 'urls' for parallel fetches." }],
+          details: { error: "No URL provided" }
+        };
+      }
+      onUpdate?.({
+        content: [{ type: "text", text: `Fetching ${urlList.length} URL(s)...` }],
+        details: { phase: "fetch", progress: 0 }
+      });
+      const { answerModel: _answerModel, auth: _auth, ...extractionOptions } = { ...options, mode };
+      const { prompt: _prompt, ...answerExtractionOptions } = extractionOptions;
+      const requestOptions = {
+        ...mode === "answer" ? answerExtractionOptions : extractionOptions,
+        ...authFetchProfile ? { authFetchProfile } : {}
+      };
+      const fetchResults = await fetchAllContent(urlList, signal, fetchOptions(requestOptions, options.proxy));
+      const presentedResults = mode === "answer" ? await Promise.all(fetchResults.map(async (result) => {
+        if (result.error)
+          return result;
+        if (result.thumbnail || result.mimeType?.startsWith("image/")) {
+          return { ...result, error: "Page answer requires textual fetched content" };
+        }
+        try {
+          if (!host.answerFromPage)
+            throw new Error("this host cannot answer from fetched pages");
+          const answer = await host.answerFromPage({
+            question: options.prompt,
+            pageText: result.content,
+            sourceUrl: result.url,
+            ...options.answerModel ? { model: options.answerModel } : {}
+          }, ctx, signal);
+          return { ...result, content: answer.text };
+        } catch (err) {
+          return { ...result, error: `Page answer failed: ${err instanceof Error ? err.message : String(err)}` };
+        }
+      })) : fetchResults;
+      const successful = presentedResults.filter((r) => !r.error).length;
+      const totalChars = presentedResults.reduce((sum, r) => sum + r.content.length, 0);
+      const responseId = generateId();
+      const data = {
+        id: responseId,
+        type: "fetch",
+        timestamp: Date.now(),
+        urls: stripThumbnails(fetchResults)
+      };
+      const storedContent = storeFetchResult(responseId, data, authFetchProfile);
+      const structuredContent = fetchStructuredContent(storedContent ? responseId : null, presentedResults);
+      if (urlList.length === 1) {
+        const result = presentedResults[0];
+        if (result.error) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Error: ${result.error}` }],
+            structuredContent,
+            details: { urls: urlList, urlCount: 1, successful: 0, error: result.error, ...storedContent ? { responseId } : {}, prompt: params.prompt, timestamp: params.timestamp, frames: params.frames }
+          };
+        }
+        const fullLength = result.content.length;
+        const slice = initialContentSlice(result.content, getMaxInlineContentChars());
+        const truncated = slice.endOffset < fullLength;
+        let output = slice.text;
+        if (truncated) {
+          output += `
+
+---
+Showing ${slice.endOffset} of ${fullLength} chars, ${slice.shownBytes} of ${slice.totalBytes} bytes, and ${slice.shownLines} of ${slice.totalLines} lines. `;
+          if (mode === "answer") {
+            output += "Answer output is truncated. Stored content is the original source, not the remaining answer. ";
+          }
+          output += storedContent ? getSearchContentEnabled ? mode === "answer" ? `Use ${toolNames.getSearchContent}({ responseId: "${responseId}", urlIndex: 0, offset: 0 }) to read the original source from the beginning.` : `Use ${toolNames.getSearchContent}({ responseId: "${responseId}", urlIndex: 0, offset: ${slice.endOffset} }) for the next slice.` : "Content retrieval is not registered." : "Authenticated fetch cache is off; repeat the fetch to read more.";
+        }
+        const content = [];
+        if (result.frames?.length) {
+          for (const frame of result.frames) {
+            content.push({ type: "image", data: frame.data, mimeType: frame.mimeType });
+            content.push({ type: "text", text: `Frame at ${frame.timestamp}` });
+          }
+        } else if (result.thumbnail) {
+          content.push({ type: "image", data: result.thumbnail.data, mimeType: result.thumbnail.mimeType });
+        }
+        content.push({ type: "text", text: output });
+        if (!truncated && storedContent && getSearchContentEnabled) {
+          const storedLabel = mode === "answer" ? "Original source content" : "Full content";
+          content.push({
+            type: "text",
+            text: `
+---
+${storedLabel} is stored as responseId "${responseId}". Use ${toolNames.getSearchContent}({ responseId: "${responseId}", urlIndex: 0, offset: 0 }) to retrieve it.`
+          });
+        }
+        const imageCount = (result.frames?.length ?? 0) + (result.thumbnail ? 1 : 0);
+        return {
+          content,
+          structuredContent,
+          details: {
+            urls: urlList,
+            urlCount: 1,
+            successful: 1,
+            totalChars: fullLength,
+            title: result.title,
+            ...storedContent ? { responseId } : {},
+            truncated,
+            hasImage: imageCount > 0,
+            imageCount,
+            prompt: params.prompt,
+            timestamp: params.timestamp,
+            frames: params.frames,
+            duration: result.duration,
+            mode,
+            mimeType: result.mimeType,
+            status: result.status,
+            totalBytes: slice.totalBytes,
+            totalLines: slice.totalLines,
+            shownBytes: slice.shownBytes,
+            shownLines: slice.shownLines
+          }
+        };
+      }
+      let output;
+      if (mode === "answer") {
+        let budget = getMaxInlineContentChars();
+        output = `## Page answers
+`;
+        for (const { url, title, content, error } of presentedResults) {
+          if (error) {
+            output += `
+### ${url}
+Error: ${error}
+`;
+            continue;
+          }
+          const shown = content.slice(0, budget);
+          budget -= shown.length;
+          const marker = shown.length === content.length ? "" : shown.length === 0 ? `
+[answer omitted; earlier answers used the output limit, fetch fewer URLs per call for complete answers]` : `
+[answer truncated at the output limit; fetch fewer URLs per call for complete answers]`;
+          output += `
+### ${title || url}
+${shown}${marker}
+`;
+        }
+      } else {
+        output = `## Fetched URLs
+
+`;
+        for (const { url, title, content, error } of presentedResults) {
+          if (error) {
+            output += `- ${url}: Error - ${error}
+`;
+          } else {
+            output += `- ${title || url} (${content.length} chars)
+`;
+          }
+        }
+      }
+      const retrievalHint = mode === "answer" ? `Stored content is the original source pages, not the answers. Use ${toolNames.getSearchContent}({ responseId: "${responseId}", urlIndex: 0, offset: 0 }) to read the first source; urlIndex follows the order above.` : `Use ${toolNames.getSearchContent}({ responseId: "${responseId}", urlIndex: 0 }) to retrieve bounded content slices.`;
+      output += storedContent ? getSearchContentEnabled ? `
+---
+${retrievalHint}` : `
+---
+Content retrieval is not registered.` : `
+---
+Authenticated fetch cache is off; repeat the fetch to read content.`;
+      return {
+        ...successful === 0 ? { isError: true } : {},
+        content: [{ type: "text", text: output }],
+        structuredContent,
+        details: { urls: urlList, urlCount: urlList.length, successful, totalChars, ...storedContent ? { responseId } : {} }
+      };
+    });
+  }
+  async function getSearchContent(rawParams) {
+    const maxInlineContentChars = settings.maxInlineContentChars;
+    const params = normalizeGetSearchContentParams(rawParams);
+    if (params.findMode !== undefined && params.findText === undefined) {
+      return {
+        content: [{ type: "text", text: `findMode ${formatInputValue(params.findMode)} requires findText; provide findText or omit findMode.` }],
+        details: { error: "findMode requires findText" }
+      };
+    }
+    const data = getResult(params.responseId);
+    if (!data) {
+      return {
+        content: [{ type: "text", text: `Error: No stored results for responseId ${formatInputValue(params.responseId)}. Use a responseId returned by ${storedContentSources}.` }],
+        details: { error: "Not found", responseId: params.responseId }
+      };
+    }
+    if (data.type === "research") {
+      const artifact = getResearchArtifact(params.responseId);
+      if (!artifact) {
+        return {
+          content: [{ type: "text", text: `Error: stored research artifact for responseId ${formatInputValue(params.responseId)} was not found. Use a responseId returned by ${storedContentSources}.` }],
+          details: { error: "Artifact not found", responseId: params.responseId }
+        };
+      }
+      const serialized = JSON.stringify(artifact, null, 2);
+      if (params.findText !== undefined) {
+        try {
+          const found = findContent(serialized, normalizeFindQueries(params.findText), params.findMode ?? "case-insensitive");
+          const { text, ...findDetails } = found;
+          return {
+            content: [{ type: "text", text }],
+            details: { responseId: artifact.id, type: "research", contentLength: serialized.length, findMode: params.findMode ?? "case-insensitive", ...findDetails }
+          };
+        } catch (err) {
+          const error = err instanceof Error ? err.message : String(err);
+          return {
+            content: [{ type: "text", text: `Unable to find ${formatInputValue(params.findText)} in research artifact for responseId ${formatInputValue(params.responseId)}: ${error}. Check findText and use a supported findMode.` }],
+            details: { error, responseId: params.responseId, type: "research" }
+          };
+        }
+      }
+      const offset = params.offset ?? 0;
+      const limit = params.limit ?? maxInlineContentChars;
+      if (!Number.isInteger(offset) || offset < 0) {
+        return {
+          content: [{ type: "text", text: `Invalid offset: received ${formatInputValue(offset)} for responseId ${formatInputValue(params.responseId)}; offset must be a non-negative integer. Use 0 or a larger integer.` }],
+          details: { error: "Invalid offset", offset }
+        };
+      }
+      if (!Number.isInteger(limit) || limit <= 0 || limit > maxInlineContentChars) {
+        return {
+          content: [{ type: "text", text: `Invalid limit: received ${formatInputValue(limit)} for responseId ${formatInputValue(params.responseId)}; limit must be an integer from 1 to ${maxInlineContentChars}. Use a value in that range.` }],
+          details: { error: "Invalid limit", limit, maxLimit: maxInlineContentChars }
+        };
+      }
+      if (offset > serialized.length) {
+        return {
+          content: [{ type: "text", text: `Offset ${offset} is out of range for responseId ${formatInputValue(params.responseId)}. Received offset ${offset}; valid range is 0-${serialized.length}. Use an offset within that range.` }],
+          details: { error: "Offset out of range", offset, contentLength: serialized.length }
+        };
+      }
+      const { endOffset, text } = sliceWithContinuation(serialized, offset, limit, maxInlineContentChars, (end) => `
+
+---
+Showing chars ${offset}-${end} of ${serialized.length}. Use ${toolNames.getSearchContent}({ responseId: "${artifact.id}", offset: ${end}, limit: ${limit} }) for the next slice.`);
+      const hasMore = endOffset < serialized.length;
+      return {
+        content: [{ type: "text", text }],
+        details: { responseId: artifact.id, type: "research", contentLength: serialized.length, offset, limit, returnedChars: endOffset - offset, nextOffset: hasMore ? endOffset : null, truncated: hasMore }
+      };
+    }
+    if (data.type === "search" && data.queries) {
+      let queryData;
+      if (params.query !== undefined) {
+        queryData = data.queries.find((q) => q.query === params.query);
+        if (!queryData) {
+          const available = data.queries.map((q) => `"${q.query}"`).join(", ");
+          return {
+            content: [{ type: "text", text: `Query ${formatInputValue(params.query)} was not found for responseId ${formatInputValue(params.responseId)}. Received query=${formatInputValue(params.query)}. Available queries: ${available || "none"}. Use one of the available queries or queryIndex.` }],
+            details: { error: "Query not found" }
+          };
+        }
+      } else if (params.queryIndex !== undefined) {
+        queryData = data.queries[params.queryIndex];
+        if (!queryData) {
+          const available = data.queries.map((q, i) => `${i}: "${q.query}"`).join(", ");
+          return {
+            content: [{ type: "text", text: `Query index ${formatInputValue(params.queryIndex)} is out of range for responseId ${formatInputValue(params.responseId)}. Received queryIndex=${formatInputValue(params.queryIndex)}; valid indexes are 0-${data.queries.length - 1}. Available queries: ${available || "none"}. Use one of the available indexes.` }],
+            details: { error: "Index out of range" }
+          };
+        }
+      } else {
+        const available = data.queries.map((q, i) => `${i}: "${q.query}"`).join(", ");
+        return {
+          content: [{ type: "text", text: `Specify query or queryIndex for responseId ${formatInputValue(params.responseId)}. Available queries: ${available || "none"}.` }],
+          details: { error: "No query specified" }
+        };
+      }
+      if (queryData.error) {
+        return {
+          content: [{ type: "text", text: `Error retrieving query ${formatInputValue(queryData.query)} from responseId ${formatInputValue(params.responseId)}: ${queryData.error}. Check the stored search result and retry with another query or queryIndex if needed.` }],
+          details: { error: queryData.error, query: queryData.query }
+        };
+      }
+      const fullResults = formatFullResults(queryData);
+      if (params.findText !== undefined) {
+        try {
+          const found = findContent(fullResults, normalizeFindQueries(params.findText), params.findMode ?? "case-insensitive");
+          const { text, ...findDetails } = found;
+          return {
+            content: [{ type: "text", text }],
+            details: { responseId: params.responseId, query: queryData.query, resultCount: queryData.results.length, contentLength: fullResults.length, findMode: params.findMode ?? "case-insensitive", ...findDetails }
+          };
+        } catch (err) {
+          const error = err instanceof Error ? err.message : String(err);
+          return {
+            content: [{ type: "text", text: `Unable to find ${formatInputValue(params.findText)} in query ${formatInputValue(queryData.query)} for responseId ${formatInputValue(params.responseId)}: ${error}. Check findText and use a supported findMode.` }],
+            details: { error, query: queryData.query }
+          };
+        }
+      }
+      const offset = params.offset ?? 0;
+      const limit = params.limit ?? maxInlineContentChars;
+      if (!Number.isInteger(offset) || offset < 0) {
+        return {
+          content: [{ type: "text", text: `Invalid offset: received ${formatInputValue(offset)} for query ${formatInputValue(queryData.query)}; offset must be a non-negative integer. Use 0 or a larger integer.` }],
+          details: { error: "Invalid offset", offset }
+        };
+      }
+      if (!Number.isInteger(limit) || limit <= 0 || limit > maxInlineContentChars) {
+        return {
+          content: [{ type: "text", text: `Invalid limit: received ${formatInputValue(limit)} for query ${formatInputValue(queryData.query)}; limit must be an integer from 1 to ${maxInlineContentChars}. Use a value in that range.` }],
+          details: { error: "Invalid limit", limit, maxLimit: maxInlineContentChars }
+        };
+      }
+      if (offset > fullResults.length) {
+        return {
+          content: [{ type: "text", text: `Offset ${offset} is out of range for query ${formatInputValue(queryData.query)} in responseId ${formatInputValue(params.responseId)}. Received offset ${offset}; valid range is 0-${fullResults.length}. Use an offset within that range.` }],
+          details: { error: "Offset out of range", offset, contentLength: fullResults.length }
+        };
+      }
+      const queryIndex = data.queries.indexOf(queryData);
+      const { endOffset, text } = sliceWithContinuation(fullResults, offset, limit, maxInlineContentChars, (end) => `
+
+---
+Showing chars ${offset}-${end} of ${fullResults.length}. Use ${toolNames.getSearchContent}({ responseId: "${params.responseId}", queryIndex: ${queryIndex}, offset: ${end}, limit: ${limit} }) for the next slice.`);
+      const returnedChars = endOffset - offset;
+      const hasMore = endOffset < fullResults.length;
+      return {
+        content: [{ type: "text", text }],
+        details: {
+          responseId: params.responseId,
+          query: queryData.query,
+          resultCount: queryData.results.length,
+          contentLength: fullResults.length,
+          offset,
+          limit,
+          returnedChars,
+          nextOffset: hasMore ? endOffset : null,
+          truncated: hasMore
+        }
+      };
+    }
+    if (data.type === "fetch" && data.urls) {
+      let urlData;
+      let selectedUrlIndex = -1;
+      if (params.url !== undefined) {
+        selectedUrlIndex = data.urls.findIndex((u) => u.url === params.url);
+        urlData = data.urls[selectedUrlIndex];
+        if (!urlData) {
+          const available = data.urls.map((u) => u.url).join(`
+  `);
+          return {
+            content: [{ type: "text", text: `URL ${formatInputValue(params.url)} was not found for responseId ${formatInputValue(params.responseId)}. Received url=${formatInputValue(params.url)}. Available URLs:
+  ${available || "  none"}
+Use one of the available URLs or urlIndex.` }],
+            details: { error: "URL not found" }
+          };
+        }
+      } else if (params.urlIndex !== undefined) {
+        selectedUrlIndex = params.urlIndex;
+        urlData = data.urls[selectedUrlIndex];
+        if (!urlData) {
+          const available = data.urls.map((u, i) => `${i}: ${u.url}`).join(`
+  `);
+          return {
+            content: [{ type: "text", text: `URL index ${formatInputValue(params.urlIndex)} is out of range for responseId ${formatInputValue(params.responseId)}. Received urlIndex=${formatInputValue(params.urlIndex)}; valid indexes are 0-${data.urls.length - 1}. Available URLs:
+  ${available || "  none"}
+Use one of the available indexes.` }],
+            details: { error: "Index out of range" }
+          };
+        }
+      } else if (data.urls.length === 1) {
+        selectedUrlIndex = 0;
+        urlData = data.urls[0];
+      } else {
+        const available = data.urls.map((u, i) => `${i}: ${u.url}`).join(`
+  `);
+        return {
+          content: [{ type: "text", text: `Specify url or urlIndex for responseId ${formatInputValue(params.responseId)}. Available URLs:
+  ${available || "  none"}` }],
+          details: { error: "No URL specified" }
+        };
+      }
+      if (urlData.error) {
+        return {
+          content: [{ type: "text", text: `Error retrieving URL ${formatInputValue(urlData.url)} from responseId ${formatInputValue(params.responseId)}: ${urlData.error}. Check the stored fetch result and retry with another URL or urlIndex if needed.` }],
+          details: { error: urlData.error, url: urlData.url }
+        };
+      }
+      if (params.findText !== undefined) {
+        try {
+          const found = findContent(urlData.content, normalizeFindQueries(params.findText), params.findMode ?? "case-insensitive");
+          const { text, ...findDetails } = found;
+          return {
+            content: [{ type: "text", text: `# ${urlData.title || urlData.url}
+
+${text}` }],
+            details: { url: urlData.url, title: urlData.title, contentLength: urlData.content.length, findMode: params.findMode ?? "case-insensitive", ...findDetails }
+          };
+        } catch (err) {
+          const error = err instanceof Error ? err.message : String(err);
+          return {
+            content: [{ type: "text", text: `Unable to find ${formatInputValue(params.findText)} in URL ${formatInputValue(urlData.url)} for responseId ${formatInputValue(params.responseId)}: ${error}. Check findText and use a supported findMode.` }],
+            details: { error, url: urlData.url }
+          };
+        }
+      }
+      const offset = params.offset ?? 0;
+      const limit = params.limit ?? maxInlineContentChars;
+      if (!Number.isInteger(offset) || offset < 0) {
+        return {
+          content: [{ type: "text", text: `Invalid offset: received ${formatInputValue(offset)} for URL ${formatInputValue(urlData.url)}; offset must be a non-negative integer. Use 0 or a larger integer.` }],
+          details: { error: "Invalid offset", offset }
+        };
+      }
+      if (!Number.isInteger(limit) || limit <= 0 || limit > maxInlineContentChars) {
+        return {
+          content: [{ type: "text", text: `Invalid limit: received ${formatInputValue(limit)} for URL ${formatInputValue(urlData.url)}; limit must be an integer from 1 to ${maxInlineContentChars}. Use a value in that range.` }],
+          details: { error: "Invalid limit", limit, maxLimit: maxInlineContentChars }
+        };
+      }
+      if (offset > urlData.content.length) {
+        return {
+          content: [{ type: "text", text: `Offset ${offset} is out of range for URL ${formatInputValue(urlData.url)} in responseId ${formatInputValue(params.responseId)}. Received offset ${offset}; valid range is 0-${urlData.content.length}. Use an offset within that range.` }],
+          details: { error: "Offset out of range", offset, contentLength: urlData.content.length }
+        };
+      }
+      const endOffset = Math.min(offset + limit, urlData.content.length);
+      const contentSlice = urlData.content.slice(offset, endOffset);
+      const hasMore = endOffset < urlData.content.length;
+      let text = `# ${urlData.title || urlData.url}
+
+${contentSlice}`;
+      if (hasMore || offset > 0) {
+        text += `
+
+---
+Showing chars ${offset}-${endOffset} of ${urlData.content.length}.`;
+        if (hasMore) {
+          text += ` Use ${toolNames.getSearchContent}({ responseId: "${params.responseId}", urlIndex: ${selectedUrlIndex}, offset: ${endOffset}, limit: ${limit} }) for the next slice.`;
+        }
+      }
+      return {
+        content: [{ type: "text", text }],
+        details: {
+          url: urlData.url,
+          title: urlData.title,
+          contentLength: urlData.content.length,
+          offset,
+          limit,
+          returnedChars: contentSlice.length,
+          nextOffset: hasMore ? endOffset : null,
+          truncated: hasMore
+        }
+      };
+    }
+    return {
+      content: [{ type: "text", text: `Invalid stored data for responseId ${formatInputValue(params.responseId)}: received type ${formatInputValue(data.type)}. Use a responseId returned by ${storedContentSources}.` }],
+      details: { error: "Invalid data" }
+    };
+  }
+  return {
+    webSearch,
+    fetchContent,
+    getSearchContent,
+    sourceCheck,
+    buildSearchReturn
+  };
+}
+const MAX_STORED_RESULTS = 50;
+const STANDALONE_DIRECT_IMAGE_ERROR = "Direct image fetch is not supported over MCP; fetch_content returns text there. Fetch images from the DM extension instead.";
+function standaloneError(error) {
+  return { content: [{ type: "text", text: `Error: ${error}` }], details: { error }, isError: true };
+}
+export function markToolError(result) {
+  const { error, queryCount, successfulQueries, urlCount, successful, searchCount, artifact } = result.details;
+  const nothingSucceeded = typeof queryCount === "number" && queryCount > 0 && successfulQueries === 0 || typeof urlCount === "number" && urlCount > 0 && successful === 0 || typeof searchCount === "number" && searchCount > 0 && artifact.errors?.length === searchCount;
+  return error !== undefined || nothingSucceeded ? { ...result, isError: true } : result;
+}
+async function standaloneProviderRejection(requested) {
+  let selection;
+  try {
+    selection = resolveRequestedProvider(requested);
+  } catch {
+    return;
+  }
+  const explicit = Array.isArray(selection) ? selection : [selection];
+  if (explicit.includes("kimi")) {
+    return "Kimi search is not supported over MCP: it authenticates only through DM's /login kimi-coding. Choose another provider, or search from DM.";
+  }
+  if (explicit.includes("openai")) {
+    let available;
+    try {
+      available = await isOpenAISearchAvailable();
+    } catch {
+      return;
+    }
+    if (!available) {
+      return `OpenAI search over MCP needs an API key: set openaiApiKey in ${WEB_SEARCH_CONFIG_PATH} or OPENAI_API_KEY. ChatGPT/Codex sign-in, openaiUseProviderBaseUrl, and DM model credentials work only inside DM.`;
+    }
+  }
+  return;
+}
+function standaloneFetchRejection(params, fetchModes) {
+  if (params.mode === "answer") {
+    return `fetch_content mode "answer" is not supported over MCP: page answers use DM's models. Use mode "readable" or "raw".`;
+  }
+  if (params.mode === undefined && fetchModes.defaultMode === "answer") {
+    return `fetch.defaultMode in ${WEB_SEARCH_CONFIG_PATH} is "answer", which is not supported over MCP. Pass mode "readable" or "raw".`;
+  }
+  return;
+}
+export function createStandaloneWebToolCore() {
+  const config = loadConfig();
+  const settings = {
+    toolNames: { ...DEFAULT_TOOL_NAMES },
+    enabledTools: {
+      webSearch: isToolEnabled(config, "webSearch"),
+      sourceCheck: isToolEnabled(config, "sourceCheck"),
+      fetchContent: isToolEnabled(config, "fetchContent"),
+      getSearchContent: isToolEnabled(config, "getSearchContent")
+    },
+    maxInlineContentChars: getMaxInlineContentChars(config),
+    fetchModes: resolveFetchModeConfig(config)
+  };
+  const storedIds = [];
+  const remember = (id) => {
+    storedIds.push(id);
+    while (storedIds.length > MAX_STORED_RESULTS)
+      deleteResult(storedIds.shift());
+  };
+  const core = createWebToolCore({
+    settings,
+    storeFetchedContent(id, data) {
+      storeResult(id, data);
+      remember(id);
+    },
+    publishResult(data) {
+      remember(data.id);
+    },
+    extractOptions: { rejectDirectImages: STANDALONE_DIRECT_IMAGE_ERROR }
+  });
+  return {
+    enabledToolNames: Object.keys(DEFAULT_TOOL_NAMES).filter((key) => settings.enabledTools[key]).map((key) => DEFAULT_TOOL_NAMES[key]),
+    async webSearch(params, signal) {
+      const rejection = await standaloneProviderRejection(params.provider);
+      return rejection ? standaloneError(rejection) : markToolError(await core.webSearch(params, signal));
+    },
+    async fetchContent(params, signal) {
+      const rejection = standaloneFetchRejection(params, settings.fetchModes);
+      return rejection ? standaloneError(rejection) : markToolError(await core.fetchContent(params, signal));
+    },
+    async getSearchContent(params, signal) {
+      return markToolError(await core.getSearchContent(params, signal));
+    },
+    async sourceCheck(params, signal) {
+      const rejection = await standaloneProviderRejection(params.provider);
+      return rejection ? standaloneError(rejection) : markToolError(await core.sourceCheck(params, signal));
+    }
+  };
+}