@qwen-code/qwen-code 0.19.6 → 0.19.7-nightly.20260708.394c1a289

package/chunks/{chunk-JN2VJ33O.js → chunk-7I4MGFBN.js}

@@ -23,28 +23,29 @@ import {
 } from "./chunk-OMX7CUOE.js";
 import {
   isAnyAutoMemPath
-} from "./chunk-MOUXUCXQ.js";
+} from "./chunk-4KJ2BPIT.js";
 import {
   InstallationManager
-} from "./chunk-BZHLWC6T.js";
+} from "./chunk-SUAKHHK7.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-RZORUN6X.js";
+} from "./chunk-FEJ2FZ3U.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-MJKMIQMK.js";
+} from "./chunk-X3YGAX7V.js";
 import {
   atomicWriteFile,
   atomicWriteFileSync
-} from "./chunk-T42ACHFI.js";
+} from "./chunk-7LTB54MK.js";
 import {
   convertSchema,
+  estimateTextTokens,
   runtimeDiagnostics,
   safeJsonParse
-} from "./chunk-YPCPZSZB.js";
+} from "./chunk-CCGOFQV3.js";
 import {
   require_lib
 } from "./chunk-IRJWHZWU.js";
@@ -70,7 +71,7 @@ import {
   setShellTracePropagation,
   shortenPath,
   unescapePath
-} from "./chunk-AVQDCKNF.js";
+} from "./chunk-22MNNNXE.js";
 import {
   require_dist
 } from "./chunk-ZERZSAZL.js";
@@ -11644,7 +11645,7 @@ var require_error = __commonJS({
     init_esbuild_shims();
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.getErrorMessage = getErrorMessage2;
-    exports.getErrorCode = getErrorCode;
+    exports.getErrorCode = getErrorCode2;
     function getErrorMessage2(error) {
       if (error instanceof Error) {
         return error.message;
@@ -11653,14 +11654,14 @@ var require_error = __commonJS({
       }
     }
     __name(getErrorMessage2, "getErrorMessage");
-    function getErrorCode(error) {
+    function getErrorCode2(error) {
       if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "number") {
         return error.code;
       } else {
         return null;
       }
     }
-    __name(getErrorCode, "getErrorCode");
+    __name(getErrorCode2, "getErrorCode");
   }
 });
 
@@ -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");
   }
