@humain/terminal 0.0.5 → 0.0.7

package/dist/humain/web-access/vendor/index.js

@@ -15,8 +15,8 @@ import { findContent } from "./content-find.js";
 import { answerFromPage } from "./page-query.js";
 import { rewriteSearchQuery } from "./query-rewrite.js";
 import { clearCloneCache } from "./github-extract.js";
-import { getConfiguredSearchRouting, normalizeSearchProviderSelection, RESOLVED_SEARCH_PROVIDERS, SEARCH_PROVIDERS, search } from "./gemini-search.js";
-import { formatSeconds, getWebSearchConfigDir, getWebSearchConfigPath, resolveCuratorNetworkConfig } from "./utils.js";
+import { ALL_SEARCH_PROVIDERS, getConfiguredSearchRouting, normalizeSearchProviderSelection, RESOLVED_SEARCH_PROVIDERS, SEARCH_PROVIDERS, search } from "./gemini-search.js";
+import { formatSeconds, getWebSearchConfigDir, getWebSearchConfigPath, installGlobalProxyFetch, resolveCuratorNetworkConfig, runWithProxy } from "./utils.js";
 import { clearResults, deleteResult, generateId, getAllResults, getResult, restoreFromSession, storeFetchedContentResult, storeResult, } from "./storage.js";
 import { activityMonitor } from "./activity.js";
 import { startCuratorServer } from "./curator-server.js";
@@ -30,10 +30,10 @@ import { join } from "node:path";
 import { isPerplexityAvailable } from "./perplexity.js";
 import { isExaAvailable } from "./exa.js";
 import { isGeminiApiAvailable } from "./gemini-api.js";
-import { getActiveGoogleEmail, getGeminiWebAvailabilityDiagnostic, isGeminiWebAvailable } from "./gemini-web.js";
+import { getActiveGoogleEmail, getGeminiWebAvailabilityDiagnostic, getGeminiWebAvailabilityDiagnosticDetails, isGeminiWebAvailable } from "./gemini-web.js";
 import { isBrowserCookieAccessAllowed } from "./gemini-web-config.js";
 import { isBraveAvailable } from "./brave.js";
-import { isOpenAISearchAvailable } from "./openai-search.js";
+import { isCurrentModelHostedSearchEligible, isOpenAISearchAvailable } from "./openai-search.js";
 import { isParallelAvailable } from "./parallel.js";
 import { isParallelMcpAvailable } from "./parallel-mcp.js";
 import { isTinyFishAvailable } from "./tinyfish.js";
@@ -51,10 +51,12 @@ import { isSearXNGAvailable } from "./searxng.js";
 import { isDuckDuckGoAvailable } from "./duckduckgo.js";
 import { isAnySearchAvailable } from "./anysearch.js";
 import { isXaiSearchAvailable } from "./xai-search.js";
+import { isKimiSearchAvailable } from "./kimi-search.js";
 import { isBrightDataAvailable } from "./brightdata.js";
 import { isSerpBaseAvailable } from "./serpbase.js";
 import { isSerperAvailable } from "./serper.js";
 import { isValyuAvailable } from "./valyu.js";
+import { isXcrawlAvailable } from "./xcrawl.js";
 import { buildSearchErrorPlan } from "./render-search-error.js";
 import { findModelWithProviderRouting, loadEnabledModelPatterns, modelMatchesEnabledPatterns, splitThinkingSuffix } from "./summary-model-scope.js";
 import { buildResearchArtifact, withClaimAssessment, storeResearchArtifact, getResearchArtifact, } from "./source-check.js";
@@ -64,6 +66,13 @@ async function fetchAllContent(urls, signal, options) {
     const extractModule = await (extractModulePromise ??= import("./extract.js"));
     return extractModule.fetchAllContent(urls, signal, options);
 }
+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");
 }
@@ -248,6 +257,34 @@ function normalizeQueryList(queryList) {
     }
     return normalized;
 }
