@qwen-code/qwen-code 0.20.0 → 0.20.1-nightly.20260724.7d17c44a3

package/chunks/{chunk-OOCI5VVU.js → chunk-LIZRAKPB.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-AJSJ5TTU.js → chunk-LP2E4MQG.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   runExitCleanup
-} from "./chunk-DP5GXXNZ.js";
+} from "./chunk-EL2IQ2S5.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-LS77BEZP.js

@@ -0,0 +1,405 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/core/tool-call-preparation.ts
+init_esbuild_shims();
+var preparationsByResponse = /* @__PURE__ */ new WeakMap();
+function setToolCallPreparations(response, preparations) {
+  preparationsByResponse.set(response, preparations);
+}
+__name(setToolCallPreparations, "setToolCallPreparations");
+function getToolCallPreparations(response) {
+  return preparationsByResponse.get(response) ?? [];
+}
+__name(getToolCallPreparations, "getToolCallPreparations");
+
+// packages/core/src/utils/runtimeDiagnostics.ts
+init_esbuild_shims();
+var RUNTIME_PROFILE_ENV = "QWEN_CODE_PROFILE_RUNTIME";
+function isRuntimeDiagnosticsEnabled(env = process.env) {
+  return env[RUNTIME_PROFILE_ENV] === "1";
+}
+__name(isRuntimeDiagnosticsEnabled, "isRuntimeDiagnosticsEnabled");
+var RuntimeDiagnosticsCollector = class {
+  static {
+    __name(this, "RuntimeDiagnosticsCollector");
+  }
+  enabled;
+  now;
+  startedAt;
+  requestIndex = 0;
+  openAIWireRequestIndex = 0;
+  anthropicWireRequestIndex = 0;
+  requests = [];
+  openaiWireRequests = [];
+  anthropicWireRequests = [];
+  tools = createInitialToolDiagnostics();
+  constructor(options = {}) {
+    this.enabled = options.enabled ?? isRuntimeDiagnosticsEnabled();
+    this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+    this.startedAt = this.now();
+  }
+  reset(options = {}) {
+    this.enabled = options.enabled ?? isRuntimeDiagnosticsEnabled();
+    this.startedAt = this.now();
+    this.requestIndex = 0;
+    this.openAIWireRequestIndex = 0;
+    this.anthropicWireRequestIndex = 0;
+    this.requests = [];
+    this.openaiWireRequests = [];
+    this.anthropicWireRequests = [];
+    this.tools = createInitialToolDiagnostics();
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  recordGenerateContentRequest(request, options) {
+    if (!this.enabled) {
+      return;
+    }
+    this.requestIndex += 1;
+    this.requests.push({
+      index: this.requestIndex,
+      timestamp: this.now(),
+      source: options.source,
+      model: request.model,
+      stream: options.stream,
+      serializedBytes: utf8Bytes(toJsonSafeRequest(request)),
+      contents: summarizeContents(request.contents),
+      systemInstructionBytes: summarizeContentTextBytes(
+        request.config?.systemInstruction
+      ),
+      generationConfigBytes: utf8Bytes(toJsonSafeConfig(request.config)),
+      tools: summarizeToolSchemas(request.config?.tools)
+    });
+  }
+  recordOpenAIWireRequest(request) {
+    if (!this.enabled) {
+      return;
+    }
+    this.openAIWireRequestIndex += 1;
+    this.openaiWireRequests.push({
+      index: this.openAIWireRequestIndex,
+      timestamp: this.now(),
+      ...summarizeOpenAIWireRequest(request)
+    });
+  }
+  recordAnthropicWireRequest(request) {
+    if (!this.enabled) {
+      return;
+    }
+    this.anthropicWireRequestIndex += 1;
+    this.anthropicWireRequests.push({
+      index: this.anthropicWireRequestIndex,
+      timestamp: this.now(),
+      ...summarizeAnthropicWireRequest(request)
+    });
+  }
+  recordToolUse(name, args) {
+    if (!this.enabled) {
+      return;
+    }
+    const argBytes = utf8Bytes(args);
+    const tool = this.getToolNameDiagnostics(name);
+    tool.uses += 1;
+    tool.argBytes += argBytes;
+    tool.maxArgBytes = Math.max(tool.maxArgBytes, argBytes);
+    this.tools.toolUseCount += 1;
+    this.tools.totalToolUseArgBytes += argBytes;
+    this.tools.maxToolUseArgBytes = Math.max(
+      this.tools.maxToolUseArgBytes,
+      argBytes
+    );
+  }
+  recordToolResult(record) {
+    if (!this.enabled) {
+      return;
+    }
+    const tool = this.getToolNameDiagnostics(record.name);
+    tool.results += 1;
+    tool.resultBytes += record.resultBytes;
+    tool.maxResultBytes = Math.max(tool.maxResultBytes, record.resultBytes);
+    if (record.isError) {
+      tool.errors += 1;
+      this.tools.toolResultErrorCount += 1;
+    }
+    this.tools.toolResultCount += 1;
+    this.tools.totalToolResultBytes += record.resultBytes;
+    this.tools.maxToolResultBytes = Math.max(
+      this.tools.maxToolResultBytes,
+      record.resultBytes
+    );
+  }
+  snapshot() {
+    return {
+      enabled: this.enabled,
+      startedAt: this.startedAt,
+      requests: this.requests.map((request) => ({
+        ...request,
+        contents: {
+          ...request.contents,
+          roleCounts: { ...request.contents.roleCounts }
+        },
+        tools: { ...request.tools }
+      })),
+      openaiWireRequests: this.openaiWireRequests.map((request) => ({
+        ...request,
+        messageBytesByRole: { ...request.messageBytesByRole },
+        topLevelKeys: [...request.topLevelKeys]
+      })),
+      anthropicWireRequests: this.anthropicWireRequests.map((request) => ({
+        ...request,
+        messageBytesByRole: { ...request.messageBytesByRole },
+        topLevelKeys: [...request.topLevelKeys]
+      })),
+      tools: {
+        ...this.tools,
+        byName: Object.fromEntries(
+          Object.entries(this.tools.byName).map(([name, value]) => [
+            name,
+            { ...value }
+          ])
+        )
+      }
+    };
+  }
+  getToolNameDiagnostics(name) {
+    const existing = this.tools.byName[name];
+    if (existing) {
+      return existing;
+    }
+    const created = createInitialToolNameDiagnostics();
+    this.tools.byName[name] = created;
+    return created;
+  }
+};
+var runtimeDiagnostics = new RuntimeDiagnosticsCollector();
+function summarizeOpenAIWireRequest(request) {
+  const requestRecord = asRecord(request);
+  const messages = Array.isArray(requestRecord["messages"]) ? requestRecord["messages"] : [];
+  const tools = Array.isArray(requestRecord["tools"]) ? requestRecord["tools"] : [];
+  const messageBytesByRole = {};
+  for (const message of messages) {
+    const messageRecord = asRecord(message);
+    const role = typeof messageRecord["role"] === "string" ? messageRecord["role"] : "unknown";
+    messageBytesByRole[role] = (messageBytesByRole[role] ?? 0) + utf8Bytes(messageRecord["content"]);
+  }
+  return {
+    model: typeof requestRecord["model"] === "string" ? requestRecord["model"] : "unknown",
+    stream: requestRecord["stream"] === true,
+    bodyBytes: utf8Bytes(request),
+    messageCount: messages.length,
+    messageBytesByRole,
+    toolsCount: tools.length,
+    toolSchemaBytes: utf8Bytes(tools),
+    topLevelKeys: Object.keys(requestRecord).sort()
+  };
+}
+__name(summarizeOpenAIWireRequest, "summarizeOpenAIWireRequest");
+function summarizeAnthropicWireRequest(request) {
+  const requestRecord = asRecord(request);
+  const messages = Array.isArray(requestRecord["messages"]) ? requestRecord["messages"] : [];
+  const tools = Array.isArray(requestRecord["tools"]) ? requestRecord["tools"] : [];
+  const messageBytesByRole = {};
+  for (const message of messages) {
+    const messageRecord = asRecord(message);
+    const role = typeof messageRecord["role"] === "string" ? messageRecord["role"] : "unknown";
+    messageBytesByRole[role] = (messageBytesByRole[role] ?? 0) + utf8Bytes(messageRecord["content"]);
+  }
+  return {
+    model: typeof requestRecord["model"] === "string" ? requestRecord["model"] : "unknown",
+    stream: requestRecord["stream"] === true,
+    bodyBytes: utf8Bytes(request),
+    messageCount: messages.length,
+    messageBytesByRole,
+    systemBytes: utf8Bytes(requestRecord["system"]),
+    toolsCount: tools.length,
+    toolSchemaBytes: utf8Bytes(tools),
+    topLevelKeys: Object.keys(requestRecord).sort()
+  };
+}
+__name(summarizeAnthropicWireRequest, "summarizeAnthropicWireRequest");
+function createInitialToolDiagnostics() {
+  return {
+    toolUseCount: 0,
+    toolResultCount: 0,
+    toolResultErrorCount: 0,
+    totalToolUseArgBytes: 0,
+    maxToolUseArgBytes: 0,
+    totalToolResultBytes: 0,
+    maxToolResultBytes: 0,
+    byName: /* @__PURE__ */ Object.create(null)
+  };
+}
+__name(createInitialToolDiagnostics, "createInitialToolDiagnostics");
+function createInitialToolNameDiagnostics() {
+  return {
+    uses: 0,
+    argBytes: 0,
+    maxArgBytes: 0,
+    results: 0,
+    errors: 0,
+    resultBytes: 0,
+    maxResultBytes: 0
+  };
+}
+__name(createInitialToolNameDiagnostics, "createInitialToolNameDiagnostics");
+function summarizeContents(contents) {
+  const summary = {
+    count: 0,
+    roleCounts: {},
+    partCount: 0,
+    textBytes: 0,
+    functionCallCount: 0,
+    functionCallArgBytes: 0,
+    functionResponseCount: 0,
+    functionResponseBytes: 0,
+    inlineDataCount: 0,
+    inlineDataBytes: 0,
+    fileDataCount: 0
+  };
+  const contentItems = Array.isArray(contents) ? contents : contents === void 0 || contents === null ? [] : [contents];
+  for (const content of contentItems) {
+    summary.count += 1;
+    if (typeof content === "string") {
+      summary.roleCounts["user"] = (summary.roleCounts["user"] ?? 0) + 1;
+      summary.partCount += 1;
+      summary.textBytes += utf8Bytes(content);
+      continue;
+    }
+    const contentRecord = asRecord(content);
+    const role = typeof contentRecord["role"] === "string" ? contentRecord["role"] : "unknown";
+    summary.roleCounts[role] = (summary.roleCounts[role] ?? 0) + 1;
+    const parts = Array.isArray(contentRecord["parts"]) ? contentRecord["parts"] : [];
+    summarizeParts(parts, summary);
+  }
+  return summary;
+}
+__name(summarizeContents, "summarizeContents");
+function summarizeContentTextBytes(content) {
+  const summary = summarizeContents(content);
+  return summary.textBytes;
+}
+__name(summarizeContentTextBytes, "summarizeContentTextBytes");
+function summarizeParts(parts, summary) {
+  for (const part of parts) {
+    summary.partCount += 1;
+    if (typeof part === "string") {
+      summary.textBytes += utf8Bytes(part);
+      continue;
+    }
+    const partRecord = asRecord(part);
+    if (typeof partRecord["text"] === "string") {
+      summary.textBytes += utf8Bytes(partRecord["text"]);
+    }
+    const functionCall = asOptionalRecord(partRecord["functionCall"]);
+    if (functionCall) {
+      summary.functionCallCount += 1;
+      summary.functionCallArgBytes += utf8Bytes(functionCall["args"]);
+    }
+    const functionResponse = asOptionalRecord(partRecord["functionResponse"]);
+    if (functionResponse) {
+      summary.functionResponseCount += 1;
+      summary.functionResponseBytes += utf8Bytes(functionResponse["response"]) + utf8Bytes(functionResponse["parts"]);
+    }
+    const inlineData = asOptionalRecord(partRecord["inlineData"]);
+    if (inlineData) {
+      summary.inlineDataCount += 1;
+      summary.inlineDataBytes += utf8Bytes(inlineData["data"]);
+    }
+    if (partRecord["fileData"]) {
+      summary.fileDataCount += 1;
+    }
+  }
+}
+__name(summarizeParts, "summarizeParts");
+function summarizeToolSchemas(tools) {
+  const toolList = Array.isArray(tools) ? tools : [];
+  let functionDeclarationCount = 0;
+  for (const tool of toolList) {
+    const toolRecord = asRecord(tool);
+    const declarations = Array.isArray(toolRecord["functionDeclarations"]) ? toolRecord["functionDeclarations"] : [];
+    functionDeclarationCount += declarations.length;
+  }
+  return {
+    count: toolList.length,
+    functionDeclarationCount,
+    schemaBytes: utf8Bytes(toolList)
+  };
+}
+__name(summarizeToolSchemas, "summarizeToolSchemas");
+function toJsonSafeRequest(request) {
+  return {
+    model: request.model,
+    contents: request.contents,
+    config: toJsonSafeConfig(request.config)
+  };
+}
+__name(toJsonSafeRequest, "toJsonSafeRequest");
+function toJsonSafeConfig(config) {
+  if (!config) {
+    return void 0;
+  }
+  const configRecord = asRecord(config);
+  const safeConfig = {};
+  for (const [key, value] of Object.entries(configRecord)) {
+    if (key === "abortSignal") {
+      continue;
+    }
+    safeConfig[key] = value;
+  }
+  return safeConfig;
+}
+__name(toJsonSafeConfig, "toJsonSafeConfig");
+function utf8Bytes(value) {
+  if (value === void 0 || value === null) {
+    return 0;
+  }
+  if (typeof value === "string") {
+    return Buffer.byteLength(value, "utf8");
+  }
+  return Buffer.byteLength(safeStringify(value), "utf8");
+}
+__name(utf8Bytes, "utf8Bytes");
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "[unserializable]";
+  }
+}
+__name(safeStringify, "safeStringify");
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+__name(asRecord, "asRecord");
+function asOptionalRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+__name(asOptionalRecord, "asOptionalRecord");
+
+export {
+  setToolCallPreparations,
+  getToolCallPreparations,
+  isRuntimeDiagnosticsEnabled,
+  RuntimeDiagnosticsCollector,
+  runtimeDiagnostics,
+  summarizeOpenAIWireRequest,
+  summarizeAnthropicWireRequest
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-BRRF37CO.js → chunk-LYTBLSSW.js}

