@qwen-code/qwen-code 0.19.8 → 0.19.9-preview.0

package/chunks/{chunk-BUZ6HGL4.js → chunk-HWTL6MPR.js}

@@ -10,49 +10,49 @@ import {
   require_rpc,
   require_umd,
   require_writer
-} from "./chunk-E6US47KI.js";
+} from "./chunk-4WKAA4KS.js";
 import {
   require_hasown
-} from "./chunk-UWCTAVOD.js";
+} from "./chunk-CR3C7WXL.js";
 import {
   DEFAULT_QWEN_MODEL,
   MAINLINE_CODER_MODEL
-} from "./chunk-OFEVLU4C.js";
+} from "./chunk-CARU2RR2.js";
 import {
   Mutex
-} from "./chunk-OMX7CUOE.js";
+} from "./chunk-VGC4I5JJ.js";
 import {
   isAnyAutoMemPath
-} from "./chunk-OACJLMLD.js";
+} from "./chunk-FBU7WRZI.js";
 import {
   InstallationManager
-} from "./chunk-SUAKHHK7.js";
+} from "./chunk-Y66VOBRP.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-FEJ2FZ3U.js";
+} from "./chunk-WTNZ6DXB.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-X3YGAX7V.js";
+} from "./chunk-JGUT3LWZ.js";
 import {
   atomicWriteFile,
   atomicWriteFileSync
-} from "./chunk-7LTB54MK.js";
+} from "./chunk-WIEO4CWB.js";
 import {
   convertSchema,
   estimateTextTokens,
   runtimeDiagnostics,
   safeJsonParse
-} from "./chunk-CCGOFQV3.js";
+} from "./chunk-TQBODCFD.js";
 import {
   require_lib
-} from "./chunk-IRJWHZWU.js";
+} from "./chunk-A4UCTEB5.js";
 import {
   FinishReason,
   GenerateContentResponse
-} from "./chunk-55ZMG67I.js";
+} from "./chunk-4LD5APFL.js";
 import {
   FatalConfigError,
   Storage,
@@ -71,13 +71,13 @@ import {
   setShellTracePropagation,
   shortenPath,
   unescapePath
-} from "./chunk-22MNNNXE.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   require_dist
-} from "./chunk-ZERZSAZL.js";
+} from "./chunk-75DOP5OR.js";
 import {
   require_src
-} from "./chunk-QN5NZ3UQ.js";
+} from "./chunk-DMTGGOSA.js";
 import {
   DiagLogLevel,
   ROOT_CONTEXT,
@@ -93,11 +93,11 @@ import {
   metrics,
   propagation,
   trace
-} from "./chunk-Z2Z3GUXZ.js";
+} from "./chunk-TB6UDU4T.js";
 import {
   __qwen_dirname,
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __commonJS,
   __esm,
@@ -45840,19 +45840,19 @@ var require_getMachineId = __commonJS({
       if (!getMachineIdImpl) {
         switch (process2.platform) {
           case "darwin":
-            getMachineIdImpl = (await import("./getMachineId-darwin-HPQPEMZR.js")).getMachineId;
+            getMachineIdImpl = (await import("./getMachineId-darwin-IUOMFXU3.js")).getMachineId;
             break;
           case "linux":
-            getMachineIdImpl = (await import("./getMachineId-linux-AUARKYHL.js")).getMachineId;
+            getMachineIdImpl = (await import("./getMachineId-linux-K7XJYFHL.js")).getMachineId;
             break;
           case "freebsd":
-            getMachineIdImpl = (await import("./getMachineId-bsd-4CASPIU4.js")).getMachineId;
+            getMachineIdImpl = (await import("./getMachineId-bsd-EXV7SWPA.js")).getMachineId;
             break;
           case "win32":
-            getMachineIdImpl = (await import("./getMachineId-win-4EFLHYIJ.js")).getMachineId;
+            getMachineIdImpl = (await import("./getMachineId-win-KBA6RAI5.js")).getMachineId;
             break;
           default:
-            getMachineIdImpl = (await import("./getMachineId-unsupported-S32ZDA2T.js")).getMachineId;
+            getMachineIdImpl = (await import("./getMachineId-unsupported-EA5FDRJ6.js")).getMachineId;
             break;
         }
       }
@@ -52768,8 +52768,8 @@ var require_async = __commonJS({
         cb(null, x);
       }
     }, "maybeRealpath");
-    var defaultReadPackage = /* @__PURE__ */ __name(function defaultReadPackage2(readFile, pkgfile, cb) {
-      readFile(pkgfile, function(readFileErr, body) {
+    var defaultReadPackage = /* @__PURE__ */ __name(function defaultReadPackage2(readFile2, pkgfile, cb) {
+      readFile2(pkgfile, function(readFileErr, body) {
         if (readFileErr) cb(readFileErr);
         else {
           try {
@@ -52804,7 +52804,7 @@ var require_async = __commonJS({
       opts = normalizeOptions(x, opts);
       var isFile = opts.isFile || defaultIsFile;
       var isDirectory = opts.isDirectory || defaultIsDir;
-      var readFile = opts.readFile || fs9.readFile;
+      var readFile2 = opts.readFile || fs9.readFile;
       var realpath = opts.realpath || defaultRealpath;
       var readPackage = opts.readPackage || defaultReadPackage;
       if (opts.readFile && opts.readPackage) {
@@ -52930,7 +52930,7 @@ var require_async = __commonJS({
           var pkgfile = path11.join(pkgdir, "package.json");
           isFile(pkgfile, function(err2, ex) {
             if (!ex) return loadpkg(path11.dirname(dir), cb2);
-            readPackage(readFile, pkgfile, function(err3, pkgParam) {
+            readPackage(readFile2, pkgfile, function(err3, pkgParam) {
               if (err3) cb2(err3);
               var pkg = pkgParam;
               if (pkg && opts.packageFilter) {
@@ -52955,7 +52955,7 @@ var require_async = __commonJS({
           isFile(pkgfile, function(err2, ex) {
             if (err2) return cb2(err2);
             if (!ex) return loadAsFile(path11.join(x2, "index"), fpkg, cb2);
-            readPackage(readFile, pkgfile, function(err3, pkgParam) {
+            readPackage(readFile2, pkgfile, function(err3, pkgParam) {
               if (err3) return cb2(err3);
               var pkg = pkgParam;
               if (pkg && opts.packageFilter) {
@@ -59215,6 +59215,9 @@ __name(detectEncodingFromBuffer, "detectEncodingFromBuffer");
 // packages/core/src/utils/pdf.ts
 init_esbuild_shims();
 import { execFile } from "node:child_process";
+import { mkdtemp, readdir, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 var MAX_PDF_TEXT_OUTPUT_CHARS = 1e5;
 var PDF_FULL_TEXT_PAGE_LIMIT = 10;
 var PDF_MAX_PAGES_PER_READ = 20;
@@ -59223,6 +59226,10 @@ var PDF_TEXT_RESULT_MAX_TOKENS = 12e3;
 var PDF_TEXT_RESULT_WRAPPER_TOKEN_CHARS = 64;
 var PDF_TEXT_RESULT_CHARS_PER_TOKEN = 4;
 var PDF_TEXT_EXTRACTION_UNAVAILABLE_MESSAGE = "pdftotext is not installed. Install poppler-utils to enable PDF text extraction (e.g. `apt-get install poppler-utils` or `brew install poppler`).";
+var PDF_RENDER_UNAVAILABLE_MESSAGE = "pdftoppm is not installed. Install poppler-utils to enable PDF page rendering (e.g. `apt-get install poppler-utils` or `brew install poppler`).";
+var PDF_RENDER_SCALE_TO_PX = 1600;
+var PDF_RENDER_MAX_TOTAL_BASE64_BYTES = 25 * 1024 * 1024;
+var PDF_RENDER_TIMEOUT_MS = 12e4;
 var MAX_PDF_PAGE_NUMBER = 1e6;
 function shouldRequirePDFPageRange(pageCount, sizeBytes) {
   const hadPdfInfo = pageCount !== null;
@@ -59447,6 +59454,125 @@ async function extractPDFText(filePath, options) {
   }
 }
 __name(extractPDFText, "extractPDFText");
+var pdftoppmAvailable;
+var pdftoppmAvailablePromise;
+async function isPdftoppmAvailable() {
+  if (pdftoppmAvailable !== void 0) return pdftoppmAvailable;
+  if (pdftoppmAvailablePromise) return pdftoppmAvailablePromise;
+  pdftoppmAvailablePromise = (async () => {
+    try {
+      const { code } = await execCommand("pdftoppm", ["-v"], {
+        timeout: 5e3
+      });
+      return code === 0;
+    } catch {
+      return false;
+    }
+  })().then((result) => {
+    pdftoppmAvailable = result;
+    return result;
+  }).finally(() => {
+    pdftoppmAvailablePromise = void 0;
+  });
+  return pdftoppmAvailablePromise;
+}
+__name(isPdftoppmAvailable, "isPdftoppmAvailable");
+function comparePdfPageFilenames(a, b) {
+  const pageNumber = /* @__PURE__ */ __name((name) => {
+    const match = /(\d+)\.jpg$/i.exec(name);
+    return match ? parseInt(match[1], 10) : 0;
+  }, "pageNumber");
+  return pageNumber(a) - pageNumber(b);
+}
+__name(comparePdfPageFilenames, "comparePdfPageFilenames");
+async function renderPDFPagesToImages(filePath, options) {
+  const available = await isPdftoppmAvailable();
+  if (!available) {
+    return { success: false, error: PDF_RENDER_UNAVAILABLE_MESSAGE };
+  }
+  let tempDir;
+  try {
+    tempDir = await mkdtemp(join(tmpdir(), "pdf-render-"));
+    const outputPrefix = join(tempDir, "page");
+    const args = [
+      "-jpeg",
+      "-scale-to",
+      String(PDF_RENDER_SCALE_TO_PX)
+    ];
+    if (options?.firstPage) {
+      args.push("-f", String(options.firstPage));
+    }
+    if (options?.lastPage && options.lastPage !== Infinity) {
+      args.push("-l", String(options.lastPage));
+    }
+    args.push("--", filePath, outputPrefix);
+    const { stderr, code, timedOut } = await execCommand("pdftoppm", args, {
+      timeout: PDF_RENDER_TIMEOUT_MS
+    });
+    if (timedOut) {
+      return {
+        success: false,
+        error: `pdftoppm timed out after ${Math.round(
+          PDF_RENDER_TIMEOUT_MS / 1e3
+        )}s. The PDF may be unusually large or complex; try the 'pages' parameter to narrow the range.`
+      };
+    }
+    if (code !== 0) {
+      if (/password/i.test(stderr)) {
+        return {
+          success: false,
+          error: "PDF is password-protected. Please provide an unprotected version."
+        };
+      }
+      if (/damaged|corrupt|invalid/i.test(stderr)) {
+        return { success: false, error: "PDF file is corrupted or invalid." };
+      }
+      return {
+        success: false,
+        error: `pdftoppm failed: ${stderr || "(no stderr)"}`
+      };
+    }
+    const entries = (await readdir(tempDir)).filter((name) => name.toLowerCase().endsWith(".jpg")).sort(comparePdfPageFilenames);
+    if (entries.length === 0) {
+      return {
+        success: false,
+        error: "pdftoppm produced no image output. The PDF may be empty or the page range may be out of bounds."
+      };
+    }
+    const images = [];
+    let totalBytes = 0;
+    let bytesTruncated = false;
+    for (const name of entries) {
+      const buffer = await readFile(join(tempDir, name));
+      const data = buffer.toString("base64");
+      if (images.length > 0 && totalBytes + data.length > PDF_RENDER_MAX_TOTAL_BASE64_BYTES) {
+        bytesTruncated = true;
+        break;
+      }
+      totalBytes += data.length;
+      images.push({ data, mimeType: "image/jpeg" });
+    }
+    return { success: true, images, bytesTruncated };
+  } catch (e) {
+    return {
+      success: false,
+      error: `pdftoppm execution failed: ${e instanceof Error ? e.message : String(e)}`
+    };
+  } finally {
+    if (tempDir) {
+      await rm(tempDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
+}
+__name(renderPDFPagesToImages, "renderPDFPagesToImages");
+
+// packages/core/src/services/visionBridge/vision-bridge-constants.ts
+init_esbuild_shims();
+var VISION_BRIDGE_MAX_IMAGES = 4;
+var VISION_BRIDGE_MAX_IMAGE_BASE64_BYTES = Math.floor(
+  9.9 * 1024 * 1024
+);
 
 // packages/core/src/utils/notebook.ts
 init_esbuild_shims();
@@ -60494,6 +60620,8 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
     const relativePathForDisplay = path2.relative(rootDirectory, filePath).replace(/\\/g, "/");
     const displayName = path2.basename(filePath);
     const modalities = config.getContentGeneratorConfig?.()?.modalities ?? {};
+    const willRenderPdfImages = fileType === "pdf" && !!modalities.image && largePdfBehavior !== "reference";
+    const renderForBridge = fileType === "pdf" && !modalities.image && preserveUnsupportedImage;
     const fileSizeInMB = stats.size / (1024 * 1024);
     const normalizedPages = pages?.trim();
     let pageRange;
@@ -60545,10 +60673,11 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
     if (willExtractPdfText && !pageRange) {
       const pageCount = await getPDFPageCount(filePath);
       const requirement = shouldRequirePDFPageRange(pageCount, stats.size);
+      const rangeRequired = willRenderPdfImages ? requirement.effectivePageCount > PDF_MAX_PAGES_PER_READ : requirement.required;
       debugLogger2.debug(
-        `PDF full-text fallback gate: file=${relativePathForDisplay}, sizeMB=${fileSizeInMB.toFixed(2)}, pageCount=${pageCount ?? "unknown"}, required=${requirement.required}, effectivePageCount=${requirement.effectivePageCount}, hadPdfInfo=${requirement.hadPdfInfo}, behavior=${largePdfBehavior}`
+        `PDF full-text fallback gate: file=${relativePathForDisplay}, sizeMB=${fileSizeInMB.toFixed(2)}, pageCount=${pageCount ?? "unknown"}, required=${requirement.required}, rangeRequired=${rangeRequired}, effectivePageCount=${requirement.effectivePageCount}, hadPdfInfo=${requirement.hadPdfInfo}, behavior=${largePdfBehavior}`
       );
-      if (requirement.required) {
+      if (rangeRequired) {
         if (largePdfBehavior === "error" && !await isPdftotextAvailable()) {
           return {
             llmContent: `[Cannot extract text from PDF: "${displayName}". ${PDF_TEXT_EXTRACTION_UNAVAILABLE_MESSAGE}]`,
@@ -60755,34 +60884,95 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
         const pdfResult = await extractPDFText(filePath, pageRange);
         if (pdfResult.success) {
           const estimatedTokens = estimatePDFTextOutputTokens(pdfResult.text);
-          if (estimatedTokens > PDF_TEXT_RESULT_MAX_TOKENS) {
-            debugLogger2.debug(
-              `PDF text extraction output exceeds token limit: file=${relativePathForDisplay}, pages=${normalizedPages ?? "all"}, estimatedTokens=${estimatedTokens}, limit=${PDF_TEXT_RESULT_MAX_TOKENS}`
-            );
-            const guidance = buildPDFTextTooLargeGuidance(
-              displayName,
-              estimatedTokens,
-              normalizedPages
-            );
-            if (!pageRange && largePdfBehavior === "reference") {
-              return {
-                llmContent: guidance,
-                returnDisplay: `Referenced large PDF: ${relativePathForDisplay}`,
-                stats
-              };
+          if (estimatedTokens <= PDF_TEXT_RESULT_MAX_TOKENS) {
+            const pagesLabel = normalizedPages ? ` (pages ${normalizedPages})` : "";
+            return {
+              llmContent: pdfResult.text,
+              returnDisplay: `Read pdf as text${pagesLabel}: ${relativePathForDisplay}`,
+              stats
+            };
+          }
+        }
+        const toImageParts = /* @__PURE__ */ __name((images, startPage) => images.map((image, index) => ({
+          inlineData: {
+            data: image.data,
+            mimeType: image.mimeType,
+            displayName: `${displayName} (page ${startPage + index})`
+          }
+        })), "toImageParts");
+        if (willRenderPdfImages) {
+          const startPage = pageRange?.firstPage ?? 1;
+          const render = await renderPDFPagesToImages(
+            filePath,
+            pageRange ?? { firstPage: 1, lastPage: PDF_MAX_PAGES_PER_READ }
+          );
+          if (render.success) {
+            const parts = toImageParts(render.images, startPage);
+            if (render.bytesTruncated) {
+              parts.push({
+                text: `[Rendered the first ${render.images.length} page(s) of "${displayName}"; later pages were omitted to stay within size limits. Use the 'pages' parameter to read a specific range.]`
+              });
+            } else if (!pageRange && render.images.length >= PDF_MAX_PAGES_PER_READ) {
+              parts.push({
+                text: `[Rendered the first ${render.images.length} page(s) (the per-read maximum) of "${displayName}". If the document has more pages, use the 'pages' parameter to read a later range.]`
+              });
+            }
+            return {
+              llmContent: parts,
+              returnDisplay: `Read pdf as ${render.images.length} image(s): ${relativePathForDisplay}`,
+              stats
+            };
+          }
+          debugLogger2.debug(
+            `PDF image render failed, falling back to text outcome: file=${relativePathForDisplay}, error=${render.error}`
+          );
+        }
+        if (renderForBridge && pdfResult.success === false) {
+          const render = await renderPDFPagesToImages(filePath, {
+            firstPage: 1,
+            lastPage: VISION_BRIDGE_MAX_IMAGES
+          });
+          if (render.success) {
+            const parts = toImageParts(render.images, 1);
+            const pageCount = await getPDFPageCount(filePath);
+            const mayHaveMore = pageCount !== null ? pageCount > render.images.length : render.images.length >= VISION_BRIDGE_MAX_IMAGES;
+            if (mayHaveMore || render.bytesTruncated) {
+              const total = pageCount !== null ? ` of ${pageCount}` : "";
+              parts.push({
+                text: `[Rendered the first ${render.images.length}${total} page(s) of "${displayName}" for transcription; later pages were not included.]`
+              });
             }
+            return {
+              llmContent: parts,
+              returnDisplay: `Rendered ${render.images.length} page(s) for transcription: ${relativePathForDisplay}`,
+              stats
+            };
+          }
+          debugLogger2.debug(
+            `PDF bridge render failed, falling back to text outcome: file=${relativePathForDisplay}, error=${render.error}`
+          );
+        }
+        if (pdfResult.success) {
+          const guidance = buildPDFTextTooLargeGuidance(
+            displayName,
+            estimatePDFTextOutputTokens(pdfResult.text),
+            normalizedPages
+          );
+          debugLogger2.debug(
+            `PDF text extraction output exceeds token limit: file=${relativePathForDisplay}, pages=${normalizedPages ?? "all"}, limit=${PDF_TEXT_RESULT_MAX_TOKENS}`
+          );
+          if (!pageRange && largePdfBehavior === "reference") {
             return {
               llmContent: guidance,
-              returnDisplay: `PDF text too large: ${relativePathForDisplay}`,
-              error: guidance,
-              errorType: "file_too_large" /* FILE_TOO_LARGE */,
+              returnDisplay: `Referenced large PDF: ${relativePathForDisplay}`,
               stats
             };
           }
-          const pagesLabel = normalizedPages ? ` (pages ${normalizedPages})` : "";
           return {
-            llmContent: pdfResult.text,
-            returnDisplay: `Read pdf as text${pagesLabel}: ${relativePathForDisplay}`,
+            llmContent: guidance,
+            returnDisplay: `PDF text too large: ${relativePathForDisplay}`,
+            error: guidance,
+            errorType: "file_too_large" /* FILE_TOO_LARGE */,
             stats
           };
         }
@@ -61746,7 +61936,7 @@ function getLanguageFromFilePath(filePath) {
     return extensionToLanguageMap[extension];
   }
   const filename = path3.basename(filePath).toLowerCase();
-  return extensionToLanguageMap[`.${filename}`];
+  return extensionToLanguageMap[filename] ?? extensionToLanguageMap[`.${filename}`];
 }
 __name(getLanguageFromFilePath, "getLanguageFromFilePath");
 
@@ -63984,6 +64174,20 @@ function parseTaggedThinkingText(text) {
 }
 __name(parseTaggedThinkingText, "parseTaggedThinkingText");
 
+// packages/core/src/core/invalid-stream-error.ts
+init_esbuild_shims();
+var InvalidStreamError = class extends Error {
+  static {
+    __name(this, "InvalidStreamError");
+  }
+  type;
+  constructor(message, type) {
+    super(message);
+    this.name = "InvalidStreamError";
+    this.type = type;
+  }
+};
+
 // packages/core/src/core/openaiContentGenerator/converter.ts
 var debugLogger6 = createDebugLogger("CONVERTER");
 var SPLIT_TOOL_MEDIA_TEXT = "(attached media from previous tool call)";
@@ -64640,6 +64844,10 @@ function hasThoughtPart(parts) {
   return parts.some((part) => part.thought === true);
 }
 __name(hasThoughtPart, "hasThoughtPart");
+var THINKING_TAG_PATTERN = /<\/?think(?:ing)?\s*>/i;
+var CLOSING_THINKING_TAG_PATTERN = /\n[^\S\r\n]*<\/think(?:ing)?[^\S\r\n]*>/i;
+var LEADING_CLOSING_THINKING_TAG_PATTERN = /^[^\S\r\n]*<\/think(?:ing)?[^\S\r\n]*>/i;
+var LEADING_THINKING_TAG_PATTERN = /^\s*<\/?think(?:ing)?\s*>/i;
 function convertOpenAIResponseToGemini(openaiResponse, requestContext) {
   const choice = openaiResponse.choices?.[0];
   const response = new GenerateContentResponse();
@@ -64723,7 +64931,7 @@ function convertOpenAIChunkToGemini(chunk, requestContext) {
     );
   }
   if (choice) {
-    const parts = [];
+    let parts = [];
     let contentParts = [];
     const reasoningText = choice.delta?.reasoning_content ?? choice.delta?.reasoning;
     if (typeof choice.delta?.content === "string") {
@@ -64768,6 +64976,12 @@ function convertOpenAIChunkToGemini(chunk, requestContext) {
           cumulativeMode: false
         }
       );
+      if (normalizedReasoningText) {
+        requestContext.hasStructuredReasoningContent = true;
+        if (THINKING_TAG_PATTERN.test(normalizedReasoningText)) {
+          requestContext.hasThinkingTagInReasoning = true;
+        }
+      }
       if (normalizedReasoningText && !requestContext.responseParsingOptions?.taggedThinkingTags) {
         parts.push(createOpenAIReasoningThoughtPart(normalizedReasoningText));
       } else if (normalizedReasoningText && !requestContext.hasTaggedThinkingThought) {
@@ -64825,10 +65039,45 @@ function convertOpenAIChunkToGemini(chunk, requestContext) {
         }
       }
     }
+    const visibleText = parts.map(
+      (part) => part.thought !== true && typeof part.text === "string" ? part.text : ""
+    ).join("");
+    const leakedThinkingTag = requestContext.hasStructuredReasoningContent === true && (requestContext.hasVisibleContent !== true && LEADING_THINKING_TAG_PATTERN.test(visibleText) || requestContext.hasThinkingTagInReasoning === true && (CLOSING_THINKING_TAG_PATTERN.test(visibleText) || requestContext.atVisibleLineStart === true && LEADING_CLOSING_THINKING_TAG_PATTERN.test(visibleText)));
+    if (/\S/.test(visibleText)) {
+      requestContext.hasVisibleContent = true;
+    }
+    if (visibleText && requestContext.hasThinkingTagInReasoning === true) {
+      const lastLineBreak = visibleText.lastIndexOf("\n");
+      const lineSuffix = visibleText.slice(lastLineBreak + 1);
+      requestContext.atVisibleLineStart = (lastLineBreak >= 0 || requestContext.atVisibleLineStart === true) && /^[^\S\r\n]*$/.test(lineSuffix);
+    }
+    if (leakedThinkingTag) {
+      requestContext.pendingUntrustedResponseParts = void 0;
+      throw new InvalidStreamError(
+        "Model response leaked thinking tags.",
+        "PROTOCOL_TAG_LEAK"
+      );
+    }
+    const toolCallWithoutName = toolCallParser.hasNamelessToolCall();
+    const completedToolCalls = choice.finish_reason ? toolCallParser.getCompletedToolCalls() : [];
+    if (choice.finish_reason && (toolCallWithoutName || choice.finish_reason === "tool_calls" && completedToolCalls.length === 0)) {
+      requestContext.pendingUntrustedResponseParts = void 0;
+      throw new InvalidStreamError(
+        "Model response contained a malformed tool call.",
+        "MALFORMED_TOOL_CALL"
+      );
+    }
+    const shouldHoldParts = !choice.finish_reason && (toolCallWithoutName || requestContext.hasThinkingTagInReasoning === true);
+    if (shouldHoldParts) {
+      (requestContext.pendingUntrustedResponseParts ??= []).push(...parts);
+      parts.length = 0;
+    } else if (requestContext.pendingUntrustedResponseParts) {
+      parts = requestContext.pendingUntrustedResponseParts.concat(parts);
+      requestContext.pendingUntrustedResponseParts = void 0;
+    }
     let toolCallsTruncated = false;
     if (choice.finish_reason) {
       toolCallsTruncated = toolCallParser.hasIncompleteToolCalls();
-      const completedToolCalls = toolCallParser.getCompletedToolCalls();
       for (const toolCall of completedToolCalls) {
         if (toolCall.name) {
           parts.push({
@@ -66538,7 +66787,11 @@ function endToolExecutionSpan(span, metadata) {
   spanCtx.ended = true;
   try {
     const duration = Date.now() - spanCtx.startTime;
-    const endAttributes = { duration_ms: duration };
+    const endAttributes = {};
+    if (metadata?.attributes) {
+      Object.assign(endAttributes, metadata.attributes);
+    }
+    endAttributes["duration_ms"] = duration;
     if (metadata) {
       if (metadata.success !== void 0)
         endAttributes["success"] = metadata.success;
@@ -68172,6 +68425,44 @@ var UiTelemetryService = class _UiTelemetryService extends EventEmitter {
 };
 var uiTelemetryService = new UiTelemetryService();
 
+// packages/core/src/telemetry/api-activity-tracker.ts
+init_esbuild_shims();
+var ApiActivityTracker = class {
+  static {
+    __name(this, "ApiActivityTracker");
+  }
+  #errors = 0;
+  #retries = 0;
+  /** Fold in one model API error (called from `logApiError`). */
+  recordError() {
+    this.#errors += 1;
+  }
+  /** Fold in one automatic retry (called from `logApiRetry`). */
+  recordRetry() {
+    this.#retries += 1;
+  }
+  /**
+   * Return the counts accumulated since the last drain and reset them to zero.
+   * The read+reset is synchronous (no `await` between), so a `recordError` /
+   * `recordRetry` racing an in-progress drain can never be lost — it simply
+   * lands in the next window.
+   */
+  drain() {
+    const counts = {
+      errors: this.#errors,
+      retries: this.#retries
+    };
+    this.#errors = 0;
+    this.#retries = 0;
+    return counts;
+  }
+  /** Peek at the pending counts without draining (tests / diagnostics). */
+  peek() {
+    return { errors: this.#errors, retries: this.#retries };
+  }
+};
+var apiActivityTracker = new ApiActivityTracker();
+
 // packages/core/src/telemetry/daemon-tracing.ts
 init_esbuild_shims();
 init_esm();
@@ -69674,6 +69965,7 @@ var MODEL_GENERATION_CONFIG_FIELDS = [
   "maxRetries",
   "retryErrorCodes",
   "enableCacheControl",
+  "forceGlobalCacheScope",
   "schemaCompliance",
   "reasoning",
   "contextWindowSize",
@@ -69870,11 +70162,11 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   let baseGenerator;
   try {
     if (authType === "openai" /* USE_OPENAI */) {
-      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-YE42PKCY.js");
+      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-OBDNNOE2.js");
       baseGenerator = createOpenAIContentGenerator(generatorConfig, config);
     } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
-      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-ZV7YLMND.js");
-      const { QwenContentGenerator } = await import("./qwenContentGenerator-NX2E7PB7.js");
+      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-LEYOU7RU.js");
+      const { QwenContentGenerator } = await import("./qwenContentGenerator-LH2U2YRG.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
@@ -69892,10 +70184,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-CPF22MA7.js");
+      const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-56U3YCP2.js");
       baseGenerator = createAnthropicContentGenerator(generatorConfig, config);
     } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
-      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-CDUNEJQE.js");
+      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-XBYBAIDQ.js");
       baseGenerator = createGeminiContentGenerator(generatorConfig, config);
     } else {
       throw new Error(
@@ -71620,6 +71912,7 @@ function logApiError(config, event) {
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
   uiTelemetryService.addEvent(uiEvent, config.getSessionId());
+  apiActivityTracker.recordError();
   if (!isInternalPromptId(event.prompt_id)) {
     recordUiTelemetryEventToChat(config, uiEvent);
   }
@@ -71886,6 +72179,7 @@ function logContentRetryFailure(config, event) {
 }
 __name(logContentRetryFailure, "logContentRetryFailure");
 function logApiRetry(config, event) {
+  apiActivityTracker.recordRetry();
   QwenLogger.getInstance(config)?.logApiRetryEvent(event);
   if (!isTelemetrySdkInitialized()) return;
   const attributes = {
@@ -72663,6 +72957,8 @@ var ReadFileTool = class _ReadFileTool extends BaseDeclarativeTool {
 };
 
 export {
+  VISION_BRIDGE_MAX_IMAGES,
+  VISION_BRIDGE_MAX_IMAGE_BASE64_BYTES,
   EVENT_TOOL_CALL,
   EVENT_API_ERROR,
   EVENT_API_RESPONSE,
@@ -72796,6 +73092,7 @@ export {
   refreshSessionContext,
   shutdownTelemetry,
   forceFlushMetrics,
+  apiActivityTracker,
   _recoverObjectsFromLine,
   parseLineTolerant,
   readLines,
@@ -72931,6 +73228,7 @@ export {
   parseThought,
   getThoughtSummary,
   TaggedThinkingParser,
+  InvalidStreamError,
   OpenAIContentConverter,
   openaiRequestCaptureContext,
   isApiError,