@qwen-code/qwen-code 0.19.7 → 0.19.8-nightly.20260710.205430235

package/chunks/chunk-5HOF2K5U.js

@@ -0,0 +1,19 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+
+// packages/cli/src/utils/updateEventEmitter.ts
+init_esbuild_shims();
+import { EventEmitter } from "node:events";
+var updateEventEmitter = new EventEmitter();
+
+export {
+  updateEventEmitter
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-GMOWQOQQ.js → chunk-5ZVIYNLN.js}

@@ -23,19 +23,19 @@ import {
 } from "./chunk-OMX7CUOE.js";
 import {
   isAnyAutoMemPath
-} from "./chunk-4KJ2BPIT.js";
+} from "./chunk-OACJLMLD.js";
 import {
   InstallationManager
 } from "./chunk-SUAKHHK7.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-FEJ2FZ3U.js";
+} from "./chunk-NY2ZOFMM.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-X3YGAX7V.js";
+} from "./chunk-KS2FRTYI.js";
 import {
   atomicWriteFile,
   atomicWriteFileSync
@@ -45,7 +45,7 @@ import {
   estimateTextTokens,
   runtimeDiagnostics,
   safeJsonParse
-} from "./chunk-CCGOFQV3.js";
+} from "./chunk-SS5P6JM6.js";
 import {
   require_lib
 } from "./chunk-IRJWHZWU.js";
@@ -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
           };
         }
@@ -69870,11 +70060,11 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   let baseGenerator;
   try {
     if (authType === "openai" /* USE_OPENAI */) {
-      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-PFF6HYB2.js");
+      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-OES264C3.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-SUUHZ6CR.js");
+      const { QwenContentGenerator } = await import("./qwenContentGenerator-QJ67LAJ5.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
@@ -69892,10 +70082,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-AKYPSZIV.js");
+      const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-55REPTTF.js");
       baseGenerator = createAnthropicContentGenerator(generatorConfig, config);
     } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
-      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-MKQACXEJ.js");
+      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-LJ2BNXHX.js");
       baseGenerator = createGeminiContentGenerator(generatorConfig, config);
     } else {
       throw new Error(
@@ -72663,6 +72853,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,