@@ -2,20 +2,20 @@
 "use strict";
 import {
   formatFetchErrorForUser
-} from "./chunk-BMWMT5Y2.js";
+} from "./chunk-WI3KCKZ5.js";
 import {
   openBrowserSecurely
 } from "./chunk-JESCGQM3.js";
-import {
-  atomicWriteFile
-} from "./chunk-BDBMYST4.js";
 import {
   combineAbortSignals
 } from "./chunk-DJ2GSRLV.js";
+import {
+  atomicWriteFile
+} from "./chunk-6X4GWOPW.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-DBE4QFZS.js → chunk-MB7ENXPR.js}

@@ -2,31 +2,32 @@
 "use strict";
 import {
   appEvents
-} from "./chunk-4XNLIGVA.js";
+} from "./chunk-JKCALGYN.js";
 import {
   CUSTOM_SANDBOX_IMAGE_ENV_VAR,
   HOST_UPDATE_RELAUNCH_ENV_VAR,
   SKIP_UPDATE_CHECK_ENV_VAR,
   requestUpdateOnExit
-} from "./chunk-AJSJ5TTU.js";
+} from "./chunk-LP2E4MQG.js";
 import {
-  require_undici
-} from "./chunk-L573Z2QZ.js";
+  loadUndici
+} from "./chunk-3Z43GZUQ.js";
 import {
   IdeClient,
   getAllProviderBaseUrls
-} from "./chunk-KX6UK4VJ.js";
-import {
-  initializeTelemetry
-} from "./chunk-ZFKNWQGQ.js";
+} from "./chunk-LI4I37W4.js";
 import {
   detectRuntime,
   getOrCreateSharedDispatcher,
+  preloadRuntimeFetchModule,
   redactProxyCredentials
-} from "./chunk-6EFTQYW7.js";
+} from "./chunk-NBQDBANR.js";
+import {
+  initializeTelemetry
+} from "./chunk-PKL3HGNZ.js";
 import {
   createDebugLogger
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   recordStartupEvent
 } from "./chunk-QSWDGAIC.js";
