@qwen-code/qwen-code 0.19.8 → 0.19.9

package/chunks/{chunk-UXEW557D.js → chunk-3AHXV67U.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   getPackageJson
-} from "./chunk-43W4YSO6.js";
+} from "./chunk-VJNBRRZG.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";
@@ -14,7 +14,7 @@ import {
 init_esbuild_shims();
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.19.8";
+  return "0.19.9";
 }
 __name(getCliVersion, "getCliVersion");
 

package/chunks/{chunk-O2YT7VB4.js → chunk-3BTRNWWD.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";

package/chunks/chunk-3G7CIHVV.js

@@ -0,0 +1,71 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getErrorMessage
+} from "./chunk-VA4KQY6V.js";
+import {
+  extensionToOutputString,
+  getExtensionManager
+} from "./chunk-P67PFTUT.js";
+import {
+  loadSettings
+} from "./chunk-4C5BQ2D2.js";
+import {
+  initializeI18n,
+  resolveLanguageSetting,
+  t
+} from "./chunk-YAUFFXDS.js";
+import {
+  writeStderrLine,
+  writeStdoutLine
+} from "./chunk-YUZI3WAC.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/commands/extensions/list.ts
+init_esbuild_shims();
+async function handleList() {
+  try {
+    const settings = loadSettings();
+    await initializeI18n(
+      resolveLanguageSetting(settings.merged.general?.language)
+    );
+    const extensionManager = await getExtensionManager();
+    const extensions = extensionManager.getLoadedExtensions();
+    if (!extensions || extensions.length === 0) {
+      writeStdoutLine(t("No extensions installed."));
+      return;
+    }
+    writeStdoutLine(
+      extensions.map(
+        (extension, _) => extensionToOutputString(extension, extensionManager, process.cwd())
+      ).join("\n\n")
+    );
+  } catch (error) {
+    writeStderrLine(getErrorMessage(error));
+    process.exit(1);
+  }
+}
+__name(handleList, "handleList");
+var listCommand = {
+  command: "list",
+  describe: t("Lists installed extensions."),
+  builder: /* @__PURE__ */ __name((yargs) => yargs, "builder"),
+  handler: /* @__PURE__ */ __name(async () => {
+    await handleList();
+  }, "handler")
+};
+
+export {
+  handleList,
+  listCommand
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-FBET5XZ2.js → chunk-3SJSQXNS.js}

@@ -7,23 +7,23 @@ import {
   getSystemDefaultsPath,
   getSystemSettingsPath,
   resolveEnvVarsInObject
-} from "./chunk-O2YT7VB4.js";
+} from "./chunk-3BTRNWWD.js";
 import {
   DEFAULT_EXCLUDED_ENV_VARS,
   HOME_ENV_BOOTSTRAP_KEYS,
   PROJECT_ENV_HARDCODED_EXCLUSIONS
-} from "./chunk-Z3I3QJK3.js";
+} from "./chunk-QRUIS3DN.js";
 import {
   getPathComparisonVariants,
   isWithinRoot,
   require_strip_json_comments
-} from "./chunk-QYUE6W3T.js";
+} from "./chunk-RDJSGHZE.js";
 import {
   require_main
-} from "./chunk-SKAZWEV5.js";
+} from "./chunk-ZJE7NSL3.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name,
   __toESM
@@ -367,6 +367,18 @@ function pickFastPathSettings(value) {
   if (isPlainObject(env)) {
     out.env = pickStringRecord(env);
   }
+  const general = value["general"];
+  if (isPlainObject(general)) {
+    const chatRecording = general["chatRecording"];
+    if (chatRecording !== void 0 && typeof chatRecording !== "boolean") {
+      throw new Error(
+        "Serve fast path settings general.chatRecording must be a boolean."
+      );
+    }
+    if (chatRecording !== void 0) {
+      out.general = { chatRecording };
+    }
+  }
   const advanced = value["advanced"];
   if (isPlainObject(advanced)) {
     const pickedAdvanced = {};
@@ -511,6 +523,9 @@ function mergeFastPathSettings(...sources) {
     if (source.env) {
       merged.env = { ...merged.env ?? {}, ...source.env };
     }
+    if (source.general) {
+      merged.general = { ...merged.general ?? {}, ...source.general };
+    }
     if (source.advanced?.excludedEnvVars) {
       merged.advanced = {
         ...merged.advanced ?? {},

package/chunks/{chunk-BUZ6HGL4.js → chunk-3VAGG5T5.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-YLV3XXFB.js";
 import {
   InstallationManager
-} from "./chunk-SUAKHHK7.js";
+} from "./chunk-TDEXZKMT.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-FEJ2FZ3U.js";
+} from "./chunk-J3JA76CF.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-X3YGAX7V.js";
+} from "./chunk-B5ORX3FG.js";
 import {
   atomicWriteFile,
   atomicWriteFileSync
-} from "./chunk-7LTB54MK.js";
+} from "./chunk-ZLXQN2QS.js";
 import {
   convertSchema,
   estimateTextTokens,
   runtimeDiagnostics,
   safeJsonParse
-} from "./chunk-CCGOFQV3.js";
+} from "./chunk-JSG7ZSBC.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-J4TSQ5EQ.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
           };
         }
@@ -69674,6 +69864,7 @@ var MODEL_GENERATION_CONFIG_FIELDS = [
   "maxRetries",
   "retryErrorCodes",
   "enableCacheControl",
+  "forceGlobalCacheScope",
   "schemaCompliance",
   "reasoning",
   "contextWindowSize",
@@ -69870,11 +70061,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-AAYONPMF.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-PJQ27GSO.js");
+      const { QwenContentGenerator } = await import("./qwenContentGenerator-K3HZ2H76.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
@@ -69892,10 +70083,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-L73TO3DB.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-J7YNZDYP.js");
       baseGenerator = createGeminiContentGenerator(generatorConfig, config);
     } else {
       throw new Error(
@@ -72663,6 +72854,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,