@qwen-code/qwen-code 0.19.6 → 0.19.7

package/chunks/chunk-SD4N3QJ2.js

@@ -0,0 +1,262 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  appEvents
+} from "./chunk-I4A4K72C.js";
+import {
+  require_undici
+} from "./chunk-54YZOP7P.js";
+import {
+  getAllProviderBaseUrls
+} from "./chunk-YEGT55NW.js";
+import {
+  initializeTelemetry
+} from "./chunk-GMOWQOQQ.js";
+import {
+  detectRuntime,
+  getOrCreateSharedDispatcher,
+  redactProxyCredentials
+} from "./chunk-H6EMK6QK.js";
+import {
+  createDebugLogger
+} from "./chunk-22MNNNXE.js";
+import {
+  recordStartupEvent
+} from "./chunk-ITOGNELQ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/startup/startup-prefetch.ts
+init_esbuild_shims();
+
+// packages/cli/src/utils/apiPreconnect.ts
+init_esbuild_shims();
+var import_undici = __toESM(require_undici(), 1);
+var debugLogger = createDebugLogger("PRECONNECT");
+var preconnectFired = false;
+var DEFAULT_BASE_URLS = {
+  openai: "https://api.openai.com",
+  "qwen-oauth": "https://coding.dashscope.aliyuncs.com",
+  anthropic: "https://api.anthropic.com",
+  dashscope: "https://dashscope.aliyuncs.com"
+};
+var ALL_DEFAULT_URLS = [
+  ...Object.values(DEFAULT_BASE_URLS),
+  ...getAllProviderBaseUrls()
+];
+function shouldSkipPreconnect() {
+  if (process.env["NODE_EXTRA_CA_CERTS"]) {
+    debugLogger.debug("Skipping preconnect: custom CA certificate configured");
+    return true;
+  }
+  return false;
+}
+__name(shouldSkipPreconnect, "shouldSkipPreconnect");
+function isInSandboxMode() {
+  return process.env["SANDBOX"] !== void 0;
+}
+__name(isInSandboxMode, "isInSandboxMode");
+function isDefaultBaseUrl(baseUrl) {
+  const normalizedInput = baseUrl.toLowerCase().replace(/^https?:\/\//, "").replace(/\/+$/, "");
+  return ALL_DEFAULT_URLS.some((defaultUrl) => {
+    const normalizedDefault = defaultUrl.toLowerCase().replace(/^https?:\/\//, "").replace(/\/+$/, "");
+    return normalizedInput === normalizedDefault || normalizedInput.startsWith(normalizedDefault + "/");
+  });
+}
+__name(isDefaultBaseUrl, "isDefaultBaseUrl");
+function getPreconnectTargetUrl(authType, resolvedBaseUrl) {
+  if (resolvedBaseUrl && /^https?:\/\//i.test(resolvedBaseUrl)) {
+    if (isDefaultBaseUrl(resolvedBaseUrl)) {
+      return resolvedBaseUrl;
+    }
+    debugLogger.debug(
+      "Skipping preconnect: resolved baseUrl is not a default URL"
+    );
+    return void 0;
+  }
+  if (authType && DEFAULT_BASE_URLS[authType]) {
+    return DEFAULT_BASE_URLS[authType];
+  }
+  return void 0;
+}
+__name(getPreconnectTargetUrl, "getPreconnectTargetUrl");
+function preconnectApi(authType, options = {}) {
+  if (preconnectFired) {
+    return;
+  }
+  if (process.env["QWEN_CODE_DISABLE_PRECONNECT"] === "1") {
+    debugLogger.debug("Preconnect disabled by environment variable");
+    preconnectFired = true;
+    return;
+  }
+  if (isInSandboxMode()) {
+    debugLogger.debug("Skipping preconnect: sandbox mode detected");
+    preconnectFired = true;
+    return;
+  }
+  if (shouldSkipPreconnect()) {
+    preconnectFired = true;
+    return;
+  }
+  if (detectRuntime() !== "node") {
+    debugLogger.debug("Skipping preconnect: unsupported runtime");
+    preconnectFired = true;
+    return;
+  }
+  if (!options.proxy) {
+    debugLogger.debug("Skipping preconnect dispatcher: no proxy configured");
+    return;
+  }
+  const proxy = options.proxy;
+  const targetUrl = getPreconnectTargetUrl(authType, options.resolvedBaseUrl);
+  if (!targetUrl) {
+    debugLogger.debug("No target URL for preconnect");
+    return;
+  }
+  preconnectFired = true;
+  debugLogger.debug(`Preconnecting to: ${targetUrl}`);
+  try {
+    const dispatcher = getOrCreateSharedDispatcher(proxy);
+    (0, import_undici.fetch)(targetUrl, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(5e3),
+      headers: {
+        "User-Agent": "QwenCode-Preconnect/1.0"
+      },
+      dispatcher
+    }).then(() => {
+      debugLogger.debug("Preconnect completed");
+    }).catch((error) => {
+      const redactedError = redactProxyCredentials(String(error));
+      debugLogger.debug(`Preconnect failed (ignored): ${redactedError}`);
+    });
+  } catch (error) {
+    const redactedError = redactProxyCredentials(String(error));
+    debugLogger.debug(`Preconnect failed (ignored): ${redactedError}`);
+  }
+}
+__name(preconnectApi, "preconnectApi");
+
+// packages/cli/src/startup/startup-prefetch.ts
+var debugLogger2 = createDebugLogger("STARTUP_PREFETCH");
+var DEFERRED_IDE_CONNECT_TIMEOUT_MS = 1e4;
+var earlyStarted = /* @__PURE__ */ new WeakSet();
+var postRenderStarted = /* @__PURE__ */ new WeakSet();
+function withTimeout(promise, name, timeoutMs) {
+  let timeoutId;
+  let timedOut = false;
+  const timeout = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      timedOut = true;
+      reject(new Error(`${name} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    timeoutId.unref?.();
+  });
+  promise.catch((err) => {
+    if (timedOut) {
+      debugLogger2.debug(`${name} underlying error after timeout:`, err);
+    }
+  });
+  return Promise.race([promise, timeout]).finally(() => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  });
+}
+__name(withTimeout, "withTimeout");
+function runDeferredTask(name, task) {
+  recordStartupEvent("startup_prefetch_started", { name });
+  void Promise.resolve().then(task).then(() => {
+    recordStartupEvent("startup_prefetch_completed", { name });
+  }).catch((err) => {
+    recordStartupEvent("startup_prefetch_failed", { name });
+    debugLogger2.warn(`${name} failed:`, err);
+  });
+}
+__name(runDeferredTask, "runDeferredTask");
+function startEarlyStartupPrefetches(config) {
+  if (earlyStarted.has(config)) return;
+  earlyStarted.add(config);
+  try {
+    const modelsConfig = config.getModelsConfig();
+    const authType = modelsConfig.getCurrentAuthType();
+    const resolvedBaseUrl = modelsConfig.getGenerationConfig().baseUrl;
+    const proxy = config.getProxy();
+    preconnectApi(authType, { resolvedBaseUrl, proxy });
+  } catch (error) {
+    debugLogger2.debug(
+      `Preconnect skipped due to error getting authType: ${error}`
+    );
+  }
+}
+__name(startEarlyStartupPrefetches, "startEarlyStartupPrefetches");
+function startPostRenderPrefetches(config, settings, options = {}) {
+  if (postRenderStarted.has(config)) return;
+  postRenderStarted.add(config);
+  if (settings.merged.general?.enableAutoUpdate !== false) {
+    runDeferredTask("update_check", async () => {
+      const [{ checkForUpdates }, { handleAutoUpdate }] = await Promise.all([
+        import("./updateCheck-E2ZX7RL7.js"),
+        import("./handleAutoUpdate-HN7ZOSXY.js")
+      ]);
+      const info = await checkForUpdates();
+      handleAutoUpdate(info, settings, config.getProjectRoot());
+    });
+  }
+  if (options.connectIde && config.getIdeMode()) {
+    runDeferredTask("ide_connect", async () => {
+      appEvents.emit("startup-ide-connection-status-changed" /* StartupIdeConnectionStatusChanged */, {
+        state: "connecting"
+      });
+      try {
+        const { connectIdeForStartup } = await import("./initializer-SRN3IM42.js");
+        await withTimeout(
+          connectIdeForStartup(config),
+          "ide_connect",
+          DEFERRED_IDE_CONNECT_TIMEOUT_MS
+        );
+        appEvents.emit("startup-ide-connection-status-changed" /* StartupIdeConnectionStatusChanged */, {
+          state: "connected"
+        });
+      } catch (err) {
+        appEvents.emit("startup-ide-connection-status-changed" /* StartupIdeConnectionStatusChanged */, {
+          state: "failed",
+          message: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      }
+    });
+  }
+  if (options.initializeTelemetry) {
+    runDeferredTask("telemetry_init", () => {
+      initializeTelemetry(config);
+    });
+  }
+  if (config.isInteractive()) {
+    runDeferredTask("background_housekeeping", async () => {
+      const { startBackgroundHousekeeping } = await import("./scheduler-ZRW3AIDU.js");
+      startBackgroundHousekeeping(config, settings);
+    });
+  }
+}
+__name(startPostRenderPrefetches, "startPostRenderPrefetches");
+
+export {
+  startEarlyStartupPrefetches,
+  startPostRenderPrefetches
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-CEYA7K7C.js → chunk-STAZRKOT.js}

@@ -6,7 +6,7 @@ import {
   getLanguageNameFromLocale,
   getLanguageSettingsOptions,
   t
-} from "./chunk-6QVRLKTZ.js";
+} from "./chunk-QAKFYMJI.js";
 import {
   DEFAULT_DARK_THEME_NAME,
   DEFAULT_LIGHT_THEME_NAME
@@ -29,36 +29,37 @@ import {
 import {
   isWorkspaceTrusted,
   updateSettingsFilePreservingFormat
-} from "./chunk-V6NH3CUC.js";
+} from "./chunk-MIG5SQNL.js";
 import {
   require_strip_json_comments
 } from "./chunk-QYUE6W3T.js";
 import {
   DEFAULT_MAX_SUBAGENT_DEPTH,
+  DEFAULT_MAX_TOOL_CALLS_PER_TURN,
   DEFAULT_STOP_HOOK_BLOCK_CAP,
   DEFAULT_TOOL_OUTPUT_BATCH_BUDGET,
   DEFAULT_TOOL_RESULTS_TOTAL_CHARS_THRESHOLD,
   DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
   DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
   stripRuntimeSnapshotPrefix
-} from "./chunk-AGZF43UV.js";
+} from "./chunk-YEGT55NW.js";
 import {
   require_main
 } from "./chunk-SKAZWEV5.js";
 import {
   DEFAULT_QWEN_CUSTOM_IGNORE_FILE_NAMES
-} from "./chunk-TOAUDIS7.js";
+} from "./chunk-TLWA7TPR.js";
 import {
   DEFAULT_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH,
   SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH_LIMIT
-} from "./chunk-JN2VJ33O.js";
+} from "./chunk-GMOWQOQQ.js";
 import {
   FatalConfigError,
   QWEN_DIR,
   Storage,
   createDebugLogger,
   getErrorMessage
-} from "./chunk-AVQDCKNF.js";
+} from "./chunk-22MNNNXE.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -1092,6 +1093,15 @@ var SETTINGS_SCHEMA = {
     description: "Image-capable model used as the vision bridge: when a text-only main model receives an image, it is transcribed by this model first. Set with /model --vision. Leave empty to auto-pick a same-provider vision model.",
     showInDialog: true
   },
+  modelFallbacks: {
+    type: "string",
+    label: "Model Fallbacks",
+    category: "Model",
+    requiresRestart: true,
+    default: "",
+    description: 'Ordered list of fallback model IDs (comma-separated, max 3) to try when the primary model hits capacity errors (429/503/529). Example: "qwen-plus,qwen-turbo". Set via CLI with --fallback-model.',
+    showInDialog: true
+  },
   voiceModel: {
     type: "string",
     label: "Voice Model",
@@ -1222,7 +1232,16 @@ var SETTINGS_SCHEMA = {
         category: "Model",
         requiresRestart: false,
         default: true,
-        description: "Skip the opt-in streaming loop-detection heuristics (content/thought repetition, read-file and action stagnation, global-duplicate and alternating tool-call patterns). Defaults to true to avoid false-positive interruptions; set to false to re-enable them as an unattended-run guardrail. A minimal always-on guard (consecutive identical tool calls plus a per-turn tool-call cap) still runs regardless of this setting.",
+        description: "Skip the opt-in streaming loop-detection heuristics (content/thought repetition, read-file and action stagnation, global-duplicate and alternating tool-call patterns). Defaults to true to avoid false-positive interruptions; set to false to re-enable them as an unattended-run guardrail. A minimal always-on guard (consecutive identical tool calls plus a per-turn tool-call cap, see model.maxToolCallsPerTurn) still runs regardless of this setting.",
+        showInDialog: false
+      },
+      maxToolCallsPerTurn: {
+        type: "number",
+        label: "Max Tool Calls Per Turn",
+        category: "Model",
+        requiresRestart: false,
+        default: DEFAULT_MAX_TOOL_CALLS_PER_TURN,
+        description: "Hard cap on tool calls within a single turn (one model turn plus its tool-result continuations; blocking Stop-hook continuations such as /goal iterations start a fresh budget). An always-on circuit breaker against runaway turns, independent of model.skipLoopDetection. Set to 0 or a negative value to disable the cap.",
         showInDialog: false
       },
       skipStartupContext: {
@@ -1886,8 +1905,8 @@ var SETTINGS_SCHEMA = {
             label: "Pager",
             category: "Tools",
             requiresRestart: false,
-            default: "cat",
-            description: "The pager command to use for shell output. Defaults to `cat`.",
+            default: void 0,
+            description: "The pager command to use for shell output. Defaults to `cat` on non-Windows platforms and unset on Windows. Set to an empty string to disable pager environment variables.",
             showInDialog: false
           },
           showColor: {
@@ -1941,6 +1960,16 @@ var SETTINGS_SCHEMA = {
         showInDialog: false,
         mergeStrategy: "union" /* UNION */
       },
+      visible: {
+        type: "array",
+        label: "Visible Deferred Tools",
+        category: "Tools",
+        requiresRestart: true,
+        default: void 0,
+        description: "Deferred tool names made visible at startup without requiring tool_search. Listed tools appear alongside core tools in the initial session.",
+        showInDialog: false,
+        mergeStrategy: "union" /* UNION */
+      },
       approvalMode: {
         type: "enum",
         label: "Tool Approval Mode",
@@ -2343,6 +2372,20 @@ var SETTINGS_SCHEMA = {
     description: "Settings for multi-agent collaboration features (Arena, Team, Swarm).",
     showInDialog: false,
     properties: {
+      maxParallelAgents: {
+        type: "number",
+        label: "Max Parallel Agents",
+        category: "Advanced",
+        requiresRestart: true,
+        default: void 0,
+        minimum: 1,
+        description: "Global maximum number of background sub-agents that can run concurrently. Additional background agents wait in a queue until a slot is available. Per-model limits are not supported yet.",
+        showInDialog: false,
+        jsonSchemaOverride: {
+          type: "integer",
+          minimum: 1
+        }
+      },
       displayMode: {
         type: "enum",
         label: "Display Mode",
@@ -4148,7 +4191,9 @@ function loadEnvironment(settings, startDir = process.cwd()) {
           if (!isQwenScopedEnvFile && excludedVars.includes(key)) {
             continue;
           }
-          if (!Object.hasOwn(process.env, key)) {
+          const existingValue = process.env[key];
+          const isEffectivelyUnset = !Object.hasOwn(process.env, key) || existingValue === "";
+          if (isEffectivelyUnset) {
             process.env[key] = parsedEnv[key];
             dotEnvSourcedKeys.add(key);
           }
@@ -4165,7 +4210,9 @@ function loadEnvironment(settings, startDir = process.cwd()) {
       if (PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) {
         continue;
       }
-      if (!Object.hasOwn(process.env, key) && typeof value === "string") {
+      const existingValue = process.env[key];
+      const isEffectivelyUnset = !Object.hasOwn(process.env, key) || existingValue === "";
+      if (isEffectivelyUnset && typeof value === "string") {
         process.env[key] = value;
         settingsEnvSourcedKeys.add(key);
       }
@@ -4214,7 +4261,8 @@ function reloadEnvironment(settings, workspaceCwd) {
       if (RELOAD_EXCLUDED_KEYS.has(key)) continue;
       if (PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) continue;
       if (typeof value !== "string") continue;
-      if (newDotEnvKeys.has(key)) continue;
+      const dotEnvValue = newDotEnvKeys.get(key);
+      if (dotEnvValue !== void 0 && dotEnvValue !== "") continue;
       if (dotEnvReadFailed && lastReloadSnapshot.has(key)) continue;
       newSettingsEnvKeys.set(key, value);
     }
@@ -4239,6 +4287,7 @@ function reloadEnvironment(settings, workspaceCwd) {
     }
   }
   for (const [key, value] of newDotEnvKeys) {
+    if (value === "" && newSettingsEnvKeys.has(key)) continue;
     if (process.env[key] !== value) {
       updatedKeys.push(key);
     }
@@ -4966,6 +5015,7 @@ export {
   resetHomeEnvBootstrapForTesting,
   resetEnvironmentTrackingForTesting,
   getHomeEnvFallbackVars,
+  findEnvFiles,
   setUpCloudShellEnvironment,
   loadEnvironment,
   reloadEnvironment,

package/chunks/{chunk-BZHLWC6T.js → chunk-SUAKHHK7.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   atomicWriteFileSync
-} from "./chunk-T42ACHFI.js";
+} from "./chunk-7LTB54MK.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-AVQDCKNF.js";
+} from "./chunk-22MNNNXE.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-ZI4MGBB5.js → chunk-TBAZMRW3.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getGlobalQwenDir
-} from "./chunk-6BEOH4KK.js";
+} from "./chunk-2NPS2UDH.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-J6ABRKAB.js → chunk-TDGF35EN.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   isTeamAutoMemPath
-} from "./chunk-MOUXUCXQ.js";
+} from "./chunk-4KJ2BPIT.js";
 import {
   createDebugLogger
-} from "./chunk-AVQDCKNF.js";
+} from "./chunk-22MNNNXE.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-TOAUDIS7.js → chunk-TLWA7TPR.js}

@@ -3,7 +3,7 @@
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-AVQDCKNF.js";
+} from "./chunk-22MNNNXE.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -858,12 +858,16 @@ var QwenIgnoreParser = class {
     if (filePath.startsWith("\\") || filePath === "/" || filePath.includes("\0")) {
       return null;
     }
+    const isDir = filePath.endsWith("/");
     const resolved = path2.resolve(this.projectRoot, filePath);
     const relativePath = path2.relative(this.projectRoot, resolved);
     if (relativePath === "" || !isPathWithinRoot(resolved, this.projectRoot)) {
       return null;
     }
-    const normalizedPath = relativePath.replace(/\\/g, "/");
+    let normalizedPath = relativePath.replace(/\\/g, "/");
+    if (isDir && !normalizedPath.endsWith("/")) {
+      normalizedPath += "/";
+    }
     if (normalizedPath.startsWith("/") || normalizedPath === "") {
       return null;
     }