@qwen-code/qwen-code 0.19.6-nightly.20260707.bcdb44c5d → 0.19.6-preview.0

package/chunks/{chunk-IPKM25FZ.js → chunk-N33JAGJ7.js}

@@ -42,9 +42,10 @@ import {
 } from "./chunk-7LTB54MK.js";
 import {
   convertSchema,
+  estimateTextTokens,
   runtimeDiagnostics,
   safeJsonParse
-} from "./chunk-NCFY7PWS.js";
+} from "./chunk-CCGOFQV3.js";
 import {
   require_lib
 } from "./chunk-IRJWHZWU.js";
@@ -52737,18 +52738,18 @@ var require_async = __commonJS({
       ];
     }, "defaultPaths");
     var defaultIsFile = /* @__PURE__ */ __name(function isFile(file, cb) {
-      fs9.stat(file, function(err, stat) {
+      fs9.stat(file, function(err, stat2) {
         if (!err) {
-          return cb(null, stat.isFile() || stat.isFIFO());
+          return cb(null, stat2.isFile() || stat2.isFIFO());
         }
         if (err.code === "ENOENT" || err.code === "ENOTDIR") return cb(null, false);
         return cb(err);
       });
     }, "isFile");
     var defaultIsDir = /* @__PURE__ */ __name(function isDirectory(dir, cb) {
-      fs9.stat(dir, function(err, stat) {
+      fs9.stat(dir, function(err, stat2) {
         if (!err) {
-          return cb(null, stat.isDirectory());
+          return cb(null, stat2.isDirectory());
         }
         if (err.code === "ENOENT" || err.code === "ENOTDIR") return cb(null, false);
         return cb(err);
@@ -53244,21 +53245,21 @@ var require_sync = __commonJS({
     }, "defaultPaths");
     var defaultIsFile = /* @__PURE__ */ __name(function isFile(file) {
       try {
-        var stat = fs9.statSync(file, { throwIfNoEntry: false });
+        var stat2 = fs9.statSync(file, { throwIfNoEntry: false });
       } catch (e) {
         if (e && (e.code === "ENOENT" || e.code === "ENOTDIR")) return false;
         throw e;
       }
-      return !!stat && (stat.isFile() || stat.isFIFO());
+      return !!stat2 && (stat2.isFile() || stat2.isFIFO());
     }, "isFile");
     var defaultIsDir = /* @__PURE__ */ __name(function isDirectory(dir) {
       try {
-        var stat = fs9.statSync(dir, { throwIfNoEntry: false });
+        var stat2 = fs9.statSync(dir, { throwIfNoEntry: false });
       } catch (e) {
         if (e && (e.code === "ENOENT" || e.code === "ENOTDIR")) return false;
         throw e;
       }
-      return !!stat && stat.isDirectory();
+      return !!stat2 && stat2.isDirectory();
     }, "isDirectory");
     var defaultRealpathSync = /* @__PURE__ */ __name(function realpathSync(x) {
       try {
@@ -53684,14 +53685,14 @@ var require_require_in_the_middle = __commonJS({
           moduleName = parsedPath.name;
           basedir = parsedPath.dir;
         } else {
-          const stat = moduleDetailsFromPath(filename);
-          if (stat === void 0) {
+          const stat2 = moduleDetailsFromPath(filename);
+          if (stat2 === void 0) {
             debug("could not parse filename: %s", filename);
             return exports2;
           }
-          moduleName = stat.name;
-          basedir = stat.basedir;
-          const fullModuleName = resolveModuleName(stat);
+          moduleName = stat2.name;
+          basedir = stat2.basedir;
+          const fullModuleName = resolveModuleName(stat2);
           debug("resolved filename to module: %s (id: %s, resolved: %s, basedir: %s)", moduleName, id, fullModuleName, basedir);
           let matchFound = false;
           if (hasWhitelist) {
@@ -53755,9 +53756,9 @@ var require_require_in_the_middle = __commonJS({
         }
       }
     };
-    function resolveModuleName(stat) {
-      const normalizedPath = path11.sep !== "/" ? stat.path.split(path11.sep).join("/") : stat.path;
-      return path11.posix.join(stat.name, normalizedPath).replace(normalize2, "");
+    function resolveModuleName(stat2) {
+      const normalizedPath = path11.sep !== "/" ? stat2.path.split(path11.sep).join("/") : stat2.path;
+      return path11.posix.join(stat2.name, normalizedPath).replace(normalize2, "");
     }
     __name(resolveModuleName, "resolveModuleName");
   }
@@ -59215,7 +59216,53 @@ __name(detectEncodingFromBuffer, "detectEncodingFromBuffer");
 init_esbuild_shims();
 import { execFile } from "node:child_process";
 var MAX_PDF_TEXT_OUTPUT_CHARS = 1e5;
+var PDF_FULL_TEXT_PAGE_LIMIT = 10;
+var PDF_MAX_PAGES_PER_READ = 20;
+var PDF_PAGE_COUNT_SIZE_HEURISTIC_BYTES = 100 * 1024;
+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 MAX_PDF_PAGE_NUMBER = 1e6;
+function shouldRequirePDFPageRange(pageCount, sizeBytes) {
+  const hadPdfInfo = pageCount !== null;
+  const effectivePageCount = pageCount ?? Math.ceil(sizeBytes / PDF_PAGE_COUNT_SIZE_HEURISTIC_BYTES);
+  return {
+    required: effectivePageCount > PDF_FULL_TEXT_PAGE_LIMIT,
+    effectivePageCount,
+    hadPdfInfo
+  };
+}
+__name(shouldRequirePDFPageRange, "shouldRequirePDFPageRange");
+function estimatePDFTextOutputTokens(text) {
+  return Math.ceil(
+    estimateTextTokens(text) + PDF_TEXT_RESULT_WRAPPER_TOKEN_CHARS / PDF_TEXT_RESULT_CHARS_PER_TOKEN
+  );
+}
+__name(estimatePDFTextOutputTokens, "estimatePDFTextOutputTokens");
+function buildLargePDFGuidance(displayName, requirement) {
+  const source = requirement.hadPdfInfo ? "has" : "appears to have about";
+  return `PDF "${displayName}" ${source} ${requirement.effectivePageCount} pages, which is too many to read at once. Use the 'pages' parameter to read a specific page range such as '1-5'. Maximum ${PDF_MAX_PAGES_PER_READ} pages per request.`;
+}
+__name(buildLargePDFGuidance, "buildLargePDFGuidance");
+function buildPDFTextTooLargeGuidance(displayName, estimatedTokens, pagesUsed) {
+  const pageRange = pagesUsed ? parsePDFPageRange(pagesUsed) : null;
+  const prefix = `PDF text extracted from "${displayName}" is too large to return safely (${estimatedTokens} estimated tokens; limit ${PDF_TEXT_RESULT_MAX_TOKENS}).`;
+  if (pageRange && pageRange.firstPage === pageRange.lastPage) {
+    return `${prefix} The selected page exceeds the output limit. Use a native PDF-capable model, split the page content externally, or extract a smaller section with another tool.`;
+  }
+  if (pageRange) {
+    const suggestedEnd = Math.floor(
+      (pageRange.firstPage + pageRange.lastPage) / 2
+    );
+    if (suggestedEnd === pageRange.firstPage) {
+      return `${prefix} Use the 'pages' parameter with a single page, for example '${pageRange.firstPage}'.`;
+    }
+    return `${prefix} Use the 'pages' parameter with fewer pages, for example '${pageRange.firstPage}-${suggestedEnd}' or a single page.`;
+  }
+  return `${prefix} Use the 'pages' parameter with a narrower range, for example '1-2' or a single page.`;
+}
+__name(buildPDFTextTooLargeGuidance, "buildPDFTextTooLargeGuidance");
 function execCommand(command, args, options = {}) {
   return new Promise((resolve2) => {
     execFile(
@@ -59299,12 +59346,31 @@ async function isPdftotextAvailable() {
   return pdftotextAvailablePromise;
 }
 __name(isPdftotextAvailable, "isPdftotextAvailable");
+async function getPDFPageCount(filePath) {
+  try {
+    const { stdout, code } = await execCommand("pdfinfo", ["--", filePath], {
+      timeout: 1e4
+    });
+    if (code !== 0) {
+      return null;
+    }
+    const match = /^Pages:\s+(\d+)/m.exec(stdout);
+    if (!match) {
+      return null;
+    }
+    const count = parseInt(match[1], 10);
+    return isNaN(count) ? null : count;
+  } catch {
+    return null;
+  }
+}
+__name(getPDFPageCount, "getPDFPageCount");
 async function extractPDFText(filePath, options) {
   const available = await isPdftotextAvailable();
   if (!available) {
     return {
       success: false,
-      error: "pdftotext is not installed. Install poppler-utils to enable PDF text extraction (e.g. `apt-get install poppler-utils` or `brew install poppler`)."
+      error: PDF_TEXT_EXTRACTION_UNAVAILABLE_MESSAGE
     };
   }
   const args = ["-layout"];
@@ -59329,12 +59395,15 @@ async function extractPDFText(filePath, options) {
         error: `pdftotext timed out after 30s. The PDF may be unusually large or complex; try the 'pages' parameter to narrow the range.`
       };
     }
-    if (maxBufferExceeded && stdout.length >= MAX_PDF_TEXT_OUTPUT_CHARS) {
+    if (maxBufferExceeded && Buffer.byteLength(stdout, "utf8") >= MAX_PDF_TEXT_OUTPUT_CHARS) {
+      const wasCharTruncated = stdout.length > MAX_PDF_TEXT_OUTPUT_CHARS;
+      const text = wasCharTruncated ? stdout.substring(0, MAX_PDF_TEXT_OUTPUT_CHARS) : stdout;
+      const truncationReason = wasCharTruncated ? `at ${MAX_PDF_TEXT_OUTPUT_CHARS} characters` : "after reaching the PDF text buffer limit";
       return {
         success: true,
-        text: stdout.substring(0, MAX_PDF_TEXT_OUTPUT_CHARS) + `
+        text: text + `
 
-... [text truncated at ${MAX_PDF_TEXT_OUTPUT_CHARS} characters. Use the 'pages' parameter to read specific page ranges.]`
+... [text truncated ${truncationReason}. Use the 'pages' parameter to read specific page ranges.]`
       };
     }
     if (code !== 0 || maxBufferExceeded) {
@@ -59646,10 +59715,224 @@ ${cellTexts.join("\n\n")}`,
 }
 __name(readNotebookWithMetadata, "readNotebookWithMetadata");
 
+// packages/core/src/utils/read-text-range.ts
+init_esbuild_shims();
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { TextDecoder as TextDecoder2 } from "node:util";
+
+// packages/core/src/utils/text-range-constants.ts
+init_esbuild_shims();
+var TEXT_RANGE_FAST_PATH_MAX_SIZE = 10 * 1024 * 1024;
+var DEFAULT_RANGE_READ_BYTES = 25e3;
+
+// packages/core/src/utils/read-text-range.ts
+var LargeNonUtf8TextError = class extends Error {
+  constructor(encoding, reason) {
+    super(
+      reason === "invalid-utf8" ? "Large text file contains invalid UTF-8 byte sequence beyond the initial encoding sample. Convert or extract a smaller UTF-8 slice and read that instead." : `Large non-UTF-8 text files are not supported for streaming reads (detected ${encoding}). Convert or extract a smaller UTF-8 slice and read that instead.`
+    );
+    this.encoding = encoding;
+    this.reason = reason;
+    this.name = "LargeNonUtf8TextError";
+  }
+  static {
+    __name(this, "LargeNonUtf8TextError");
+  }
+};
+async function readTextRange(request4) {
+  request4.signal?.throwIfAborted();
+  const stats = request4.stats ?? await stat(request4.path);
+  const maxOutputBytes = normalizeMaxBytes(request4.maxOutputBytes);
+  if (stats.size < TEXT_RANGE_FAST_PATH_MAX_SIZE) {
+    const { content, encoding, bom } = await readFileWithEncodingInfo(
+      request4.path,
+      request4.signal
+    );
+    request4.signal?.throwIfAborted();
+    const range = sliceDecodedContent(
+      content,
+      request4.offset,
+      request4.limit,
+      maxOutputBytes
+    );
+    return {
+      ...range,
+      encoding,
+      bom,
+      lineEnding: detectLineEndingFromContent(content)
+    };
+  }
+  return readLargeUtf8Range(request4, maxOutputBytes);
+}
+__name(readTextRange, "readTextRange");
+function normalizeMaxBytes(maxOutputBytes) {
+  if (maxOutputBytes === Number.POSITIVE_INFINITY) {
+    return Number.POSITIVE_INFINITY;
+  }
+  if (!Number.isFinite(maxOutputBytes)) {
+    return DEFAULT_RANGE_READ_BYTES;
+  }
+  return Math.max(0, Math.floor(maxOutputBytes));
+}
+__name(normalizeMaxBytes, "normalizeMaxBytes");
+function sliceDecodedContent(content, offset, limit, maxOutputBytes) {
+  const lines = content.split("\n");
+  const originalLineCount = lines.length;
+  const start = Math.min(Math.max(0, offset ?? 0), originalLineCount);
+  const end = limit === void 0 ? originalLineCount : Math.min(start + Math.max(0, limit), originalLineCount);
+  const selected = lines.slice(start, end).join("\n");
+  const truncated = truncateUtf8(selected, maxOutputBytes);
+  return {
+    content: truncated.content,
+    originalLineCount,
+    originalLineCountExact: true,
+    truncatedByBytes: truncated.truncated
+  };
+}
+__name(sliceDecodedContent, "sliceDecodedContent");
+async function readLargeUtf8Range(request4, maxOutputBytes) {
+  const encoding = await detectFileEncoding(request4.path);
+  if (!isUtf8CompatibleEncoding(encoding)) {
+    throw new LargeNonUtf8TextError(encoding);
+  }
+  const offset = Math.max(0, request4.offset ?? 0);
+  const endLine = offset + Math.max(0, request4.limit ?? Number.POSITIVE_INFINITY);
+  let currentLine = 0;
+  let output = "";
+  let outputBytes = 0;
+  let truncatedByBytes = false;
+  let bom = false;
+  let firstChunk = true;
+  let lineEnding = "lf";
+  let previousChunkEndedWithCR = false;
+  let originalLineCountExact = true;
+  let stoppedEarly = false;
+  const decoder = new TextDecoder2("utf-8", {
+    fatal: true,
+    ignoreBOM: true
+  });
+  const stream = createReadStream(request4.path, {
+    highWaterMark: 512 * 1024,
+    signal: request4.signal
+  });
+  function appendSelected(fragment) {
+    if (fragment.length === 0 || truncatedByBytes) {
+      return;
+    }
+    const available = maxOutputBytes - outputBytes;
+    if (available <= 0) {
+      truncatedByBytes = true;
+      return;
+    }
+    const truncated = truncateUtf8(fragment, available);
+    output += truncated.content;
+    outputBytes += Buffer.byteLength(truncated.content, "utf8");
+    if (truncated.truncated) {
+      truncatedByBytes = true;
+    }
+  }
+  __name(appendSelected, "appendSelected");
+  function isSelectedLine() {
+    return currentLine >= offset && currentLine < endLine;
+  }
+  __name(isSelectedLine, "isSelectedLine");
+  function decodeUtf8Chunk(chunk, options) {
+    try {
+      return decoder.decode(chunk, options);
+    } catch {
+      throw new LargeNonUtf8TextError(encoding, "invalid-utf8");
+    }
+  }
+  __name(decodeUtf8Chunk, "decodeUtf8Chunk");
+  try {
+    for await (const rawChunk of stream) {
+      request4.signal?.throwIfAborted();
+      let chunk = decodeUtf8Chunk(rawChunk, { stream: true });
+      if (firstChunk) {
+        firstChunk = false;
+        if (chunk.charCodeAt(0) === 65279) {
+          chunk = chunk.slice(1);
+          bom = true;
+        }
+      }
+      if (previousChunkEndedWithCR && chunk.startsWith("\n") || chunk.includes("\r\n")) {
+        lineEnding = "crlf";
+      }
+      previousChunkEndedWithCR = chunk.endsWith("\r");
+      let start = 0;
+      let newline = chunk.indexOf("\n", start);
+      while (newline !== -1) {
+        if (isSelectedLine()) {
+          appendSelected(chunk.slice(start, newline));
+          if (currentLine + 1 < endLine) {
+            appendSelected("\n");
+          }
+        }
+        currentLine++;
+        start = newline + 1;
+        if (currentLine >= endLine || truncatedByBytes) {
+          originalLineCountExact = false;
+          stoppedEarly = true;
+          break;
+        }
+        newline = chunk.indexOf("\n", start);
+      }
+      if (start < chunk.length && isSelectedLine()) {
+        appendSelected(chunk.slice(start));
+      }
+      if (currentLine >= endLine || truncatedByBytes) {
+        originalLineCountExact = false;
+        stoppedEarly = true;
+        break;
+      }
+    }
+  } finally {
+    stream.destroy();
+  }
+  if (!stoppedEarly) {
+    decodeUtf8Chunk();
+  }
+  return {
+    content: output,
+    originalLineCount: currentLine + 1,
+    encoding: "utf-8",
+    bom,
+    lineEnding,
+    originalLineCountExact,
+    truncatedByBytes
+  };
+}
+__name(readLargeUtf8Range, "readLargeUtf8Range");
+function truncateUtf8(content, maxBytes) {
+  const bytes = Buffer.byteLength(content, "utf8");
+  if (bytes <= maxBytes) {
+    return { content, truncated: false };
+  }
+  if (maxBytes <= 0) {
+    return { content: "", truncated: true };
+  }
+  const buffer = Buffer.from(content, "utf8");
+  let end = Math.min(maxBytes, buffer.length);
+  while (end > 0 && (buffer[end] & 192) === 128) {
+    end--;
+  }
+  return {
+    content: buffer.subarray(0, end).toString("utf8"),
+    truncated: true
+  };
+}
+__name(truncateUtf8, "truncateUtf8");
+function detectLineEndingFromContent(content) {
+  return content.includes("\r\n") ? "crlf" : "lf";
+}
+__name(detectLineEndingFromContent, "detectLineEndingFromContent");
+
 // packages/core/src/utils/fileUtils.ts
 var debugLogger2 = createDebugLogger("FILE_UTILS");
 var DEFAULT_ENCODING = "utf-8";
-var PDF_EXTRACTION_MAX_MB = 100;
+var PDF_FULL_TEXT_EXTRACTION_MAX_MB = 100;
+var PDF_PAGED_TEXT_EXTRACTION_MAX_MB = 512;
 function detectBOM(buf) {
   if (buf.length >= 4) {
     if (buf[0] === 255 && buf[1] === 254 && buf[2] === 0 && buf[3] === 0) {
@@ -59777,8 +60060,11 @@ function bomEncodingToName(bomEncoding) {
   }
 }
 __name(bomEncodingToName, "bomEncodingToName");
-async function readFileWithEncodingInfo(filePath) {
-  const full = await fs2.promises.readFile(filePath);
+async function readFileWithEncodingInfo(filePath, signal) {
+  const full = await fs2.promises.readFile(
+    filePath,
+    signal === void 0 ? void 0 : { signal }
+  );
   return decodeBufferWithEncodingInfo(full);
 }
 __name(readFileWithEncodingInfo, "readFileWithEncodingInfo");
@@ -59793,8 +60079,24 @@ async function countFileLines(filePath) {
 }
 __name(countFileLines, "countFileLines");
 async function readFileWithLineAndLimit(params) {
-  const { path: filePath, limit, line } = params;
-  const { content, encoding, bom } = await readFileWithEncodingInfo(filePath);
+  const { path: filePath, limit, line, maxOutputBytes, signal } = params;
+  const stats = params.stats ?? await fs2.promises.stat(filePath);
+  if (line !== void 0 && line > 0 || Number.isFinite(limit) || maxOutputBytes !== void 0) {
+    return readTextRange({
+      path: filePath,
+      offset: line || 0,
+      limit,
+      maxOutputBytes: normalizeRangeReadByteLimit(maxOutputBytes),
+      stats,
+      ...signal !== void 0 ? { signal } : {}
+    });
+  }
+  signal?.throwIfAborted();
+  const { content, encoding, bom } = await readFileWithEncodingInfo(
+    filePath,
+    signal
+  );
+  signal?.throwIfAborted();
   const lines = content.split("\n");
   const originalLineCount = lines.length;
   const startLine = line || 0;
@@ -59805,7 +60107,8 @@ async function readFileWithLineAndLimit(params) {
     content: selectedLines.join("\n"),
     bom,
     encoding,
-    originalLineCount
+    originalLineCount,
+    originalLineCountExact: true
   };
 }
 __name(readFileWithLineAndLimit, "readFileWithLineAndLimit");
@@ -60146,9 +60449,17 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
     limit: legacyLimit,
     pages: legacyPages
   };
-  const { offset, limit, pages, preserveUnsupportedImage = false } = options;
+  const {
+    offset,
+    limit,
+    pages,
+    preserveUnsupportedImage = false,
+    signal,
+    largePdfBehavior = "error"
+  } = options;
   const rootDirectory = config.getTargetDir();
   try {
+    signal?.throwIfAborted();
     let stats;
     try {
       stats = await fs2.promises.stat(filePath);
@@ -60184,16 +60495,83 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
     const displayName = path2.basename(filePath);
     const modalities = config.getContentGeneratorConfig?.()?.modalities ?? {};
     const fileSizeInMB = stats.size / (1024 * 1024);
-    const willExtractPdfText = fileType === "pdf" && (pages !== void 0 || !modalities.pdf);
-    if (willExtractPdfText && fileSizeInMB > PDF_EXTRACTION_MAX_MB) {
+    const normalizedPages = pages?.trim();
+    let pageRange;
+    if (fileType === "pdf" && normalizedPages !== void 0) {
+      const invalidPagesDisplay = `Invalid PDF pages parameter: ${relativePathForDisplay}`;
+      const invalidPagesResult = /* @__PURE__ */ __name((message) => ({
+        llmContent: message,
+        returnDisplay: invalidPagesDisplay,
+        error: message,
+        errorType: "invalid_tool_params" /* INVALID_TOOL_PARAMS */
+      }), "invalidPagesResult");
+      const parsedPageRange = parsePDFPageRange(normalizedPages);
+      if (!parsedPageRange) {
+        return invalidPagesResult(
+          `Invalid pages parameter: '${normalizedPages}'. Use formats like '5' or '1-10'.`
+        );
+      }
+      if (parsedPageRange.lastPage === Infinity) {
+        return invalidPagesResult(
+          `Open-ended page ranges (e.g. '3-') are not supported; specify an explicit end page within the ${PDF_MAX_PAGES_PER_READ}-page limit (e.g. '3-22').`
+        );
+      }
+      if (parsedPageRange.lastPage - parsedPageRange.firstPage + 1 > PDF_MAX_PAGES_PER_READ) {
+        return invalidPagesResult(
+          `Pages range exceeds maximum of ${PDF_MAX_PAGES_PER_READ} pages per request.`
+        );
+      }
+      pageRange = parsedPageRange;
+    }
+    const willExtractPdfText = fileType === "pdf" && (pageRange !== void 0 || !modalities.pdf);
+    if (!pageRange && willExtractPdfText && fileSizeInMB > PDF_FULL_TEXT_EXTRACTION_MAX_MB) {
       return {
-        llmContent: `PDF file is too large for text extraction: ${fileSizeInMB.toFixed(2)}MB exceeds the ${PDF_EXTRACTION_MAX_MB}MB limit. Use the 'pages' parameter to read a narrower range, or split the document.`,
-        returnDisplay: `PDF file too large (${fileSizeInMB.toFixed(2)}MB > ${PDF_EXTRACTION_MAX_MB}MB).`,
+        llmContent: `PDF file is too large for full text extraction: ${fileSizeInMB.toFixed(2)}MB exceeds the ${PDF_FULL_TEXT_EXTRACTION_MAX_MB}MB limit. Use the 'pages' parameter to read a narrower range, or split the document into smaller files before retrying.`,
+        returnDisplay: `PDF file too large (${fileSizeInMB.toFixed(2)}MB > ${PDF_FULL_TEXT_EXTRACTION_MAX_MB}MB).`,
         error: `PDF exceeds extraction size limit: ${filePath} (${fileSizeInMB.toFixed(2)}MB)`,
-        errorType: "file_too_large" /* FILE_TOO_LARGE */
+        errorType: "file_too_large" /* FILE_TOO_LARGE */,
+        stats
       };
     }
-    if (fileSizeInMB > 9.9 && !willExtractPdfText) {
+    if (pageRange && fileSizeInMB > PDF_PAGED_TEXT_EXTRACTION_MAX_MB) {
+      return {
+        llmContent: `PDF file is too large for page-range text extraction: ${fileSizeInMB.toFixed(2)}MB exceeds the ${PDF_PAGED_TEXT_EXTRACTION_MAX_MB}MB limit. Split the document into smaller files before retrying.`,
+        returnDisplay: `PDF file too large (${fileSizeInMB.toFixed(2)}MB > ${PDF_PAGED_TEXT_EXTRACTION_MAX_MB}MB).`,
+        error: `PDF exceeds page-range extraction size limit: ${filePath} (${fileSizeInMB.toFixed(2)}MB)`,
+        errorType: "file_too_large" /* FILE_TOO_LARGE */,
+        stats
+      };
+    }
+    if (willExtractPdfText && !pageRange) {
+      const pageCount = await getPDFPageCount(filePath);
+      const requirement = shouldRequirePDFPageRange(pageCount, stats.size);
+      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}`
+      );
+      if (requirement.required) {
+        if (largePdfBehavior === "error" && !await isPdftotextAvailable()) {
+          return {
+            llmContent: `[Cannot extract text from PDF: "${displayName}". ${PDF_TEXT_EXTRACTION_UNAVAILABLE_MESSAGE}]`,
+            returnDisplay: `Failed to read pdf: ${relativePathForDisplay}`,
+            error: PDF_TEXT_EXTRACTION_UNAVAILABLE_MESSAGE,
+            errorType: "read_content_failure" /* READ_CONTENT_FAILURE */,
+            stats
+          };
+        }
+        const guidance = buildLargePDFGuidance(displayName, requirement);
+        const returnDisplay = largePdfBehavior === "reference" ? `Referenced large PDF: ${relativePathForDisplay}` : `PDF requires page range: ${relativePathForDisplay}`;
+        return {
+          llmContent: guidance,
+          returnDisplay,
+          ...largePdfBehavior === "error" ? {
+            error: guidance,
+            errorType: "file_too_large" /* FILE_TOO_LARGE */
+          } : {},
+          stats
+        };
+      }
+    }
+    if (fileSizeInMB > 9.9 && !willExtractPdfText && fileType !== "text") {
       return {
         llmContent: "File size exceeds the 10MB limit.",
         returnDisplay: "File size exceeds the 10MB limit.",
@@ -60250,11 +60628,17 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
         const { content, _meta } = await config.getFileSystemService().readTextFile({
           path: filePath,
           limit: limit ?? config.getTruncateToolOutputLines(),
-          line: offset
+          line: offset,
+          maxOutputBytes: getRangeReadByteLimit(config),
+          stats,
+          ...signal !== void 0 ? { signal } : {}
         });
-        const originalLineCount = _meta?.originalLineCount ?? await countFileLines(filePath);
         const selectedLines = content.split("\n").map((line) => line.trimEnd());
         const startLine = offset || 0;
+        const selectedLineCount = content.length === 0 ? 0 : selectedLines.length;
+        const hasOriginalLineCount = _meta?.originalLineCount !== void 0;
+        const originalLineCount = _meta?.originalLineCount ?? (stats.size >= TEXT_RANGE_FAST_PATH_MAX_SIZE ? startLine + selectedLineCount : await countFileLines(filePath));
+        const originalLineCountExact = _meta?.originalLineCountExact === false ? false : hasOriginalLineCount || stats.size < TEXT_RANGE_FAST_PATH_MAX_SIZE;
         const configCharLimit = config.getTruncateToolOutputThreshold();
         let llmContent = "";
         let contentLengthTruncated = false;
@@ -60286,12 +60670,25 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
           llmContent = selectedLines.join("\n");
           linesIncluded = selectedLines.length;
         }
+        if (_meta?.truncatedByBytes === true) {
+          const marker = "... [truncated]";
+          if (!llmContent.endsWith(marker)) {
+            const prefix = Number.isFinite(configCharLimit) ? llmContent.slice(
+              0,
+              Math.max(configCharLimit - marker.length - 1, 0)
+            ) : llmContent;
+            const separator = prefix.length === 0 || prefix.endsWith("\n") ? "" : "\n";
+            llmContent = prefix + separator + marker;
+          }
+          contentLengthTruncated = true;
+        }
         const actualEndLine = startLine + linesIncluded;
-        const contentRangeTruncated = startLine > 0 || actualEndLine < originalLineCount;
+        const contentRangeTruncated = startLine > 0 || !originalLineCountExact || actualEndLine < originalLineCount;
         const isTruncated = contentRangeTruncated || contentLengthTruncated;
+        const lineCountLabel = originalLineCountExact ? `${originalLineCount}` : `at least ${originalLineCount}`;
         let returnDisplay = "";
         if (isTruncated) {
-          returnDisplay = `Read lines ${startLine + 1}-${actualEndLine} of ${originalLineCount} from ${relativePathForDisplay}`;
+          returnDisplay = `Read lines ${startLine + 1}-${actualEndLine} of ${lineCountLabel} from ${relativePathForDisplay}`;
           if (contentLengthTruncated) {
             returnDisplay += " (truncated)";
           }
@@ -60301,6 +60698,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
           returnDisplay,
           isTruncated,
           originalLineCount,
+          originalLineCountExact,
           linesShown: [startLine + 1, actualEndLine],
           stats
         };
@@ -60331,7 +60729,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
         };
       }
       case "pdf": {
-        if (!pages && modalities.pdf) {
+        if (!pageRange && modalities.pdf) {
           const contentBuffer = await fs2.promises.readFile(filePath);
           const base64Data = contentBuffer.toString("base64");
           const base64SizeInMB = base64Data.length / (1024 * 1024);
@@ -60354,16 +60752,38 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
             returnDisplay: `Read pdf file: ${relativePathForDisplay}`
           };
         }
-        const pageRange = pages ? parsePDFPageRange(pages) : void 0;
-        const pdfResult = await extractPDFText(
-          filePath,
-          pageRange ?? void 0
-        );
+        const pdfResult = await extractPDFText(filePath, pageRange);
         if (pdfResult.success) {
-          const pagesLabel = pages ? ` (pages ${pages})` : "";
+          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
+              };
+            }
+            return {
+              llmContent: guidance,
+              returnDisplay: `PDF text too large: ${relativePathForDisplay}`,
+              error: guidance,
+              errorType: "file_too_large" /* FILE_TOO_LARGE */,
+              stats
+            };
+          }
+          const pagesLabel = normalizedPages ? ` (pages ${normalizedPages})` : "";
           return {
             llmContent: pdfResult.text,
-            returnDisplay: `Read pdf as text${pagesLabel}: ${relativePathForDisplay}`
+            returnDisplay: `Read pdf as text${pagesLabel}: ${relativePathForDisplay}`,
+            stats
           };
         }
         return {
@@ -60402,6 +60822,9 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       }
     }
   } catch (error) {
+    if (signal?.aborted || isAbortError(error)) {
+      throw error;
+    }
     const errorMessage2 = getErrorMessage(error);
     const displayPath = path2.relative(rootDirectory, filePath).replace(/\\/g, "/");
     return {
@@ -60413,6 +60836,24 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
   }
 }
 __name(processSingleFileContent, "processSingleFileContent");
+function getRangeReadByteLimit(config) {
+  const charLimit = config.getTruncateToolOutputThreshold();
+  if (charLimit === Number.POSITIVE_INFINITY) {
+    return Number.POSITIVE_INFINITY;
+  }
+  if (!Number.isFinite(charLimit)) {
+    return DEFAULT_RANGE_READ_BYTES;
+  }
+  return Math.max(DEFAULT_RANGE_READ_BYTES, Math.floor(charLimit) * 4);
+}
+__name(getRangeReadByteLimit, "getRangeReadByteLimit");
+function normalizeRangeReadByteLimit(maxOutputBytes) {
+  if (maxOutputBytes === Number.POSITIVE_INFINITY) {
+    return Number.POSITIVE_INFINITY;
+  }
+  return typeof maxOutputBytes === "number" && Number.isFinite(maxOutputBytes) ? maxOutputBytes : DEFAULT_RANGE_READ_BYTES;
+}
+__name(normalizeRangeReadByteLimit, "normalizeRangeReadByteLimit");
 async function fileExists(filePath) {
   try {
     await fsPromises.access(filePath, fs2.constants.F_OK);
@@ -69429,11 +69870,11 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   let baseGenerator;
   try {
     if (authType === "openai" /* USE_OPENAI */) {
-      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-WAO7PPR6.js");
+      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-BA6NWY4S.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-5NZ5EHRA.js");
+      const { QwenContentGenerator } = await import("./qwenContentGenerator-U4ZSLGFN.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
@@ -69451,10 +69892,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-PPPLABT5.js");
+      const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-AKYPSZIV.js");
       baseGenerator = createAnthropicContentGenerator(generatorConfig, config);
     } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
-      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-O7OCAUQU.js");
+      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-DCM2XGDQ.js");
       baseGenerator = createGeminiContentGenerator(generatorConfig, config);
     } else {
       throw new Error(
@@ -71996,7 +72437,7 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
     }
     return "ask";
   }
-  async execute() {
+  async execute(signal) {
     const absPath = path10.resolve(this.params.file_path);
     const projectRoot = this.config.getTargetDir();
     const isAutoMem = isAnyAutoMemPath(absPath, projectRoot);
@@ -72029,7 +72470,8 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
       {
         offset: this.params.offset,
         limit: this.params.limit,
-        pages: this.params.pages
+        pages: this.params.pages,
+        signal
       }
     );
     if (result.error) {
@@ -72054,7 +72496,8 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
     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.
+      const totalLabel = result.originalLineCountExact === false ? `at least ${total}` : total;
+      llmContent = `Showing lines ${start}-${end} of ${totalLabel} total lines.
 
 ---
 
@@ -72131,7 +72574,7 @@ var ReadFileTool = class _ReadFileTool extends BaseDeclarativeTool {
     super(
       _ReadFileTool.Name,
       ToolDisplayNames.READ_FILE,
-      `Reads and returns the content of a specified file. The file_path argument MUST be an absolute path. Always construct it by combining the project root with the file's relative path (e.g. project root '/path/to/project/' + relative 'foo/bar.txt' = '/path/to/project/foo/bar.txt'). If the user provides a relative path, resolve it against the project root first. If the file is large, the content will be truncated. The tool's response will clearly indicate if truncation has occurred and will provide details on how to read more of the file using the 'offset' and 'limit' parameters. Handles text, images (PNG, JPG, GIF, WEBP, SVG, BMP), PDF files, and Jupyter notebooks (.ipynb). For text files, it can read specific line ranges. For PDF files, use the 'pages' parameter to extract specific page ranges as text (e.g. '1-5'). Max 20 pages per request. This tool can read Jupyter notebooks (.ipynb) and returns structured cell content with outputs.`,
+      `Reads and returns the content of a specified file. The file_path argument MUST be an absolute path. Always construct it by combining the project root with the file's relative path (e.g. project root '/path/to/project/' + relative 'foo/bar.txt' = '/path/to/project/foo/bar.txt'). If the user provides a relative path, resolve it against the project root first. If the file is large, the content will be truncated. The tool's response will clearly indicate if truncation has occurred and will provide details on how to read more of the file using the 'offset' and 'limit' parameters. Handles text, images (PNG, JPG, GIF, WEBP, SVG, BMP), PDF files, and Jupyter notebooks (.ipynb). For text files, it can read specific line ranges. For PDF files, use the 'pages' parameter to extract specific page ranges as text (e.g. '1-5'). Max ${PDF_MAX_PAGES_PER_READ} pages per request. Large PDFs cannot be read all at once when the model does not support native PDF input; retry with narrower page ranges if the tool reports a PDF is too large. This tool can read Jupyter notebooks (.ipynb) and returns structured cell content with outputs.`,
       "read" /* Read */,
       {
         properties: {
@@ -72148,7 +72591,7 @@ var ReadFileTool = class _ReadFileTool extends BaseDeclarativeTool {
             type: "integer"
           },
           pages: {
-            description: "Optional: For PDF files, the page range to extract as text (e.g., '1-5', '3', '10-20'). Pages are 1-indexed. Max 20 pages per request. Open-ended ranges like '3-' are not supported. When provided, PDF content is extracted as text regardless of model capabilities.",
+            description: `Optional: For PDF files, the page range to extract as text (e.g., '1-5', '3', '10-20'). Pages are 1-indexed. Max ${PDF_MAX_PAGES_PER_READ} pages per request. Open-ended ranges like '3-' are not supported. Use this for large PDFs or when the model does not support native PDF input.`,
             type: "string"
           }
         },
@@ -72201,9 +72644,9 @@ var ReadFileTool = class _ReadFileTool extends BaseDeclarativeTool {
         return `Invalid pages parameter: '${params.pages}'. Use formats like '5' or '1-10'.`;
       }
       if (parsed.lastPage === Infinity) {
-        return `Open-ended page ranges (e.g. '3-') are not supported; specify an explicit end page within the 20-page limit (e.g. '3-22').`;
+        return `Open-ended page ranges (e.g. '3-') are not supported; specify an explicit end page within the ${PDF_MAX_PAGES_PER_READ}-page limit (e.g. '3-22').`;
       }
-      const maxPages = 20;
+      const maxPages = PDF_MAX_PAGES_PER_READ;
       if (parsed.lastPage - parsed.firstPage + 1 > maxPages) {
         return `Pages range exceeds maximum of ${maxPages} pages per request.`;
       }
@@ -72560,6 +73003,11 @@ export {
  * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Qwen Team
@@ -72571,11 +73019,6 @@ export {
  * (suggestion generation, forked queries) so that logging, recording,
  * and UI layers can consistently recognise and filter them.
  */
-/**
- * @license
- * Copyright 2026 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
 /**
  * @license
  * Copyright 2025 Qwen