@qwen-code/qwen-code 0.23.3 → 0.23.4

package/chunks/{chunk-HBU7EKY4.js → chunk-TRKIKBUW.js}

@@ -6,13 +6,10 @@ import {
 } from "./chunk-5ETULJLP.js";
 import {
   defaultModalities
-} from "./chunk-ZHKTKHMO.js";
+} from "./chunk-7MIBD3LG.js";
 import {
   Mutex
 } from "./chunk-VGC4I5JJ.js";
-import {
-  isAnyAutoMemPath
-} from "./chunk-EDIDYZBT.js";
 import {
   PDF_MAX_PAGES_PER_READ,
   VISION_BRIDGE_MAX_IMAGES,
@@ -21,7 +18,13 @@ import {
   isCacheableReadResult,
   parsePDFPageRange,
   processSingleFileContent
-} from "./chunk-J6MB5ZHZ.js";
+} from "./chunk-QZW6WRB7.js";
+import {
+  isAnyAutoMemPath
+} from "./chunk-EDIDYZBT.js";
+import {
+  getCurrentToolCallSource
+} from "./chunk-CFMZLE3L.js";
 import {
   generateLegacyMcpToolName,
   normalizeToolNameForProvider
@@ -31,7 +34,7 @@ import {
 } from "./chunk-TIGXX4PA.js";
 import {
   DEFAULT_QWEN_MODEL
-} from "./chunk-3UXUOFO6.js";
+} from "./chunk-7W2Y3PZD.js";
 import {
   atomicWriteFile
 } from "./chunk-XFFRI3WM.js";