@@ -34,8 +35,7 @@ import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
 import {
-  __name,
-  __toESM
+  __name
 } from "./chunk-J2S4EL5Y.js";
 
 // packages/cli/src/startup/startup-prefetch.ts
@@ -43,9 +43,9 @@ 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 preconnectInFlight;
 var DEFAULT_BASE_URLS = {
   openai: "https://api.openai.com",
   "qwen-oauth": "https://coding.dashscope.aliyuncs.com",
@@ -127,25 +127,23 @@ function preconnectApi(authType, options = {}) {
   }
   preconnectFired = true;
   debugLogger.debug(`Preconnecting to: ${targetUrl}`);
-  try {
+  preconnectInFlight = (async () => {
+    await preloadRuntimeFetchModule();
     const dispatcher = getOrCreateSharedDispatcher(proxy);
-    (0, import_undici.fetch)(targetUrl, {
+    const { fetch: undiciFetch } = await loadUndici();
+    await undiciFetch(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) {
+    debugLogger.debug("Preconnect completed");
+  })().catch((error) => {
     const redactedError = redactProxyCredentials(String(error));
     debugLogger.debug(`Preconnect failed (ignored): ${redactedError}`);
-  }
+  });
 }
 __name(preconnectApi, "preconnectApi");
 
@@ -227,21 +225,21 @@ function startPostRenderPrefetches(config, settings, options = {}) {
   if (settings.merged.general?.enableAutoUpdate !== false && process.env[SKIP_UPDATE_CHECK_ENV_VAR] !== "true" && !process.env[CUSTOM_SANDBOX_IMAGE_ENV_VAR]) {
     runDeferredTask("update_check", async () => {
       const [
-        { checkForUpdatesDetailed },
+        { checkForUpdatesDetailed, describeUpdateCheckFailure },
         { handleAutoUpdate },
         { getInstallationInfo },
         { updateEventEmitter },
         { t }
       ] = await Promise.all([
-        import("./updateCheck-YZZB7YBU.js"),
-        import("./handleAutoUpdate-QQVIWXKT.js"),
-        import("./installationInfo-6J3WPXNS.js"),
+        import("./updateCheck-MXIU6DWQ.js"),
+        import("./handleAutoUpdate-Q572P3FL.js"),
+        import("./installationInfo-XUAOVMEE.js"),
         import("./updateEventEmitter-5MKC7BLQ.js"),
-        import("./i18n-N6OBDORT.js")
+        import("./i18n-OBB4R7SR.js")
       ]);
-      const updateFailedMessage = t(
-        "Failed to check for updates. Please check your network or registry configuration."
-      );
+      const updateCheckSkippedMessage = /* @__PURE__ */ __name((error) => t("Update check skipped ({{reason}}) \u2014 run /update to retry.", {
+        reason: describeUpdateCheckFailure(error)
+      }), "updateCheckSkippedMessage");
       try {
         const result = await checkForUpdatesDetailed();
         if (result.status === "update") {
@@ -266,6 +264,10 @@ ${t(
             return;
           }
           const installationInfo = getInstallationInfo(projectRoot, true);
+          if (installationInfo.packageManager === "npm") {
+            void handleAutoUpdate(result.info, settings, projectRoot);
+            return;
+          }
           if (installationInfo.updateCommand || installationInfo.isStandalone && installationInfo.standaloneDir) {
             if (requestUpdateOnExit()) {
               updateEventEmitter.emit("update-info", {
@@ -287,12 +289,14 @@ ${t(
           }
         } else if (result.status === "error") {
           updateEventEmitter.emit("update-failed", {
-            message: updateFailedMessage
+            message: updateCheckSkippedMessage(result.error),
+            severity: "warning"
           });
         }
       } catch (error) {
         updateEventEmitter.emit("update-failed", {
-          message: updateFailedMessage
+          message: updateCheckSkippedMessage(error),
+          severity: "warning"
         });
         throw error;
       }
@@ -304,7 +308,7 @@ ${t(
         state: "connecting"
       });
       try {
-        const { connectIdeForStartup } = await import("./initializer-6WCFNDLL.js");
+        const { connectIdeForStartup } = await import("./initializer-LXEY6V3C.js");
         await withTimeout(
           connectIdeForStartup(config),
           "ide_connect",
@@ -324,13 +328,11 @@ ${t(
     });
   }
   if (options.initializeTelemetry) {
-    runDeferredTask("telemetry_init", () => {
-      initializeTelemetry(config);
-    });
+    runDeferredTask("telemetry_init", () => initializeTelemetry(config));
   }
   if (config.isInteractive()) {
     runDeferredTask("background_housekeeping", async () => {
-      const { startBackgroundHousekeeping } = await import("./scheduler-Z7QLMUWA.js");
+      const { startBackgroundHousekeeping } = await import("./scheduler-TTEITHBF.js");
       startBackgroundHousekeeping(config, settings);
     });
   }

package/chunks/{chunk-GKY2OJ7R.js → chunk-MOHAWVLH.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   escapeAnsiCtrlCodes
-} from "./chunk-RS7MT2QG.js";
+} from "./chunk-IPUUTYMV.js";
+import {
+  createDebugLogger
+} from "./chunk-OQB4EXO4.js";
 import {
   wrapper_default
 } from "./chunk-TYAMGABM.js";
-import {
-  createDebugLogger
-} from "./chunk-C27BYUX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";