@qwen-code/qwen-code 0.15.12-preview.3 → 0.16.0-nightly.20260522.48b0a8bfc

package/chunks/{chunk-XLQ4E5PS.js → chunk-4U3O4VDA.js}

@@ -1,8 +1,5 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  require_safer
-} from "./chunk-SYCJMSIJ.js";
 import {
   require_hasown
 } from "./chunk-UWCTAVOD.js";
@@ -12,30 +9,31 @@ import {
 } from "./chunk-OFEVLU4C.js";
 import {
   isAutoMemPath
-} from "./chunk-CM2IESUE.js";
+} from "./chunk-PR4T27R7.js";
 import {
   DEFAULT_OPENAI_BASE_URL,
   convertSchema,
   normalize,
+  runtimeDiagnostics,
   safeJsonParse,
   tokenLimit
-} from "./chunk-UXW7MYAW.js";
+} from "./chunk-MAY32HXD.js";
 import {
   InstallationManager
-} from "./chunk-G27O2LD2.js";
+} from "./chunk-D5NTAHYL.js";
 import {
   FinishReason,
   GenerateContentResponse
 } from "./chunk-T4VD6OJ4.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-TPGOGCWM.js";
+} from "./chunk-YJLGXDQJ.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-FYMSCRHM.js";
+} from "./chunk-PVVL5Q3W.js";
 import {
   FatalConfigError,
   Storage,
@@ -51,7 +49,7 @@ import {
   setSessionContext,
   shortenPath,
   unescapePath
-} from "./chunk-GJXIKCKL.js";
+} from "./chunk-XP27SJMH.js";
 import {
   require_dist
 } from "./chunk-ZERZSAZL.js";
@@ -87,6 +85,75 @@ import {
   __toESM
 } from "./chunk-J2S4EL5Y.js";
 
