@duckmind/dm-linux-x64 0.65.4 → 0.65.6

package/extensions/dm-web-access/gemini-search.js

@@ -10,6 +10,7 @@ import { isBraveAvailable, searchWithBrave } from "./brave.js";
 import {
   isCurrentModelHostedSearchEligible,
   isOpenAISearchAvailable,
+  OpenAIAlphaSearchUnsupportedError,
   searchWithCurrentModelOpenAI,
   searchWithOpenAI
 } from "./openai-search.js";
@@ -33,11 +34,15 @@ import { isXcrawlAvailable, searchWithXCrawl } from "./xcrawl.js";
 import { isXaiSearchAvailable, searchWithXai } from "./xai-search.js";
 import { isBrightDataAvailable, searchWithBrightData } from "./brightdata.js";
 import { isSerpBaseAvailable, searchWithSerpBase } from "./serpbase.js";
+import { isSerpApiAvailable, searchWithSerpApi } from "./serpapi.js";
 import { isSerperAvailable, searchWithSerper } from "./serper.js";
+import { isSerplyAvailable, searchWithSerply } from "./serply.js";
+import { isBaizhiAvailable, searchWithBaizhi } from "./baizhi.js";
 import { isValyuAvailable, searchWithValyu } from "./valyu.js";
 import { isKimiSearchAvailable, searchWithKimi } from "./kimi-search.js";
+import { isMistralAvailable, searchWithMistral } from "./mistral-search.js";
 import { getWebSearchConfigPath } from "./utils.js";
-export const RESOLVED_SEARCH_PROVIDERS = ["openai", "brave", "parallel", "parallel-mcp", "tinyfish", "search1api", "searchinfinity", "querit", "tavily", "firecrawl", "jina", "searxng", "duckduckgo", "perplexity", "gemini", "kimi", "exa", "serpdive", "kagi", "ollama", "anysearch", "xai", "brightdata", "serpbase", "serper", "valyu", "bocha", "xcrawl"];
+export const RESOLVED_SEARCH_PROVIDERS = ["openai", "brave", "parallel", "parallel-mcp", "tinyfish", "search1api", "searchinfinity", "querit", "tavily", "firecrawl", "jina", "searxng", "duckduckgo", "perplexity", "gemini", "kimi", "exa", "serpdive", "kagi", "ollama", "anysearch", "xai", "mistral", "brightdata", "serpbase", "serpapi", "serper", "serply", "valyu", "bocha", "xcrawl", "baizhi"];
 export const SEARCH_PROVIDERS = ["auto", "all", ...RESOLVED_SEARCH_PROVIDERS];
 
 export class SearchProviderError extends Error {
@@ -79,12 +84,30 @@ function getSearchConfig() {
     throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
   }
   const searchModel = normalizeSearchModel(raw.searchModel);
+  const webSearch = raw.webSearch;
+  if (webSearch !== undefined && (!webSearch || typeof webSearch !== "object" || Array.isArray(webSearch))) {
+    throw new Error(`webSearch in ${CONFIG_PATH} must be an object`);
+  }
+  const allowedProviders = webSearch && Object.hasOwn(webSearch, "allowedProviders") ? normalizeResolvedProviderList(webSearch.allowedProviders, `webSearch.allowedProviders in ${CONFIG_PATH}`) : undefined;
   const searchProviderConfigured = Object.hasOwn(raw, "searchProvider") || Object.hasOwn(raw, "provider");
+  const searchProvider = normalizeSearchProviderSelection(raw.searchProvider ?? raw.provider, `provider in ${CONFIG_PATH}`);
+  const searchRouting = Object.hasOwn(raw, "searchRouting") ? normalizeSearchRouting(raw.searchRouting) : undefined;
+  if (allowedProviders) {
+    if (Object.hasOwn(raw, "searchProvider")) {
+      assertSearchProviderSelectionAllowed(normalizeSearchProviderSelection(raw.searchProvider), `searchProvider in ${CONFIG_PATH}`, allowedProviders);
+    }
+    if (Object.hasOwn(raw, "provider")) {
+      assertSearchProviderSelectionAllowed(normalizeSearchProviderSelection(raw.provider), `provider in ${CONFIG_PATH}`, allowedProviders);
+    }
+    if (searchRouting)
+      assertSearchProviderSelectionAllowed(searchRouting.providers, `searchRouting.providers in ${CONFIG_PATH}`, allowedProviders);
+  }
   cachedSearchConfig = {
-    searchProvider: normalizeSearchProviderSelection(raw.searchProvider ?? raw.provider, `provider in ${CONFIG_PATH}`),
+    searchProvider,
     searchProviderConfigured,
-    ...Object.hasOwn(raw, "searchRouting") ? { searchRouting: normalizeSearchRouting(raw.searchRouting) } : {},
-    ...searchModel ? { searchModel } : {}
+    ...searchRouting ? { searchRouting } : {},
+    ...searchModel ? { searchModel } : {},
+    ...allowedProviders ? { allowedProviders } : {}
   };
   return cachedSearchConfig;
 }
@@ -143,6 +166,18 @@ function normalizeResolvedProviderList(value, label) {
   }
   return providers;
 }
+export function assertSearchProviderSelectionAllowed(selection, label = "provider", allowedProviders = getSearchConfig().allowedProviders) {
+  if (!allowedProviders)
+    return;
+  const requested = Array.isArray(selection) ? selection : selection === "auto" || selection === "all" ? [] : [selection];
+  const disabled = requested.filter((provider) => !allowedProviders.includes(provider));
+  if (disabled.length > 0) {
+    throw new Error(`${label} ${disabled.length === 1 ? `references disabled provider "${disabled[0]}"` : `references disabled providers: ${disabled.join(", ")}`}; allowed by webSearch.allowedProviders: ${allowedProviders.join(", ")}`);
+  }
+}
+export function getAllowedSearchProviders() {
+  return getSearchConfig().allowedProviders ?? RESOLVED_SEARCH_PROVIDERS;
+}
 export function normalizeSearchProviderSelection(value, label = "provider") {
   if (Array.isArray(value))
     return normalizeResolvedProviderList(value, label);
@@ -155,20 +190,10 @@ function errorMessage(err) {
 function isAbortError(err) {
   return errorMessage(err).toLowerCase().includes("abort");
 }
-function shouldTryOpenAIInAuto(options) {
-  if (options.recencyFilter)
-    return false;
-  if (typeof options.numResults === "number" && Number.isFinite(options.numResults) && Math.floor(options.numResults) !== 5) {
-    return false;
-  }
-  return true;
-}
 function isOpenAICodexSelected(ctx) {
   return ctx?.model?.provider === "openai-codex";
 }
 async function tryOpenAIInAuto(query, options, fallbackErrors) {
-  if (!shouldTryOpenAIInAuto(options))
-    return null;
   try {
     if (await isOpenAISearchAvailable(options.extensionContext)) {
       const result = await searchWithOpenAI(query, options, options.extensionContext);
@@ -229,6 +254,8 @@ function classifyProviderError(provider, err) {
     kind = "credential";
   } else if (isAbortError(err)) {
     kind = "aborted";
+  } else if (err instanceof OpenAIAlphaSearchUnsupportedError) {
+    kind = "unsupported";
   } else if (provider === "xai" && status === 403 && /spending[- ]limit|(?:no|out of) credits?|insufficient quota|quota (?:exceeded|exhausted)|credits? (?:exhausted|depleted|used up)/.test(lower)) {
     kind = "quota";
   } else if (status === 401 || status === 403) {
@@ -237,7 +264,7 @@ function classifyProviderError(provider, err) {
     kind = "unsupported";
   } else if (status === 400 || status === 422) {
     kind = "invalid-request";
-  } else if (status === 402 || status === 429) {
+  } else if (status === 402 || status === 429 || provider === "tavily" && status === 432) {
     kind = "quota";
   } else if (status !== undefined && (status === 408 || status === 425 || status >= 500)) {
     kind = "transient";
@@ -295,12 +322,20 @@ async function searchWithResolvedProvider(provider, query, options, useCurrentMo
     return { ...await searchWithAnySearch(query, options), provider };
   if (provider === "xai")
     return { ...await searchWithXai(query, options, options.extensionContext), provider };
+  if (provider === "mistral")
+    return { ...await searchWithMistral(query, options), provider };
   if (provider === "brightdata")
     return { ...await searchWithBrightData(query, options), provider };
   if (provider === "serpbase")
     return { ...await searchWithSerpBase(query, options), provider };
+  if (provider === "serpapi")
+    return { ...await searchWithSerpApi(query, options), provider };
   if (provider === "serper")
     return { ...await searchWithSerper(query, options), provider };
+  if (provider === "serply")
+    return { ...await searchWithSerply(query, options), provider };
+  if (provider === "baizhi")
+    return { ...await searchWithBaizhi(query, options), provider };
   if (provider === "valyu")
     return { ...await searchWithValyu(query, options), provider };
   if (provider === "xcrawl")
@@ -364,12 +399,20 @@ async function isResolvedProviderAvailable(provider, options, useCurrentModel =
     return isAnySearchAvailable();
   if (provider === "xai")
     return isXaiSearchAvailable(options.extensionContext);
+  if (provider === "mistral")
+    return isMistralAvailable();
   if (provider === "brightdata")
     return isBrightDataAvailable();
   if (provider === "serpbase")
     return isSerpBaseAvailable();
+  if (provider === "serpapi")
+    return isSerpApiAvailable();
   if (provider === "serper")
     return isSerperAvailable();
+  if (provider === "serply")
+    return isSerplyAvailable();
+  if (provider === "baizhi")
+    return isBaizhiAvailable();
   if (provider === "valyu")
     return isValyuAvailable();
   if (provider === "xcrawl")
@@ -393,7 +436,7 @@ async function isGeminiWebOptionallyAvailable() {
     return false;
   }
 }
-function providerLabel(provider) {
+export function providerLabel(provider) {
   if (provider === "openai")
     return "OpenAI";
   if (provider === "parallel-mcp")
@@ -426,12 +469,20 @@ function providerLabel(provider) {
     return "Ollama";
   if (provider === "xai")
     return "xAI";
+  if (provider === "mistral")
+    return "Mistral";
   if (provider === "brightdata")
     return "Bright Data";
   if (provider === "serpbase")
     return "SerpBase";
+  if (provider === "serpapi")
+    return "SerpApi";
   if (provider === "serper")
     return "Serper";
+  if (provider === "serply")
+    return "Serply";
+  if (provider === "baizhi")
+    return "Baizhi";
   if (provider === "valyu")
     return "Valyu";
   return provider.charAt(0).toUpperCase() + provider.slice(1);
@@ -445,12 +496,13 @@ async function searchWithAllProvider(provider, query, options) {
   throw new Error("Gemini API search returned no results.");
 }
 async function searchWithProviders(query, options, selectedProviders) {
-  const providers = selectedProviders ?? (await Promise.all(ALL_SEARCH_PROVIDERS.map(async (provider) => ({
+  const allowed = getAllowedSearchProviders();
+  const providers = selectedProviders ?? (await Promise.all(ALL_SEARCH_PROVIDERS.filter((provider) => allowed.includes(provider)).map(async (provider) => ({
     provider,
     available: provider === "gemini" ? isGeminiApiAvailable() : await isResolvedProviderAvailable(provider, options)
   })))).filter((entry) => entry.available).map((entry) => entry.provider);
   if (providers.length === 0) {
-    throw new Error('No configured search provider available for provider "all". Parallel MCP, DuckDuckGo, Kimi, AnySearch, xAI, Bright Data, SerpBase, Serper, Valyu, and XCrawl are excluded.');
+    throw new Error('No configured search provider available for provider "all". Parallel MCP, DuckDuckGo, Kimi, AnySearch, xAI, Mistral, Bright Data, SerpBase, SerpApi, Serper, Serply, Valyu, and XCrawl are excluded.');
   }
   const settled = await Promise.allSettled(providers.map((provider) => selectedProviders ? searchWithResolvedProvider(provider, query, options) : searchWithAllProvider(provider, query, options)));
   if (options.signal?.aborted)
@@ -534,6 +586,7 @@ async function searchWithConfiguredRouting(query, options, routing) {
 export async function search(query, options = {}) {
   const config = getSearchConfig();
   const provider = options.provider === undefined || options.provider === "auto" ? config.searchProvider : options.provider;
+  assertSearchProviderSelectionAllowed(provider, "Requested provider");
   if (Array.isArray(provider)) {
     return searchWithProviders(query, options, normalizeResolvedProviderList(provider, "provider"));
   }
@@ -545,7 +598,8 @@ export async function search(query, options = {}) {
     return searchWithConfiguredRouting(query, options, config.searchRouting);
   }
   const fallbackErrors = [];
-  if (isSearXNGAvailable()) {
+  const allowed = new Set(config.allowedProviders ?? RESOLVED_SEARCH_PROVIDERS);
+  if (allowed.has("searxng") && isSearXNGAvailable()) {
     try {
       const result = await searchWithSearXNG(query, options);
       return { ...result, provider: "searxng" };
@@ -556,13 +610,13 @@ export async function search(query, options = {}) {
     }
   }
   let triedOpenAI = false;
-  if (!options.extensionContext || isOpenAICodexSelected(options.extensionContext)) {
+  if (allowed.has("openai") && (!options.extensionContext || isOpenAICodexSelected(options.extensionContext))) {
     triedOpenAI = true;
     const result = await tryOpenAIInAuto(query, options, fallbackErrors);
     if (result)
       return result;
   }
-  if (isExaAvailable()) {
+  if (allowed.has("exa") && isExaAvailable()) {
     try {
       const result = await searchWithExa(query, options);
       if (result)
@@ -573,12 +627,12 @@ export async function search(query, options = {}) {
       fallbackErrors.push(`Exa: ${errorMessage(err)}`);
     }
   }
-  if (!triedOpenAI) {
+  if (allowed.has("openai") && !triedOpenAI) {
     const result = await tryOpenAIInAuto(query, options, fallbackErrors);
     if (result)
       return result;
   }
-  if (isBraveAvailable()) {
+  if (allowed.has("brave") && isBraveAvailable()) {
     try {
       const result = await searchWithBrave(query, options);
       return { ...result, provider: "brave" };
@@ -588,7 +642,7 @@ export async function search(query, options = {}) {
       fallbackErrors.push(`Brave: ${errorMessage(err)}`);
     }
   }
-  if (isParallelAvailable()) {
+  if (allowed.has("parallel") && isParallelAvailable()) {
     try {
       const result = await searchWithParallel(query, options);
       return { ...result, provider: "parallel" };
@@ -598,7 +652,7 @@ export async function search(query, options = {}) {
       fallbackErrors.push(`Parallel: ${errorMessage(err)}`);
     }
   }
-  if (isTinyFishAvailable()) {
+  if (allowed.has("tinyfish") && isTinyFishAvailable()) {
     try {
       const result = await searchWithTinyFish(query, options);
       return { ...result, provider: "tinyfish" };
@@ -608,7 +662,7 @@ export async function search(query, options = {}) {
       fallbackErrors.push(`TinyFish: ${errorMessage(err)}`);
     }
   }
-  if (isSearch1APIAvailable()) {
+  if (allowed.has("search1api") && isSearch1APIAvailable()) {
     try {
       const result = await searchWithSearch1API(query, options);
       return { ...result, provider: "search1api" };
@@ -618,7 +672,7 @@ export async function search(query, options = {}) {
       fallbackErrors.push(`Search1API: ${errorMessage(err)}`);
     }
   }
-  if (isSearchinfinityAvailable()) {
+  if (allowed.has("searchinfinity") && isSearchinfinityAvailable()) {
     try {
       const result = await searchWithSearchinfinity(query, options);
       return { ...result, provider: "searchinfinity" };
@@ -628,7 +682,7 @@ export async function search(query, options = {}) {
       fallbackErrors.push(`Searchinfinity: ${errorMessage(err)}`);
     }
   }
-  if (isQueritAvailable()) {
+  if (allowed.has("querit") && isQueritAvailable()) {
     try {
       const result = await searchWithQuerit(query, options);
       return { ...result, provider: "querit" };
@@ -638,7 +692,7 @@ export async function search(query, options = {}) {
       fallbackErrors.push(`Querit: ${errorMessage(err)}`);
     }
   }
-  if (isTavilyAvailable()) {
+  if (allowed.has("tavily") && isTavilyAvailable()) {
     try {
       const result = await searchWithTavily(query, options);
       return { ...result, provider: "tavily" };
@@ -648,7 +702,7 @@ export async function search(query, options = {}) {
       fallbackErrors.push(`Tavily: ${errorMessage(err)}`);
     }
   }
-  if (isFirecrawlAvailable()) {
+  if (allowed.has("firecrawl") && isFirecrawlAvailable()) {
     try {
       const result = await searchWithFirecrawl(query, options);
       return { ...result, provider: "firecrawl" };
@@ -658,7 +712,7 @@ export async function search(query, options = {}) {
       fallbackErrors.push(`Firecrawl: ${errorMessage(err)}`);
     }
   }
-  if (isJinaSearchAvailable()) {
+  if (allowed.has("jina") && isJinaSearchAvailable()) {
     try {
       const result = await searchWithJina(query, options);
       return { ...result, provider: "jina" };
@@ -668,7 +722,7 @@ export async function search(query, options = {}) {
       fallbackErrors.push(`Jina: ${errorMessage(err)}`);
     }
   }
-  if (isSerpdiveAvailable()) {
+  if (allowed.has("serpdive") && isSerpdiveAvailable()) {
     try {
       const result = await searchWithSerpdive(query, options);
       return { ...result, provider: "serpdive" };
@@ -678,7 +732,7 @@ export async function search(query, options = {}) {
       fallbackErrors.push(`SERPdive: ${errorMessage(err)}`);
     }
   }
-  if (isKagiAvailable()) {
+  if (allowed.has("kagi") && isKagiAvailable()) {
     try {
       const result = await searchWithKagi(query, options);
       return { ...result, provider: "kagi" };
@@ -688,7 +742,7 @@ export async function search(query, options = {}) {
       fallbackErrors.push(`Kagi: ${errorMessage(err)}`);
     }
   }
-  if (isBochaAvailable()) {
+  if (allowed.has("bocha") && isBochaAvailable()) {
     try {
       const result = await searchWithBocha(query, options);
       return { ...result, provider: "bocha" };
@@ -698,7 +752,7 @@ export async function search(query, options = {}) {
       fallbackErrors.push(`Bocha: ${errorMessage(err)}`);
     }
   }
-  if (isOllamaAvailable()) {
+  if (allowed.has("ollama") && isOllamaAvailable()) {
     try {
       const result = await searchWithOllama(query, options);
       return { ...result, provider: "ollama" };
@@ -708,7 +762,7 @@ export async function search(query, options = {}) {
       fallbackErrors.push(`Ollama: ${errorMessage(err)}`);
     }
   }
-  if (isPerplexityAvailable()) {
+  if (allowed.has("perplexity") && isPerplexityAvailable()) {
     try {
       const result = await searchWithPerplexity(query, options);
       return { ...result, provider: "perplexity" };
@@ -718,15 +772,16 @@ export async function search(query, options = {}) {
       fallbackErrors.push(`Perplexity: ${errorMessage(err)}`);
     }
   }
-  try {
-    const geminiResult = await searchWithGemini(query, options, false);
-    if (geminiResult)
-      return { ...geminiResult, provider: "gemini" };
-  } catch (err) {
-    if (isAbortError(err))
-      throw err;
-    fallbackErrors.push(`Gemini: ${errorMessage(err)}`);
-  }
+  if (allowed.has("gemini"))
+    try {
+      const geminiResult = await searchWithGemini(query, options, false);
+      if (geminiResult)
+        return { ...geminiResult, provider: "gemini" };
+    } catch (err) {
+      if (isAbortError(err))
+        throw err;
+      fallbackErrors.push(`Gemini: ${errorMessage(err)}`);
+    }
   if (fallbackErrors.length > 0) {
     throw new Error(`Auto provider search failed:
   - ${fallbackErrors.join(`
@@ -738,7 +793,7 @@ export async function search(query, options = {}) {
 ` + `  3. Set OPENAI_API_KEY, BRAVE_API_KEY, PARALLEL_API_KEY, TINYFISH_API_KEY, SEARCH1API_KEY, SEARCHINFINITY_API_KEY, QUERIT_API_KEY, TAVILY_API_KEY, FIRECRAWL_BASE_URL, JINA_API_KEY, SERPDIVE_API_KEY, KAGI_API_KEY, BOCHA_API_KEY, OLLAMA_API_KEY, SEARXNG_BASE_URL, EXA_API_KEY, PERPLEXITY_API_KEY, GEMINI_API_KEY, or CLOUDFLARE_API_KEY env vars
 ` + `  4. Set GOOGLE_GEMINI_BASE_URL with CLOUDFLARE_API_KEY for Cloudflare AI Gateway routing
 ` + `  5. Sign into gemini.google.com in a supported Chromium-based browser
-` + '  6. Explicitly select provider: "anysearch" for anonymous AnySearch, "xcrawl" for XCrawl, "xai" for Grok, "brightdata" with brightdataSerpZone for paid Bright Data SERP, "serpbase" or "serper" for Google SERP, or "valyu" for research search');
+` + '  6. Explicitly select provider: "anysearch" for anonymous AnySearch, "xcrawl" for XCrawl, "xai" for Grok, "mistral" for Mistral Conversations web search, "brightdata" with brightdataSerpZone for paid Bright Data SERP, "serpbase", "serpapi", "serper", or "serply" for Google SERP, or "valyu" for research search');
 }
 async function searchWithGeminiApi(query, options = {}) {
   const requestSignal = AbortSignal.any([

package/extensions/dm-web-access/github-extract.js

@@ -404,13 +404,8 @@ async function removeCloneRuntimeAsync(parentPath, runtimePath) {
 async function sweepStaleCloneRuntimes(parentPath) {
   const normalizedParentPath = resolvePath(parentPath);
   const bootId = process.platform === "linux" ? await readLinuxBootIdAsync() : null;
-  let directory;
-  try {
-    directory = await opendirAsync(normalizedParentPath);
-  } catch {
-    return;
-  }
   try {
+    const directory = await opendirAsync(normalizedParentPath);
     for await (const entry of directory) {
       if (!entry.name.startsWith("runtime-"))
         continue;
@@ -432,11 +427,7 @@ async function sweepStaleCloneRuntimes(parentPath) {
         await removeCloneRuntimeAsync(normalizedParentPath, runtimePath);
       } catch {}
     }
-  } catch {} finally {
-    try {
-      await directory.close();
-    } catch {}
-  }
+  } catch {}
 }
 function startStaleCloneRuntimeCleanup(parentPath) {
   const normalizedParentPath = resolvePath(parentPath);