@@ -55599,13 +55600,13 @@ var require_B3MultiPropagator = __commonJS({
       return Array.isArray(header) ? header[0] : header;
     }
     __name(parseHeader, "parseHeader");
-    function getHeaderValue(carrier, getter, key) {
+    function getHeaderValue2(carrier, getter, key) {
       const header = getter.get(carrier, key);
       return parseHeader(header);
     }
-    __name(getHeaderValue, "getHeaderValue");
+    __name(getHeaderValue2, "getHeaderValue");
     function getTraceId(carrier, getter) {
-      const traceId = getHeaderValue(carrier, getter, constants_1.X_B3_TRACE_ID);
+      const traceId = getHeaderValue2(carrier, getter, constants_1.X_B3_TRACE_ID);
       if (typeof traceId === "string") {
         return traceId.padStart(32, "0");
       }
@@ -55613,7 +55614,7 @@ var require_B3MultiPropagator = __commonJS({
     }
     __name(getTraceId, "getTraceId");
     function getSpanId2(carrier, getter) {
-      const spanId = getHeaderValue(carrier, getter, constants_1.X_B3_SPAN_ID);
+      const spanId = getHeaderValue2(carrier, getter, constants_1.X_B3_SPAN_ID);
       if (typeof spanId === "string") {
         return spanId;
       }
@@ -55621,12 +55622,12 @@ var require_B3MultiPropagator = __commonJS({
     }
     __name(getSpanId2, "getSpanId");
     function getDebug(carrier, getter) {
-      const debug = getHeaderValue(carrier, getter, constants_1.X_B3_FLAGS);
+      const debug = getHeaderValue2(carrier, getter, constants_1.X_B3_FLAGS);
       return debug === "1" ? "1" : void 0;
     }
     __name(getDebug, "getDebug");
     function getTraceFlags(carrier, getter) {
-      const traceFlags = getHeaderValue(carrier, getter, constants_1.X_B3_SAMPLED);
+      const traceFlags = getHeaderValue2(carrier, getter, constants_1.X_B3_SAMPLED);
       const debug = getDebug(carrier, getter);
       if (debug === "1" || VALID_SAMPLED_VALUES.has(traceFlags)) {
         return api_1.TraceFlags.SAMPLED;
@@ -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");
@@ -60124,6 +60427,10 @@ async function detectFileType(filePath) {
   return "text";
 }
 __name(detectFileType, "detectFileType");
+function isCacheableReadResult(result) {
+  return typeof result.llmContent === "string" && result.originalLineCount !== void 0;
+}
+__name(isCacheableReadResult, "isCacheableReadResult");
 function mediaModalityKey(fileType) {
   if (fileType === "image" || fileType === "pdf" || fileType === "audio" || fileType === "video") {
     return fileType;
@@ -60142,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);
@@ -60180,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 (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 (fileSizeInMB > 9.9 && !willExtractPdfText) {
+    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.",
@@ -60246,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;
@@ -60282,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)";
           }
@@ -60297,6 +60698,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
           returnDisplay,
           isTruncated,
           originalLineCount,
+          originalLineCountExact,
           linesShown: [startLine + 1, actualEndLine],
           stats
         };
@@ -60327,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);
@@ -60350,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 {
@@ -60398,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 {
@@ -60409,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);
@@ -63395,6 +63840,66 @@ var subagentNameContext = new AsyncLocalStorage();
 // packages/core/src/core/openaiContentGenerator/converter.ts
 init_esbuild_shims();
 
+// packages/core/src/utils/thoughtUtils.ts
+init_esbuild_shims();
+var START_DELIMITER = "**";
+var END_DELIMITER = "**";
+var OPENAI_REASONING_THOUGHT_MARKER = Symbol("openaiReasoningThought");
+function createOpenAIReasoningThoughtPart(text) {
+  const part = { text, thought: true };
+  Object.defineProperty(part, OPENAI_REASONING_THOUGHT_MARKER, {
+    value: true
+  });
+  return part;
+}
+__name(createOpenAIReasoningThoughtPart, "createOpenAIReasoningThoughtPart");
+function isOpenAIReasoningThoughtPart(part) {
+  return Boolean(
+    part[OPENAI_REASONING_THOUGHT_MARKER]
+  );
+}
+__name(isOpenAIReasoningThoughtPart, "isOpenAIReasoningThoughtPart");
+function parseThought(rawText) {
+  const startIndex = rawText.indexOf(START_DELIMITER);
+  if (startIndex === -1) {
+    return { subject: "", description: rawText };
+  }
+  const endIndex = rawText.indexOf(
+    END_DELIMITER,
+    startIndex + START_DELIMITER.length
+  );
+  if (endIndex === -1) {
+    return { subject: "", description: rawText };
+  }
+  const subject = rawText.substring(startIndex + START_DELIMITER.length, endIndex).trim();
+  const description = (rawText.substring(0, startIndex) + rawText.substring(endIndex + END_DELIMITER.length)).trim();
+  return { subject, description };
+}
+__name(parseThought, "parseThought");
+function getThoughtSummary(response) {
+  if (response.candidates && response.candidates.length > 0) {
+    const candidate = response.candidates[0];
+    if (candidate.content && candidate.content.parts && candidate.content.parts.length > 0) {
+      const thoughtParts = candidate.content.parts.filter(
+        (part) => part.thought
+      );
+      if (thoughtParts.length === 0) {
+        return null;
+      }
+      const thoughtText = thoughtParts.map((part) => part.text ?? "").join("");
+      if (!thoughtText) {
+        return null;
+      }
+      if (thoughtParts.some(isOpenAIReasoningThoughtPart)) {
+        return { subject: "", description: thoughtText };
+      }
+      return parseThought(thoughtText);
+    }
+  }
+  return null;
+}
+__name(getThoughtSummary, "getThoughtSummary");
+
 // packages/core/src/core/openaiContentGenerator/taggedThinkingParser.ts
 init_esbuild_shims();
 var debugLogger5 = createDebugLogger("TAGGED_THINKING_PARSER");
@@ -63605,7 +64110,7 @@ async function convertGeminiToolsToOpenAI(geminiTools, schemaCompliance = "auto"
     }
     if (actualTool.functionDeclarations) {
       for (const func of actualTool.functionDeclarations) {
-        if (func.name && func.description) {
+        if (func.name) {
           let parameters;
           if (func.parametersJsonSchema) {
             const paramsCopy = {
@@ -63624,7 +64129,7 @@ async function convertGeminiToolsToOpenAI(geminiTools, schemaCompliance = "auto"
             type: "function",
             function: {
               name: func.name,
-              description: func.description,
+              description: func.description ?? "",
               parameters
             }
           });
@@ -64131,22 +64636,21 @@ function convertOpenAITextToParts(text, requestContext, final = true) {
   return parseTaggedThinkingText(text);
 }
 __name(convertOpenAITextToParts, "convertOpenAITextToParts");
+function hasThoughtPart(parts) {
+  return parts.some((part) => part.thought === true);
+}
+__name(hasThoughtPart, "hasThoughtPart");
 function convertOpenAIResponseToGemini(openaiResponse, requestContext) {
   const choice = openaiResponse.choices?.[0];
   const response = new GenerateContentResponse();
   if (choice) {
     const parts = [];
-    if (!requestContext.responseParsingOptions?.taggedThinkingTags) {
-      const reasoningText = choice.message.reasoning_content ?? choice.message.reasoning;
-      if (reasoningText) {
-        parts.push({ text: reasoningText, thought: true });
-      }
-    }
-    if (choice.message.content) {
-      parts.push(
-        ...convertOpenAITextToParts(choice.message.content, requestContext)
-      );
+    const textParts = choice.message.content ? convertOpenAITextToParts(choice.message.content, requestContext) : [];
+    const reasoningText = choice.message.reasoning_content ?? choice.message.reasoning;
+    if (reasoningText && !hasThoughtPart(textParts)) {
+      parts.push(createOpenAIReasoningThoughtPart(reasoningText));
     }
+    parts.push(...textParts);
     if (choice.message.tool_calls) {
       for (const toolCall of choice.message.tool_calls) {
         if (toolCall.function) {
@@ -64220,22 +64724,8 @@ function convertOpenAIChunkToGemini(chunk, requestContext) {
   }
   if (choice) {
     const parts = [];
-    if (!requestContext.responseParsingOptions?.taggedThinkingTags) {
-      const reasoningText = choice.delta?.reasoning_content ?? choice.delta?.reasoning;
-      if (reasoningText) {
-        const normalizedReasoningText = normalizeStreamingTextDelta(
-          reasoningText,
-          requestContext.reasoningDeltaState ??= {
-            emittedText: "",
-            emittedLength: 0,
-            cumulativeMode: false
-          }
-        );
-        if (normalizedReasoningText) {
-          parts.push({ text: normalizedReasoningText, thought: true });
-        }
-      }
-    }
+    let contentParts = [];
+    const reasoningText = choice.delta?.reasoning_content ?? choice.delta?.reasoning;
     if (typeof choice.delta?.content === "string") {
       const normalizedContent = normalizeStreamingTextDelta(
         choice.delta.content,
@@ -64246,17 +64736,74 @@ function convertOpenAIChunkToGemini(chunk, requestContext) {
         }
       );
       if (normalizedContent || choice.finish_reason) {
-        parts.push(
-          ...convertOpenAITextToParts(
-            normalizedContent,
-            requestContext,
-            Boolean(choice.finish_reason)
-          )
+        contentParts = convertOpenAITextToParts(
+          normalizedContent,
+          requestContext,
+          Boolean(choice.finish_reason)
         );
       }
     } else if (choice.finish_reason) {
-      parts.push(...convertOpenAITextToParts("", requestContext, true));
+      contentParts = convertOpenAITextToParts("", requestContext, true);
+    }
+    if (hasThoughtPart(contentParts)) {
+      requestContext.hasTaggedThinkingThought = true;
+      requestContext.pendingReasoningText = void 0;
+      debugLogger6.debug(
+        "convertOpenAIChunkToGemini: tagged thinking content emitted a thought; dropping buffered reasoning"
+      );
+      if (requestContext.pendingContentParts?.length) {
+        debugLogger6.debug(
+          `convertOpenAIChunkToGemini: flushing ${requestContext.pendingContentParts.length} buffered content part(s) before tagged content`
+        );
+        parts.push(...requestContext.pendingContentParts);
+        requestContext.pendingContentParts = void 0;
+      }
     }
+    if (reasoningText && (!requestContext.responseParsingOptions?.taggedThinkingTags || !requestContext.hasTaggedThinkingThought)) {
+      const normalizedReasoningText = normalizeStreamingTextDelta(
+        reasoningText,
+        requestContext.reasoningDeltaState ??= {
+          emittedText: "",
+          emittedLength: 0,
+          cumulativeMode: false
+        }
+      );
+      if (normalizedReasoningText && !requestContext.responseParsingOptions?.taggedThinkingTags) {
+        parts.push(createOpenAIReasoningThoughtPart(normalizedReasoningText));
+      } else if (normalizedReasoningText && !requestContext.hasTaggedThinkingThought) {
+        requestContext.pendingReasoningText = (requestContext.pendingReasoningText ?? "") + normalizedReasoningText;
+        debugLogger6.debug(
+          `convertOpenAIChunkToGemini: buffered reasoning text (${requestContext.pendingReasoningText.length} chars) for tagged stream`
+        );
+      }
+    }
+    if (requestContext.responseParsingOptions?.taggedThinkingTags && !requestContext.hasTaggedThinkingThought && requestContext.pendingReasoningText && contentParts.length) {
+      requestContext.pendingContentParts = [
+        ...requestContext.pendingContentParts ?? [],
+        ...contentParts
+      ];
+      debugLogger6.debug(
+        `convertOpenAIChunkToGemini: buffered ${contentParts.length} content part(s) behind pending reasoning`
+      );
+      contentParts = [];
+    }
+    if (choice.finish_reason && requestContext.responseParsingOptions?.taggedThinkingTags && !requestContext.hasTaggedThinkingThought && requestContext.pendingReasoningText) {
+      debugLogger6.debug(
+        "convertOpenAIChunkToGemini: flushing buffered reasoning for tagged stream with no tagged thought"
+      );
+      parts.push(
+        createOpenAIReasoningThoughtPart(requestContext.pendingReasoningText)
+      );
+      requestContext.pendingReasoningText = void 0;
+    }
+    if (choice.finish_reason && requestContext.pendingContentParts?.length) {
+      debugLogger6.debug(
+        `convertOpenAIChunkToGemini: flushing ${requestContext.pendingContentParts.length} buffered content part(s) on stream finish`
+      );
+      parts.push(...requestContext.pendingContentParts);
+      requestContext.pendingContentParts = void 0;
+    }
+    parts.push(...contentParts);
     if (choice.delta?.tool_calls) {
       for (const toolCall of choice.delta.tool_calls) {
         const index = toolCall.index ?? 0;
@@ -64632,6 +65179,267 @@ var v4_default = v4;
 
 // packages/core/src/utils/openaiLogger.ts
 import * as os2 from "os";
+
+// packages/core/src/utils/rateLimit.ts
+init_esbuild_shims();
+
+// packages/core/src/utils/quotaErrorDetection.ts
+init_esbuild_shims();
+function isApiError(error) {
+  return typeof error === "object" && error !== null && "error" in error && typeof error.error === "object" && error.error !== null && "message" in error.error;
+}
+__name(isApiError, "isApiError");
+function isStructuredError(error) {
+  return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
+}
+__name(isStructuredError, "isStructuredError");
+function isProQuotaExceededError(error) {
+  const checkMessage = /* @__PURE__ */ __name((message) => message.includes("Quota exceeded for quota metric 'Gemini") && message.includes("Pro Requests'"), "checkMessage");
+  if (typeof error === "string") {
+    return checkMessage(error);
+  }
+  if (isStructuredError(error)) {
+    return checkMessage(error.message);
+  }
+  if (isApiError(error)) {
+    return checkMessage(error.error.message);
+  }
+  if (error && typeof error === "object" && "response" in error) {
+    const gaxiosError = error;
+    if (gaxiosError.response && gaxiosError.response.data) {
+      if (typeof gaxiosError.response.data === "string") {
+        return checkMessage(gaxiosError.response.data);
+      }
+      if (typeof gaxiosError.response.data === "object" && gaxiosError.response.data !== null && "error" in gaxiosError.response.data) {
+        const errorData = gaxiosError.response.data;
+        return checkMessage(errorData.error?.message || "");
+      }
+    }
+  }
+  return false;
+}
+__name(isProQuotaExceededError, "isProQuotaExceededError");
+function isGenericQuotaExceededError(error) {
+  if (typeof error === "string") {
+    return error.includes("Quota exceeded for quota metric");
+  }
+  if (isStructuredError(error)) {
+    return error.message.includes("Quota exceeded for quota metric");
+  }
+  if (isApiError(error)) {
+    return error.error.message.includes("Quota exceeded for quota metric");
+  }
+  return false;
+}
+__name(isGenericQuotaExceededError, "isGenericQuotaExceededError");
+function isQwenQuotaExceededError(error) {
+  if (typeof error !== "object" || error === null) {
+    return false;
+  }
+  const { status, code, message } = error;
+  return status === 429 && code === "insufficient_quota" && typeof message === "string" && message.toLowerCase().includes("free allocated quota exceeded");
+}
+__name(isQwenQuotaExceededError, "isQwenQuotaExceededError");
+
+// packages/core/src/utils/retryPolicy.ts
+init_esbuild_shims();
+var MAX_TIMEOUT_MS = 2147483647;
+function getRetryDelayMs(options) {
+  const normalizedAttempt = Math.max(1, options.attempt);
+  const delayCeilingMs = Math.min(options.maxDelayMs, MAX_TIMEOUT_MS);
+  const exponent = Math.min(normalizedAttempt - 1, 31);
+  const cappedExponentialDelayMs = Math.min(
+    options.initialDelayMs * Math.pow(2, exponent),
+    delayCeilingMs
+  );
+  const retryAfterMode = options.retryAfterMode ?? "ignore";
+  const retryAfterMs = retryAfterMode === "ignore" ? null : getRetryAfterDelayMs(options.error);
+  if (retryAfterMs !== null && retryAfterMs > 0) {
+    const retryAfterCapMs = Math.min(
+      options.retryAfterMaxDelayMs ?? options.maxDelayMs,
+      MAX_TIMEOUT_MS
+    );
+    const cappedRetryAfterMs = Math.min(retryAfterMs, retryAfterCapMs);
+    return Math.max(cappedExponentialDelayMs, cappedRetryAfterMs);
+  }
+  const jitterRatio = options.jitterRatio ?? 0;
+  if (jitterRatio <= 0) return cappedExponentialDelayMs;
+  const random = options.random ?? Math.random;
+  const jitter = cappedExponentialDelayMs * jitterRatio * (random() * 2 - 1);
+  return Math.min(
+    Math.max(0, cappedExponentialDelayMs + jitter),
+    delayCeilingMs
+  );
+}
+__name(getRetryDelayMs, "getRetryDelayMs");
+function getRetryAfterDelayMs(error) {
+  const value = getHeaderValue(error, "retry-after") ?? getResponseHeaderValue(error, "retry-after");
+  if (value === null) return null;
+  const trimmed = value.trim();
+  if (/^\d+(\.\d+)?$/.test(trimmed)) {
+    const seconds = Number(trimmed);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+      return Math.min(seconds * 1e3, MAX_TIMEOUT_MS);
+    }
+  }
+  const retryAtMs = Date.parse(trimmed);
+  if (!Number.isFinite(retryAtMs)) return null;
+  const delayMs = retryAtMs - Date.now();
+  return delayMs > 0 ? Math.min(delayMs, MAX_TIMEOUT_MS) : 0;
+}
+__name(getRetryAfterDelayMs, "getRetryAfterDelayMs");
+function getHeaderValue(error, headerName) {
+  if (!hasHeaders(error)) return null;
+  const { headers } = error;
+  if (typeof headers.get === "function") {
+    const value = headers.get(headerName);
+    return typeof value === "string" ? value : null;
+  }
+  if (typeof headers !== "object" || headers === null) return null;
+  const lowerHeaderName = headerName.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() !== lowerHeaderName) continue;
+    return typeof value === "string" ? value : null;
+  }
+  return null;
+}
+__name(getHeaderValue, "getHeaderValue");
+function getResponseHeaderValue(error, headerName) {
+  if (!hasResponseHeaders(error)) return null;
+  return getHeaderValue(error.response, headerName);
+}
+__name(getResponseHeaderValue, "getResponseHeaderValue");
+function hasHeaders(error) {
+  return typeof error === "object" && error !== null && "headers" in error && error.headers != null;
+}
+__name(hasHeaders, "hasHeaders");
+function hasResponseHeaders(error) {
+  return typeof error === "object" && error !== null && "response" in error && typeof error.response === "object" && error.response !== null && "headers" in error.response && error.response.headers != null;
+}
+__name(hasResponseHeaders, "hasResponseHeaders");
+
+// packages/core/src/utils/rateLimit.ts
+var RATE_LIMIT_ERROR_CODES = /* @__PURE__ */ new Set([429, 503, 1302, 1305]);
+function isRateLimitError(error, extraCodes) {
+  const code = getErrorCode(error);
+  if (code === null) return false;
+  if (RATE_LIMIT_ERROR_CODES.has(code)) return true;
+  if (extraCodes && extraCodes.includes(code)) return true;
+  return false;
+}
+__name(isRateLimitError, "isRateLimitError");
+function getRateLimitErrorDetails(error) {
+  const statusCode = getErrorStatus(error);
+  const payload = getProviderErrorPayload(error);
+  const message = getRawErrorMessage(error);
+  const transport = message?.includes("event:error") || message?.includes("HTTP_STATUS/") ? "sse" : statusCode !== void 0 ? "http" : "unknown";
+  return {
+    ...statusCode !== void 0 ? { statusCode } : {},
+    ...payload?.code !== void 0 ? { providerCode: String(payload.code) } : {},
+    ...payload?.message !== void 0 ? { providerMessage: payload.message } : {},
+    ...payload?.requestId !== void 0 ? { requestId: payload.requestId } : {},
+    transport
+  };
+}
+__name(getRateLimitErrorDetails, "getRateLimitErrorDetails");
+function getRateLimitRetryDelayMs(attempt, options) {
+  return getRetryDelayMs({
+    attempt,
+    initialDelayMs: options.initialDelayMs,
+    maxDelayMs: options.maxDelayMs,
+    retryAfterMode: "minimum",
+    retryAfterMaxDelayMs: options.maxDelayMs,
+    error: options.error
+  });
+}
+__name(getRateLimitRetryDelayMs, "getRateLimitRetryDelayMs");
+function getErrorCode(error) {
+  if (isApiError(error)) {
+    const n = Number(error.error.code);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  const msg = error instanceof Error ? error.message : typeof error === "string" ? error : null;
+  if (msg) {
+    const i = msg.indexOf("{");
+    if (i !== -1) {
+      try {
+        const p = JSON.parse(msg.substring(i));
+        if (isApiError(p)) {
+          const n = Number(p.error.code);
+          if (Number.isFinite(n) && n > 0) return n;
+        }
+      } catch {
+      }
+    }
+  }
+  if (isStructuredError(error) && typeof error.status === "number") {
+    return error.status;
+  }
+  if (error instanceof Error && "status" in error) {
+    const s = error.status;
+    if (typeof s === "number") return s;
+  }
+  return getErrorStatus(error) ?? null;
+}
+__name(getErrorCode, "getErrorCode");
+function getProviderErrorPayload(error) {
+  for (const payload of getJsonPayloads(error)) {
+    if (typeof payload !== "object" || payload === null) continue;
+    const direct = payload;
+    const nestedError = payload.error;
+    const nested = typeof nestedError === "object" && nestedError !== null ? nestedError : void 0;
+    const source = nested ?? direct;
+    const code = typeof source.code === "string" || typeof source.code === "number" ? source.code : void 0;
+    const message = typeof source.message === "string" ? source.message : void 0;
+    const requestId = typeof source.request_id === "string" ? source.request_id : typeof source.requestId === "string" ? source.requestId : typeof direct.request_id === "string" ? direct.request_id : typeof direct.requestId === "string" ? direct.requestId : void 0;
+    if (code !== void 0 || message !== void 0 || requestId !== void 0) {
+      return { code, message, requestId };
+    }
+  }
+  if (isApiError(error)) {
+    return {
+      code: error.error.code,
+      message: error.error.message
+    };
+  }
+  return null;
+}
+__name(getProviderErrorPayload, "getProviderErrorPayload");
+function getJsonPayloads(error) {
+  const message = getRawErrorMessage(error);
+  if (!message) return [];
+  const payloads = [];
+  for (const line of message.split(/\r?\n/)) {
+    if (!line.startsWith("data:")) continue;
+    const data = line.slice("data:".length).trim();
+    if (!data || data === "[DONE]") continue;
+    try {
+      payloads.push(JSON.parse(data));
+    } catch {
+    }
+  }
+  if (payloads.length > 0) return payloads;
+  const jsonStart = message.indexOf("{");
+  const jsonEnd = message.lastIndexOf("}");
+  if (jsonStart !== -1 && jsonEnd > jsonStart) {
+    try {
+      payloads.push(
+        JSON.parse(message.slice(jsonStart, jsonEnd + 1))
+      );
+    } catch {
+    }
+  }
+  return payloads;
+}
+__name(getJsonPayloads, "getJsonPayloads");
+function getRawErrorMessage(error) {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  return null;
+}
+__name(getRawErrorMessage, "getRawErrorMessage");
+
+// packages/core/src/utils/openaiLogger.ts
 var debugLogger7 = createDebugLogger("OPENAI_LOGGER");
 var MAIN_SESSION_PROMPT_ID_DELIMITER = "########";
 var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
@@ -64703,6 +65511,24 @@ function contextForPromptId(promptId) {
   };
 }
 __name(contextForPromptId, "contextForPromptId");
+function getString(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+__name(getString, "getString");
+function getErrorRequestId(error) {
+  const source = error;
+  return getString(source.requestID) ?? getString(source.request_id) ?? getString(source.requestId) ?? getString(source.response_id) ?? getRateLimitErrorDetails(error).requestId;
+}
+__name(getErrorRequestId, "getErrorRequestId");
+function serializeError(error) {
+  const requestId = getErrorRequestId(error);
+  return {
+    message: error.message,
+    stack: error.stack,
+    ...requestId ? { requestId } : {}
+  };
+}
+__name(serializeError, "serializeError");
 var OpenAILogger = class {
   static {
     __name(this, "OpenAILogger");
@@ -64754,10 +65580,7 @@ var OpenAILogger = class {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       request: request4,
       response: response || null,
-      error: error ? {
-        message: error.message,
-        stack: error.stack
-      } : null,
+      error: error ? serializeError(error) : null,
       context: contextForPromptId(promptId),
       system: {
         hostname: os2.hostname(),
@@ -69047,11 +69870,11 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   let baseGenerator;
   try {
     if (authType === "openai" /* USE_OPENAI */) {
-      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-GM77FLII.js");
+      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-5LJ5A7YY.js");
       baseGenerator = createOpenAIContentGenerator(generatorConfig, config);
     } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
-      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-LWLA6MQG.js");
-      const { QwenContentGenerator } = await import("./qwenContentGenerator-QSCXQIKJ.js");
+      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-ZV7YLMND.js");
+      const { QwenContentGenerator } = await import("./qwenContentGenerator-E2JSB4FJ.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
@@ -69069,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-H5ZOEENQ.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-YDUUKAM2.js");
+      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-WCH4GWD3.js");
       baseGenerator = createGeminiContentGenerator(generatorConfig, config);
     } else {
       throw new Error(
@@ -71614,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);
@@ -71647,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) {
@@ -71661,7 +72485,7 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
       };
     }
     if (cacheEnabled && (result.stats ?? stats)) {
-      const cacheable = typeof result.llmContent === "string" && result.originalLineCount !== void 0;
+      const cacheable = isCacheableReadResult(result);
       const recordStats = result.stats ?? stats;
       cache.recordRead(absPath, recordStats, {
         full: isFullRead && !result.isTruncated,
@@ -71672,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.
 
 ---
 
@@ -71749,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: {
@@ -71759,14 +72584,14 @@ var ReadFileTool = class _ReadFileTool extends BaseDeclarativeTool {
           },
           offset: {
             description: "Optional: For text files, the 0-based line number to start reading from. Requires 'limit' to be set. Use for paginating through large files.",
-            type: "number"
+            type: "integer"
           },
           limit: {
             description: "Optional: For text files, maximum number of lines to read. Use with 'offset' to paginate through large files. If omitted, reads the entire file (if feasible, up to a default limit).",
-            type: "number"
+            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"
           }
         },
@@ -71796,11 +72621,11 @@ var ReadFileTool = class _ReadFileTool extends BaseDeclarativeTool {
     if (!path10.isAbsolute(filePath)) {
       return `File path must be absolute, but was relative: ${filePath}. You must provide an absolute path.`;
     }
-    if (params.offset !== void 0 && params.offset < 0) {
-      return "Offset must be a non-negative number";
+    if (params.offset !== void 0 && (!Number.isInteger(params.offset) || params.offset < 0)) {
+      return "Offset must be a non-negative integer";
     }
-    if (params.limit !== void 0 && params.limit <= 0) {
-      return "Limit must be a positive number";
+    if (params.limit !== void 0 && (!Number.isInteger(params.limit) || params.limit <= 0)) {
+      return "Limit must be a positive integer";
     }
     if (params.pages !== void 0) {
       const pages = params.pages.trim();
@@ -71819,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.`;
       }
@@ -71899,6 +72724,7 @@ export {
   isWithinRoot,
   isBinaryFile,
   detectFileType,
+  isCacheableReadResult,
   processSingleFileContent,
   fileExists,
   FileOperation,
@@ -72100,9 +72926,23 @@ export {
   MemoryExtractEvent,
   MemoryDreamEvent,
   MemoryRecallEvent,
+  createOpenAIReasoningThoughtPart,
+  isOpenAIReasoningThoughtPart,
+  parseThought,
+  getThoughtSummary,
   TaggedThinkingParser,
   OpenAIContentConverter,
   openaiRequestCaptureContext,
+  isApiError,
+  isStructuredError,
+  isProQuotaExceededError,
+  isGenericQuotaExceededError,
+  isQwenQuotaExceededError,
+  getRetryDelayMs,
+  getRetryAfterDelayMs,
+  isRateLimitError,
+  getRateLimitErrorDetails,
+  getRateLimitRetryDelayMs,
   resolveOpenAILogDir,
   OpenAILogger,
   openaiLogger,
@@ -72163,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
@@ -72176,12 +73021,12 @@ export {
  */
 /**
  * @license
- * Copyright 2026 Qwen Team
+ * Copyright 2025 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2025 Qwen
+ * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
 /*! Bundled license information: