@humain/terminal 0.0.17 → 0.1.0

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

@@ -8,6 +8,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 };
 import { Box, Text, truncateToWidth } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import pLimit from "p-limit";
 import { StringEnum } from "@earendil-works/pi-ai/compat";
 import { normalizeFetchContentParams } from "./fetch-params.js";
 import { resolveAuthFetchProfile } from "./auth-fetch.js";
@@ -51,6 +52,7 @@ import { isSearXNGAvailable } from "./searxng.js";
 import { isDuckDuckGoAvailable } from "./duckduckgo.js";
 import { isAnySearchAvailable } from "./anysearch.js";
 import { isXaiSearchAvailable } from "./xai-search.js";
+import { isMistralAvailable } from "./mistral-search.js";
 import { isKimiSearchAvailable } from "./kimi-search.js";
 import { isBrightDataAvailable } from "./brightdata.js";
 import { isSerpBaseAvailable } from "./serpbase.js";
@@ -135,6 +137,20 @@ const DEFAULT_CURATOR_TIMEOUT_SECONDS = 20;
 const DEFAULT_REMOTE_CURATOR_TIMEOUT_SECONDS = 60;
 const MAX_CURATOR_TIMEOUT_SECONDS = 600;
 const MAX_SUMMARY_GENERATION_DEADLINE_MS = 600_000;