+// Some local models serialize a multi-query list into the single-string `query`
+// field as a JSON array (query: "[\"a\", \"b\"]") instead of using the
+// `queries` parameter. Forwarding that raw string verbatim makes every backend
+// search for the literal array text and return zero results, with no signal to
+// the model that its argument shape was wrong. Expand a string that parses as a
+// JSON array of strings so each element is searched independently.
+function expandQueryString(query) {
+    if (typeof query !== "string")
+        return [];
+    const trimmed = query.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            // Only expand an unambiguously string-only array. Mixed or non-string
+            // arrays are kept as the literal query so we never silently drop
+            // members or collapse them into an empty search.
+            if (Array.isArray(parsed) && parsed.every((entry) => typeof entry === "string")) {
+                return parsed
+                    .map((entry) => entry.trim())
+                    .filter((entry) => entry.length > 0);
+            }
+        }
+        catch {
+            // Not JSON — treat as a literal query string.
+        }
+    }
+    return [query];
+}
 function getCuratorTimeoutSeconds() {
     const source = loadConfig();
     const explicit = normalizeCuratorTimeoutSeconds(source.curatorTimeoutSeconds);
@@ -271,7 +308,7 @@ function shouldAutoOpenCuratorBrowser(config) {
     return true;
 }
 async function getProviderAvailability(ctx) {
-    const geminiWebAvail = await isGeminiWebAvailable();
+    const geminiWebAvail = await getOptionalGeminiWebAvailability();
     const geminiApiAvail = isGeminiApiAvailable();
     const providers = {
         openai: await isOpenAISearchAvailable(ctx),
@@ -294,19 +331,29 @@ async function getProviderAvailability(ctx) {
         perplexity: isPerplexityAvailable(),
         exa: isExaAvailable(),
         gemini: geminiApiAvail || !!geminiWebAvail,
+        kimi: await isKimiSearchAvailable(ctx),
         anysearch: isAnySearchAvailable(),
+        xcrawl: isXcrawlAvailable(),
         xai: await isXaiSearchAvailable(ctx),
         brightdata: isBrightDataAvailable(),
         serpbase: isSerpBaseAvailable(),
         serper: isSerperAvailable(),
         valyu: isValyuAvailable(),
     };
+    const allSearchProviders = new Set(ALL_SEARCH_PROVIDERS);
     return {
-        // Parallel MCP, DuckDuckGo, AnySearch, xAI, Bright Data, SerpBase, Serper, and Valyu are explicit-only, so they never make `all` eligible.
-        all: Object.entries(providers).some(([provider, available]) => provider !== "parallel-mcp" && provider !== "duckduckgo" && provider !== "anysearch" && provider !== "xai" && provider !== "brightdata" && provider !== "serpbase" && provider !== "serper" && provider !== "valyu" && provider !== "gemini" && available) || geminiApiAvail,
+        all: Object.entries(providers).some(([provider, available]) => provider !== "gemini" && allSearchProviders.has(provider) && available) || geminiApiAvail,
         ...providers,
     };
 }
+async function getOptionalGeminiWebAvailability() {
+    try {
+        return await isGeminiWebAvailable();
+    }
+    catch {
+        return null;
+    }
+}
 function shouldUseOpenAICodexDefault(ctx) {
     return ctx?.model?.provider === "openai-codex";
 }
@@ -330,7 +377,7 @@ async function loadCuratorBootstrap(requestedProvider, ctx, options) {
     };
 }
 export function resolveCuratorDefaultProvider(provider, available, ctx, options) {
-    return resolveProvider(provider, available, options, shouldUseOpenAICodexDefault(ctx));
+    return resolveProvider(provider, available, options, shouldUseOpenAICodexDefault(ctx), ctx);
 }
 function firstAvailableProvider(available, preferOpenAI, fallback) {
     if (available.searxng)
@@ -373,7 +420,7 @@ function firstAvailableProvider(available, preferOpenAI, fallback) {
         return "gemini";
     return fallback;
 }
-function resolveProvider(provider, available, options, preferOpenAICodexDefault = false) {
+function resolveProvider(provider, available, options, preferOpenAICodexDefault = false, ctx) {
     if (Array.isArray(provider))
         return "all";
     const preferOpenAI = shouldPreferOpenAI(options, preferOpenAICodexDefault);
@@ -381,10 +428,12 @@ function resolveProvider(provider, available, options, preferOpenAICodexDefault
         const routing = getConfiguredSearchRouting();
         if (routing) {
             for (const candidate of routing.providers) {
+                if (candidate === "openai" && routing.useCurrentModel === true && !isCurrentModelHostedSearchEligible(ctx))
+                    continue;
                 if (available[candidate])
                     return candidate;
             }
-            return routing.providers[0];
+            return routing.providers.find(candidate => candidate !== "openai" || routing.useCurrentModel !== true || isCurrentModelHostedSearchEligible(ctx)) ?? routing.providers[0];
         }
         return firstAvailableProvider(available, preferOpenAI, "exa");
     }
@@ -495,6 +544,25 @@ function normalizeFindQueries(value) {
         throw new Error("findText must contain at least one non-empty string");
     return queries;
 }
+function normalizeFindMode(value) {
+    if (value === undefined)
+        return undefined;
+    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);
@@ -819,11 +887,18 @@ function handleSessionChange(ctx) {
 }
 export default function (pi) {
     const initConfig = loadConfigForExtensionInit();
+    installGlobalProxyFetch();
     const toolNames = resolveToolNames(initConfig);
     const webSearchEnabled = isToolEnabled(initConfig, "webSearch");
     const sourceCheckEnabled = isToolEnabled(initConfig, "sourceCheck");
     const fetchContentEnabled = isToolEnabled(initConfig, "fetchContent");
     const getSearchContentEnabled = isToolEnabled(initConfig, "getSearchContent");
+    // Names as registered this session, so fetch failure guidance never points
+    // at tools that are disabled or were renamed after init.
+    const registeredToolNames = {
+        ...(webSearchEnabled ? { webSearch: toolNames.webSearch } : {}),
+        ...(fetchContentEnabled ? { fetchContent: toolNames.fetchContent } : {}),
+    };
     const storedContentSources = joinToolNames([
         ...(webSearchEnabled ? [toolNames.webSearch] : []),
         ...(sourceCheckEnabled ? [toolNames.sourceCheck] : []),
@@ -837,13 +912,13 @@ export default function (pi) {
         : "Full original content is stored internally, but the retrieval tool is not registered.";
     const curateKey = initConfig.shortcuts?.curate || DEFAULT_SHORTCUTS.curate;
     const activityKey = initConfig.shortcuts?.activity || DEFAULT_SHORTCUTS.activity;
-    function startBackgroundFetch(urls) {
+    function startBackgroundFetch(urls, proxy) {
         if (urls.length === 0)
             return null;
         const fetchId = generateId();
         const controller = new AbortController();
         pendingFetches.set(fetchId, controller);
-        fetchAllContent(urls, controller.signal)
+        runWithProxy(proxy, () => fetchAllContent(urls, controller.signal, withRegisteredFetchOptions(undefined, registeredToolNames, proxy)))
             .then((fetched) => {
             if (!sessionActive || !pendingFetches.has(fetchId))
                 return;
@@ -1107,7 +1182,7 @@ export default function (pi) {
             }
         }
         else if (opts.includeContent) {
-            fetchId = startBackgroundFetch(opts.urls);
+            fetchId = startBackgroundFetch(opts.urls, opts.proxy);
             if (fetchId && !hasApprovedSummary) {
                 output += `---\nContent fetching in background [${fetchId}]. Will notify when ready.`;
             }
@@ -1217,20 +1292,22 @@ export default function (pi) {
                 defaultSummaryModel: pc.defaultSummaryModel,
             }, {
                 async onSummarize(selectedQueryIndices, summarizeSignal, model, feedback) {
-                    if (pendingCurates.get(callId) !== pc)
-                        throw new Error("Curator session is no longer active.");
-                    pc.onUpdate?.({
-                        content: [{ type: "text", text: "Generating summary draft..." }],
-                        details: { phase: "generating-summary", progress: 0.9, curatorUrl: pc.curatorUrl, timeoutSeconds: pc.timeoutSeconds, shortcut: curateKey },
-                    });
-                    const draft = await generateSummaryForSelectedIndices(selectedQueryIndices, pc.searchResults, pc.summaryContext, summarizeSignal, model, feedback);
-                    if (pendingCurates.get(callId) !== pc)
-                        throw new Error("Curator session is no longer active.");
-                    pc.onUpdate?.({
-                        content: [{ type: "text", text: "Summary draft ready — waiting for approval..." }],
-                        details: { phase: "waiting-for-approval", progress: 1, curatorUrl: pc.curatorUrl, timeoutSeconds: pc.timeoutSeconds, shortcut: curateKey },
+                    return runWithProxy(pc.proxy, async () => {
+                        if (pendingCurates.get(callId) !== pc)
+                            throw new Error("Curator session is no longer active.");
+                        pc.onUpdate?.({
+                            content: [{ type: "text", text: "Generating summary draft..." }],
+                            details: { phase: "generating-summary", progress: 0.9, curatorUrl: pc.curatorUrl, timeoutSeconds: pc.timeoutSeconds, shortcut: curateKey },
+                        });
+                        const draft = await generateSummaryForSelectedIndices(selectedQueryIndices, pc.searchResults, pc.summaryContext, summarizeSignal, model, feedback);
+                        if (pendingCurates.get(callId) !== pc)
+                            throw new Error("Curator session is no longer active.");
+                        pc.onUpdate?.({
+                            content: [{ type: "text", text: "Summary draft ready — waiting for approval..." }],
+                            details: { phase: "waiting-for-approval", progress: 1, curatorUrl: pc.curatorUrl, timeoutSeconds: pc.timeoutSeconds, shortcut: curateKey },
+                        });
+                        return draft;
                     });
-                    return draft;
                 },
                 onSubmit(payload) {
                     if (pendingCurates.get(callId) !== pc)
@@ -1248,6 +1325,7 @@ export default function (pi) {
                         inlineContent: filteredInline.length > 0 ? filteredInline : undefined,
                         curated: true,
                         curatedFrom: pc.searchResults.size,
+                        proxy: pc.proxy,
                     };
                     if (!payload.rawResults) {
                         const resolvedSummary = resolveSummaryForSubmit(payload, pc.searchResults);
@@ -1277,6 +1355,7 @@ export default function (pi) {
                             workflow: pc.workflow,
                             approvedSummary: resolvedSummary.approvedSummary,
                             summaryMeta: resolvedSummary.summaryMeta,
+                            proxy: pc.proxy,
                         }));
                     }
                     else {
@@ -1309,23 +1388,25 @@ export default function (pi) {
                     }
                 },
                 async onAddSearch(query, provider) {
-                    if (pendingCurates.get(callId) !== pc)
-                        throw new Error("Curator session is no longer active.");
-                    const requestedProvider = resolveCuratorSearchProvider(provider, pc.searchProvider);
-                    const response = await search(query, {
-                        provider: requestedProvider,
-                        numResults: pc.numResults,
-                        recencyFilter: pc.recencyFilter,
-                        domainFilter: pc.domainFilter,
-                        includeContent: pc.includeContent,
-                        signal: addSearchSignal,
-                        extensionContext: ctx,
+                    return runWithProxy(pc.proxy, async () => {
+                        if (pendingCurates.get(callId) !== pc)
+                            throw new Error("Curator session is no longer active.");
+                        const requestedProvider = resolveCuratorSearchProvider(provider, pc.searchProvider);
+                        const response = await search(query, {
+                            provider: requestedProvider,
+                            numResults: pc.numResults,
+                            recencyFilter: pc.recencyFilter,
+                            domainFilter: pc.domainFilter,
+                            includeContent: pc.includeContent,
+                            signal: addSearchSignal,
+                            extensionContext: ctx,
+                        });
+                        if (pendingCurates.get(callId) !== pc)
+                            throw new Error("Curator session is no longer active.");
+                        if (response.inlineContent)
+                            pc.allInlineContent.push(...response.inlineContent);
+                        return toCuratorSearchEntries(response);
                     });
-                    if (pendingCurates.get(callId) !== pc)
-                        throw new Error("Curator session is no longer active.");
-                    if (response.inlineContent)
-                        pc.allInlineContent.push(...response.inlineContent);
-                    return toCuratorSearchEntries(response);
                 },
                 onAddSearchResults(entries) {
                     if (pendingCurates.get(callId) !== pc)
@@ -1335,9 +1416,11 @@ export default function (pi) {
                     }
                 },
                 async onRewriteQuery(query, rewriteSignal) {
-                    if (pendingCurates.get(callId) !== pc)
-                        throw new Error("Curator session is no longer active.");
-                    return rewriteSearchQuery(query, pc.summaryContext, rewriteSignal);
+                    return runWithProxy(pc.proxy, async () => {
+                        if (pendingCurates.get(callId) !== pc)
+                            throw new Error("Curator session is no longer active.");
+                        return rewriteSearchQuery(query, pc.summaryContext, rewriteSignal);
+                    });
                 },
             });
             if (pendingCurates.get(callId) !== pc) {
@@ -1457,7 +1540,7 @@ export default function (pi) {
         pi.registerTool({
             name: toolNames.webSearch,
             label: "Web Search",
-            description: `Search the web using OpenAI, Brave, Parallel, Parallel MCP, TinyFish, Search1API, Searchinfinity, Querit, Tavily, Firecrawl, Jina, SERPdive, Kagi, Bocha, Ollama, SearXNG, DuckDuckGo, Exa, Perplexity, Gemini, AnySearch, Valyu, xAI, Bright Data, SerpBase, or Serper. Pass a provider array to search only those providers simultaneously, or use provider "all" to search every eligible provider except Parallel MCP, DuckDuckGo, AnySearch, Valyu, xAI, Bright Data, SerpBase, and Serper. Returns an AI-synthesized answer with source citations. OpenAI search uses a Codex subscription or OpenAI API key; xAI search uses a SuperGrok/X Premium subscription or xAI API key. Parallel MCP, DuckDuckGo, AnySearch, Valyu, xAI, Bright Data, SerpBase, and Serper are available only when explicitly selected. For comprehensive research, prefer queries (plural) with 2-4 varied angles over a single query — each query gets its own synthesized answer, so varying phrasing and scope gives much broader coverage. When includeContent is true, full page content is fetched in the background. Searches auto-open the interactive browser curator and stream results live; set workflow to "none" to skip curation or "auto-summary" for a model-generated summary without the browser curator. The configured provider is used when provider is omitted or set to auto; omit provider unless explicitly overriding it. Without a configured provider, SearXNG is preferred first for local/private search. When the active Pi model is openai-codex, Codex-backed OpenAI search is preferred next. Otherwise Exa is preferred before OpenAI, then Brave, Parallel, TinyFish, Search1API, Searchinfinity, Querit, Tavily, Firecrawl, Jina, SERPdive, Kagi, Bocha, Ollama, Perplexity, Gemini API, or Gemini Web.`,
+            description: `Search the web using OpenAI, Brave, Parallel, Parallel MCP, TinyFish, Search1API, Searchinfinity, Querit, Tavily, Firecrawl, Jina, SERPdive, Kagi, Bocha, Ollama, SearXNG, DuckDuckGo, Exa, Perplexity, Gemini, Kimi, AnySearch, XCrawl, Valyu, xAI, Bright Data, SerpBase, or Serper. Pass a provider array to search only those providers simultaneously, or use provider "all" to search every eligible provider except Parallel MCP, DuckDuckGo, Kimi, AnySearch, XCrawl, Valyu, xAI, Bright Data, SerpBase, and Serper. Returns an AI-synthesized answer with source citations. OpenAI search uses a Codex subscription or OpenAI API key; Kimi search uses a Kimi Code Plan authenticated through /login kimi-coding; xAI search uses a SuperGrok/X Premium subscription or xAI API key. Parallel MCP, DuckDuckGo, Kimi, AnySearch, XCrawl, Valyu, xAI, Bright Data, SerpBase, and Serper are available only when explicitly selected. For comprehensive research, prefer queries (plural) with 2-4 varied angles over a single query — each query gets its own synthesized answer, so varying phrasing and scope gives much broader coverage. When includeContent is true, full page content is fetched in the background. Searches auto-open the interactive browser curator and stream results live; set workflow to "none" to skip curation or "auto-summary" for a model-generated summary without the browser curator. The configured provider is used when provider is omitted or set to auto; omit provider unless explicitly overriding it. Without a configured provider, SearXNG is preferred first for local/private search. When the active Pi model is openai-codex, Codex-backed OpenAI search is preferred next. Otherwise Exa is preferred before OpenAI, then Brave, Parallel, TinyFish, Search1API, Searchinfinity, Querit, Tavily, Firecrawl, Jina, SERPdive, Kagi, Bocha, Ollama, Perplexity, Gemini API, or Gemini Web.`,
             promptSnippet: "Use for web research questions. Prefer {queries:[...]} with 2-4 varied angles over a single query for broader coverage. Omit provider unless explicitly overriding the configured default.",
             parameters: Type.Object({
                 query: Type.Optional(Type.String({ description: "Single search query. For research tasks, prefer 'queries' with multiple varied angles instead." })),
@@ -1466,290 +1549,297 @@ export default function (pi) {
                 includeContent: Type.Optional(Type.Boolean({ description: "Fetch full page content (async)" })),
                 recencyFilter: Type.Optional(StringEnum(["day", "week", "month", "year"], { description: "Filter by recency" })),
                 domainFilter: Type.Optional(Type.Array(Type.String(), { description: "Limit to domains (prefix with - to exclude)" })),
-                provider: Type.Optional(searchProviderSchema("Search provider or non-empty list of providers to search simultaneously; use all to search every eligible provider except Parallel MCP, DuckDuckGo, AnySearch, xAI, Bright Data, SerpBase, Serper, and Valyu, omit this field to use the configured provider, or use auto when none is configured")),
+                provider: Type.Optional(searchProviderSchema("Search provider or non-empty list of providers to search simultaneously; use all to search every eligible provider except Parallel MCP, DuckDuckGo, Kimi, AnySearch, XCrawl, Valyu, xAI, Bright Data, SerpBase, and Serper, omit this field to use the configured provider, or use auto when none is configured")),
                 workflow: Type.Optional(StringEnum(["none", "summary-review", "auto-summary"], {
                     description: "Search workflow mode: none = no curator, summary-review = open curator with auto summary draft (default), auto-summary = generate summary without opening curator",
                 })),
+                proxy: Type.Optional(Type.String({
+                    description: "http(s) proxy URL (e.g. http://host:port) used for every outbound request in this call (search APIs and content fetches). Node fetch ignores HTTP(S)_PROXY env vars, so set this (or `proxy` in web-search.json) when direct access is blocked; empty string forces direct access.",
+                })),
             }),
             async execute(callId, params, signal, onUpdate, ctx) {
-                const rawQueryList = Array.isArray(params.queries)
-                    ? params.queries
-                    : (params.query !== undefined ? [params.query] : []);
-                const queryList = normalizeQueryList(rawQueryList);
-                const configWorkflow = loadConfigForExtensionInit().workflow;
-                const workflow = resolveWorkflow(params.workflow ?? configWorkflow, ctx?.hasUI !== false);
-                const shouldCurate = workflow === "summary-review";
-                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" },
-                    };
-                }
-                if (shouldCurate && !ctx) {
-                    return {
-                        content: [{ type: "text", text: "Error: Curation requires an active extension context." }],
-                        details: { error: "Missing extension context" },
-                    };
-                }
-                if (shouldCurate) {
-                    closeCurator(callId);
-                    let resolvePromise = () => { };
-                    const promise = new Promise((resolve) => {
-                        resolvePromise = resolve;
-                    });
-                    const includeContent = params.includeContent ?? false;
-                    const searchResults = new Map();
-                    const resultSlots = new Map();
+                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 configWorkflow = loadConfigForExtensionInit().workflow;
+                    const workflow = resolveWorkflow(params.workflow ?? configWorkflow, ctx?.hasUI !== false);
+                    const shouldCurate = workflow === "summary-review";
+                    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" },
+                        };
+                    }
+                    if (shouldCurate && !ctx) {
+                        return {
+                            content: [{ type: "text", text: "Error: Curation requires an active extension context." }],
+                            details: { error: "Missing extension context" },
+                        };
+                    }
+                    if (shouldCurate) {
+                        closeCurator(callId);
+                        let resolvePromise = () => { };
+                        const promise = new Promise((resolve) => {
+                            resolvePromise = resolve;
+                        });
+                        const includeContent = params.includeContent ?? false;
+                        const searchResults = new Map();
+                        const resultSlots = new Map();
+                        const allInlineContent = [];
+                        let nextResultIndex = queryList.length;
+                        const searchAbort = new AbortController();
+                        const searchSignal = signal
+                            ? AbortSignal.any([signal, searchAbort.signal])
+                            : searchAbort.signal;
+                        let cancelled = false;
+                        const requestedProvider = resolveRequestedProvider(params.provider);
+                        const bootstrap = await loadCuratorBootstrap(requestedProvider, ctx, {
+                            numResults: params.numResults,
+                            recencyFilter,
+                        });
+                        const availableProviders = bootstrap.availableProviders;
+                        const defaultProvider = bootstrap.defaultProvider;
+                        const searchProvider = requestedProvider;
+                        const curatorTimeoutSeconds = bootstrap.timeoutSeconds;
+                        const curatorWorkflow = "summary-review";
+                        const summaryContext = {
+                            model: ctx.model,
+                            modelRegistry: ctx.modelRegistry,
+                            cwd: ctx.cwd,
+                            isProjectTrusted: () => ctx.isProjectTrusted(),
+                        };
+                        const summaryModelChoices = await loadSummaryModelChoices(summaryContext);
+                        const pc = {
+                            phase: "searching",
+                            workflow: curatorWorkflow,
+                            summaryContext,
+                            searchResults,
+                            resultSlots,
+                            allInlineContent,
+                            queryList,
+                            includeContent,
+                            numResults: params.numResults,
+                            recencyFilter,
+                            domainFilter: params.domainFilter,
+                            availableProviders,
+                            defaultProvider,
+                            searchProvider,
+                            summaryModels: summaryModelChoices.summaryModels,
+                            defaultSummaryModel: summaryModelChoices.defaultSummaryModel,
+                            timeoutSeconds: curatorTimeoutSeconds,
+                            proxy: typeof params.proxy === "string" ? params.proxy : undefined,
+                            onUpdate: onUpdate,
+                            signal,
+                            abortSearches: () => {
+                                if (!searchAbort.signal.aborted)
+                                    searchAbort.abort();
+                            },
+                            finish: () => { },
+                            cancel: () => { },
+                        };
+                        const finish = (value) => {
+                            if (cancelled)
+                                return;
+                            cancelled = true;
+                            pc.abortSearches();
+                            signal?.removeEventListener("abort", onAbort);
+                            pendingCurates.delete(callId);
+                            resolvePromise(value);
+                        };
+                        const cancel = (reason = "stale") => {
+                            if (cancelled)
+                                return;
+                            const conn = activeCurators.get(callId)?.getConnectionState();
+                            finish(buildCurationCancelledReturn(reason, {
+                                queries: Array.from(searchResults.values()),
+                                queryCount: queryList.length,
+                                browserConnected: conn?.browserConnected,
+                                lastHeartbeatAgeMs: conn?.lastHeartbeatAgeMs,
+                                curatorUrl: pc.curatorUrl,
+                                browserOpenError: pc.browserOpenError,
+                            }));
+                        };
+                        pc.finish = finish;
+                        pc.cancel = cancel;
+                        const onAbort = () => closeCurator(callId);
+                        pendingCurates.set(callId, pc);
+                        signal?.addEventListener("abort", onAbort, { once: true });
+                        pc.browserPromise = openCuratorBrowser(callId, pc, ctx, false);
+                        for (let qi = 0; qi < queryList.length; qi++) {
+                            if (signal?.aborted || cancelled || searchAbort.signal.aborted)
+                                break;
+                            onUpdate?.({
+                                content: [{ type: "text", text: `Searching ${qi + 1}/${queryList.length}: "${queryList[qi]}"...` }],
+                                details: { phase: "searching", progress: qi / queryList.length, currentQuery: queryList[qi] },
+                            });
+                            const requestedProvider = pc.searchProvider;
+                            try {
+                                const response = await search(queryList[qi], {
+                                    provider: requestedProvider,
+                                    numResults: params.numResults,
+                                    recencyFilter,
+                                    domainFilter: params.domainFilter,
+                                    includeContent: params.includeContent,
+                                    signal: searchSignal,
+                                    extensionContext: ctx,
+                                });
+                                if (signal?.aborted || cancelled || searchAbort.signal.aborted)
+                                    break;
+                                if (response.inlineContent)
+                                    allInlineContent.push(...response.inlineContent);
+                                const entries = toCuratorSearchEntries(response);
+                                const curator = activeCurators.get(callId);
+                                for (let entryIndex = 0; entryIndex < entries.length; entryIndex++) {
+                                    const entry = entries[entryIndex];
+                                    const resultIndex = entryIndex === 0 ? qi : nextResultIndex++;
+                                    const indexedEntry = {
+                                        ...entry,
+                                        queryIndex: resultIndex,
+                                        query: queryList[qi],
+                                    };
+                                    searchResults.set(resultIndex, indexedCuratorEntryToQueryResult(indexedEntry));
+                                    resultSlots.set(resultIndex, qi);
+                                    if (curator) {
+                                        if (entry.error) {
+                                            curator.pushError(resultIndex, entry.error, entry.provider, { query: queryList[qi], slotIndex: qi });
+                                        }
+                                        else {
+                                            curator.pushResult(resultIndex, { ...entry, query: queryList[qi], slotIndex: qi });
+                                        }
+                                    }
+                                }
+                            }
+                            catch (err) {
+                                if (signal?.aborted || cancelled || searchAbort.signal.aborted)
+                                    break;
+                                const message = err instanceof Error ? err.message : String(err);
+                                const failedProvider = toCuratorProvider(requestedProvider);
+                                searchResults.set(qi, { query: queryList[qi], answer: "", results: [], error: message, provider: failedProvider });
+                                resultSlots.set(qi, qi);
+                                const curator = activeCurators.get(callId);
+                                if (curator) {
+                                    curator.pushError(qi, message, failedProvider, { query: queryList[qi], slotIndex: qi });
+                                }
+                            }
+                        }
+                        if (signal?.aborted || cancelled || searchAbort.signal.aborted) {
+                            cancel();
+                            return promise;
+                        }
+                        await pc.browserPromise;
+                        const curator = activeCurators.get(callId);
+                        if (curator && !cancelled) {
+                            curator.searchesDone();
+                            if (pc.browserOpenError) {
+                                pc.onUpdate?.({
+                                    content: [{ type: "text", text: `All searches complete. Open the curator manually: ${pc.curatorUrl}` }],
+                                    details: {
+                                        phase: "curator-fallback",
+                                        progress: 1,
+                                        curatorUrl: pc.curatorUrl,
+                                        timeoutSeconds: pc.timeoutSeconds,
+                                        shortcut: curateKey,
+                                        browserOpenError: pc.browserOpenError,
+                                    },
+                                });
+                            }
+                            else {
+                                pc.onUpdate?.({
+                                    content: [{ type: "text", text: "All searches complete — waiting for summary approval in browser..." }],
+                                    details: {
+                                        phase: "curating",
+                                        progress: 1,
+                                        curatorUrl: pc.curatorUrl,
+                                        timeoutSeconds: pc.timeoutSeconds,
+                                        shortcut: curateKey,
+                                    },
+                                });
+                            }
+                        }
+                        return promise;
+                    }
+                    const searchResults = [];
+                    const allUrls = [];
                     const allInlineContent = [];
-                    let nextResultIndex = queryList.length;
-                    const searchAbort = new AbortController();
-                    const searchSignal = signal
-                        ? AbortSignal.any([signal, searchAbort.signal])
-                        : searchAbort.signal;
-                    let cancelled = false;
-                    const requestedProvider = resolveRequestedProvider(params.provider);
-                    const bootstrap = await loadCuratorBootstrap(requestedProvider, ctx, {
-                        numResults: params.numResults,
-                        recencyFilter,
-                    });
-                    const availableProviders = bootstrap.availableProviders;
-                    const defaultProvider = bootstrap.defaultProvider;
-                    const searchProvider = requestedProvider;
-                    const curatorTimeoutSeconds = bootstrap.timeoutSeconds;
-                    const curatorWorkflow = "summary-review";
-                    const summaryContext = {
-                        model: ctx.model,
-                        modelRegistry: ctx.modelRegistry,
-                        cwd: ctx.cwd,
-                        isProjectTrusted: () => ctx.isProjectTrusted(),
-                    };
-                    const summaryModelChoices = await loadSummaryModelChoices(summaryContext);
-                    const pc = {
-                        phase: "searching",
-                        workflow: curatorWorkflow,
-                        summaryContext,
-                        searchResults,
-                        resultSlots,
-                        allInlineContent,
-                        queryList,
-                        includeContent,
-                        numResults: params.numResults,
-                        recencyFilter,
-                        domainFilter: params.domainFilter,
-                        availableProviders,
-                        defaultProvider,
-                        searchProvider,
-                        summaryModels: summaryModelChoices.summaryModels,
-                        defaultSummaryModel: summaryModelChoices.defaultSummaryModel,
-                        timeoutSeconds: curatorTimeoutSeconds,
-                        onUpdate: onUpdate,
-                        signal,
-                        abortSearches: () => {
-                            if (!searchAbort.signal.aborted)
-                                searchAbort.abort();
-                        },
-                        finish: () => { },
-                        cancel: () => { },
-                    };
-                    const finish = (value) => {
-                        if (cancelled)
-                            return;
-                        cancelled = true;
-                        pc.abortSearches();
-                        signal?.removeEventListener("abort", onAbort);
-                        pendingCurates.delete(callId);
-                        resolvePromise(value);
-                    };
-                    const cancel = (reason = "stale") => {
-                        if (cancelled)
-                            return;
-                        const conn = activeCurators.get(callId)?.getConnectionState();
-                        finish(buildCurationCancelledReturn(reason, {
-                            queries: Array.from(searchResults.values()),
-                            queryCount: queryList.length,
-                            browserConnected: conn?.browserConnected,
-                            lastHeartbeatAgeMs: conn?.lastHeartbeatAgeMs,
-                            curatorUrl: pc.curatorUrl,
-                            browserOpenError: pc.browserOpenError,
-                        }));
-                    };
-                    pc.finish = finish;
-                    pc.cancel = cancel;
-                    const onAbort = () => closeCurator(callId);
-                    pendingCurates.set(callId, pc);
-                    signal?.addEventListener("abort", onAbort, { once: true });
-                    pc.browserPromise = openCuratorBrowser(callId, pc, ctx, false);
-                    for (let qi = 0; qi < queryList.length; qi++) {
-                        if (signal?.aborted || cancelled || searchAbort.signal.aborted)
-                            break;
+                    const resolvedProvider = resolveRequestedProvider(params.provider);
+                    for (let i = 0; i < queryList.length; i++) {
+                        const query = queryList[i];
                         onUpdate?.({
-                            content: [{ type: "text", text: `Searching ${qi + 1}/${queryList.length}: "${queryList[qi]}"...` }],
-                            details: { phase: "searching", progress: qi / queryList.length, currentQuery: queryList[qi] },
+                            content: [{ type: "text", text: `Searching ${i + 1}/${queryList.length}: "${query}"...` }],
+                            details: { phase: "search", progress: i / queryList.length, currentQuery: query },
                         });
-                        const requestedProvider = pc.searchProvider;
                         try {
-                            const response = await search(queryList[qi], {
-                                provider: requestedProvider,
+                            const { answer, results, inlineContent, provider } = await search(query, {
+                                provider: resolvedProvider,
                                 numResults: params.numResults,
                                 recencyFilter,
                                 domainFilter: params.domainFilter,
                                 includeContent: params.includeContent,
-                                signal: searchSignal,
+                                signal,
                                 extensionContext: ctx,
                             });
-                            if (signal?.aborted || cancelled || searchAbort.signal.aborted)
-                                break;
-                            if (response.inlineContent)
-                                allInlineContent.push(...response.inlineContent);
-                            const entries = toCuratorSearchEntries(response);
-                            const curator = activeCurators.get(callId);
-                            for (let entryIndex = 0; entryIndex < entries.length; entryIndex++) {
-                                const entry = entries[entryIndex];
-                                const resultIndex = entryIndex === 0 ? qi : nextResultIndex++;
-                                const indexedEntry = {
-                                    ...entry,
-                                    queryIndex: resultIndex,
-                                    query: queryList[qi],
-                                };
-                                searchResults.set(resultIndex, indexedCuratorEntryToQueryResult(indexedEntry));
-                                resultSlots.set(resultIndex, qi);
-                                if (curator) {
-                                    if (entry.error) {
-                                        curator.pushError(resultIndex, entry.error, entry.provider, { query: queryList[qi], slotIndex: qi });
-                                    }
-                                    else {
-                                        curator.pushResult(resultIndex, { ...entry, query: queryList[qi], slotIndex: qi });
-                                    }
+                            searchResults.push({ query, answer, results, error: null, provider });
+                            for (const r of results) {
+                                if (!allUrls.includes(r.url)) {
+                                    allUrls.push(r.url);
                                 }
                             }
+                            if (inlineContent)
+                                allInlineContent.push(...inlineContent);
                         }
                         catch (err) {
-                            if (signal?.aborted || cancelled || searchAbort.signal.aborted)
-                                break;
+                            if (signal?.aborted || isAbortError(err))
+                                throw err;
                             const message = err instanceof Error ? err.message : String(err);
-                            const failedProvider = toCuratorProvider(requestedProvider);
-                            searchResults.set(qi, { query: queryList[qi], answer: "", results: [], error: message, provider: failedProvider });
-                            resultSlots.set(qi, qi);
-                            const curator = activeCurators.get(callId);
-                            if (curator) {
-                                curator.pushError(qi, message, failedProvider, { query: queryList[qi], slotIndex: qi });
-                            }
+                            const requestedProvider = toCuratorProvider(resolvedProvider);
+                            searchResults.push({ query, answer: "", results: [], error: message, provider: requestedProvider });
                         }
                     }
-                    if (signal?.aborted || cancelled || searchAbort.signal.aborted) {
-                        cancel();
-                        return promise;
-                    }
-                    await pc.browserPromise;
-                    const curator = activeCurators.get(callId);
-                    if (curator && !cancelled) {
-                        curator.searchesDone();
-                        if (pc.browserOpenError) {
-                            pc.onUpdate?.({
-                                content: [{ type: "text", text: `All searches complete. Open the curator manually: ${pc.curatorUrl}` }],
-                                details: {
-                                    phase: "curator-fallback",
-                                    progress: 1,
-                                    curatorUrl: pc.curatorUrl,
-                                    timeoutSeconds: pc.timeoutSeconds,
-                                    shortcut: curateKey,
-                                    browserOpenError: pc.browserOpenError,
-                                },
-                            });
-                        }
-                        else {
-                            pc.onUpdate?.({
-                                content: [{ type: "text", text: "All searches complete — waiting for summary approval in browser..." }],
-                                details: {
-                                    phase: "curating",
-                                    progress: 1,
-                                    curatorUrl: pc.curatorUrl,
-                                    timeoutSeconds: pc.timeoutSeconds,
-                                    shortcut: curateKey,
-                                },
-                            });
+                    let approvedSummary;
+                    let summaryMeta;
+                    if (workflow === "auto-summary") {
+                        if (!ctx) {
+                            return {
+                                content: [{ type: "text", text: "Error: Auto-summary requires an active extension context." }],
+                                details: { error: "Missing extension context" },
+                            };
                         }
-                    }
-                    return promise;
-                }
-                const searchResults = [];
-                const allUrls = [];
-                const allInlineContent = [];
-                const resolvedProvider = resolveRequestedProvider(params.provider);
-                for (let i = 0; i < queryList.length; i++) {
-                    const query = queryList[i];
-                    onUpdate?.({
-                        content: [{ type: "text", text: `Searching ${i + 1}/${queryList.length}: "${query}"...` }],
-                        details: { phase: "search", progress: i / queryList.length, currentQuery: query },
-                    });
-                    try {
-                        const { answer, results, inlineContent, provider } = await search(query, {
-                            provider: resolvedProvider,
-                            numResults: params.numResults,
-                            recencyFilter,
-                            domainFilter: params.domainFilter,
-                            includeContent: params.includeContent,
-                            signal,
-                            extensionContext: ctx,
+                        onUpdate?.({
+                            content: [{ type: "text", text: "Generating summary..." }],
+                            details: { phase: "generating-summary", progress: 1 },
                         });
-                        searchResults.push({ query, answer, results, error: null, provider });
-                        for (const r of results) {
-                            if (!allUrls.includes(r.url)) {
-                                allUrls.push(r.url);
-                            }
-                        }
-                        if (inlineContent)
-                            allInlineContent.push(...inlineContent);
-                    }
-                    catch (err) {
-                        if (signal?.aborted || isAbortError(err))
-                            throw err;
-                        const message = err instanceof Error ? err.message : String(err);
-                        const requestedProvider = toCuratorProvider(resolvedProvider);
-                        searchResults.push({ query, answer: "", results: [], error: message, provider: requestedProvider });
-                    }
-                }
-                let approvedSummary;
-                let summaryMeta;
-                if (workflow === "auto-summary") {
-                    if (!ctx) {
-                        return {
-                            content: [{ type: "text", text: "Error: Auto-summary requires an active extension context." }],
-                            details: { error: "Missing extension context" },
+                        const summaryContext = {
+                            model: ctx.model,
+                            modelRegistry: ctx.modelRegistry,
+                            cwd: ctx.cwd,
+                            isProjectTrusted: () => ctx.isProjectTrusted(),
                         };
+                        const summaryModelChoices = await loadSummaryModelChoices(summaryContext);
+                        const generated = await generateSummaryDraft(searchResults, summaryContext, signal, summaryModelChoices.defaultSummaryModel ?? undefined, undefined, undefined, getSummaryGenerationDeadlineMs());
+                        approvedSummary = generated.summary;
+                        summaryMeta = generated.meta;
                     }
-                    onUpdate?.({
-                        content: [{ type: "text", text: "Generating summary..." }],
-                        details: { phase: "generating-summary", progress: 1 },
+                    return buildSearchReturn({
+                        queryList,
+                        results: searchResults,
+                        urls: allUrls,
+                        includeContent: params.includeContent ?? false,
+                        inlineContent: allInlineContent.length > 0 ? allInlineContent : undefined,
+                        workflow: workflow === "auto-summary" ? "auto-summary" : undefined,
+                        approvedSummary,
+                        summaryMeta,
+                        proxy: typeof params.proxy === "string" ? params.proxy : undefined,
                     });
-                    const summaryContext = {
-                        model: ctx.model,
-                        modelRegistry: ctx.modelRegistry,
-                        cwd: ctx.cwd,
-                        isProjectTrusted: () => ctx.isProjectTrusted(),
-                    };
-                    const summaryModelChoices = await loadSummaryModelChoices(summaryContext);
-                    const generated = await generateSummaryDraft(searchResults, summaryContext, signal, summaryModelChoices.defaultSummaryModel ?? undefined, undefined, undefined, getSummaryGenerationDeadlineMs());
-                    approvedSummary = generated.summary;
-                    summaryMeta = generated.meta;
-                }
-                return buildSearchReturn({
-                    queryList,
-                    results: searchResults,
-                    urls: allUrls,
-                    includeContent: params.includeContent ?? false,
-                    inlineContent: allInlineContent.length > 0 ? allInlineContent : undefined,
-                    workflow: workflow === "auto-summary" ? "auto-summary" : undefined,
-                    approvedSummary,
-                    summaryMeta,
                 });
             },
             renderCall(args, theme) {
                 const input = args;
                 const rawQueryList = Array.isArray(input.queries)
                     ? input.queries
-                    : (input.query !== undefined ? [input.query] : []);
+                    : (input.query !== undefined ? expandQueryString(input.query) : []);
                 const queryList = normalizeQueryList(rawQueryList);
                 if (queryList.length === 0) {
                     return new Text(theme.fg("toolTitle", theme.bold("search ")) + theme.fg("error", "(no query)"), 0, 0);
@@ -1969,91 +2059,96 @@ export default function (pi) {
                 fetchContent: Type.Optional(Type.Boolean({ description: "Fetch up to 5 result pages for exact passage extraction." })),
                 recencyFilter: Type.Optional(StringEnum(["day", "week", "month", "year"], { description: "Filter by recency." })),
                 domainFilter: Type.Optional(Type.Array(Type.String(), { description: "Limit to domains; prefix with - to exclude." })),
-                provider: Type.Optional(searchProviderSchema("Search provider or non-empty list of providers to search simultaneously; all searches every eligible provider except DuckDuckGo, AnySearch, xAI, Bright Data, SerpBase, Serper, and Valyu")),
+                provider: Type.Optional(searchProviderSchema("Search provider or non-empty list of providers to search simultaneously; all searches every eligible provider except Parallel MCP, DuckDuckGo, Kimi, AnySearch, XCrawl, Valyu, xAI, Bright Data, SerpBase, and Serper")),
+                proxy: Type.Optional(Type.String({
+                    description: "http(s) proxy URL (e.g. http://host:port) used for every outbound request in this call (search APIs and result-page fetches). Empty string forces direct access.",
+                })),
             }),
             async execute(_callId, params, signal, _onUpdate, ctx) {
-                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,
-                        });
+                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;
-                        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);
+                        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) });
                         }
                     }
-                    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);
+                    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, withRegisteredFetchOptions(undefined, registeredToolNames, 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) }));
+                        }
                     }
-                    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("\n\n") : undefined,
-                    results,
-                    fetched,
-                    recency: recencyFilter,
-                    domainFilter,
-                }), [claim]);
-                if (errors.length > 0)
-                    artifact.errors = errors;
-                storeResearchArtifact(artifact);
-                pi.appendEntry("web-search-results", {
-                    id: artifact.id,
-                    type: "research",
-                    timestamp: artifact.timestamp,
-                    artifact,
+                    const artifact = withClaimAssessment(buildResearchArtifact({
+                        query: claim,
+                        provider,
+                        summary: summaries.length > 0 ? summaries.join("\n\n") : undefined,
+                        results,
+                        fetched,
+                        recency: recencyFilter,
+                        domainFilter,
+                    }), [claim]);
+                    if (errors.length > 0)
+                        artifact.errors = errors;
+                    storeResearchArtifact(artifact);
+                    pi.appendEntry("web-search-results", {
+                        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 },
+                    };
                 });
-                return {
-                    content: [{ type: "text", text: formatSourceCheckResult(artifact, getSearchContentEnabled ? toolNames.getSearchContent : null) }],
-                    details: { responseId: artifact.id, artifact, sourceCount: artifact.sources.length, passageCount: artifact.passages.length },
-                };
             },
         });
     if (fetchContentEnabled)
@@ -2075,7 +2170,7 @@ export default function (pi) {
                     description: "Fetch mode: readable (default extraction), raw (exact textual HTTP body), or answer (answer prompt using only fetched content).",
                 })),
                 answerModel: Type.Optional(Type.String({
-                    description: "Optional provider/model-id override for mode answer. Defaults to the current Pi model.",
+                    description: "Optional provider/model-id override for mode answer. Defaults to fetch.answerProvider + fetch.answerModel when configured, otherwise the current Pi model.",
                 })),
                 timestamp: Type.Optional(Type.String({
                     description: "Extract video frame(s) at a timestamp or time range. Single: '1:23:45', '23:45', or '85' (seconds). Range: '23:41-25:00' extracts evenly-spaced frames across that span (default 6). Use frames with ranges to control density; single+frames uses a fixed 5s interval. YouTube requires yt-dlp + ffmpeg; local videos require ffmpeg. Use a range when you know the approximate area but not the exact moment — you'll get a contact sheet to visually identify the right frame.",
@@ -2091,6 +2186,9 @@ export default function (pi) {
                 auth: Type.Optional(Type.Union([Type.String(), Type.Boolean()], {
                     description: "Opt into an authFetch profile for local browser-cookie fetching. Use a profile name, or true only when exactly one profile exists.",
                 })),
+                proxy: Type.Optional(Type.String({
+                    description: "http(s) proxy URL (e.g. http://host:port) used for this fetch. Needed when the target is unreachable directly; localhost and NO_PROXY hosts always bypass the proxy. Empty string forces direct access.",
+                })),
             }),
             async execute(_toolCallId, params, signal, onUpdate, ctx) {
                 let normalized;
@@ -2102,159 +2200,159 @@ export default function (pi) {
                     return { content: [{ type: "text", text: `Error: ${error}` }], details: { error } };
                 }
                 const { urlList, options } = normalized;
-                const mode = options.mode ?? "readable";
-                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);
+                return runWithProxy(options.proxy, async () => {
+                    const mode = options.mode ?? "readable";
+                    if (mode === "answer" && !options.prompt) {
+                        return { content: [{ type: "text", text: "Error: mode answer requires prompt." }], details: { error: "mode answer requires prompt" } };
                     }
-                    catch (err) {
-                        const error = err instanceof Error ? err.message : String(err);
-                        return { content: [{ type: "text", text: `Error: ${error}` }], details: { error } };
+                    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 (urlList.length === 0) {
-                    return {
-                        content: [{ type: "text", text: "Error: No URL provided." }],
-                        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;
-                const fetchOptions = mode === "answer"
-                    ? (() => {
-                        const { prompt: _prompt, ...rest } = extractionOptions;
-                        return { ...rest, ...(authFetchProfile ? { authFetchProfile } : {}) };
-                    })()
-                    : { ...extractionOptions, ...(authFetchProfile ? { authFetchProfile } : {}) };
-                const fetchResults = await fetchAllContent(urlList, signal, fetchOptions);
-                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" };
-                        }
+                    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 {
-                            const answer = await answerFromPage({
-                                question: options.prompt,
-                                pageText: result.content,
-                                sourceUrl: result.url,
-                                ...(options.answerModel ? { model: options.answerModel } : {}),
-                            }, ctx, signal);
-                            return { ...result, content: answer.text };
+                            authFetchProfile = resolveAuthFetchProfile(options.auth);
                         }
                         catch (err) {
-                            return { ...result, error: `Page answer failed: ${err instanceof Error ? err.message : String(err)}` };
+                            const error = err instanceof Error ? err.message : String(err);
+                            return { content: [{ type: "text", text: `Error: ${error}` }], details: { error } };
                         }
-                    }))
-                    : 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(pi, responseId, data, authFetchProfile);
-                // Single URL: return content directly (possibly truncated) with responseId
-                if (urlList.length === 1) {
-                    const result = presentedResults[0];
-                    if (result.error) {
+                    }
+                    if (urlList.length === 0) {
                         return {
-                            content: [{ type: "text", text: `Error: ${result.error}` }],
-                            details: { urls: urlList, urlCount: 1, successful: 0, error: result.error, ...(storedContent ? { responseId } : {}), prompt: params.prompt, timestamp: params.timestamp, frames: params.frames },
+                            content: [{ type: "text", text: "Error: No URL provided." }],
+                            details: { error: "No URL provided" },
                         };
                     }
-                    const fullLength = result.content.length;
-                    const slice = initialContentSlice(result.content, getMaxInlineContentChars());
-                    const truncated = slice.endOffset < fullLength;
-                    let output = slice.text;
-                    if (truncated) {
-                        output += `\n\n---\nShowing ${slice.endOffset} of ${fullLength} chars, ${slice.shownBytes} of ${slice.totalBytes} bytes, and ${slice.shownLines} of ${slice.totalLines} lines. `;
-                        output += storedContent
-                            ? getSearchContentEnabled
-                                ? `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}` });
+                    onUpdate?.({
+                        content: [{ type: "text", text: `Fetching ${urlList.length} URL(s)...` }],
+                        details: { phase: "fetch", progress: 0 },
+                    });
+                    const { answerModel: _answerModel, auth: _auth, ...extractionOptions } = options;
+                    const fetchOptions = mode === "answer"
+                        ? (() => {
+                            const { prompt: _prompt, ...rest } = extractionOptions;
+                            return { ...rest, ...(authFetchProfile ? { authFetchProfile } : {}) };
+                        })()
+                        : { ...extractionOptions, ...(authFetchProfile ? { authFetchProfile } : {}) };
+                    const fetchResults = await fetchAllContent(urlList, signal, withRegisteredFetchOptions(fetchOptions, registeredToolNames, 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 {
+                                const answer = await 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(pi, responseId, data, authFetchProfile);
+                    if (urlList.length === 1) {
+                        const result = presentedResults[0];
+                        if (result.error) {
+                            return {
+                                content: [{ type: "text", text: `Error: ${result.error}` }],
+                                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 += `\n\n---\nShowing ${slice.endOffset} of ${fullLength} chars, ${slice.shownBytes} of ${slice.totalBytes} bytes, and ${slice.shownLines} of ${slice.totalLines} lines. `;
+                            output += storedContent
+                                ? getSearchContentEnabled
+                                    ? `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 });
+                        const imageCount = (result.frames?.length ?? 0) + (result.thumbnail ? 1 : 0);
+                        return {
+                            content,
+                            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,
+                            },
+                        };
                     }
-                    else if (result.thumbnail) {
-                        content.push({ type: "image", data: result.thumbnail.data, mimeType: result.thumbnail.mimeType });
+                    let output = "## Fetched URLs\n\n";
+                    for (const { url, title, content, error } of presentedResults) {
+                        if (error) {
+                            output += `- ${url}: Error - ${error}\n`;
+                        }
+                        else {
+                            output += `- ${title || url} (${content.length} chars)\n`;
+                        }
                     }
-                    content.push({ type: "text", text: output });
-                    const imageCount = (result.frames?.length ?? 0) + (result.thumbnail ? 1 : 0);
+                    output += storedContent
+                        ? getSearchContentEnabled
+                            ? `\n---\nUse ${toolNames.getSearchContent}({ responseId: "${responseId}", urlIndex: 0 }) to retrieve bounded content slices.`
+                            : "\n---\nContent retrieval is not registered."
+                        : "\n---\nAuthenticated fetch cache is off; repeat the fetch to read content.";
                     return {
-                        content,
-                        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,
-                        },
+                        content: [{ type: "text", text: output }],
+                        details: { urls: urlList, urlCount: urlList.length, successful, totalChars, ...(storedContent ? { responseId } : {}) },
                     };
-                }
-                // Multi-URL: existing behavior (summary + responseId)
-                let output = "## Fetched URLs\n\n";
-                for (const { url, title, content, error } of presentedResults) {
-                    if (error) {
-                        output += `- ${url}: Error - ${error}\n`;
-                    }
-                    else {
-                        output += `- ${title || url} (${content.length} chars)\n`;
-                    }
-                }
-                output += storedContent
-                    ? getSearchContentEnabled
-                        ? `\n---\nUse ${toolNames.getSearchContent}({ responseId: "${responseId}", urlIndex: 0 }) to retrieve bounded content slices.`
-                        : "\n---\nContent retrieval is not registered."
-                    : "\n---\nAuthenticated fetch cache is off; repeat the fetch to read content.";
-                return {
-                    content: [{ type: "text", text: output }],
-                    details: { urls: urlList, urlCount: urlList.length, successful, totalChars, ...(storedContent ? { responseId } : {}) },
-                };
+                });
             },
             renderCall(args, theme) {
                 const { urlList, options } = normalizeFetchContentParams(args);
@@ -2385,23 +2483,16 @@ export default function (pi) {
                 queryIndex: Type.Optional(Type.Integer({ minimum: 0, description: "Get content for query at index" })),
                 url: Type.Optional(Type.String({ description: "Get content for this URL" })),
                 urlIndex: Type.Optional(Type.Integer({ minimum: 0, description: "Get content for URL at index" })),
-                offset: Type.Optional(Type.Integer({ minimum: 0, description: "Character offset for fetched URL content slices (default 0). Cannot be combined with findText." })),
-                limit: Type.Optional(Type.Integer({ minimum: 1, maximum: maxInlineContentChars, description: "Maximum characters to return for fetched URL content slices (default and max are set by maxInlineContentChars). Cannot be combined with findText." })),
+                offset: Type.Optional(Type.Integer({ minimum: 0, description: "Character offset for fetched URL content slices (default 0). Ignored when findText is supplied." })),
+                limit: Type.Optional(Type.Integer({ minimum: 1, maximum: maxInlineContentChars, description: "Maximum characters to return for fetched URL content slices (default and max are set by maxInlineContentChars). Ignored when findText is supplied." })),
                 findText: Type.Optional(Type.Union([
                     Type.String({ minLength: 1, maxLength: 500 }),
                     Type.Array(Type.String({ minLength: 1, maxLength: 500 }), { minItems: 1, maxItems: 10 }),
-                ], { description: "Text or texts to find in the selected stored content. Cannot be combined with offset or limit." })),
+                ], { description: "Text or texts to find in the selected stored content. When supplied, offset and limit are ignored." })),
                 findMode: Type.Optional(StringEnum(["exact", "case-insensitive", "fuzzy"], { description: "Matching mode for findText (default: case-insensitive). Requires findText." })),
             }),
-            async execute(_toolCallId, params) {
-                if (params.findText !== undefined && (params.offset !== undefined || params.limit !== undefined)) {
-                    const offset = formatInputValue(params.offset);
-                    const limit = formatInputValue(params.limit);
-                    return {
-                        content: [{ type: "text", text: `findText cannot be combined with offset or limit. Received offset=${offset}, limit=${limit}; omit offset and limit when using findText.` }],
-                        details: { error: "Incompatible find options" },
-                    };
-                }
+            async execute(_toolCallId, rawParams) {
+                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.` }],
@@ -2424,6 +2515,23 @@ export default function (pi) {
                         };
                     }
                     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) {
@@ -2490,7 +2598,7 @@ export default function (pi) {
                     const fullResults = formatFullResults(queryData);
                     if (params.findText !== undefined) {
                         try {
-                            const found = findContent(fullResults, normalizeFindQueries(params.findText), (params.findMode ?? "case-insensitive"));
+                            const found = findContent(fullResults, normalizeFindQueries(params.findText), params.findMode ?? "case-insensitive");
                             const { text, ...findDetails } = found;
                             return {
                                 content: [{ type: "text", text }],
@@ -2550,7 +2658,7 @@ export default function (pi) {
                     }
                     if (params.findText !== undefined) {
                         try {
-                            const found = findContent(urlData.content, normalizeFindQueries(params.findText), (params.findMode ?? "case-insensitive"));
+                            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}\n\n${text}` }],
@@ -2994,14 +3102,16 @@ export default function (pi) {
                 const cookies = await isGeminiWebAvailable();
                 if (!cookies) {
                     const diagnostic = getGeminiWebAvailabilityDiagnostic();
+                    const diagnosticDetails = getGeminiWebAvailabilityDiagnosticDetails();
+                    const attempted = formatCookieAttempts(diagnosticDetails?.attempts ?? []);
                     const text = diagnostic
-                        ? `Gemini Web is unavailable: ${diagnostic}`
+                        ? `Gemini Web is unavailable: ${diagnostic}${attempted ? ` Attempted browser profiles: ${attempted}.` : ""}`
                         : "Gemini Web is unavailable. Sign into gemini.google.com in a supported Chromium-based browser.";
                     pi.sendMessage({
                         customType: "google-account",
                         content: [{ type: "text", text }],
                         display: true,
-                        details: { available: false, cookieAccessAllowed: true, diagnostic },
+                        details: { available: false, cookieAccessAllowed: true, diagnostic, cookieDiagnostic: diagnosticDetails },
                     }, { triggerTurn: true, deliverAs: "followUp" });
                     return;
                 }
@@ -3017,6 +3127,9 @@ export default function (pi) {
                 }, { triggerTurn: true, deliverAs: "followUp" });
             },
         });
+    function formatCookieAttempts(attempts) {
+        return attempts.map(({ browser, profile, status }) => `${browser}/${profile} (${status})`).join(", ");
+    }
     if (isCommandEnabled(initConfig, "search"))
         pi.registerCommand("search", {
             description: "Browse stored web search results",