@qwen-code/qwen-code 0.19.2 → 0.19.3-nightly.20260701.a974594d7

package/chunks/{chunk-WA5OJGFL.js → chunk-B5MPZI4K.js}

@@ -23,28 +23,28 @@ import {
 } from "./chunk-OMX7CUOE.js";
 import {
   isAnyAutoMemPath
-} from "./chunk-BNXANYLH.js";
+} from "./chunk-MOUXUCXQ.js";
 import {
   InstallationManager
-} from "./chunk-T2VDEFUU.js";
+} from "./chunk-BZHLWC6T.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-OIC6S73E.js";
+} from "./chunk-E5I6YSNO.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-TOEGRAVX.js";
+} from "./chunk-JV7A66DR.js";
 import {
   atomicWriteFile,
   atomicWriteFileSync
-} from "./chunk-3UALQ56H.js";
+} from "./chunk-T42ACHFI.js";
 import {
   convertSchema,
   runtimeDiagnostics,
   safeJsonParse
-} from "./chunk-CGEGHF2C.js";
+} from "./chunk-YPCPZSZB.js";
 import {
   require_lib
 } from "./chunk-IRJWHZWU.js";
@@ -70,7 +70,7 @@ import {
   setShellTracePropagation,
   shortenPath,
   unescapePath
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-AVQDCKNF.js";
 import {
   require_dist
 } from "./chunk-ZERZSAZL.js";
@@ -12747,7 +12747,7 @@ var require_service_config = __commonJS({
     exports.validateRetryThrottling = validateRetryThrottling;
     exports.validateServiceConfig = validateServiceConfig;
     exports.extractAndSelectServiceConfig = extractAndSelectServiceConfig;
-    var os5 = __require("os");
+    var os4 = __require("os");
     var constants_1 = require_constants2();
     var DURATION_REGEX = /^\d+(\.\d{1,9})?s$/;
     var CLIENT_LANGUAGE_STRING = "node";
@@ -13054,7 +13054,7 @@ var require_service_config = __commonJS({
         if (Array.isArray(validatedConfig.clientHostname)) {
           let hostnameMatched = false;
           for (const hostname2 of validatedConfig.clientHostname) {
-            if (hostname2 === os5.hostname()) {
+            if (hostname2 === os4.hostname()) {
               hostnameMatched = true;
             }
           }
@@ -24757,7 +24757,7 @@ var require_subchannel_call = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.Http2SubchannelCall = void 0;
     var http2 = __require("http2");
-    var os5 = __require("os");
+    var os4 = __require("os");
     var constants_1 = require_constants2();
     var metadata_1 = require_metadata();
     var stream_decoder_1 = require_stream_decoder();
@@ -24765,7 +24765,7 @@ var require_subchannel_call = __commonJS({
     var constants_2 = require_constants2();
     var TRACER_NAME = "subchannel_call";
     function getSystemErrorName(errno) {
-      for (const [name, num] of Object.entries(os5.constants.errno)) {
+      for (const [name, num] of Object.entries(os4.constants.errno)) {
         if (num === errno) {
           return name;
         }
@@ -44576,7 +44576,7 @@ var require_ProcessDetector = __commonJS({
     exports.processDetector = void 0;
     var api_1 = (init_esm(), __toCommonJS(esm_exports));
     var semconv_1 = require_semconv2();
-    var os5 = __require("os");
+    var os4 = __require("os");
     var ProcessDetector = class {
       static {
         __name(this, "ProcessDetector");
@@ -44599,7 +44599,7 @@ var require_ProcessDetector = __commonJS({
           attributes[semconv_1.ATTR_PROCESS_COMMAND] = process.argv[1];
         }
         try {
-          const userInfo = os5.userInfo();
+          const userInfo = os4.userInfo();
           attributes[semconv_1.ATTR_PROCESS_OWNER] = userInfo.username;
         } catch (e) {
           api_1.diag.debug(`error obtaining process owner: ${e}`);
@@ -50949,8 +50949,8 @@ var require_homedir = __commonJS({
   "node_modules/resolve/lib/homedir.js"(exports, module) {
     "use strict";
     init_esbuild_shims();
-    var os5 = __require("os");
-    module.exports = os5.homedir || /* @__PURE__ */ __name(function homedir3() {
+    var os4 = __require("os");
+    module.exports = os4.homedir || /* @__PURE__ */ __name(function homedir3() {
       var home = process.env.HOME;
       var user = process.env.LOGNAME || process.env.USER || process.env.LNAME || process.env.USERNAME;
       if (process.platform === "win32") {
@@ -57009,7 +57009,6 @@ var require_src31 = __commonJS({
 
 // packages/core/src/tools/read-file.ts
 init_esbuild_shims();
-import os4 from "node:os";
 import path10 from "node:path";
 import fs8 from "node:fs/promises";
 
@@ -58997,7 +58996,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
             stats
           };
         } catch (e) {
-          const msg = e instanceof Error ? e.message : String(e);
+          const msg = getErrorMessage(e);
           return {
             llmContent: `Error parsing notebook ${relativePathForDisplay}: ${msg}`,
             returnDisplay: `Error reading notebook: ${relativePathForDisplay}`,
@@ -59016,7 +59015,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       }
     }
   } catch (error) {
-    const errorMessage2 = error instanceof Error ? error.message : String(error);
+    const errorMessage2 = getErrorMessage(error);
     const displayPath = path2.relative(rootDirectory, filePath).replace(/\\/g, "/");
     return {
       llmContent: `Error reading file ${displayPath}: ${errorMessage2}`,
@@ -59073,6 +59072,13 @@ var EVENT_SUBAGENT_EXECUTION = "qwen-code.subagent_execution";
 var EVENT_SKILL_LAUNCH = "qwen-code.skill_launch";
 var EVENT_AUTH = "qwen-code.auth";
 var EVENT_USER_FEEDBACK = "qwen-code.user_feedback";
+var EVENT_TOOL_OUTPUT_TRUNCATED = "qwen-code.tool_output_truncated";
+var DEFAULT_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH = 1024 * 1024;
+var SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH_LIMIT = 100 * 1024 * 1024;
+function isValidSensitiveSpanAttributeMaxLength(value) {
+  return Number.isSafeInteger(value) && value >= 1 && value <= SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH_LIMIT;
+}
+__name(isValidSensitiveSpanAttributeMaxLength, "isValidSensitiveSpanAttributeMaxLength");
 var EVENT_PROMPT_SUGGESTION = "qwen-code.prompt_suggestion";
 var EVENT_SPECULATION = "qwen-code.speculation";
 var EVENT_WORKFLOW_KEYWORD = "qwen-code.workflow_keyword";
@@ -60999,13 +61005,16 @@ var UserPromptEvent = class {
   prompt_id;
   auth_type;
   prompt;
-  constructor(prompt_length, prompt_Id, auth_type, prompt) {
+  /** Model that actually processed the prompt (e.g. an inline override). */
+  model;
+  constructor(prompt_length, prompt_Id, auth_type, prompt, model) {
     this["event.name"] = "user_prompt";
     this["event.timestamp"] = (/* @__PURE__ */ new Date()).toISOString();
     this.prompt_length = prompt_length;
     this.prompt_id = prompt_Id;
     this.auth_type = auth_type;
     this.prompt = prompt;
+    this.model = model;
   }
 };
 var UserRetryEvent = class {
@@ -61149,12 +61158,18 @@ var ApiCancelEvent = class {
   model;
   prompt_id;
   auth_type;
-  constructor(model, prompt_id, auth_type) {
+  // Pending self-paced /loop wakeups dropped by this abort, when any. Lets a
+  // user abort that ends a loop be told apart from an ordinary cancellation.
+  // Named for wakeups (not "loops") to avoid colliding with loop_type, the
+  // unrelated repetition-detection vocabulary in this file.
+  loop_wakeups_cancelled;
+  constructor(model, prompt_id, auth_type, loop_wakeups_cancelled) {
     this["event.name"] = "api_cancel";
     this["event.timestamp"] = (/* @__PURE__ */ new Date()).toISOString();
     this.model = model;
     this.prompt_id = prompt_id;
     this.auth_type = auth_type;
+    this.loop_wakeups_cancelled = loop_wakeups_cancelled;
   }
 };
 var ApiResponseEvent = class {
@@ -61235,9 +61250,11 @@ var LoopType = /* @__PURE__ */ ((LoopType2) => {
   LoopType2["REPETITIVE_THOUGHTS"] = "repetitive_thoughts";
   LoopType2["READ_FILE_LOOP"] = "read_file_loop";
   LoopType2["ACTION_STAGNATION"] = "action_stagnation";
+  LoopType2["SHELL_COMMAND_STAGNATION"] = "shell_command_stagnation";
   LoopType2["GLOBAL_TOOL_CALL_DUPLICATE"] = "global_tool_call_duplicate";
   LoopType2["ALTERNATING_TOOL_CALL_PATTERN"] = "alternating_tool_call_pattern";
   LoopType2["TURN_TOOL_CALL_CAP"] = "turn_tool_call_cap";
+  LoopType2["INVALID_TOOL_PARAMS_STAGNATION"] = "invalid_tool_params_stagnation";
   return LoopType2;
 })(LoopType || {});
 var LoopDetectedEvent = class {
@@ -62696,22 +62713,21 @@ function convertOpenAITextToParts(text, requestContext, final = true) {
   return parseTaggedThinkingText(text);
 }
 __name(convertOpenAITextToParts, "convertOpenAITextToParts");
+function hasThoughtPart(parts) {
+  return parts.some((part) => part.thought === true);
+}
+__name(hasThoughtPart, "hasThoughtPart");
 function convertOpenAIResponseToGemini(openaiResponse, requestContext) {
   const choice = openaiResponse.choices?.[0];
   const response = new GenerateContentResponse();
   if (choice) {
     const parts = [];
-    if (!requestContext.responseParsingOptions?.taggedThinkingTags) {
-      const reasoningText = choice.message.reasoning_content ?? choice.message.reasoning;
-      if (reasoningText) {
-        parts.push({ text: reasoningText, thought: true });
-      }
-    }
-    if (choice.message.content) {
-      parts.push(
-        ...convertOpenAITextToParts(choice.message.content, requestContext)
-      );
+    const textParts = choice.message.content ? convertOpenAITextToParts(choice.message.content, requestContext) : [];
+    const reasoningText = choice.message.reasoning_content ?? choice.message.reasoning;
+    if (reasoningText && !hasThoughtPart(textParts)) {
+      parts.push({ text: reasoningText, thought: true });
     }
+    parts.push(...textParts);
     if (choice.message.tool_calls) {
       for (const toolCall of choice.message.tool_calls) {
         if (toolCall.function) {
@@ -62785,22 +62801,8 @@ function convertOpenAIChunkToGemini(chunk, requestContext) {
   }
   if (choice) {
     const parts = [];
-    if (!requestContext.responseParsingOptions?.taggedThinkingTags) {
-      const reasoningText = choice.delta?.reasoning_content ?? choice.delta?.reasoning;
-      if (reasoningText) {
-        const normalizedReasoningText = normalizeStreamingTextDelta(
-          reasoningText,
-          requestContext.reasoningDeltaState ??= {
-            emittedText: "",
-            emittedLength: 0,
-            cumulativeMode: false
-          }
-        );
-        if (normalizedReasoningText) {
-          parts.push({ text: normalizedReasoningText, thought: true });
-        }
-      }
-    }
+    let contentParts = [];
+    const reasoningText = choice.delta?.reasoning_content ?? choice.delta?.reasoning;
     if (typeof choice.delta?.content === "string") {
       const normalizedContent = normalizeStreamingTextDelta(
         choice.delta.content,
@@ -62811,17 +62813,72 @@ function convertOpenAIChunkToGemini(chunk, requestContext) {
         }
       );
       if (normalizedContent || choice.finish_reason) {
-        parts.push(
-          ...convertOpenAITextToParts(
-            normalizedContent,
-            requestContext,
-            Boolean(choice.finish_reason)
-          )
+        contentParts = convertOpenAITextToParts(
+          normalizedContent,
+          requestContext,
+          Boolean(choice.finish_reason)
         );
       }
     } else if (choice.finish_reason) {
-      parts.push(...convertOpenAITextToParts("", requestContext, true));
+      contentParts = convertOpenAITextToParts("", requestContext, true);
+    }
+    if (hasThoughtPart(contentParts)) {
+      requestContext.hasTaggedThinkingThought = true;
+      requestContext.pendingReasoningText = void 0;
+      debugLogger6.debug(
+        "convertOpenAIChunkToGemini: tagged thinking content emitted a thought; dropping buffered reasoning"
+      );
+      if (requestContext.pendingContentParts?.length) {
+        debugLogger6.debug(
+          `convertOpenAIChunkToGemini: flushing ${requestContext.pendingContentParts.length} buffered content part(s) before tagged content`
+        );
+        parts.push(...requestContext.pendingContentParts);
+        requestContext.pendingContentParts = void 0;
+      }
     }
+    if (reasoningText && (!requestContext.responseParsingOptions?.taggedThinkingTags || !requestContext.hasTaggedThinkingThought)) {
+      const normalizedReasoningText = normalizeStreamingTextDelta(
+        reasoningText,
+        requestContext.reasoningDeltaState ??= {
+          emittedText: "",
+          emittedLength: 0,
+          cumulativeMode: false
+        }
+      );
+      if (normalizedReasoningText && !requestContext.responseParsingOptions?.taggedThinkingTags) {
+        parts.push({ text: normalizedReasoningText, thought: true });
+      } else if (normalizedReasoningText && !requestContext.hasTaggedThinkingThought) {
+        requestContext.pendingReasoningText = (requestContext.pendingReasoningText ?? "") + normalizedReasoningText;
+        debugLogger6.debug(
+          `convertOpenAIChunkToGemini: buffered reasoning text (${requestContext.pendingReasoningText.length} chars) for tagged stream`
+        );
+      }
+    }
+    if (requestContext.responseParsingOptions?.taggedThinkingTags && !requestContext.hasTaggedThinkingThought && requestContext.pendingReasoningText && contentParts.length) {
+      requestContext.pendingContentParts = [
+        ...requestContext.pendingContentParts ?? [],
+        ...contentParts
+      ];
+      debugLogger6.debug(
+        `convertOpenAIChunkToGemini: buffered ${contentParts.length} content part(s) behind pending reasoning`
+      );
+      contentParts = [];
+    }
+    if (choice.finish_reason && requestContext.responseParsingOptions?.taggedThinkingTags && !requestContext.hasTaggedThinkingThought && requestContext.pendingReasoningText) {
+      debugLogger6.debug(
+        "convertOpenAIChunkToGemini: flushing buffered reasoning for tagged stream with no tagged thought"
+      );
+      parts.push({ text: requestContext.pendingReasoningText, thought: true });
+      requestContext.pendingReasoningText = void 0;
+    }
+    if (choice.finish_reason && requestContext.pendingContentParts?.length) {
+      debugLogger6.debug(
+        `convertOpenAIChunkToGemini: flushing ${requestContext.pendingContentParts.length} buffered content part(s) on stream finish`
+      );
+      parts.push(...requestContext.pendingContentParts);
+      requestContext.pendingContentParts = void 0;
+    }
+    parts.push(...contentParts);
     if (choice.delta?.tool_calls) {
       for (const toolCall of choice.delta.tool_calls) {
         const index = toolCall.index ?? 0;
@@ -63103,6 +63160,12 @@ function mergeConsecutiveAssistantMessages(messages) {
         if (combinedToolCalls.length > 0) {
           lastMessage.tool_calls = combinedToolCalls;
         }
+        const lastReasoning = lastMessage.reasoning_content;
+        const currentReasoning = message.reasoning_content;
+        const combinedReasoning = [lastReasoning, currentReasoning].filter(Boolean).join("");
+        if (combinedReasoning) {
+          lastMessage.reasoning_content = combinedReasoning;
+        }
         continue;
       }
     }
@@ -63504,23 +63567,71 @@ import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
 // packages/core/src/telemetry/detailed-span-attributes.ts
 init_esbuild_shims();
 import { createHash as createHash2 } from "node:crypto";
-var MAX_CONTENT_SIZE = 60 * 1024;
 var SYSTEM_PROMPT_PREVIEW_LENGTH = 500;
+var SHORT_TRUNCATION_SUFFIX = "...[TRUNCATED]";
 var seenHashes = /* @__PURE__ */ new Set();
-function isEnabled(config) {
+function areSensitiveSpanAttributesEnabled(config) {
   return isTelemetrySdkInitialized() && config.getTelemetryIncludeSensitiveSpanAttributes();
 }
-__name(isEnabled, "isEnabled");
-function truncateContent(content, maxSize = MAX_CONTENT_SIZE) {
-  if (content.length <= maxSize) {
+__name(areSensitiveSpanAttributesEnabled, "areSensitiveSpanAttributesEnabled");
+function truncateContent(content, maxSize = DEFAULT_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH, originalLength = content.length) {
+  if (!Number.isSafeInteger(maxSize) || maxSize < 1) {
+    throw new TypeError(
+      `maxSize must be a positive safe integer, got ${String(maxSize)}`
+    );
+  }
+  if (!Number.isSafeInteger(originalLength) || originalLength < 0) {
+    throw new TypeError(
+      `originalLength must be a non-negative safe integer, got ${String(
+        originalLength
+      )}`
+    );
+  }
+  if (originalLength < content.length) {
+    throw new TypeError(
+      `originalLength must be greater than or equal to content length, got ${originalLength} for content length ${content.length}`
+    );
+  }
+  if (originalLength <= maxSize && content.length <= maxSize) {
     return { content, truncated: false };
   }
+  if (originalLength > content.length && content.length <= maxSize) {
+    return { content, truncated: true };
+  }
+  const suffix = `
+
+[TRUNCATED - Content exceeds configured limit of ${maxSize} characters]`;
+  if (suffix.length >= maxSize) {
+    if (SHORT_TRUNCATION_SUFFIX.length >= maxSize) {
+      return {
+        content: SHORT_TRUNCATION_SUFFIX.slice(0, maxSize),
+        truncated: true
+      };
+    }
+    return {
+      content: content.slice(0, maxSize - SHORT_TRUNCATION_SUFFIX.length) + SHORT_TRUNCATION_SUFFIX,
+      truncated: true
+    };
+  }
   return {
-    content: content.slice(0, maxSize) + "\n\n[TRUNCATED - Content exceeds 60KB limit]",
+    content: content.slice(0, maxSize - suffix.length) + suffix,
     truncated: true
   };
 }
 __name(truncateContent, "truncateContent");
+function getMaxContentSize(config) {
+  return config.getTelemetrySensitiveSpanAttributeMaxLength();
+}
+__name(getMaxContentSize, "getMaxContentSize");
+function truncatePrefixedContent(prefix, content, maxSize) {
+  const prefixedContent = `${prefix}${content}`;
+  const result = truncateContent(prefixedContent, maxSize);
+  return {
+    ...result,
+    originalLength: content.length
+  };
+}
+__name(truncatePrefixedContent, "truncatePrefixedContent");
 function shortHash(content) {
   return createHash2("sha256").update(content).digest("hex").slice(0, 12);
 }
@@ -63531,20 +63642,24 @@ function stringifyContentUnion(value) {
 }
 __name(stringifyContentUnion, "stringifyContentUnion");
 function addUserPromptAttributes(config, span, promptText) {
-  if (!isEnabled(config) || !promptText) return;
-  const { content, truncated } = truncateContent(promptText);
+  if (!areSensitiveSpanAttributesEnabled(config) || !promptText) return;
+  const { content, truncated, originalLength } = truncatePrefixedContent(
+    `[USER PROMPT]
+`,
+    promptText,
+    getMaxContentSize(config)
+  );
   span.setAttributes({
-    new_context: `[USER PROMPT]
-${content}`,
+    new_context: content,
     ...truncated && {
       new_context_truncated: true,
-      new_context_original_length: promptText.length
+      new_context_original_length: originalLength
     }
   });
 }
 __name(addUserPromptAttributes, "addUserPromptAttributes");
 function addSystemPromptAttributes(config, span, systemInstruction) {
-  if (!isEnabled(config) || !systemInstruction) return;
+  if (!areSensitiveSpanAttributesEnabled(config) || !systemInstruction) return;
   const text = stringifyContentUnion(systemInstruction);
   if (!text) return;
   const hash = `sp_${shortHash(text)}`;
@@ -63555,7 +63670,10 @@ function addSystemPromptAttributes(config, span, systemInstruction) {
   });
   if (!seenHashes.has(hash)) {
     seenHashes.add(hash);
-    const { content, truncated } = truncateContent(text);
+    const { content, truncated } = truncateContent(
+      text,
+      getMaxContentSize(config)
+    );
     span.setAttribute("system_prompt", content);
     if (truncated) {
       span.setAttribute("system_prompt_truncated", true);
@@ -63564,7 +63682,7 @@ function addSystemPromptAttributes(config, span, systemInstruction) {
 }
 __name(addSystemPromptAttributes, "addSystemPromptAttributes");
 function addToolSchemaAttributes(config, span, tools) {
-  if (!isEnabled(config) || !tools?.length) return;
+  if (!areSensitiveSpanAttributesEnabled(config) || !tools?.length) return;
   const declarations = [];
   for (const tool of tools) {
     const inner = tool["functionDeclarations"];
@@ -63584,12 +63702,18 @@ function addToolSchemaAttributes(config, span, tools) {
     const hashKey = `tool_${hash}`;
     if (!seenHashes.has(hashKey)) {
       seenHashes.add(hashKey);
-      const { content, truncated } = truncateContent(declJson);
+      const { content, truncated } = truncateContent(
+        declJson,
+        getMaxContentSize(config)
+      );
       span.addEvent("tool_schema", {
         tool_name: name,
         tool_hash: hash,
         tool_definition: content,
-        ...truncated && { tool_definition_truncated: true }
+        ...truncated && {
+          tool_definition_truncated: true,
+          tool_definition_original_length: declJson.length
+        }
       });
     }
   }
@@ -63599,40 +63723,53 @@ function addToolSchemaAttributes(config, span, tools) {
   });
 }
 __name(addToolSchemaAttributes, "addToolSchemaAttributes");
-function addModelOutputAttributes(config, span, responseText) {
-  if (!isEnabled(config) || !responseText) return;
-  const { content, truncated } = truncateContent(responseText);
+function addModelOutputAttributes(config, span, responseText, originalLength) {
+  if (!areSensitiveSpanAttributesEnabled(config) || !responseText) return;
+  const responseTextOriginalLength = originalLength ?? responseText.length;
+  const { content, truncated } = truncateContent(
+    responseText,
+    getMaxContentSize(config),
+    responseTextOriginalLength
+  );
   span.setAttributes({
     "response.model_output": content,
     ...truncated && {
       "response.model_output_truncated": true,
-      "response.model_output_original_length": responseText.length
+      "response.model_output_original_length": responseTextOriginalLength
     }
   });
 }
 __name(addModelOutputAttributes, "addModelOutputAttributes");
 function addToolInputAttributes(config, span, toolName, toolInput) {
-  if (!isEnabled(config)) return;
-  const { content, truncated } = truncateContent(toolInput);
+  if (!areSensitiveSpanAttributesEnabled(config)) return;
+  const { content, truncated, originalLength } = truncatePrefixedContent(
+    `[TOOL INPUT: ${toolName}]
+`,
+    toolInput,
+    getMaxContentSize(config)
+  );
   span.setAttributes({
-    tool_input: `[TOOL INPUT: ${toolName}]
-${content}`,
+    tool_input: content,
     ...truncated && {
       tool_input_truncated: true,
-      tool_input_original_length: toolInput.length
+      tool_input_original_length: originalLength
     }
   });
 }
 __name(addToolInputAttributes, "addToolInputAttributes");
 function addToolResultAttributes(config, span, toolName, toolResult) {
-  if (!isEnabled(config)) return;
-  const { content, truncated } = truncateContent(toolResult);
+  if (!areSensitiveSpanAttributesEnabled(config)) return;
+  const { content, truncated, originalLength } = truncatePrefixedContent(
+    `[TOOL RESULT: ${toolName}]
+`,
+    toolResult,
+    getMaxContentSize(config)
+  );
   span.setAttributes({
-    tool_result: `[TOOL RESULT: ${toolName}]
-${content}`,
+    tool_result: content,
     ...truncated && {
       tool_result_truncated: true,
-      tool_result_original_length: toolResult.length
+      tool_result_original_length: originalLength
     }
   });
 }
@@ -64017,6 +64154,34 @@ function endLLMRequestSpan(span, metadata) {
       }
     }
     spanCtx.span.setAttributes(endAttributes);
+    try {
+      if (metadata?.config && metadata.success) {
+        const model = String(spanCtx.attributes["qwen-code.model"] ?? "");
+        if (metadata.requestSetupMs !== void 0) {
+          recordApiRequestBreakdown(metadata.config, metadata.requestSetupMs, {
+            model,
+            phase: "request_preparation" /* REQUEST_PREPARATION */
+          });
+        }
+        if (metadata.ttftMs !== void 0) {
+          recordApiRequestBreakdown(metadata.config, metadata.ttftMs, {
+            model,
+            phase: "network_latency" /* NETWORK_LATENCY */
+          });
+        }
+        const breakdownSamplingMs = metadata.ttftMs !== void 0 ? Math.max(0, duration - metadata.ttftMs) : void 0;
+        if (breakdownSamplingMs !== void 0 && breakdownSamplingMs > 0) {
+          recordApiRequestBreakdown(metadata.config, breakdownSamplingMs, {
+            model,
+            phase: "response_processing" /* RESPONSE_PROCESSING */
+          });
+        }
+      }
+    } catch (error) {
+      debugLogger8.warn(
+        `Failed to record API request breakdown histogram: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
     if (metadata === void 0 || metadata.success) {
       spanCtx.span.setStatus({ code: SpanStatusCode.OK });
     } else {
@@ -65416,6 +65581,30 @@ function parseTelemetryTargetValue(value) {
   return void 0;
 }
 __name(parseTelemetryTargetValue, "parseTelemetryTargetValue");
+function parseSensitiveSpanAttributeMaxLengthEnvValue(envName, value) {
+  if (value === void 0) return void 0;
+  const trimmed = value.trim();
+  const parsed = Number(trimmed);
+  if (!/^\d+$/.test(trimmed) || !isValidSensitiveSpanAttributeMaxLength(parsed)) {
+    throw new FatalConfigError(
+      `Invalid ${envName}: must be a positive integer no greater than ${SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH_LIMIT}, got '${value}'`
+    );
+  }
+  return parsed;
+}
+__name(parseSensitiveSpanAttributeMaxLengthEnvValue, "parseSensitiveSpanAttributeMaxLengthEnvValue");
+function parseSensitiveSpanAttributeMaxLengthSetting(settingName, value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "number" || !isValidSensitiveSpanAttributeMaxLength(value)) {
+    throw new FatalConfigError(
+      `Invalid ${settingName}: must be a positive integer no greater than ${SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH_LIMIT}, got ${String(
+        value
+      )}`
+    );
+  }
+  return value;
+}
+__name(parseSensitiveSpanAttributeMaxLengthSetting, "parseSensitiveSpanAttributeMaxLengthSetting");
 async function resolveTelemetrySettings(options) {
   const argv = options.argv ?? {};
   const env = options.env ?? {};
@@ -65446,6 +65635,13 @@ async function resolveTelemetrySettings(options) {
   const includeSensitiveSpanAttributes = parseBooleanEnvFlag(
     env["QWEN_TELEMETRY_INCLUDE_SENSITIVE_SPAN_ATTRIBUTES"]
   ) ?? settings.includeSensitiveSpanAttributes ?? false;
+  const sensitiveSpanAttributeMaxLength = parseSensitiveSpanAttributeMaxLengthEnvValue(
+    "QWEN_TELEMETRY_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH",
+    env["QWEN_TELEMETRY_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH"]
+  ) ?? parseSensitiveSpanAttributeMaxLengthSetting(
+    "telemetry.sensitiveSpanAttributeMaxLength",
+    settings.sensitiveSpanAttributeMaxLength
+  ) ?? DEFAULT_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH;
   const outfile = argv.telemetryOutfile ?? env["QWEN_TELEMETRY_OUTFILE"] ?? settings.outfile;
   const otlpTracesEndpoint = env["QWEN_TELEMETRY_OTLP_TRACES_ENDPOINT"] ?? env["OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"] ?? settings.otlpTracesEndpoint;
   const otlpLogsEndpoint = env["QWEN_TELEMETRY_OTLP_LOGS_ENDPOINT"] ?? env["OTEL_EXPORTER_OTLP_LOGS_ENDPOINT"] ?? settings.otlpLogsEndpoint;
@@ -65487,6 +65683,7 @@ async function resolveTelemetrySettings(options) {
     otlpMetricsEndpoint,
     logPrompts,
     includeSensitiveSpanAttributes,
+    sensitiveSpanAttributeMaxLength,
     outfile,
     resourceAttributes,
     metrics: { includeSessionId: metricsIncludeSessionId },
@@ -65520,6 +65717,12 @@ var createInitialModelMetrics = /* @__PURE__ */ __name(() => ({
   ...createInitialModelMetricsCore(),
   bySource: /* @__PURE__ */ Object.create(null)
 }), "createInitialModelMetrics");
+var createInitialSkillMetrics = /* @__PURE__ */ __name(() => ({
+  totalCalls: 0,
+  totalSuccess: 0,
+  totalFail: 0,
+  byName: {}
+}), "createInitialSkillMetrics");
 var createInitialMetrics = /* @__PURE__ */ __name(() => ({
   models: {},
   tools: {
@@ -65538,7 +65741,8 @@ var createInitialMetrics = /* @__PURE__ */ __name(() => ({
   files: {
     totalLinesAdded: 0,
     totalLinesRemoved: 0
-  }
+  },
+  skills: createInitialSkillMetrics()
 }), "createInitialMetrics");
 var UiTelemetryService = class _UiTelemetryService extends EventEmitter {
   static {
@@ -65570,6 +65774,23 @@ var UiTelemetryService = class _UiTelemetryService extends EventEmitter {
   getMetricsForSession(sessionId) {
     return this.#sessionMetrics.get(sessionId) ?? createInitialMetrics();
   }
+  recordSkillInvocation(skillName, success, sessionId) {
+    this.#accumulateSkillInvocation(this.#metrics, skillName, success);
+    if (sessionId && !this.#closedSessions.has(sessionId)) {
+      if (!this.#sessionMetrics.has(sessionId)) {
+        this.#sessionMetrics.set(sessionId, createInitialMetrics());
+      }
+      this.#accumulateSkillInvocation(
+        this.#sessionMetrics.get(sessionId),
+        skillName,
+        success
+      );
+    }
+    this.emit("update", {
+      metrics: this.#metrics,
+      lastPromptTokenCount: this.#lastPromptTokenCount
+    });
+  }
   getLastPromptTokenCount() {
     return this.#lastPromptTokenCount;
   }
@@ -65703,6 +65924,38 @@ var UiTelemetryService = class _UiTelemetryService extends EventEmitter {
       }
     }
   }
+  #accumulateSkillInvocation(metrics2, skillName, success) {
+    const skills = metrics2.skills ?? createInitialSkillMetrics();
+    metrics2.skills = skills;
+    skills.totalCalls++;
+    if (success) {
+      skills.totalSuccess++;
+    } else {
+      skills.totalFail++;
+    }
+    if (!Object.prototype.hasOwnProperty.call(skills.byName, skillName)) {
+      Object.defineProperty(skills.byName, skillName, {
+        value: {
+          count: 0,
+          success: 0,
+          fail: 0
+        },
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+    const skillStats = skills.byName[skillName];
+    if (!skillStats) {
+      return;
+    }
+    skillStats.count++;
+    if (success) {
+      skillStats.success++;
+    } else {
+      skillStats.fail++;
+    }
+  }
   #getOrCreateModelMetrics(metrics2, modelName) {
     if (!metrics2.models[modelName]) {
       metrics2.models[modelName] = createInitialModelMetrics();
@@ -66220,7 +66473,6 @@ __name(snapshotRetryMetadata, "snapshotRetryMetadata");
 var debugLogger10 = createDebugLogger("LOGGING_CONTENT_GENERATOR");
 var MAX_RESPONSE_TEXT_LENGTH = 4096;
 var RESPONSE_TEXT_TRUNCATION_SUFFIX = "...[truncated]";
-var MAX_RESPONSE_TEXT_PREFIX_LENGTH = MAX_RESPONSE_TEXT_LENGTH - RESPONSE_TEXT_TRUNCATION_SUFFIX.length;
 var LoggingContentGenerator = class {
   constructor(wrapped, config, generatorConfig) {
     this.wrapped = wrapped;
@@ -66357,9 +66609,14 @@ var LoggingContentGenerator = class {
           () => this.wrapped.generateContent(req, userPromptId)
         );
         const durationMs = Date.now() - startTime;
-        const responseText = isInternal ? void 0 : this.extractResponseText(result);
-        if (!isInternal) {
-          addModelOutputAttributes(this.config, llmSpan, responseText);
+        const shouldCollectSensitiveSpanAttributes = !isInternal && this.shouldCollectSensitiveSpanAttributes();
+        const modelOutput = shouldCollectSensitiveSpanAttributes ? this.extractResponseTextForSensitiveSpan(
+          result,
+          this.config.getTelemetrySensitiveSpanAttributeMaxLength()
+        ) : void 0;
+        const responseText = isInternal ? void 0 : this.extractResponseText(result, MAX_RESPONSE_TEXT_LENGTH);
+        if (shouldCollectSensitiveSpanAttributes) {
+          this.safelyAddModelOutputAttributes(llmSpan, modelOutput);
         }
         this.safelyLogApiResponse(
           result.responseId ?? "",
@@ -66391,7 +66648,8 @@ var LoggingContentGenerator = class {
         finishReason: response.candidates?.[0]?.finishReason || void 0,
         thoughtsTokenCount: response.usageMetadata?.thoughtsTokenCount,
         subagentName: subagentNameContext.getStore() || void 0,
-        ...retrySnapshot
+        ...retrySnapshot,
+        config: this.config
       });
       return response;
     } catch (error) {
@@ -66404,7 +66662,8 @@ var LoggingContentGenerator = class {
         errorType: getErrorType(error),
         errorStatusCode: getErrorStatus(error),
         subagentName: subagentNameContext.getStore() || void 0,
-        ...retrySnapshot
+        ...retrySnapshot,
+        config: this.config
       });
       await context.with(spanContext, async () => {
         this.safelyLogApiError("", durationMs, error, req.model, userPromptId);
@@ -66477,7 +66736,8 @@ var LoggingContentGenerator = class {
         errorType: getErrorType(error),
         errorStatusCode: getErrorStatus(error),
         subagentName: subagentNameContext.getStore() || void 0,
-        ...retrySnapshot
+        ...retrySnapshot,
+        config: this.config
       });
       try {
         await this.safelyLogOpenAIInteraction(
@@ -66554,7 +66814,8 @@ var LoggingContentGenerator = class {
           error: "Stream span timed out (idle)",
           responseId: firstResponseId || void 0,
           subagentName: subagentName || void 0,
-          ...retrySnapshot
+          ...retrySnapshot,
+          config: this.config
         });
         spanEndedByTimeout = true;
       }, STREAM_IDLE_TIMEOUT_MS);
@@ -66591,7 +66852,15 @@ var LoggingContentGenerator = class {
       }
       const durationMs = Date.now() - startTime;
       const consolidatedResponse = shouldCollectResponses ? this.consolidateGeminiResponsesForLogging(responses) : void 0;
-      const streamResponseText = isInternal ? void 0 : this.extractResponseText(consolidatedResponse);
+      const shouldCollectSensitiveSpanAttributes = !isInternal && span !== void 0 && this.shouldCollectSensitiveSpanAttributes();
+      const streamModelOutput = shouldCollectSensitiveSpanAttributes ? this.extractResponseTextForSensitiveSpan(
+        consolidatedResponse,
+        this.config.getTelemetrySensitiveSpanAttributeMaxLength()
+      ) : void 0;
+      const streamResponseText = isInternal ? void 0 : this.extractResponseText(
+        consolidatedResponse,
+        MAX_RESPONSE_TEXT_LENGTH
+      );
       if (!spanEndedByTimeout) {
         runInSpan(
           () => this.safelyLogApiResponse(
@@ -66603,8 +66872,8 @@ var LoggingContentGenerator = class {
             streamResponseText
           )
         );
-        if (!isInternal && span) {
-          addModelOutputAttributes(this.config, span, streamResponseText);
+        if (shouldCollectSensitiveSpanAttributes && span) {
+          this.safelyAddModelOutputAttributes(span, streamModelOutput);
         }
         await runInSpan(
           () => this.safelyLogOpenAIInteraction(
@@ -66659,7 +66928,8 @@ var LoggingContentGenerator = class {
           subagentName: subagentName || void 0,
           errorType: lastError ? getErrorType(lastError) : void 0,
           errorStatusCode: lastError ? getErrorStatus(lastError) : void 0,
-          ...retrySnapshot
+          ...retrySnapshot,
+          config: this.config
         });
       }
     }
@@ -66812,40 +67082,84 @@ var LoggingContentGenerator = class {
     ];
     return consolidated;
   }
-  extractResponseText(response) {
-    const parts = response?.candidates?.[0]?.content?.parts;
-    if (!parts?.length) {
-      return void 0;
-    }
+  extractResponseText(response, maxLength) {
     let text = "";
-    let hasText = false;
     let truncated = false;
-    const appendText = /* @__PURE__ */ __name((partText) => {
-      hasText = true;
+    const maxPrefixLength = Math.max(
+      0,
+      maxLength - RESPONSE_TEXT_TRUNCATION_SUFFIX.length
+    );
+    const hasText = this.forEachVisibleResponseText(response, (partText) => {
       if (truncated) {
         return;
       }
-      const remaining = MAX_RESPONSE_TEXT_PREFIX_LENGTH - text.length;
+      const remaining = maxPrefixLength - text.length;
       if (partText.length <= remaining) {
         text += partText;
         return;
       }
       text += partText.slice(0, Math.max(0, remaining));
       truncated = true;
-    }, "appendText");
+    });
+    if (!hasText) {
+      return void 0;
+    }
+    return truncated ? `${text}${RESPONSE_TEXT_TRUNCATION_SUFFIX}` : text;
+  }
+  extractResponseTextForSensitiveSpan(response, maxLength) {
+    let text = "";
+    let originalLength = 0;
+    const hasText = this.forEachVisibleResponseText(response, (partText) => {
+      originalLength += partText.length;
+      const remaining = maxLength - text.length;
+      if (remaining > 0) {
+        text += partText.slice(0, remaining);
+      }
+    });
+    if (!hasText) {
+      return void 0;
+    }
+    return { text, originalLength };
+  }
+  forEachVisibleResponseText(response, onText) {
+    const parts = response?.candidates?.[0]?.content?.parts;
+    if (!parts?.length) {
+      return false;
+    }
+    let hasText = false;
     for (const part of parts) {
-      if (typeof part === "string") {
-        appendText(part);
+      const text = this.getVisibleResponsePartText(part);
+      if (text === void 0) {
         continue;
       }
-      if ("text" in part && typeof part.text === "string" && !("thought" in part && part.thought)) {
-        appendText(part.text);
-      }
+      hasText = true;
+      onText(text);
     }
-    if (!hasText) {
-      return void 0;
+    return hasText;
+  }
+  getVisibleResponsePartText(part) {
+    if (typeof part === "string") {
+      return part;
     }
-    return truncated ? `${text}${RESPONSE_TEXT_TRUNCATION_SUFFIX}` : text;
+    if ("text" in part && typeof part.text === "string" && !("thought" in part && part.thought)) {
+      return part.text;
+    }
+    return void 0;
+  }
+  safelyAddModelOutputAttributes(span, modelOutput) {
+    try {
+      addModelOutputAttributes(
+        this.config,
+        span,
+        modelOutput?.text,
+        modelOutput?.originalLength
+      );
+    } catch (error) {
+      debugLogger10.warn("Failed to add model output span attributes:", error);
+    }
+  }
+  shouldCollectSensitiveSpanAttributes() {
+    return areSensitiveSpanAttributesEnabled(this.config);
   }
   async countTokens(req) {
     return this.wrapped.countTokens(req);
@@ -67227,11 +67541,11 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   let baseGenerator;
   try {
     if (authType === "openai" /* USE_OPENAI */) {
-      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-F74IPQ6E.js");
+      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-ORZZ7VFO.js");
       baseGenerator = createOpenAIContentGenerator(generatorConfig, config);
     } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
-      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-K4AASPCV.js");
-      const { QwenContentGenerator } = await import("./qwenContentGenerator-ATTK5P4D.js");
+      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-OI2B7PES.js");
+      const { QwenContentGenerator } = await import("./qwenContentGenerator-H643PL2G.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
@@ -67249,10 +67563,10 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
         throw new Error(error instanceof Error ? error.message : String(error));
       }
     } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
-      const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-E3TQ5XJJ.js");
+      const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-CA3JTAMO.js");
       baseGenerator = createAnthropicContentGenerator(generatorConfig, config);
     } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
-      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-XTG6SFLA.js");
+      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-7NIFF2L4.js");
       baseGenerator = createGeminiContentGenerator(generatorConfig, config);
     } else {
       throw new Error(
@@ -67560,7 +67874,8 @@ var QwenLogger = class _QwenLogger {
     const rumEvent = this.createActionEvent("user", "new_prompt", {
       properties: {
         prompt_id: event.prompt_id,
-        prompt_length: event.prompt_length
+        prompt_length: event.prompt_length,
+        ...event.model ? { model: event.model } : {}
       }
     });
     this.enqueueLogEvent(rumEvent);
@@ -67701,7 +68016,8 @@ var QwenLogger = class _QwenLogger {
       properties: {
         model: event.model,
         prompt_id: event.prompt_id,
-        auth_type: event.auth_type
+        auth_type: event.auth_type,
+        loop_wakeups_cancelled: event.loop_wakeups_cancelled
       }
     });
     this.enqueueLogEvent(rumEvent);
@@ -68774,6 +69090,9 @@ function logUserPrompt(config, event) {
   if (event.auth_type) {
     attributes["auth_type"] = event.auth_type;
   }
+  if (event.model) {
+    attributes["model"] = event.model;
+  }
   if (shouldLogUserPrompts(config)) {
     attributes["prompt"] = event.prompt;
   }
@@ -68847,7 +69166,9 @@ function logToolOutputTruncated(config, event) {
   const attributes = {
     ...getCommonAttributes(config),
     ...event,
-    "event.name": "tool_output_truncated",
+    // event class's `eventName` (short, no prefix) leaks via spread — override with
+    // full namespaced constant for OTel compliance. Same pattern as other event loggers.
+    "event.name": EVENT_TOOL_OUTPUT_TRUNCATED,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
   const logger = import_api_logs2.logs.getLogger(SERVICE_NAME);
@@ -69411,6 +69732,14 @@ function logSkillLaunch(config, event) {
   logger.emit(logRecord);
 }
 __name(logSkillLaunch, "logSkillLaunch");
+function recordSkillInvocation(config, event) {
+  uiTelemetryService.recordSkillInvocation(
+    event.skillName,
+    event.success,
+    config.getSessionId()
+  );
+}
+__name(recordSkillInvocation, "recordSkillInvocation");
 function logUserFeedback(config, event) {
   const uiEvent = {
     ...event,
@@ -69737,8 +70066,8 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
     return [{ path: this.params.file_path, line: this.params.offset }];
   }
   /**
-   * Returns 'ask' for paths outside the workspace/temp/userSkills directories,
-   * so that external file reads require user confirmation.
+   * Returns 'ask' for paths outside the workspace/qwen-managed temp/userSkills
+   * directories, so that external file reads require user confirmation.
    */
   async getDefaultPermission() {
     const filePath = path10.resolve(this.params.file_path);
@@ -69749,7 +70078,6 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
       // are advertised to the model as polling targets via read_file.
       path10.join(this.config.storage.getProjectDir(), "subagents"),
       Storage.getGlobalTempDir(),
-      os4.tmpdir(),
       ...this.config.storage.getUserSkillsDirs(),
       Storage.getUserExtensionsDir()
     ];
@@ -69989,6 +70317,9 @@ export {
   EVENT_TOOL_CALL,
   EVENT_API_ERROR,
   EVENT_API_RESPONSE,
+  DEFAULT_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH,
+  SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH_LIMIT,
+  isValidSensitiveSpanAttributeMaxLength,
   MAIN_SOURCE,
   subagentNameContext,
   UiTelemetryService,
@@ -70081,6 +70412,7 @@ export {
   SemanticAttributes,
   sanitizeHookName,
   QwenLogger,
+  areSensitiveSpanAttributesEnabled,
   truncateContent,
   addUserPromptAttributes,
   addSystemPromptAttributes,
@@ -70165,6 +70497,7 @@ export {
   logExtensionDisable,
   logAuth,
   logSkillLaunch,
+  recordSkillInvocation,
   logUserFeedback,
   logArenaSessionStarted,
   logArenaAgentCompleted,