@qwen-code/qwen-code 0.19.2 → 0.19.3-nightly.20260630.e00fe6a27

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

@@ -23,28 +23,28 @@ import {
 } from "./chunk-OMX7CUOE.js";
 import {
   isAnyAutoMemPath
-} from "./chunk-BNXANYLH.js";
+} from "./chunk-RD6YJJJ6.js";
 import {
   InstallationManager
-} from "./chunk-T2VDEFUU.js";
+} from "./chunk-SKQZZVAV.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-OIC6S73E.js";
+} from "./chunk-BUUQ5HPX.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-TOEGRAVX.js";
+} from "./chunk-BX5YO7UW.js";
 import {
   atomicWriteFile,
   atomicWriteFileSync
-} from "./chunk-3UALQ56H.js";
+} from "./chunk-3227DZO4.js";
 import {
   convertSchema,
   runtimeDiagnostics,
   safeJsonParse
-} from "./chunk-CGEGHF2C.js";
+} from "./chunk-BKXBARJZ.js";
 import {
   require_lib
 } from "./chunk-IRJWHZWU.js";
@@ -70,7 +70,7 @@ import {
   setShellTracePropagation,
   shortenPath,
   unescapePath
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-UX4SGCGN.js";
 import {
   require_dist
 } from "./chunk-ZERZSAZL.js";
@@ -59073,6 +59073,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";
@@ -61149,12 +61156,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,6 +61248,7 @@ 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";
@@ -63103,6 +63117,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 +63524,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 +63599,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 +63627,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 +63639,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 +63659,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 +63680,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 +64111,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 +65538,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 +65592,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 +65640,7 @@ async function resolveTelemetrySettings(options) {
     otlpMetricsEndpoint,
     logPrompts,
     includeSensitiveSpanAttributes,
+    sensitiveSpanAttributeMaxLength,
     outfile,
     resourceAttributes,
     metrics: { includeSessionId: metricsIncludeSessionId },
@@ -65520,6 +65674,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 +65698,8 @@ var createInitialMetrics = /* @__PURE__ */ __name(() => ({
   files: {
     totalLinesAdded: 0,
     totalLinesRemoved: 0
-  }
+  },
+  skills: createInitialSkillMetrics()
 }), "createInitialMetrics");
 var UiTelemetryService = class _UiTelemetryService extends EventEmitter {
   static {
@@ -65570,6 +65731,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 +65881,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 +66430,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 +66566,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 +66605,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 +66619,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 +66693,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 +66771,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 +66809,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 +66829,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 +66885,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 +67039,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 +67498,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-4WUVA3Q2.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-6HNGHALT.js");
+      const { QwenContentGenerator } = await import("./qwenContentGenerator-MVYYR44B.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
@@ -67249,10 +67520,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-KWSJAQ7B.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-ZVWRHXOO.js");
       baseGenerator = createGeminiContentGenerator(generatorConfig, config);
     } else {
       throw new Error(
@@ -67701,7 +67972,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);
@@ -68847,7 +69119,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 +69685,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,
@@ -69989,6 +70271,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 +70366,7 @@ export {
   SemanticAttributes,
   sanitizeHookName,
   QwenLogger,
+  areSensitiveSpanAttributesEnabled,
   truncateContent,
   addUserPromptAttributes,
   addSystemPromptAttributes,
@@ -70165,6 +70451,7 @@ export {
   logExtensionDisable,
   logAuth,
   logSkillLaunch,
+  recordSkillInvocation,
   logUserFeedback,
   logArenaSessionStarted,
   logArenaAgentCompleted,