+const SEARCH_QUERY_CONCURRENCY = 3;
+// Limit each batch independently so separate Pi tool calls can still run in parallel.
+function runSearchQueries(queries, run) {
+    const limit = pLimit(SEARCH_QUERY_CONCURRENCY);
+    return Promise.all(queries.map((query, index) => limit(() => run(query, index))));
+}
+// Keep primary query indexes stable for curator slots, then interleave additional
+// provider entries deterministically instead of assigning by completion order.
+function curatorResultIndex(queryIndex, entryIndex, queryCount) {
+    return entryIndex * queryCount + queryIndex;
+}
+function curatorResultIndexCapacity(queryCount) {
+    return queryCount * RESOLVED_SEARCH_PROVIDERS.length;
+}
 function searchProviderSchema(description) {
     return Type.Union([
         StringEnum([...SEARCH_PROVIDERS]),
@@ -335,6 +351,7 @@ async function getProviderAvailability(ctx) {
         anysearch: isAnySearchAvailable(),
         xcrawl: isXcrawlAvailable(),
         xai: await isXaiSearchAvailable(ctx),
+        mistral: isMistralAvailable(),
         brightdata: isBrightDataAvailable(),
         serpbase: isSerpBaseAvailable(),
         serper: isSerperAvailable(),
@@ -918,7 +935,8 @@ export default function (pi) {
         const fetchId = generateId();
         const controller = new AbortController();
         pendingFetches.set(fetchId, controller);
-        runWithProxy(proxy, () => fetchAllContent(urls, controller.signal, withRegisteredFetchOptions(undefined, registeredToolNames, proxy)))
+        Promise.resolve()
+            .then(() => runWithProxy(proxy, () => fetchAllContent(urls, controller.signal, withRegisteredFetchOptions(undefined, registeredToolNames, proxy))))
             .then((fetched) => {
             if (!sessionActive || !pendingFetches.has(fetchId))
                 return;
@@ -1134,7 +1152,7 @@ export default function (pi) {
             };
         }
         const selected = filterByQueryIndices(payload.selectedQueryIndices, resultsByIndex).results;
-        const fallbackResults = selected.length > 0 ? selected : [...resultsByIndex.values()];
+        const fallbackResults = selected.length > 0 ? selected : orderedSearchResults(resultsByIndex);
         const deterministic = buildDeterministicSummary(fallbackResults);
         return {
             approvedSummary: deterministic.summary,
@@ -1189,6 +1207,11 @@ export default function (pi) {
         }
         const searchId = storeAndPublishSearch(opts.results);
         const isBackgroundFetch = fetchId !== null && !hasInlineReady;
+        // The model only sees `content`, not `details`: surface the id it needs to
+        // call get_search_content, the same way fetch_content does.
+        if (getSearchContentEnabled && !hasApprovedSummary) {
+            output += `\n---\nResults stored as responseId "${searchId}". Use ${toolNames.getSearchContent}({ responseId: "${searchId}", queryIndex: 0 }) to retrieve them.`;
+        }
         return {
             content: [{ type: "text", text: output.trim() }],
             details: {
@@ -1244,8 +1267,13 @@ export default function (pi) {
         }
         return { results: filteredResults, urls: filteredUrls };
     }
+    function orderedSearchResults(resultsByIndex) {
+        return [...resultsByIndex.entries()]
+            .sort(([leftIndex], [rightIndex]) => leftIndex - rightIndex)
+            .map(([, result]) => result);
+    }
     function collectAllResultsAndUrls(resultsByIndex) {
-        const results = [...resultsByIndex.values()];
+        const results = orderedSearchResults(resultsByIndex);
         const urls = [];
         for (const result of results) {
             for (const source of result.results) {
@@ -1283,6 +1311,7 @@ export default function (pi) {
             const sessionToken = randomUUID();
             handle = await startCuratorServer({
                 queries: pc.queryList,
+                initialResultIndexCapacity: curatorResultIndexCapacity(pc.queryList.length),
                 sessionToken,
                 timeout: pc.timeoutSeconds,
                 availableProviders: pc.availableProviders,
@@ -1361,7 +1390,7 @@ export default function (pi) {
                     else {
                         const conn = activeCurators.get(callId)?.getConnectionState();
                         pc.finish(buildCurationCancelledReturn(reason, {
-                            queries: Array.from(pc.searchResults.values()),
+                            queries: orderedSearchResults(pc.searchResults),
                             queryCount: pc.queryList.length,
                             browserConnected: conn?.browserConnected,
                             lastHeartbeatAgeMs: conn?.lastHeartbeatAgeMs,
@@ -1540,16 +1569,16 @@ 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, 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.`,
+            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, Mistral, 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, Mistral, 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; Mistral search uses a Mistral API key. Parallel MCP, DuckDuckGo, Kimi, AnySearch, XCrawl, Valyu, xAI, Mistral, 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." })),
-                queries: Type.Optional(Type.Array(Type.String(), { description: "Multiple queries searched in sequence, each returning its own synthesized answer. Prefer this for research — vary phrasing, scope, and angle across 2-4 queries to maximize coverage. Good: ['React vs Vue performance benchmarks 2026', 'React vs Vue developer experience comparison', 'React ecosystem size vs Vue ecosystem']. Bad: ['React vs Vue', 'React vs Vue comparison', 'React vs Vue review'] (too similar, redundant results)." })),
+                queries: Type.Optional(Type.Array(Type.String(), { description: "Multiple queries searched concurrently (up to three at a time), each returning its own synthesized answer. Prefer this for research — vary phrasing, scope, and angle across 2-4 queries to maximize coverage. Good: ['React vs Vue performance benchmarks 2026', 'React vs Vue developer experience comparison', 'React ecosystem size vs Vue ecosystem']. Bad: ['React vs Vue', 'React vs Vue comparison', 'React vs Vue review'] (too similar, redundant results)." })),
                 numResults: Type.Optional(Type.Integer({ minimum: 1, maximum: 20, description: "Results per query (default: 5, max: 20)" })),
                 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, 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")),
+                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, Mistral, 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",
                 })),
@@ -1589,7 +1618,6 @@ export default function (pi) {
                         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])
@@ -1654,7 +1682,7 @@ export default function (pi) {
                                 return;
                             const conn = activeCurators.get(callId)?.getConnectionState();
                             finish(buildCurationCancelledReturn(reason, {
-                                queries: Array.from(searchResults.values()),
+                                queries: orderedSearchResults(searchResults),
                                 queryCount: queryList.length,
                                 browserConnected: conn?.browserConnected,
                                 lastHeartbeatAgeMs: conn?.lastHeartbeatAgeMs,
@@ -1668,16 +1696,17 @@ export default function (pi) {
                         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++) {
+                        let completedSearches = 0;
+                        await runSearchQueries(queryList, async (query, qi) => {
                             if (signal?.aborted || cancelled || searchAbort.signal.aborted)
-                                break;
+                                return;
                             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 "${query}" (${completedSearches}/${queryList.length} complete)...` }],
+                                details: { phase: "searching", progress: completedSearches / queryList.length, currentQuery: query },
                             });
                             const requestedProvider = pc.searchProvider;
                             try {
-                                const response = await search(queryList[qi], {
+                                const response = await search(query, {
                                     provider: requestedProvider,
                                     numResults: params.numResults,
                                     recencyFilter,
@@ -1687,44 +1716,53 @@ export default function (pi) {
                                     extensionContext: ctx,
                                 });
                                 if (signal?.aborted || cancelled || searchAbort.signal.aborted)
-                                    break;
+                                    return;
                                 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 resultIndex = curatorResultIndex(qi, entryIndex, queryList.length);
                                     const indexedEntry = {
                                         ...entry,
                                         queryIndex: resultIndex,
-                                        query: queryList[qi],
+                                        query,
                                     };
                                     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 });
+                                            curator.pushError(resultIndex, entry.error, entry.provider, { query, slotIndex: qi });
                                         }
                                         else {
-                                            curator.pushResult(resultIndex, { ...entry, query: queryList[qi], slotIndex: qi });
+                                            curator.pushResult(resultIndex, { ...entry, query, slotIndex: qi });
                                         }
                                     }
                                 }
                             }
                             catch (err) {
                                 if (signal?.aborted || cancelled || searchAbort.signal.aborted)
-                                    break;
+                                    return;
                                 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 });
+                                searchResults.set(qi, { query, 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 });
+                                    curator.pushError(qi, message, failedProvider, { query, slotIndex: qi });
                                 }
                             }
-                        }
+                            finally {
+                                completedSearches++;
+                                if (!signal?.aborted && !cancelled && !searchAbort.signal.aborted) {
+                                    onUpdate?.({
+                                        content: [{ type: "text", text: `Completed ${completedSearches}/${queryList.length} searches.` }],
+                                        details: { phase: "searching", progress: completedSearches / queryList.length, currentQuery: query },
+                                    });
+                                }
+                            }
+                        });
                         if (signal?.aborted || cancelled || searchAbort.signal.aborted) {
                             cancel();
                             return promise;
@@ -1761,15 +1799,15 @@ export default function (pi) {
                         }
                         return promise;
                     }
-                    const searchResults = [];
+                    let completedSearches = 0;
                     const allUrls = [];
                     const allInlineContent = [];
                     const resolvedProvider = resolveRequestedProvider(params.provider);
-                    for (let i = 0; i < queryList.length; i++) {
-                        const query = queryList[i];
+                    const queryResponses = await runSearchQueries(queryList, async (query) => {
+                        signal?.throwIfAborted();
                         onUpdate?.({
-                            content: [{ type: "text", text: `Searching ${i + 1}/${queryList.length}: "${query}"...` }],
-                            details: { phase: "search", progress: i / queryList.length, currentQuery: query },
+                            content: [{ type: "text", text: `Searching "${query}" (${completedSearches}/${queryList.length} complete)...` }],
+                            details: { phase: "search", progress: completedSearches / queryList.length, currentQuery: query },
                         });
                         try {
                             const { answer, results, inlineContent, provider } = await search(query, {
@@ -1781,22 +1819,36 @@ export default function (pi) {
                                 signal,
                                 extensionContext: ctx,
                             });
-                            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);
+                            return { result: { query, answer, results, error: null, provider }, 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 });
+                            return {
+                                result: { query, answer: "", results: [], error: message, provider: requestedProvider },
+                                inlineContent: undefined,
+                            };
+                        }
+                        finally {
+                            completedSearches++;
+                            if (!signal?.aborted) {
+                                onUpdate?.({
+                                    content: [{ type: "text", text: `Completed ${completedSearches}/${queryList.length} searches.` }],
+                                    details: { phase: "search", progress: completedSearches / queryList.length, currentQuery: query },
+                                });
+                            }
                         }
+                    });
+                    const searchResults = queryResponses.map(response => response.result);
+                    for (const response of queryResponses) {
+                        for (const result of response.result.results) {
+                            if (!allUrls.includes(result.url))
+                                allUrls.push(result.url);
+                        }
+                        if (response.inlineContent)
+                            allInlineContent.push(...response.inlineContent);
                     }
                     let approvedSummary;
                     let summaryMeta;
@@ -2059,7 +2111,7 @@ 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 Parallel MCP, DuckDuckGo, Kimi, AnySearch, XCrawl, Valyu, xAI, Bright Data, SerpBase, and Serper")),
+                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, Mistral, 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.",
                 })),
@@ -2834,6 +2886,7 @@ export default function (pi) {
                 try {
                     const handle = await startCuratorServer({
                         queries,
+                        initialResultIndexCapacity: curatorResultIndexCapacity(queries.length),
                         sessionToken,
                         timeout: curatorTimeoutSeconds,
                         availableProviders,
@@ -2912,19 +2965,21 @@ export default function (pi) {
                             }
                         },
                         async onAddSearch(query, provider) {
-                            if (commandHandle && !isCommandActive()) {
-                                throw new Error("Curator session is no longer active.");
-                            }
-                            const requestedProvider = resolveCuratorSearchProvider(provider, currentSearchProvider);
-                            const response = await search(query, {
-                                provider: requestedProvider,
-                                signal: searchAbort.signal,
-                                extensionContext: ctx,
+                            return runWithProxy(undefined, async () => {
+                                if (commandHandle && !isCommandActive()) {
+                                    throw new Error("Curator session is no longer active.");
+                                }
+                                const requestedProvider = resolveCuratorSearchProvider(provider, currentSearchProvider);
+                                const response = await search(query, {
+                                    provider: requestedProvider,
+                                    signal: searchAbort.signal,
+                                    extensionContext: ctx,
+                                });
+                                if (commandHandle && !isCommandActive()) {
+                                    throw new Error("Curator session is no longer active.");
+                                }
+                                return toCuratorSearchEntries(response);
                             });
-                            if (commandHandle && !isCommandActive()) {
-                                throw new Error("Curator session is no longer active.");
-                            }
-                            return toCuratorSearchEntries(response);
                         },
                         onAddSearchResults(entries) {
                             if (commandHandle && !isCommandActive())
@@ -2986,46 +3041,45 @@ export default function (pi) {
                     }
                     if (queries.length > 0) {
                         (async () => {
-                            let nextResultIndex = queries.length;
-                            for (let qi = 0; qi < queries.length; qi++) {
+                            await runSearchQueries(queries, async (query, qi) => {
                                 if (aborted || !isCommandActive())
-                                    break;
+                                    return;
                                 const requestedProvider = currentSearchProvider;
                                 try {
-                                    const response = await search(queries[qi], {
+                                    const response = await runWithProxy(undefined, () => search(query, {
                                         provider: requestedProvider,
                                         signal: searchAbort.signal,
                                         extensionContext: ctx,
-                                    });
+                                    }));
                                     if (aborted || !isCommandActive())
-                                        break;
+                                        return;
                                     const entries = toCuratorSearchEntries(response);
                                     for (let entryIndex = 0; entryIndex < entries.length; entryIndex++) {
                                         const entry = entries[entryIndex];
-                                        const resultIndex = entryIndex === 0 ? qi : nextResultIndex++;
+                                        const resultIndex = curatorResultIndex(qi, entryIndex, queries.length);
                                         const indexedEntry = {
                                             ...entry,
                                             queryIndex: resultIndex,
-                                            query: queries[qi],
+                                            query,
                                         };
                                         collected.set(resultIndex, indexedCuratorEntryToQueryResult(indexedEntry));
                                         if (entry.error) {
-                                            handle.pushError(resultIndex, entry.error, entry.provider, { query: queries[qi], slotIndex: qi });
+                                            handle.pushError(resultIndex, entry.error, entry.provider, { query, slotIndex: qi });
                                         }
                                         else {
-                                            handle.pushResult(resultIndex, { ...entry, query: queries[qi], slotIndex: qi });
+                                            handle.pushResult(resultIndex, { ...entry, query, slotIndex: qi });
                                         }
                                     }
                                 }
                                 catch (err) {
                                     if (aborted || !isCommandActive())
-                                        break;
+                                        return;
                                     const message = err instanceof Error ? err.message : String(err);
                                     const failedProvider = toCuratorProvider(requestedProvider);
-                                    handle.pushError(qi, message, failedProvider, { query: queries[qi], slotIndex: qi });
-                                    collected.set(qi, { query: queries[qi], answer: "", results: [], error: message, provider: failedProvider });
+                                    handle.pushError(qi, message, failedProvider, { query, slotIndex: qi });
+                                    collected.set(qi, { query, answer: "", results: [], error: message, provider: failedProvider });
                                 }
-                            }
+                            });
                             if (!aborted && isCommandActive())
                                 handle.searchesDone();
                         })();