+// node_modules/safer-buffer/safer.js
+var require_safer = __commonJS({
+  "node_modules/safer-buffer/safer.js"(exports2, module2) {
+    "use strict";
+    init_esbuild_shims();
+    var buffer = __require("buffer");
+    var Buffer3 = buffer.Buffer;
+    var safer = {};
+    var key;
+    for (key in buffer) {
+      if (!buffer.hasOwnProperty(key)) continue;
+      if (key === "SlowBuffer" || key === "Buffer") continue;
+      safer[key] = buffer[key];
+    }
+    var Safer = safer.Buffer = {};
+    for (key in Buffer3) {
+      if (!Buffer3.hasOwnProperty(key)) continue;
+      if (key === "allocUnsafe" || key === "allocUnsafeSlow") continue;
+      Safer[key] = Buffer3[key];
+    }
+    safer.Buffer.prototype = Buffer3.prototype;
+    if (!Safer.from || Safer.from === Uint8Array.from) {
+      Safer.from = function(value, encodingOrOffset, length) {
+        if (typeof value === "number") {
+          throw new TypeError('The "value" argument must not be of type number. Received type ' + typeof value);
+        }
+        if (value && typeof value.length === "undefined") {
+          throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
+        }
+        return Buffer3(value, encodingOrOffset, length);
+      };
+    }
+    if (!Safer.alloc) {
+      Safer.alloc = function(size, fill, encoding) {
+        if (typeof size !== "number") {
+          throw new TypeError('The "size" argument must be of type number. Received type ' + typeof size);
+        }
+        if (size < 0 || size >= 2 * (1 << 30)) {
+          throw new RangeError('The value "' + size + '" is invalid for option "size"');
+        }
+        var buf = Buffer3(size);
+        if (!fill || fill.length === 0) {
+          buf.fill(0);
+        } else if (typeof encoding === "string") {
+          buf.fill(fill, encoding);
+        } else {
+          buf.fill(fill);
+        }
+        return buf;
+      };
+    }
+    if (!safer.kStringMaxLength) {
+      try {
+        safer.kStringMaxLength = process.binding("buffer").kStringMaxLength;
+      } catch (e) {
+      }
+    }
+    if (!safer.constants) {
+      safer.constants = {
+        MAX_LENGTH: safer.kMaxLength
+      };
+      if (safer.kStringMaxLength) {
+        safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength;
+      }
+    }
+    module2.exports = safer;
+  }
+});
+
 // packages/core/node_modules/iconv-lite/lib/bom-handling.js
 var require_bom_handling = __commonJS({
   "packages/core/node_modules/iconv-lite/lib/bom-handling.js"(exports2) {
@@ -63532,6 +63599,147 @@ function normalizeSource(source) {
   return Array.isArray(source) ? source.join("") : source;
 }
 __name(normalizeSource, "normalizeSource");
+function parseNotebook(content) {
+  const jsonContent = content.charCodeAt(0) === 65279 ? content.slice(1) : content;
+  const parsed = JSON.parse(jsonContent);
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("Invalid notebook: expected a JSON object");
+  }
+  const notebook = parsed;
+  if (!Array.isArray(notebook.cells)) {
+    throw new Error("Invalid notebook: missing cells array");
+  }
+  for (let i = 0; i < notebook.cells.length; i++) {
+    const cell = notebook.cells[i];
+    if (!cell || typeof cell !== "object" || Array.isArray(cell)) {
+      throw new Error(`Invalid notebook: cell at index ${i} is not an object`);
+    }
+  }
+  return notebook;
+}
+__name(parseNotebook, "parseNotebook");
+function inferNotebookJsonFormat(content) {
+  const lineMatch = content.match(/\n([ \t]+)"/);
+  const indent = lineMatch?.[1];
+  let inferredIndent;
+  if (indent !== void 0) {
+    inferredIndent = /^ +$/.test(indent) ? indent.length : indent;
+  }
+  return {
+    indent: inferredIndent,
+    trailingNewline: content.endsWith("\n")
+  };
+}
+__name(inferNotebookJsonFormat, "inferNotebookJsonFormat");
+function serializeNotebook(notebook, format = { indent: 1, trailingNewline: true }) {
+  const serialized = JSON.stringify(notebook, null, format.indent);
+  return format.trailingNewline ? `${serialized}
+` : serialized;
+}
+__name(serializeNotebook, "serializeNotebook");
+function getCellDisplayId(cell, index) {
+  return typeof cell.id === "string" && cell.id.length > 0 ? cell.id : `cell-${index}`;
+}
+__name(getCellDisplayId, "getCellDisplayId");
+function hasStableCellIds(notebook) {
+  return notebook.cells.every(
+    (cell) => typeof cell.id === "string" && cell.id.length > 0
+  );
+}
+__name(hasStableCellIds, "hasStableCellIds");
+function findCellIndexesByDisplayId(notebook, cellId) {
+  const indexes = [];
+  notebook.cells.forEach((cell, index) => {
+    if (getCellDisplayId(cell, index) === cellId) {
+      indexes.push(index);
+    }
+  });
+  return indexes;
+}
+__name(findCellIndexesByDisplayId, "findCellIndexesByDisplayId");
+function isAmbiguousCellId(notebook, cellId) {
+  return findCellIndexesByDisplayId(notebook, cellId).length > 1;
+}
+__name(isAmbiguousCellId, "isAmbiguousCellId");
+function findCellIndex(notebook, cellId) {
+  const indexes = findCellIndexesByDisplayId(notebook, cellId);
+  return indexes.length === 1 ? indexes[0] : -1;
+}
+__name(findCellIndex, "findCellIndex");
+function getNotebookLanguage(notebook) {
+  return notebook.metadata?.language_info?.name ?? notebook.metadata?.kernelspec?.language ?? "python";
+}
+__name(getNotebookLanguage, "getNotebookLanguage");
+function shouldGenerateCellIds(notebook) {
+  return (notebook.nbformat ?? 0) > 4 || (notebook.nbformat ?? 0) === 4 && (notebook.nbformat_minor ?? 0) >= 5;
+}
+__name(shouldGenerateCellIds, "shouldGenerateCellIds");
+function makeCellId(notebook) {
+  if (!shouldGenerateCellIds(notebook)) {
+    return void 0;
+  }
+  const existingDisplayIds = new Set(
+    notebook.cells.map((cell, index) => getCellDisplayId(cell, index))
+  );
+  let fallbackIndex = 1;
+  let fallback = `qwen-cell-${fallbackIndex}`;
+  while (existingDisplayIds.has(fallback)) {
+    fallbackIndex++;
+    fallback = `qwen-cell-${fallbackIndex}`;
+  }
+  return fallback;
+}
+__name(makeCellId, "makeCellId");
+function inferNotebookSourceArrayStyle(notebook) {
+  const sourceCell = notebook.cells.find((cell) => cell.source !== void 0);
+  return sourceCell ? Array.isArray(sourceCell.source) : true;
+}
+__name(inferNotebookSourceArrayStyle, "inferNotebookSourceArrayStyle");
+function inferInsertedCellSourceArrayStyle(notebook, insertAt) {
+  const previousCell = notebook.cells[insertAt - 1];
+  if (previousCell?.source !== void 0) {
+    return Array.isArray(previousCell.source);
+  }
+  const nextCell = notebook.cells[insertAt];
+  if (nextCell?.source !== void 0) {
+    return Array.isArray(nextCell.source);
+  }
+  return inferNotebookSourceArrayStyle(notebook);
+}
+__name(inferInsertedCellSourceArrayStyle, "inferInsertedCellSourceArrayStyle");
+function toNotebookSource(source, preferArray) {
+  if (!preferArray) {
+    return source;
+  }
+  if (source.length === 0) {
+    return [];
+  }
+  const lines = [];
+  let start = 0;
+  for (let i = 0; i < source.length; i++) {
+    if (source[i] === "\n") {
+      lines.push(source.slice(start, i + 1));
+      start = i + 1;
+    }
+  }
+  if (start < source.length) {
+    lines.push(source.slice(start));
+  }
+  return lines;
+}
+__name(toNotebookSource, "toNotebookSource");
+function normalizeEditedCell(cell, finalType) {
+  cell.cell_type = finalType;
+  cell.metadata ??= {};
+  if (finalType === "code") {
+    cell.execution_count = null;
+    cell.outputs = [];
+    return;
+  }
+  delete cell.execution_count;
+  delete cell.outputs;
+}
+__name(normalizeEditedCell, "normalizeEditedCell");
 function processOutputText(text) {
   if (!text) return "";
   return Array.isArray(text) ? text.join("") : text;
@@ -63567,7 +63775,7 @@ function processOutput(output) {
 }
 __name(processOutput, "processOutput");
 function processCell(cell, index, language) {
-  const cellId = cell.id ?? `cell-${index}`;
+  const cellId = getCellDisplayId(cell, index);
   const source = normalizeSource(cell.source);
   const parts = [];
   switch (cell.cell_type) {
@@ -63607,20 +63815,22 @@ function processCell(cell, index, language) {
   return parts.join("\n");
 }
 __name(processCell, "processCell");
-async function readNotebook(filePath) {
+async function readNotebookWithMetadata(filePath) {
   const raw = await fs.promises.readFile(filePath, "utf-8");
-  const notebook = JSON.parse(raw);
-  const language = notebook.metadata?.language_info?.name ?? notebook.metadata?.kernelspec?.language ?? "python";
+  const notebook = parseNotebook(raw);
+  const language = getNotebookLanguage(notebook);
   if (!notebook.cells || notebook.cells.length === 0) {
-    return "(empty notebook)";
+    return { content: "(empty notebook)", isTruncated: false };
   }
   const header = `Jupyter Notebook (${language}, ${notebook.cells.length} cells)`;
   const cellTexts = [];
   let totalLength = header.length;
+  let isTruncated = false;
   for (let i = 0; i < notebook.cells.length; i++) {
     const cellText = processCell(notebook.cells[i], i, language);
     totalLength += cellText.length + 2;
     if (totalLength > MAX_NOTEBOOK_OUTPUT_CHARS) {
+      isTruncated = true;
       cellTexts.push(
         `... [${notebook.cells.length - i} remaining cells truncated, total ${notebook.cells.length} cells. Use shell to inspect: cat <path> | jq '.cells[${i}:]']`
       );
@@ -63628,11 +63838,14 @@ async function readNotebook(filePath) {
     }
     cellTexts.push(cellText);
   }
-  return `${header}
+  return {
+    content: `${header}
 
-${cellTexts.join("\n\n")}`;
+${cellTexts.join("\n\n")}`,
+    isTruncated
+  };
 }
-__name(readNotebook, "readNotebook");
+__name(readNotebookWithMetadata, "readNotebookWithMetadata");
 
 // packages/core/src/utils/fileUtils.ts
 var debugLogger2 = createDebugLogger("FILE_UTILS");
@@ -63694,6 +63907,42 @@ function isValidUtf8(buffer) {
   }
 }
 __name(isValidUtf8, "isValidUtf8");
+function decodeBufferWithEncodingInfo(full) {
+  if (full.length === 0) {
+    return { content: "", encoding: "utf-8", bom: false };
+  }
+  const bomInfo = detectBOM(full);
+  if (bomInfo) {
+    return {
+      content: decodeBOMBuffer(full, bomInfo),
+      encoding: bomEncodingToName(bomInfo.encoding),
+      // Mark bom: true for all Unicode BOM variants (UTF-8/16/32) so that
+      // the BOM is re-written on save and the file's original format is preserved.
+      bom: true
+    };
+  }
+  if (isValidUtf8(full)) {
+    return { content: full.toString("utf8"), encoding: "utf-8", bom: false };
+  }
+  const detected = detectEncodingFromBuffer(full);
+  if (detected && !isUtf8CompatibleEncoding(detected)) {
+    try {
+      if (iconvEncodingExists(detected)) {
+        return {
+          content: iconvDecode(full, detected),
+          encoding: detected,
+          bom: false
+        };
+      }
+    } catch (e) {
+      debugLogger2.warn(
+        `Failed to decode buffer as ${detected}: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+  }
+  return { content: full.toString("utf8"), encoding: "utf-8", bom: false };
+}
+__name(decodeBufferWithEncodingInfo, "decodeBufferWithEncodingInfo");
 function decodeBOMBuffer(buf, bomInfo) {
   const content = buf.subarray(bomInfo.bomLength);
   switch (bomInfo.encoding) {
@@ -63731,37 +63980,7 @@ function bomEncodingToName(bomEncoding) {
 __name(bomEncodingToName, "bomEncodingToName");
 async function readFileWithEncodingInfo(filePath) {
   const full = await fs2.promises.readFile(filePath);
-  if (full.length === 0) return { content: "", encoding: "utf-8", bom: false };
-  const bomInfo = detectBOM(full);
-  if (bomInfo) {
-    return {
-      content: decodeBOMBuffer(full, bomInfo),
-      encoding: bomEncodingToName(bomInfo.encoding),
-      // Mark bom: true for all Unicode BOM variants (UTF-8/16/32) so that
-      // the BOM is re-written on save and the file's original format is preserved.
-      bom: true
-    };
-  }
-  if (isValidUtf8(full)) {
-    return { content: full.toString("utf8"), encoding: "utf-8", bom: false };
-  }
-  const detected = detectEncodingFromBuffer(full);
-  if (detected && !isUtf8CompatibleEncoding(detected)) {
-    try {
-      if (iconvEncodingExists(detected)) {
-        return {
-          content: iconvDecode(full, detected),
-          encoding: detected,
-          bom: false
-        };
-      }
-    } catch (e) {
-      debugLogger2.warn(
-        `Failed to decode file ${filePath} as ${detected}: ${e instanceof Error ? e.message : String(e)}`
-      );
-    }
-  }
-  return { content: full.toString("utf8"), encoding: "utf-8", bom: false };
+  return decodeBufferWithEncodingInfo(full);
 }
 __name(readFileWithEncodingInfo, "readFileWithEncodingInfo");
 async function readFileWithEncoding(filePath) {
@@ -64341,10 +64560,12 @@ async function processSingleFileContent(filePath, config, offset, limit, pages)
       }
       case "notebook": {
         try {
-          const content = await readNotebook(filePath);
+          const { content, isTruncated } = await readNotebookWithMetadata(filePath);
           return {
             llmContent: content,
-            returnDisplay: `Read notebook: ${relativePathForDisplay}`
+            returnDisplay: `Read notebook: ${relativePathForDisplay}`,
+            isTruncated,
+            stats
           };
         } catch (e) {
           const msg = e instanceof Error ? e.message : String(e);
@@ -64434,6 +64655,8 @@ var SPAN_INTERACTION = "qwen-code.interaction";
 var SPAN_LLM_REQUEST = "qwen-code.llm_request";
 var SPAN_TOOL = "qwen-code.tool";
 var SPAN_TOOL_EXECUTION = "qwen-code.tool.execution";
+var SPAN_TOOL_BLOCKED_ON_USER = "qwen-code.tool.blocked_on_user";
+var SPAN_HOOK = "qwen-code.hook";
 
 // packages/core/src/telemetry/metrics.ts
 var TOOL_CALL_COUNT = `${SERVICE_NAME}.tool.call.count`;
@@ -64472,9 +64695,19 @@ var MEMORY_DREAM_DURATION = `${SERVICE_NAME}.memory.dream.duration`;
 var MEMORY_RECALL_COUNT = `${SERVICE_NAME}.memory.recall.count`;
 var MEMORY_RECALL_DURATION = `${SERVICE_NAME}.memory.recall.duration`;
 var baseMetricDefinition = {
-  getCommonAttributes: /* @__PURE__ */ __name((config) => ({
-    "session.id": config.getSessionId()
-  }), "getCommonAttributes")
+  // session.id on metrics is opt-in: each session is a new value, so
+  // attaching it by default would create unbounded time-series fan-out on
+  // every metric backend. Operators who need session-level metric slicing
+  // can enable QWEN_TELEMETRY_METRICS_INCLUDE_SESSION_ID or
+  // telemetry.metrics.includeSessionId. Spans and logs always carry
+  // session.id for trace/log correlation.
+  getCommonAttributes: /* @__PURE__ */ __name((config) => {
+    const out = {};
+    if (config.getTelemetryMetricsIncludeSessionId()) {
+      out["session.id"] = config.getSessionId();
+    }
+    return out;
+  }, "getCommonAttributes")
 };
 var COUNTER_DEFINITIONS = {
   [TOOL_CALL_COUNT]: {
@@ -68036,6 +68269,22 @@ var v4_default = v4;
 // packages/core/src/utils/openaiLogger.ts
 import * as os2 from "os";
 var debugLogger6 = createDebugLogger("OPENAI_LOGGER");
+var MAIN_SESSION_PROMPT_ID_DELIMITER = "########";
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function resolveOpenAILogDir(customLogDir, cwd) {
+  const baseCwd = cwd || process.cwd();
+  if (!customLogDir) {
+    return path5.join(baseCwd, "logs", "openai");
+  }
+  let resolvedPath = customLogDir;
+  if (customLogDir === "~" || customLogDir.startsWith("~/")) {
+    resolvedPath = path5.join(os2.homedir(), customLogDir.slice(1));
+  } else if (!path5.isAbsolute(customLogDir)) {
+    resolvedPath = path5.resolve(baseCwd, customLogDir);
+  }
+  return path5.normalize(resolvedPath);
+}
+__name(resolveOpenAILogDir, "resolveOpenAILogDir");
 function sanitizeDiagnosticSuffix(suffix) {
   if (!suffix) return void 0;
   const sanitized = suffix.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -68060,6 +68309,36 @@ function promptIdSuffixForFilename(promptId) {
   return sanitizeDiagnosticSuffix(extractSubagentSuffix(promptId));
 }
 __name(promptIdSuffixForFilename, "promptIdSuffixForFilename");
+function sessionIdFromPromptId(promptId) {
+  if (!promptId) return void 0;
+  const mainSessionDelimiterIndex = promptId.indexOf(
+    MAIN_SESSION_PROMPT_ID_DELIMITER
+  );
+  if (mainSessionDelimiterIndex > 0) {
+    return promptId.slice(0, mainSessionDelimiterIndex);
+  }
+  if (UUID_PATTERN.test(promptId)) {
+    return promptId;
+  }
+  const parts = promptId.split("#");
+  if (parts.length >= 3 && parts[0]) {
+    return parts[0];
+  }
+  return void 0;
+}
+__name(sessionIdFromPromptId, "sessionIdFromPromptId");
+function contextForPromptId(promptId) {
+  const trimmedPromptId = promptId?.trim();
+  const sessionId = sessionIdFromPromptId(trimmedPromptId);
+  if (!trimmedPromptId && !sessionId) {
+    return null;
+  }
+  return {
+    ...trimmedPromptId ? { promptId: trimmedPromptId } : {},
+    ...sessionId ? { sessionId } : {}
+  };
+}
+__name(contextForPromptId, "contextForPromptId");
 var OpenAILogger = class {
   static {
     __name(this, "OpenAILogger");
@@ -68074,18 +68353,7 @@ var OpenAILogger = class {
    *            pass the project working directory from Config.getWorkingDir().
    */
   constructor(customLogDir, cwd) {
-    const baseCwd = cwd || process.cwd();
-    if (customLogDir) {
-      let resolvedPath = customLogDir;
-      if (customLogDir === "~" || customLogDir.startsWith("~/")) {
-        resolvedPath = path5.join(os2.homedir(), customLogDir.slice(1));
-      } else if (!path5.isAbsolute(customLogDir)) {
-        resolvedPath = path5.resolve(baseCwd, customLogDir);
-      }
-      this.logDir = path5.normalize(resolvedPath);
-    } else {
-      this.logDir = path5.join(baseCwd, "logs", "openai");
-    }
+    this.logDir = resolveOpenAILogDir(customLogDir, cwd);
   }
   /**
    * Initialize the logger by creating the log directory if it doesn't exist
@@ -68126,6 +68394,7 @@ var OpenAILogger = class {
         message: error.message,
         stack: error.stack
       } : null,
+      context: contextForPromptId(promptId),
       system: {
         hostname: os2.hostname(),
         platform: os2.platform(),
@@ -68774,6 +69043,17 @@ __name(addToolResultAttributes, "addToolResultAttributes");
 
 // packages/core/src/telemetry/session-tracing.ts
 var debugLogger8 = createDebugLogger("SESSION_TRACING");
+function resolveParentContext(parent) {
+  if (parent) {
+    return trace.setSpan(context.active(), parent.span);
+  }
+  const active = context.active();
+  if (trace.getSpan(active)) {
+    return active;
+  }
+  return getSessionContext() ?? active;
+}
+__name(resolveParentContext, "resolveParentContext");
 var NOOP_SPAN = trace.wrapSpanContext({
   traceId: "0".repeat(32),
   spanId: "0".repeat(16),
@@ -68787,26 +69067,55 @@ var interactionSequence = 0;
 var lastInteractionCtx;
 var cleanupIntervalStarted = false;
 var SPAN_TTL_MS = 30 * 60 * 1e3;
-function ensureCleanupInterval() {
-  if (cleanupIntervalStarted) return;
-  cleanupIntervalStarted = true;
-  const interval = setInterval(() => {
-    const cutoff = Date.now() - SPAN_TTL_MS;
-    for (const [spanId, weakRef] of activeSpans) {
-      const ctx = weakRef.deref();
-      if (ctx === void 0) {
-        activeSpans.delete(spanId);
-        strongSpans.delete(spanId);
-      } else if (ctx.startTime < cutoff) {
-        if (!ctx.ended) {
-          ctx.ended = true;
+function sweepStaleSpans(now) {
+  const cutoff = now - SPAN_TTL_MS;
+  for (const [spanId, weakRef] of activeSpans) {
+    const ctx = weakRef.deref();
+    if (ctx === void 0) {
+      activeSpans.delete(spanId);
+      strongSpans.delete(spanId);
+    } else if (ctx.startTime < cutoff) {
+      if (!ctx.ended) {
+        ctx.ended = true;
+        const ageMs = now - ctx.startTime;
+        const toolName = ctx.attributes["tool.name"];
+        const callId = ctx.attributes["tool.call_id"];
+        try {
+          ctx.span.setAttributes({
+            "qwen-code.span.ttl_expired": true,
+            "qwen-code.span.duration_ms": ageMs,
+            ...ctx.type === "tool.blocked_on_user" ? {
+              decision: "aborted",
+              source: "system"
+            } : {}
+          });
+        } catch (error) {
+          debugLogger8.warn(
+            `Failed to stamp TTL attrs on stale span ${spanId}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        const ctxLabel = toolName && callId ? `${ctx.type} (tool.name=${toolName}, tool.call_id=${callId})` : ctx.type;
+        debugLogger8.warn(
+          `Stale ${ctxLabel} span ended by TTL safety net (age=${ageMs}ms, spanId=${spanId})`
+        );
+        try {
           ctx.span.end();
+        } catch (error) {
+          debugLogger8.warn(
+            `Failed to end stale span ${spanId}: ${error instanceof Error ? error.message : String(error)}`
+          );
         }
-        activeSpans.delete(spanId);
-        strongSpans.delete(spanId);
       }
+      activeSpans.delete(spanId);
+      strongSpans.delete(spanId);
     }
-  }, 6e4);
+  }
+}
+__name(sweepStaleSpans, "sweepStaleSpans");
+function ensureCleanupInterval() {
+  if (cleanupIntervalStarted) return;
+  cleanupIntervalStarted = true;
+  const interval = setInterval(() => sweepStaleSpans(Date.now()), 6e4);
   if (typeof interval.unref === "function") {
     interval.unref();
   }
@@ -68816,6 +69125,15 @@ function getSpanId(span) {
   return span.spanContext().spanId || "";
 }
 __name(getSpanId, "getSpanId");
+var SPAN_ERROR_MAX_CHARS = 1024;
+function truncateSpanError(s) {
+  if (s.length <= SPAN_ERROR_MAX_CHARS) return s;
+  let end = SPAN_ERROR_MAX_CHARS;
+  const code = s.charCodeAt(end - 1);
+  if (code >= 55296 && code <= 56319) end--;
+  return s.slice(0, end) + "\u2026[truncated]";
+}
+__name(truncateSpanError, "truncateSpanError");
 function getTracer() {
   return trace.getTracer(SERVICE_NAME, "1.0.0");
 }
@@ -68879,7 +69197,7 @@ function startLLMRequestSpan(model, promptId) {
     return NOOP_SPAN;
   }
   const parentCtx = interactionContext.getStore();
-  const ctx = parentCtx ? trace.setSpan(context.active(), parentCtx.span) : getSessionContext() ?? context.active();
+  const ctx = resolveParentContext(parentCtx);
   const attributes = {
     "qwen-code.model": model,
     "qwen-code.prompt_id": promptId,
@@ -68916,7 +69234,8 @@ function endLLMRequestSpan(span, metadata) {
       if (metadata.outputTokens !== void 0)
         endAttributes["output_tokens"] = metadata.outputTokens;
       endAttributes["success"] = metadata.success;
-      if (metadata.error !== void 0) endAttributes["error"] = metadata.error;
+      if (metadata.error !== void 0)
+        endAttributes["error"] = truncateSpanError(metadata.error);
     }
     spanCtx.span.setAttributes(endAttributes);
     if (metadata === void 0 || metadata.success) {
@@ -68924,7 +69243,7 @@ function endLLMRequestSpan(span, metadata) {
     } else {
       spanCtx.span.setStatus({
         code: SpanStatusCode.ERROR,
-        message: metadata.error ?? "unknown error"
+        message: metadata.error ? truncateSpanError(metadata.error) : "unknown error"
       });
     }
   } catch (error) {
@@ -68948,7 +69267,7 @@ function startToolSpan(toolName, attrs) {
     return NOOP_SPAN;
   }
   const parentCtx = interactionContext.getStore();
-  const ctx = parentCtx ? trace.setSpan(context.active(), parentCtx.span) : getSessionContext() ?? context.active();
+  const ctx = resolveParentContext(parentCtx);
   const attributes = {
     "tool.name": toolName,
     ...attrs
@@ -68989,7 +69308,8 @@ function endToolSpan(span, metadata) {
     if (metadata) {
       if (metadata.success !== void 0)
         endAttributes["success"] = metadata.success;
-      if (metadata.error !== void 0) endAttributes["error"] = metadata.error;
+      if (metadata.error !== void 0)
+        endAttributes["error"] = truncateSpanError(metadata.error);
     }
     spanCtx.span.setAttributes(endAttributes);
     if (metadata) {
@@ -68998,7 +69318,7 @@ function endToolSpan(span, metadata) {
       } else {
         spanCtx.span.setStatus({
           code: SpanStatusCode.ERROR,
-          message: metadata.error ?? "tool error"
+          message: metadata.error ? truncateSpanError(metadata.error) : "tool error"
         });
       }
     }
@@ -69028,7 +69348,7 @@ function startToolExecutionSpan() {
       "startToolExecutionSpan called outside runInToolSpanContext \u2014 span will not be parented to tool span"
     );
   }
-  const ctx = parentCtx ? trace.setSpan(context.active(), parentCtx.span) : getSessionContext() ?? context.active();
+  const ctx = resolveParentContext(parentCtx);
   const span = getTracer().startSpan(
     SPAN_TOOL_EXECUTION,
     { kind: SpanKind.INTERNAL },
@@ -69057,16 +69377,17 @@ function endToolExecutionSpan(span, metadata) {
     if (metadata) {
       if (metadata.success !== void 0)
         endAttributes["success"] = metadata.success;
-      if (metadata.error !== void 0) endAttributes["error"] = metadata.error;
+      if (metadata.error !== void 0)
+        endAttributes["error"] = truncateSpanError(metadata.error);
     }
     spanCtx.span.setAttributes(endAttributes);
-    if (metadata) {
+    if (metadata && !metadata.cancelled) {
       if (metadata.success !== false) {
         spanCtx.span.setStatus({ code: SpanStatusCode.OK });
       } else {
         spanCtx.span.setStatus({
           code: SpanStatusCode.ERROR,
-          message: metadata.error ?? "tool execution error"
+          message: metadata.error ? truncateSpanError(metadata.error) : "tool execution error"
         });
       }
     }
@@ -69086,6 +69407,144 @@ function endToolExecutionSpan(span, metadata) {
   strongSpans.delete(spanId);
 }
 __name(endToolExecutionSpan, "endToolExecutionSpan");
+function startToolBlockedOnUserSpan(toolSpan, attrs) {
+  if (!isTelemetrySdkInitialized()) {
+    return NOOP_SPAN;
+  }
+  ensureCleanupInterval();
+  const parentSpanId = getSpanId(toolSpan);
+  const parentSpanCtx = activeSpans.get(parentSpanId)?.deref();
+  if (!parentSpanCtx) {
+    debugLogger8.debug(
+      "startToolBlockedOnUserSpan: tool span not in activeSpans (already ended?) \u2014 using resolveParentContext fallback"
+    );
+  }
+  const ctx = parentSpanCtx ? trace.setSpan(context.active(), parentSpanCtx.span) : resolveParentContext(void 0);
+  const attributes = {};
+  if (attrs?.tool_name !== void 0) attributes["tool.name"] = attrs.tool_name;
+  if (attrs?.call_id !== void 0) attributes["tool.call_id"] = attrs.call_id;
+  const span = getTracer().startSpan(
+    SPAN_TOOL_BLOCKED_ON_USER,
+    { kind: SpanKind.INTERNAL, attributes },
+    ctx
+  );
+  const spanId = getSpanId(span);
+  const spanContextObj = {
+    span,
+    startTime: Date.now(),
+    attributes,
+    type: "tool.blocked_on_user"
+  };
+  activeSpans.set(spanId, new WeakRef(spanContextObj));
+  strongSpans.set(spanId, spanContextObj);
+  return span;
+}
+__name(startToolBlockedOnUserSpan, "startToolBlockedOnUserSpan");
+function endToolBlockedOnUserSpan(span, metadata) {
+  const spanId = getSpanId(span);
+  const spanCtx = activeSpans.get(spanId)?.deref();
+  if (!spanCtx || spanCtx.ended) return;
+  spanCtx.ended = true;
+  try {
+    const duration = Date.now() - spanCtx.startTime;
+    const endAttributes = { duration_ms: duration };
+    if (metadata?.decision !== void 0)
+      endAttributes["decision"] = metadata.decision;
+    if (metadata?.source !== void 0)
+      endAttributes["source"] = metadata.source;
+    spanCtx.span.setAttributes(endAttributes);
+  } catch (error) {
+    debugLogger8.warn(
+      `Failed to update blocked_on_user span attributes: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  try {
+    spanCtx.span.end();
+  } catch (error) {
+    debugLogger8.warn(
+      `Failed to end blocked_on_user span: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  activeSpans.delete(spanId);
+  strongSpans.delete(spanId);
+}
+__name(endToolBlockedOnUserSpan, "endToolBlockedOnUserSpan");
+function startHookSpan(opts) {
+  if (!isTelemetrySdkInitialized()) {
+    return NOOP_SPAN;
+  }
+  ensureCleanupInterval();
+  const parentCtx = toolContext.getStore() ?? interactionContext.getStore() ?? void 0;
+  const ctx = resolveParentContext(parentCtx);
+  const attributes = {
+    hook_event: opts.hookEvent,
+    "tool.name": opts.toolName
+  };
+  if (opts.toolUseId !== void 0) attributes["tool.use_id"] = opts.toolUseId;
+  if (opts.isInterrupt !== void 0)
+    attributes["is_interrupt"] = opts.isInterrupt;
+  const span = getTracer().startSpan(
+    SPAN_HOOK,
+    { kind: SpanKind.INTERNAL, attributes },
+    ctx
+  );
+  const spanId = getSpanId(span);
+  const spanContextObj = {
+    span,
+    startTime: Date.now(),
+    attributes,
+    type: "hook"
+  };
+  activeSpans.set(spanId, new WeakRef(spanContextObj));
+  strongSpans.set(spanId, spanContextObj);
+  return span;
+}
+__name(startHookSpan, "startHookSpan");
+function endHookSpan(span, metadata) {
+  const spanId = getSpanId(span);
+  const spanCtx = activeSpans.get(spanId)?.deref();
+  if (!spanCtx || spanCtx.ended) return;
+  spanCtx.ended = true;
+  try {
+    const duration = Date.now() - spanCtx.startTime;
+    const endAttributes = { duration_ms: duration };
+    if (metadata) {
+      if (metadata.success !== void 0)
+        endAttributes["success"] = metadata.success;
+      if (metadata.shouldProceed !== void 0)
+        endAttributes["should_proceed"] = metadata.shouldProceed;
+      if (metadata.shouldStop !== void 0)
+        endAttributes["should_stop"] = metadata.shouldStop;
+      if (metadata.blockType !== void 0)
+        endAttributes["block_type"] = metadata.blockType;
+      if (metadata.hasAdditionalContext !== void 0)
+        endAttributes["has_additional_context"] = metadata.hasAdditionalContext;
+      if (metadata.error !== void 0)
+        endAttributes["error"] = truncateSpanError(metadata.error);
+    }
+    spanCtx.span.setAttributes(endAttributes);
+    if (metadata?.error !== void 0) {
+      spanCtx.span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: truncateSpanError(metadata.error)
+      });
+    }
+  } catch (error) {
+    debugLogger8.warn(
+      `Failed to update hook span attributes/status: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  try {
+    spanCtx.span.end();
+  } catch (error) {
+    debugLogger8.warn(
+      `Failed to end hook span: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  activeSpans.delete(spanId);
+  strongSpans.delete(spanId);
+}
+__name(endHookSpan, "endHookSpan");
 function getActiveInteractionSpan() {
   const ctx = interactionContext.getStore() ?? lastInteractionCtx;
   if (!ctx || ctx.ended) return void 0;
@@ -69173,11 +69632,33 @@ function initializeTelemetry(config) {
     return;
   }
   const debugLogger12 = createDebugLogger("OTEL");
+  const userAttrs = config.getTelemetryResourceAttributes() ?? {};
+  const userServiceName = userAttrs["service.name"];
+  const {
+    "service.name": _ignoredServiceName,
+    "service.version": _ignoredServiceVersion,
+    "session.id": _ignoredSessionId,
+    ...nonReservedUserAttrs
+  } = userAttrs;
   const resource = (0, import_resources2.resourceFromAttributes)({
-    [SemanticResourceAttributes.SERVICE_NAME]: SERVICE_NAME,
-    [SemanticResourceAttributes.SERVICE_VERSION]: config.getCliVersion() || "unknown",
-    "session.id": config.getSessionId()
+    ...nonReservedUserAttrs,
+    // `.trim() || SERVICE_NAME`: catches both empty string (`""`) and
+    // whitespace-only values (`" "`, `"\t"`) that would otherwise produce
+    // a blank service name on Resource (some backends reject these). Both
+    // settings (no value trimming there) and env (`%20` decodes to `" "`)
+    // can deliver whitespace-only values, so trim at the fallback point.
+    [SemanticResourceAttributes.SERVICE_NAME]: userServiceName?.trim() || SERVICE_NAME,
+    [SemanticResourceAttributes.SERVICE_VERSION]: config.getCliVersion() || "unknown"
   });
+  const attrWarnings = config.getTelemetryResourceAttributeWarnings() ?? [];
+  if (attrWarnings.length > 0) {
+    console.warn(
+      `[qwen-code telemetry] ${attrWarnings.length} resource attribute issue(s):`
+    );
+    for (const w of attrWarnings) {
+      console.warn(`  - ${w}`);
+    }
+  }
   const otlpEndpoint = config.getTelemetryOtlpEndpoint();
   const otlpProtocol = config.getTelemetryOtlpProtocol();
   const parsedEndpoint = parseOtlpEndpoint(otlpEndpoint, otlpProtocol);
@@ -69341,6 +69822,104 @@ __name(shutdownTelemetry, "shutdownTelemetry");
 
 // packages/core/src/telemetry/config.ts
 init_esbuild_shims();
+
+// packages/core/src/telemetry/resource-attributes.ts
+init_esbuild_shims();
+init_esm();
+var RESERVED_RESOURCE_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
+  "service.version",
+  "session.id"
+]);
+function warn(msg, warnings) {
+  diag.warn(msg);
+  warnings?.push(msg);
+}
+__name(warn, "warn");
+function parseOtelResourceAttributes(raw, warnings) {
+  if (!raw) return {};
+  const out = {};
+  for (const pair of raw.split(",")) {
+    const trimmed = pair.trim();
+    if (!trimmed) continue;
+    const idx = trimmed.indexOf("=");
+    if (idx < 0) {
+      warn(
+        `Skipping malformed OTEL_RESOURCE_ATTRIBUTES entry: "${trimmed}" (hint: percent-encode literal commas as %2C)`,
+        warnings
+      );
+      continue;
+    }
+    const rawKey = trimmed.slice(0, idx).trim();
+    if (!rawKey) continue;
+    const valueRaw = trimmed.slice(idx + 1).trim();
+    let key;
+    try {
+      key = decodeURIComponent(rawKey);
+    } catch {
+      warn(
+        `Invalid percent-encoding in OTEL_RESOURCE_ATTRIBUTES key "${rawKey}", using raw key`,
+        warnings
+      );
+      key = rawKey;
+    }
+    let value;
+    try {
+      value = decodeURIComponent(valueRaw);
+    } catch {
+      warn(
+        `Invalid percent-encoding in OTEL_RESOURCE_ATTRIBUTES for key "${key}", using raw value`,
+        warnings
+      );
+      value = valueRaw;
+    }
+    out[key] = value;
+  }
+  return out;
+}
+__name(parseOtelResourceAttributes, "parseOtelResourceAttributes");
+function stripReservedResourceAttributes(attrs, source, warnings) {
+  for (const k of RESERVED_RESOURCE_ATTRIBUTE_KEYS) {
+    if (k in attrs) {
+      warn(`${source} cannot override reserved key "${k}"; ignoring`, warnings);
+      delete attrs[k];
+    }
+  }
+  return attrs;
+}
+__name(stripReservedResourceAttributes, "stripReservedResourceAttributes");
+function coerceStringResourceAttributes(raw, warnings) {
+  if (raw === null || raw === void 0) return {};
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    warn(
+      "settings.telemetry.resourceAttributes must be an object; ignoring",
+      warnings
+    );
+    return {};
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    const key = k.trim();
+    if (!key) {
+      warn(
+        "settings.telemetry.resourceAttributes has an empty or whitespace-only key; ignoring",
+        warnings
+      );
+      continue;
+    }
+    if (typeof v === "string") {
+      out[key] = v;
+    } else {
+      warn(
+        `settings.telemetry.resourceAttributes value for "${key}" must be a string (got ${typeof v}); ignoring`,
+        warnings
+      );
+    }
+  }
+  return out;
+}
+__name(coerceStringResourceAttributes, "coerceStringResourceAttributes");
+
+// packages/core/src/telemetry/config.ts
 function parseBooleanEnvFlag(value) {
   if (value === void 0) return void 0;
   return value === "true" || value === "1";
@@ -69391,6 +69970,33 @@ async function resolveTelemetrySettings(options) {
   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;
   const otlpMetricsEndpoint = env["QWEN_TELEMETRY_OTLP_METRICS_ENDPOINT"] ?? env["OTEL_EXPORTER_OTLP_METRICS_ENDPOINT"] ?? settings.otlpMetricsEndpoint;
+  const resourceAttributeWarnings = [];
+  const envResourceAttrs = stripReservedResourceAttributes(
+    parseOtelResourceAttributes(
+      env["OTEL_RESOURCE_ATTRIBUTES"],
+      resourceAttributeWarnings
+    ),
+    "OTEL_RESOURCE_ATTRIBUTES",
+    resourceAttributeWarnings
+  );
+  const settingsResourceAttrs = stripReservedResourceAttributes(
+    coerceStringResourceAttributes(
+      settings.resourceAttributes,
+      resourceAttributeWarnings
+    ),
+    "settings.telemetry.resourceAttributes",
+    resourceAttributeWarnings
+  );
+  const mergedResourceAttrs = {
+    ...envResourceAttrs,
+    ...settingsResourceAttrs
+  };
+  const otelServiceName = env["OTEL_SERVICE_NAME"]?.trim();
+  if (otelServiceName) {
+    mergedResourceAttrs["service.name"] = otelServiceName;
+  }
+  const resourceAttributes = Object.keys(mergedResourceAttrs).length ? mergedResourceAttrs : void 0;
+  const metricsIncludeSessionId = parseBooleanEnvFlag(env["QWEN_TELEMETRY_METRICS_INCLUDE_SESSION_ID"]) ?? settings.metrics?.includeSessionId ?? false;
   return {
     enabled,
     target,
@@ -69401,7 +70007,10 @@ async function resolveTelemetrySettings(options) {
     otlpMetricsEndpoint,
     logPrompts,
     includeSensitiveSpanAttributes,
-    outfile
+    outfile,
+    resourceAttributes,
+    metrics: { includeSessionId: metricsIncludeSessionId },
+    resourceAttributeWarnings: resourceAttributeWarnings.length ? resourceAttributeWarnings : void 0
   };
 }
 __name(resolveTelemetrySettings, "resolveTelemetrySettings");
@@ -69614,6 +70223,7 @@ var LoggingContentGenerator = class {
     this.wrapped = wrapped;
     this.config = config;
     this.modalities = generatorConfig.modalities;
+    this.generatorAuthType = generatorConfig.authType;
     if (generatorConfig.enableOpenAILogging) {
       this.openaiLogger = new OpenAILogger(
         generatorConfig.openAILoggingDir,
@@ -69628,6 +70238,7 @@ var LoggingContentGenerator = class {
   openaiLogger;
   schemaCompliance;
   modalities;
+  generatorAuthType;
   getWrapped() {
     return this.wrapped;
   }
@@ -69651,7 +70262,7 @@ var LoggingContentGenerator = class {
         model,
         durationMs,
         prompt_id,
-        this.config.getAuthType(),
+        this.generatorAuthType,
         usageMetadata,
         responseText,
         subagentNameContext.getStore()
@@ -69670,7 +70281,7 @@ var LoggingContentGenerator = class {
         model,
         durationMs,
         promptId: prompt_id,
-        authType: this.config.getAuthType(),
+        authType: this.generatorAuthType,
         errorMessage,
         errorType,
         statusCode: errorStatus,
@@ -69710,6 +70321,10 @@ var LoggingContentGenerator = class {
     const isInternal = isInternalPromptId(userPromptId);
     const session = this.startCaptureSession();
     try {
+      runtimeDiagnostics.recordGenerateContentRequest(req, {
+        stream: false,
+        source: "generateContent"
+      });
       if (!isInternal) {
         addSystemPromptAttributes(
           this.config,
@@ -69801,6 +70416,10 @@ var LoggingContentGenerator = class {
     const session = this.startCaptureSession();
     let stream;
     try {
+      runtimeDiagnostics.recordGenerateContentRequest(req, {
+        stream: true,
+        source: "generateContentStream"
+      });
       if (!isInternal) {
         addSystemPromptAttributes(
           this.config,
@@ -69935,47 +70554,51 @@ var LoggingContentGenerator = class {
       const durationMs = Date.now() - startTime;
       const consolidatedResponse = shouldCollectResponses ? this.consolidateGeminiResponsesForLogging(responses) : void 0;
       const streamResponseText = isInternal ? void 0 : this.extractResponseText(consolidatedResponse);
-      runInSpan(
-        () => this.safelyLogApiResponse(
-          firstResponseId,
-          durationMs,
-          firstModelVersion || model,
-          userPromptId,
-          lastUsageMetadata,
-          streamResponseText
-        )
-      );
-      if (!isInternal && span) {
-        addModelOutputAttributes(this.config, span, streamResponseText);
+      if (!spanEndedByTimeout) {
+        runInSpan(
+          () => this.safelyLogApiResponse(
+            firstResponseId,
+            durationMs,
+            firstModelVersion || model,
+            userPromptId,
+            lastUsageMetadata,
+            streamResponseText
+          )
+        );
+        if (!isInternal && span) {
+          addModelOutputAttributes(this.config, span, streamResponseText);
+        }
+        await runInSpan(
+          () => this.safelyLogOpenAIInteraction(
+            openaiRequest,
+            consolidatedResponse,
+            void 0,
+            userPromptId
+          )
+        );
       }
-      await runInSpan(
-        () => this.safelyLogOpenAIInteraction(
-          openaiRequest,
-          consolidatedResponse,
-          void 0,
-          userPromptId
-        )
-      );
     } catch (error) {
       errorOccurred = true;
-      const durationMs = Date.now() - startTime;
-      runInSpan(
-        () => this.safelyLogApiError(
-          firstResponseId,
-          durationMs,
-          error,
-          firstModelVersion || model,
-          userPromptId
-        )
-      );
-      await runInSpan(
-        () => this.safelyLogOpenAIInteraction(
-          openaiRequest,
-          void 0,
-          error,
-          userPromptId
-        )
-      );
+      if (!spanEndedByTimeout) {
+        const durationMs = Date.now() - startTime;
+        runInSpan(
+          () => this.safelyLogApiError(
+            firstResponseId,
+            durationMs,
+            error,
+            firstModelVersion || model,
+            userPromptId
+          )
+        );
+        await runInSpan(
+          () => this.safelyLogOpenAIInteraction(
+            openaiRequest,
+            void 0,
+            error,
+            userPromptId
+          )
+        );
+      }
       throw error;
     } finally {
       if (spanEndTimeout !== void 0) {
@@ -71675,11 +72298,11 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   }
   let baseGenerator;
   if (authType === "openai" /* USE_OPENAI */) {
-    const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-3H7XOZBW.js");
+    const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-XRP5JM6P.js");
     baseGenerator = createOpenAIContentGenerator(generatorConfig, config);
   } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
-    const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-JSQ7EPR3.js");
-    const { QwenContentGenerator } = await import("./qwenContentGenerator-FAU3QPYO.js");
+    const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-EEJGROP7.js");
+    const { QwenContentGenerator } = await import("./qwenContentGenerator-EOX3HZXX.js");
     try {
       const qwenClient = await getQwenOauthClient(
         config,
@@ -71696,10 +72319,10 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
       );
     }
   } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
-    const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-4QE6LTVV.js");
+    const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-RQJNXJIY.js");
     baseGenerator = createAnthropicContentGenerator(generatorConfig, config);
   } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
-    const { createGeminiContentGenerator } = await import("./geminiContentGenerator-DYHZPKJX.js");
+    const { createGeminiContentGenerator } = await import("./geminiContentGenerator-GYIOVT4A.js");
     baseGenerator = createGeminiContentGenerator(generatorConfig, config);
   } else {
     throw new Error(
@@ -73520,7 +74143,9 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
     }
     if (useFastPath && stats && isFullRead) {
       const status = cache.check(stats);
-      if (status.state === "fresh" && status.entry.lastReadAt !== void 0 && status.entry.lastReadWasFull && status.entry.lastReadCacheable && (status.entry.lastWriteAt === void 0 || status.entry.lastReadAt > status.entry.lastWriteAt)) {
+      if (status.state === "fresh" && status.entry.lastReadAt !== void 0 && status.entry.lastReadWasFull && status.entry.lastReadCacheable && // Only quote-back if that read is still in history (issue
+      // #4239: idle microcompaction flips this off when it blanks it).
+      status.entry.readResidentInHistory && (status.entry.lastWriteAt === void 0 || status.entry.lastReadAt > status.entry.lastWriteAt)) {
         debugLogger11.debug("hit", { path: absPath });
         return this.unchangedResult(absPath);
       }
@@ -73552,7 +74177,7 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
       });
     }
     let llmContent;
-    if (result.isTruncated) {
+    if (result.isTruncated && result.linesShown && result.originalLineCount !== void 0) {
       const [start, end] = result.linesShown;
       const total = result.originalLineCount;
       llmContent = `Showing lines ${start}-${end} of ${total} total lines.
@@ -73678,6 +74303,17 @@ var ReadFileTool = class _ReadFileTool extends BaseDeclarativeTool {
     if (params.limit !== void 0 && params.limit <= 0) {
       return "Limit must be a positive number";
     }
+    if (params.pages !== void 0) {
+      const pages = params.pages.trim();
+      params.pages = pages.length > 0 ? pages : void 0;
+    }
+    const ext = path7.extname(filePath).toLowerCase();
+    if ((params.offset !== void 0 || params.limit !== void 0) && ext === ".ipynb") {
+      return "offset and limit are not supported for Jupyter notebook (.ipynb) files. Notebooks are always read in full with structured cell output.";
+    }
+    if (params.pages !== void 0 && ext === ".ipynb") {
+      return "pages is not supported for Jupyter notebook (.ipynb) files. Notebooks are always read in full with structured cell output.";
+    }
     if (params.pages) {
       const parsed = parsePDFPageRange(params.pages);
       if (!parsed) {
@@ -73711,6 +74347,7 @@ export {
   UiTelemetryService,
   uiTelemetryService,
   safeJsonStringify,
+  require_safer,
   iconvEncode,
   iconvEncodingExists,
   isUtf8CompatibleEncoding,
@@ -73735,8 +74372,22 @@ export {
   getSystemEncoding,
   windowsCodePageToEncoding,
   detectEncodingFromBuffer,
+  normalizeSource,
+  parseNotebook,
+  inferNotebookJsonFormat,
+  serializeNotebook,
+  getCellDisplayId,
+  hasStableCellIds,
+  isAmbiguousCellId,
+  findCellIndex,
+  getNotebookLanguage,
+  makeCellId,
+  inferInsertedCellSourceArrayStyle,
+  toNotebookSource,
+  normalizeEditedCell,
   DEFAULT_ENCODING,
   detectBOM,
+  decodeBufferWithEncodingInfo,
   readFileWithEncodingInfo,
   readFileWithEncoding,
   countFileLines,
@@ -73790,6 +74441,7 @@ export {
   addModelOutputAttributes,
   addToolInputAttributes,
   addToolResultAttributes,
+  truncateSpanError,
   startInteractionSpan,
   endInteractionSpan,
   startLLMRequestSpan,
@@ -73799,6 +74451,10 @@ export {
   endToolSpan,
   startToolExecutionSpan,
   endToolExecutionSpan,
+  startToolBlockedOnUserSpan,
+  endToolBlockedOnUserSpan,
+  startHookSpan,
+  endHookSpan,
   getActiveInteractionSpan,
   isTelemetrySdkInitialized,
   initializeTelemetry,
@@ -73900,6 +74556,7 @@ export {
   TaggedThinkingParser,
   OpenAIContentConverter,
   openaiRequestCaptureContext,
+  resolveOpenAILogDir,
   OpenAILogger,
   openaiLogger,
   parseBooleanEnvFlag,
@@ -73908,6 +74565,7 @@ export {
   TelemetryTarget,
   DEFAULT_TELEMETRY_TARGET,
   DEFAULT_OTLP_ENDPOINT,
+  defaultModalities,
   MODEL_GENERATION_CONFIG_FIELDS,
   AUTH_ENV_MAPPINGS,
   DEFAULT_MODELS,