@@ -106,7 +109,7 @@ import {
   recordTokenUsageMetrics,
   recordToolCallMetrics,
   recordToolExecutionMetrics
-} from "./chunk-W5ZQMAEM.js";
+} from "./chunk-4Y2I3CI3.js";
 import {
   SemanticAttributes,
   init_esm,
@@ -114,7 +117,7 @@ import {
 } from "./chunk-74TONY4F.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-HUXPEUFL.js";
+} from "./chunk-SYROIHU7.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
@@ -122,7 +125,7 @@ import {
   StructuredToolError,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-TP6FYVQT.js";
+} from "./chunk-RSWBT7AZ.js";
 import {
   Storage,
   createDebugLogger,
@@ -1882,6 +1885,8 @@ var FLUSH_INTERVAL_MS = 1e3 * 60;
 var ERROR_LOG_INTERVAL_MS = 5 * 60 * 1e3;
 var MAX_EVENTS = 1e3;
 var MAX_RETRY_EVENTS = 100;
+var ERROR_TEXT_PROPERTY_KEYS = ["error_message", "error_excerpt"];
+var REDACTED_ERROR_TEXT = "***REDACTED***";
 var QwenLogger = class _QwenLogger {
   static {
     __name(this, "QwenLogger");
@@ -1942,6 +1947,7 @@ var QwenLogger = class _QwenLogger {
   }
   enqueueLogEvent(event) {
     try {
+      this.redactEventErrorText(event);
       const wasAtCapacity = this.events.size >= MAX_EVENTS;
       if (wasAtCapacity) {
         this.events.shift();
@@ -1956,6 +1962,21 @@ var QwenLogger = class _QwenLogger {
       this.debugLogger.error("QwenLogger: Failed to enqueue log event.", error);
     }
   }
+  redactEventErrorText(event) {
+    const properties = event.properties;
+    if (properties) {
+      for (const key of ERROR_TEXT_PROPERTY_KEYS) {
+        const value = properties[key];
+        if (typeof value === "string") {
+          properties[key] = REDACTED_ERROR_TEXT;
+        }
+      }
+    }
+    const message = event.message;
+    if (typeof message === "string") {
+      event.message = REDACTED_ERROR_TEXT;
+    }
+  }
   createRumEvent(eventType, type, name, properties) {
     return {
       timestamp: Date.now(),
@@ -2684,9 +2705,6 @@ var QwenLogger = class _QwenLogger {
       success: event.success ? 1 : 0,
       exit_code: event.exit_code
     };
-    if (event.error && this.config?.getTelemetryLogPromptsEnabled()) {
-      properties["error"] = event.error;
-    }
     const rumEvent = this.createActionEvent(
       "hook",
       `hook_call#${event.hook_event_name}`,
@@ -6453,8 +6471,10 @@ function transformMcpContentToParts(sdkResponse) {
   const funcResponse = sdkResponse?.[0]?.functionResponse;
   const mcpContent = funcResponse?.response?.["content"];
   const toolName = funcResponse?.name || "unknown tool";
+  const structured = funcResponse?.response?.["structuredContent"];
+  const structuredParts = structured !== void 0 ? [{ text: JSON.stringify(structured) }] : [];
   if (!Array.isArray(mcpContent)) {
-    return [{ text: "[Error: Could not parse tool response]" }];
+    return structuredParts.length ? structuredParts : [{ text: "[Error: Could not parse tool response]" }];
   }
   const transformed = mcpContent.flatMap(
     (block) => {
@@ -6473,7 +6493,10 @@ function transformMcpContentToParts(sdkResponse) {
       }
     }
   );
-  return transformed.filter((part) => part !== null);
+  const contentParts = transformed.filter(
+    (part) => part !== null
+  );
+  return contentParts.some((part) => part.text === structuredParts[0]?.text) ? contentParts : [...structuredParts, ...contentParts];
 }
 __name(transformMcpContentToParts, "transformMcpContentToParts");
 function getMcpErrorImageContent(rawResponseParts) {
@@ -6623,6 +6646,8 @@ var ToolCallEvent = class {
   "event.name";
   "event.timestamp";
   call_id;
+  parent_call_id;
+  source;
   function_name;
   function_args;
   duration_ms;
@@ -6644,6 +6669,9 @@ var ToolCallEvent = class {
     this["event.name"] = "tool_call";
     this["event.timestamp"] = (/* @__PURE__ */ new Date()).toISOString();
     this.call_id = call.request.callId;
+    if (call.request.parentCallId)
+      this.parent_call_id = call.request.parentCallId;
+    if (call.request.source) this.source = call.request.source;
     this.function_name = call.request.name;
     this.function_args = call.request.name === ToolNames.STRUCTURED_OUTPUT ? { ...STRUCTURED_OUTPUT_REDACTED_ARGS } : call.request.args;
     this.duration_ms = call.durationMs ?? 0;
@@ -8234,7 +8262,8 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
     const projectRoot = this.config.getTargetDir();
     const isAutoMem = isAnyAutoMemPath(absPath, projectRoot);
     const cacheEnabled = !this.config.getFileReadCacheDisabled();
-    const useFastPath = cacheEnabled && !isAutoMem;
+    const nestedRead = getCurrentToolCallSource()?.kind === "code_mode";
+    const useFastPath = cacheEnabled && !isAutoMem && !nestedRead;
     const cache = this.config.getFileReadCache();
     const isFullRead = this.params.offset === void 0 && this.params.limit === void 0 && this.params.pages === void 0;
     let stats;
@@ -8289,6 +8318,7 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
         full: isFullRead && !result.isTruncated,
         cacheable
       });
+      if (nestedRead) cache.markReadEvictedFromHistory(recordStats);
     }
     let llmContent;
     if (result.isTruncated && result.linesShown && result.originalLineCount !== void 0) {

package/chunks/{chunk-GCDXVPFK.js → chunk-TW2RLZPC.js}

@@ -2,10 +2,13 @@
 "use strict";
 import {
   JsonFormatter
-} from "./chunk-BZM5U74J.js";
+} from "./chunk-I6JRN375.js";
 import {
   parseAndFormatApiError
-} from "./chunk-N7VWZDWW.js";
+} from "./chunk-DCRVSIK6.js";
+import {
+  stripAnsiAndControl
+} from "./chunk-4Y2I3CI3.js";
 import {
   FatalBudgetExceededError,
   FatalCancellationError,
@@ -14,7 +17,7 @@ import {
 } from "./chunk-ZAFYHRVY.js";
 import {
   runExitCleanup
-} from "./chunk-JYKWOREU.js";
+} from "./chunk-WMEX6CFP.js";
 import {
   writeStderrLine
 } from "./chunk-7FA2II6K.js";
@@ -121,17 +124,38 @@ async function handleError(error, config, customErrorCode) {
   }
 }
 __name(handleError, "handleError");
-function handleToolError(toolName, toolError, config, errorCode, resultDisplay) {
+var TOOL_NAME_ECHO_LIMIT = 64;
+var DENIAL_REASON_ECHO_LIMIT = 500;
+function sanitizeForStderr(text, limit) {
+  const clean = stripAnsiAndControl(text.replace(/\s+/g, " ")).replace(new RegExp("\\p{Cf}", "gu"), "").trim();
+  return clean.length > limit ? `${clean.slice(0, limit)}\u2026` : clean;
+}
+__name(sanitizeForStderr, "sanitizeForStderr");
+function handleToolError(toolName, toolError, config, errorCode, resultDisplay, options = {}) {
   const isExecutionDenied = errorCode === "execution_denied" /* EXECUTION_DENIED */;
   const isNonInteractive = !config.isInteractive();
   const isTextMode = config.getOutputFormat() === "text" /* TEXT */;
   if (isExecutionDenied && isNonInteractive && isTextMode) {
-    const warningMessage = `Warning: Tool "${toolName}" requires user approval but cannot execute in non-interactive mode.
+    const displayName = sanitizeForStderr(toolName, TOOL_NAME_ECHO_LIMIT);
+    if (options.approvalRequired) {
+      process.stderr.write(
+        `Warning: Tool "${displayName}" requires user approval but cannot execute in non-interactive mode.
 To enable automatic tool execution, use the -y flag (YOLO mode):
 Example: qwen -p 'your prompt' -y
 
-`;
-    process.stderr.write(warningMessage);
+`
+      );
+    } else {
+      const reason = sanitizeForStderr(
+        resultDisplay || toolError.message,
+        DENIAL_REASON_ECHO_LIMIT
+      );
+      process.stderr.write(
+        `Warning: Tool "${displayName}" was not run: ${reason || "the call was denied."}
+
+`
+      );
+    }
   }
   debugLogger.error(
     `Error executing tool ${toolName}: ${resultDisplay || toolError.message}`

package/chunks/chunk-U6H3XTFA.js

@@ -0,0 +1,95 @@
+// 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/code-mode/protocol.ts
+init_esbuild_shims();
+var CODE_MODE_MAX_CONTROL_FRAME_BYTES = 1048576;
+var CODE_MODE_MAX_FRAME_BYTES = 16 * 1024 * 1024;
+var CODE_MODE_MAX_MEDIA_BYTES = 10 * 1024 * 1024;
+var CODE_MODE_MAX_MEDIA_ITEMS = 16;
+var CODE_MODE_MAX_SOURCE_CHARS = 131072;
+var CODE_MODE_MAX_OUTPUT_CHARS = 1e5;
+var CODE_MODE_TIMEOUT_MS = 3e4;
+function hasBoundedImageContent(message) {
+  if (message.type !== "tool_result") return false;
+  const content = message.result?.content;
+  if (!Array.isArray(content) || content.length === 0 || content.length > CODE_MODE_MAX_MEDIA_ITEMS) {
+    return false;
+  }
+  let decodedBytes = 0;
+  for (const item of content) {
+    if (item?.type !== "image" || typeof item.mimeType !== "string" || !item.mimeType.toLowerCase().startsWith("image/") || typeof item.data !== "string" || item.data.length === 0) {
+      return false;
+    }
+    const padding = item.data.endsWith("==") ? 2 : item.data.endsWith("=") ? 1 : 0;
+    decodedBytes += Math.floor(item.data.length * 3 / 4) - padding;
+    if (decodedBytes > CODE_MODE_MAX_MEDIA_BYTES) return false;
+  }
+  return true;
+}
+__name(hasBoundedImageContent, "hasBoundedImageContent");
+function maxFrameBytes(message) {
+  if (message.type === "complete" || message.type === "error") {
+    return CODE_MODE_MAX_FRAME_BYTES;
+  }
+  if (hasBoundedImageContent(message)) return CODE_MODE_MAX_FRAME_BYTES;
+  return CODE_MODE_MAX_CONTROL_FRAME_BYTES;
+}
+__name(maxFrameBytes, "maxFrameBytes");
+function encodeFrame(message) {
+  const body = Buffer.from(JSON.stringify(message));
+  if (body.byteLength > maxFrameBytes(message)) {
+    throw new Error("Code mode protocol frame exceeds the size limit.");
+  }
+  const frame = Buffer.allocUnsafe(body.byteLength + 4);
+  frame.writeUInt32BE(body.byteLength, 0);
+  body.copy(frame, 4);
+  return frame;
+}
+__name(encodeFrame, "encodeFrame");
+var FrameDecoder = class {
+  static {
+    __name(this, "FrameDecoder");
+  }
+  buffer = Buffer.alloc(0);
+  push(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    const messages = [];
+    while (this.buffer.byteLength >= 4) {
+      const length = this.buffer.readUInt32BE(0);
+      if (length > CODE_MODE_MAX_FRAME_BYTES) {
+        throw new Error("Code mode protocol frame exceeds the size limit.");
+      }
+      if (this.buffer.byteLength < length + 4) break;
+      const body = this.buffer.subarray(4, length + 4);
+      this.buffer = this.buffer.subarray(length + 4);
+      const message = JSON.parse(body.toString("utf8"));
+      if (length > maxFrameBytes(message)) {
+        throw new Error("Code mode protocol frame exceeds the size limit.");
+      }
+      messages.push(message);
+    }
+    return messages;
+  }
+};
+
+export {
+  CODE_MODE_MAX_MEDIA_BYTES,
+  CODE_MODE_MAX_MEDIA_ITEMS,
+  CODE_MODE_MAX_SOURCE_CHARS,
+  CODE_MODE_MAX_OUTPUT_CHARS,
+  CODE_MODE_TIMEOUT_MS,
+  encodeFrame,
+  FrameDecoder
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */