@qwen-code/qwen-code 0.23.2-preview.0 → 0.23.2

package/chunks/{web-search-HFUQF44Q.js → web-search-CRNXKZ2X.js}

@@ -1,5 +1,9 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  ALL_PROVIDERS,
+  findProviderByCredentials
+} from "./chunk-2WC3Y7YY.js";
 import {
   buildModelIdContext,
   resolveModelId
@@ -7,21 +11,23 @@ import {
 import {
   DASHSCOPE_REGIONAL_HOSTS,
   OpenAI
-} from "./chunk-VF6D6EGV.js";
+} from "./chunk-S5QR6CB5.js";
 import {
   delay
 } from "./chunk-HNLMYDQE.js";
 import {
   DEFAULT_DASHSCOPE_BASE_URL,
   resolveRequestTimeout
-} from "./chunk-6YEOCHSE.js";
+} from "./chunk-VBLAI2HA.js";
 import "./chunk-4ALNJDHL.js";
 import {
   buildSessionAwareFetch
 } from "./chunk-NOO4QFXM.js";
 import "./chunk-XBVNNDPK.js";
 import "./chunk-FPGTNKCP.js";
-import "./chunk-DTB5BXRG.js";
+import {
+  getDefaultApiKeyEnvVar
+} from "./chunk-JO77FGNZ.js";
 import {
   buildRuntimeFetchOptions,
   preloadRuntimeFetchModule
@@ -53,6 +59,7 @@ var MAX_CANDIDATE_URLS = 25;
 var MAX_OPENED_URLS = 25;
 var NO_SEARCH_RETRY_BASE_DELAY_MS = 750;
 var NO_SEARCH_RETRY_JITTER_MS = 500;
+var DEFAULT_WEB_SEARCH_MODEL = "qwen3.8-flash";
 function classifyDashScopeBaseUrl(baseUrl) {
   let url;
   try {
@@ -79,13 +86,183 @@ function isDashScopeCompatibleBaseUrl(baseUrl) {
   return classifyDashScopeBaseUrl(baseUrl) === null;
 }
 __name(isDashScopeCompatibleBaseUrl, "isDashScopeCompatibleBaseUrl");
+function safeUrlHost(baseUrl) {
+  try {
+    return new URL(baseUrl).hostname || "[invalid]";
+  } catch {
+    return "[invalid]";
+  }
+}
+__name(safeUrlHost, "safeUrlHost");
+function normalizedBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+__name(normalizedBaseUrl, "normalizedBaseUrl");
+function findProviderByEndpoint(baseUrl) {
+  const normalized = normalizedBaseUrl(baseUrl);
+  return ALL_PROVIDERS.find((provider) => {
+    const configured = provider.baseUrl;
+    if (typeof configured === "string") {
+      return normalizedBaseUrl(configured) === normalized;
+    }
+    return configured?.some(
+      (option) => normalizedBaseUrl(option.url) === normalized
+    );
+  });
+}
+__name(findProviderByEndpoint, "findProviderByEndpoint");
+var gateDebugLogger = createDebugLogger("WEB_SEARCH");
+function isUsableSearchEntry(entry) {
+  return entry.authType !== "qwen-oauth" /* QWEN_OAUTH */ && !!entry.baseUrl && isDashScopeCompatibleBaseUrl(entry.baseUrl) && (!!entry.apiKey?.trim() || !!entry.envKey && !!process.env[entry.envKey]?.trim());
+}
+__name(isUsableSearchEntry, "isUsableSearchEntry");
+function isAutoEligibleDashScopeHost(baseUrl) {
+  if (classifyDashScopeBaseUrl(baseUrl) !== null) {
+    return false;
+  }
+  let hostname;
+  try {
+    hostname = new URL(baseUrl).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  return !hostname.startsWith("coding.") && !hostname.startsWith("coding-intl.");
+}
+__name(isAutoEligibleDashScopeHost, "isAutoEligibleDashScopeHost");
+function findPrimaryModelEntry(config) {
+  const modelId = config.getModel();
+  const authType = config.getCurrentAuthType();
+  const registryBaseUrl = config.getCurrentModelRegistryBaseUrl();
+  const matches = authType ? config.getAllConfiguredModels([authType]).filter((m) => m.id === modelId) : [];
+  const selected = registryBaseUrl ? matches.find(
+    (m) => m.registryBaseUrl === registryBaseUrl || m.baseUrl === registryBaseUrl
+  ) : void 0;
+  const entry = selected ? isUsableSearchEntry(selected) ? selected : void 0 : matches.find(isUsableSearchEntry);
+  if (entry?.baseUrl && entry.envKey) {
+    return {
+      authType: entry.authType,
+      modelId: entry.id,
+      baseUrl: entry.baseUrl,
+      envKey: entry.envKey,
+      registryBaseUrl: entry.registryBaseUrl
+    };
+  }
+  const modelsConfig = config.getModelsConfig();
+  const generation = modelsConfig.getGenerationConfig();
+  if (generation.baseUrl && generation.authType) {
+    const apiKeySource = modelsConfig.getGenerationConfigSources()["apiKey"];
+    const sourceEnvKey = apiKeySource?.kind === "env" ? apiKeySource.envKey : void 0;
+    const declaredEnvKey = generation.apiKeyEnvKey;
+    const envKey = sourceEnvKey ?? (!apiKeySource && declaredEnvKey && process.env[declaredEnvKey]?.trim() ? declaredEnvKey : void 0);
+    const apiKey = envKey ? void 0 : generation.apiKey;
+    const fallbackEnvKey = getDefaultApiKeyEnvVar(generation.authType);
+    if (apiKey?.trim() || envKey && process.env[envKey]?.trim() || !envKey && !apiKey && process.env[fallbackEnvKey]?.trim()) {
+      return {
+        authType: generation.authType,
+        modelId: generation.model ?? modelId,
+        baseUrl: generation.baseUrl,
+        envKey: envKey ?? (apiKey ? void 0 : fallbackEnvKey),
+        apiKey,
+        customHeaders: generation.customHeaders
+      };
+    }
+  }
+  return void 0;
+}
+__name(findPrimaryModelEntry, "findPrimaryModelEntry");
+function resolveAutoBackend(config, settings) {
+  const unavailable = /* @__PURE__ */ __name((reason) => {
+    gateDebugLogger.debug(`[WebSearch] auto backend unavailable: ${reason}`);
+    return {
+      ok: false,
+      silent: true,
+      notice: `WebSearch is not configured and no backend could be derived automatically: ${reason}.`
+    };
+  }, "unavailable");
+  const entry = findPrimaryModelEntry(config);
+  if (!entry) {
+    return unavailable(
+      "the selected model has no provider entry carrying both a baseUrl and a usable direct credential"
+    );
+  }
+  if (entry.authType !== "openai" /* USE_OPENAI */) {
+    return unavailable(
+      `the selected model uses the ${entry.authType} protocol, but the search side request requires an OpenAI-compatible provider`
+    );
+  }
+  const credentialMatchedPreset = findProviderByCredentials(
+    entry.baseUrl,
+    entry.envKey
+  );
+  const preset = credentialMatchedPreset?.baseUrl !== void 0 ? credentialMatchedPreset : findProviderByEndpoint(entry.baseUrl);
+  const presetKnowsEndpoint = preset?.baseUrl !== void 0;
+  if (presetKnowsEndpoint) {
+    if (preset?.webSearch?.backend !== "dashscope") {
+      return unavailable(
+        `provider "${preset?.id}" declares no built-in web search backend`
+      );
+    }
+  } else if (!isAutoEligibleDashScopeHost(entry.baseUrl)) {
+    return unavailable(
+      `endpoint host ${safeUrlHost(entry.baseUrl)} is not known to serve the DashScope search tools`
+    );
+  }
+  if (!isUsableSearchEntry(entry)) {
+    return unavailable(
+      "the selected model has no usable direct credential, or the entry cannot back a side request"
+    );
+  }
+  const resolvedEntry = config.getResolvedModelConfig(
+    entry.authType,
+    entry.modelId,
+    entry.registryBaseUrl
+  );
+  return {
+    ok: true,
+    backend: {
+      modelId: DEFAULT_WEB_SEARCH_MODEL,
+      apiKeyEnvKey: entry.envKey,
+      apiKey: entry.apiKey,
+      baseUrl: entry.baseUrl,
+      webExtractor: settings?.webExtractor !== false,
+      customHeaders: entry.customHeaders ?? resolvedEntry?.generationConfig?.customHeaders
+    }
+  };
+}
+__name(resolveAutoBackend, "resolveAutoBackend");
 function evaluateWebSearchGate(config) {
   const settings = config.getWebSearchSettings();
+  if (settings?.enabled === false) {
+    return {
+      ok: false,
+      silent: true,
+      notice: "WebSearch is disabled by configuration."
+    };
+  }
   const selector = settings?.model?.trim();
   if (!selector) {
+    if (!settings?.baseUrl) {
+      try {
+        const derived = resolveAutoBackend(config, settings);
+        if (derived.ok || settings?.enabled !== true) {
+          return derived;
+        }
+      } catch (e) {
+        gateDebugLogger.debug(
+          `[WebSearch] auto backend derivation threw: ${e instanceof Error ? e.message : String(e)}`
+        );
+        if (settings?.enabled !== true) {
+          return {
+            ok: false,
+            silent: true,
+            notice: "WebSearch is not configured and no backend could be derived automatically."
+          };
+        }
+      }
+    }
     return {
       ok: false,
-      notice: 'WebSearch is enabled but no search model is configured.\nAdd a search model to settings.json (recommended: qwen3.6-plus):\n  {\n    "tools": { "webSearch": { "enabled": true, "model": "qwen3.6-plus" } },\n    "modelProviders": {\n      "openai": [{ "id": "qwen3.6-plus",\n        "baseUrl": "' + DEFAULT_DASHSCOPE_BASE_URL + '",\n        "envKey": "DASHSCOPE_API_KEY" }]\n    }\n  }\nOr via env: ENABLE_WEB_SEARCH=true WEB_SEARCH_MODEL=qwen3.6-plus\nWEB_SEARCH_BASE_URL=' + DEFAULT_DASHSCOPE_BASE_URL + " (plus WEB_SEARCH_API_KEY)."
+      notice: 'WebSearch is enabled but no search model is configured.\nAdd a search model to settings.json (recommended: qwen3.8-flash):\n  {\n    "tools": { "webSearch": { "enabled": true, "model": "qwen3.8-flash" } },\n    "modelProviders": {\n      "openai": [{ "id": "qwen3.8-flash",\n        "baseUrl": "' + DEFAULT_DASHSCOPE_BASE_URL + '",\n        "envKey": "DASHSCOPE_API_KEY" }]\n    }\n  }\nOr via env: ENABLE_WEB_SEARCH=true WEB_SEARCH_MODEL=qwen3.8-flash\nWEB_SEARCH_BASE_URL=' + DEFAULT_DASHSCOPE_BASE_URL + " (plus WEB_SEARCH_API_KEY)."
     };
   }
   let resolved;
@@ -150,8 +327,7 @@ function evaluateWebSearchGate(config) {
       notice: `WebSearch is enabled but the search model "${selector}" does not match any model declared under modelProviders.`
     };
   }
-  const isUsableEntry = /* @__PURE__ */ __name((m) => m.authType !== "qwen-oauth" /* QWEN_OAUTH */ && !!m.baseUrl && isDashScopeCompatibleBaseUrl(m.baseUrl) && !!m.envKey && !!process.env[m.envKey]?.trim(), "isUsableEntry");
-  const entry = matches.find(isUsableEntry) ?? matches[0];
+  const entry = matches.find(isUsableSearchEntry) ?? matches[0];
   if (entry.authType === "qwen-oauth" /* QWEN_OAUTH */) {
     return {
       ok: false,
@@ -368,7 +544,7 @@ var WebSearchToolInvocation = class extends BaseToolInvocation {
     const backend = gate.backend;
     await preloadRuntimeFetchModule();
     const startedAt = Date.now();
-    const apiKey = process.env[backend.apiKeyEnvKey];
+    const apiKey = backend.apiKey ?? (backend.apiKeyEnvKey ? process.env[backend.apiKeyEnvKey] : void 0);
     const runtimeOptions = buildRuntimeFetchOptions(
       "openai",
       this.config.getProxy()
@@ -721,6 +897,7 @@ var WebSearchTool = class _WebSearchTool extends BaseDeclarativeTool {
   }
 };
 export {
+  DEFAULT_WEB_SEARCH_MODEL,
   WebSearchTool,
   evaluateWebSearchGate
 };

package/chunks/{web-shell-static-POZHGGXE.js → web-shell-static-BFDESDD4.js}

@@ -4,14 +4,15 @@ import {
   WEB_SHELL_CSP,
   buildWebShellCsp,
   buildWebShellPermissionsPolicy,
-  isDocumentNavigation,
-  isPreAuthWebShellRequest,
   loopbackSandboxOrigins,
   mountWebShellAssets,
   mountWebShellSpaFallback,
   portFromHostHeader
-} from "./chunk-NFIDVZND.js";
-import "./chunk-IRKQ4YYX.js";
+} from "./chunk-QB3KS3N3.js";
+import {
+  isDocumentNavigation,
+  isPreAuthWebShellRequest
+} from "./chunk-SVWWF5TZ.js";
 import {
   resolveWebShellDir
 } from "./chunk-FBX2SDQ4.js";