@qwen-code/qwen-code 0.21.1 → 0.21.2-nightly.20260801.bc382c3ff

package/chunks/{chunk-PT722TDT.js → chunk-M2F5PLOW.js}

@@ -5,20 +5,20 @@ import {
 } from "./chunk-VGC4I5JJ.js";
 import {
   isAnyAutoMemPath
-} from "./chunk-SGFT55XI.js";
+} from "./chunk-E4WHKETF.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-Y4IHBGBP.js";
+} from "./chunk-BV4QX43X.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   SchemaValidator,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-Y6AXW2OG.js";
+} from "./chunk-I5GNT6ZS.js";
 import {
   DEFAULT_QWEN_MODEL
-} from "./chunk-VCPIZRYH.js";
+} from "./chunk-TFFMATHX.js";
 import {
   estimateTextTokens,
   generateLegacyMcpToolName,
@@ -29,10 +29,10 @@ import {
 } from "./chunk-ZBVS26BY.js";
 import {
   InstallationManager
-} from "./chunk-A3NDJ5SB.js";
+} from "./chunk-TYERNYH4.js";
 import {
   atomicWriteFile
-} from "./chunk-7XATOOE7.js";
+} from "./chunk-UH7Z7Y45.js";
 import {
   isTelemetrySdkInitialized,
   recordApiErrorMetrics,
@@ -53,7 +53,7 @@ import {
   recordSubagentExecutionMetrics,
   recordTokenUsageMetrics,
   recordToolCallMetrics
-} from "./chunk-BGTQCTQW.js";
+} from "./chunk-O2ZYHG33.js";
 import {
   require_src,
   safeJsonStringify
@@ -89,6 +89,7 @@ import {
   EVENT_PROMPT_SUGGESTION,
   EVENT_PROTOCOL_TAG_SANITIZED,
   EVENT_RIPGREP_FALLBACK,
+  EVENT_RIPGREP_RUNTIME_RECOVERY,
   EVENT_SKILL_LAUNCH,
   EVENT_SLASH_COMMAND,
   EVENT_SPECULATION,
@@ -101,7 +102,7 @@ import {
   EVENT_WORKFLOW_KEYWORD,
   EVENT_WORKFLOW_RUN,
   SERVICE_NAME
-} from "./chunk-S7W2GKIO.js";
+} from "./chunk-G7XXKQYS.js";
 import {
   Storage,
   createDebugLogger,
@@ -112,7 +113,7 @@ import {
   makeRelative,
   shortenPath,
   unescapePath
-} from "./chunk-UHUSJ6X7.js";
+} from "./chunk-3RXUYQJI.js";
 import {
   SemanticAttributes,
   init_esm
@@ -5813,10 +5814,10 @@ var require_lib = __commonJS({
     exports.analyse = analyse;
     var detectFile = /* @__PURE__ */ __name((filepath, opts = {}) => new Promise((resolve, reject) => {
       let fd;
-      const fs7 = (0, node_1.default)();
+      const fs8 = (0, node_1.default)();
       const handler = /* @__PURE__ */ __name((err, buffer) => {
         if (fd) {
-          fs7.closeSync(fd);
+          fs8.closeSync(fd);
         }
         if (err) {
           reject(err);
@@ -5825,26 +5826,26 @@ var require_lib = __commonJS({
         }
       }, "handler");
       if (opts && opts.sampleSize) {
-        fd = fs7.openSync(filepath, "r");
+        fd = fs8.openSync(filepath, "r");
         const sample = Buffer.allocUnsafe(opts.sampleSize);
-        fs7.read(fd, sample, 0, opts.sampleSize, opts.offset, (err) => {
+        fs8.read(fd, sample, 0, opts.sampleSize, opts.offset, (err) => {
           handler(err, sample);
         });
         return;
       }
-      fs7.readFile(filepath, handler);
+      fs8.readFile(filepath, handler);
     }), "detectFile");
     exports.detectFile = detectFile;
     var detectFileSync = /* @__PURE__ */ __name((filepath, opts = {}) => {
-      const fs7 = (0, node_1.default)();
+      const fs8 = (0, node_1.default)();
       if (opts && opts.sampleSize) {
-        const fd = fs7.openSync(filepath, "r");
+        const fd = fs8.openSync(filepath, "r");
         const sample = Buffer.allocUnsafe(opts.sampleSize);
-        fs7.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
-        fs7.closeSync(fd);
+        fs8.readSync(fd, sample, 0, opts.sampleSize, opts.offset);
+        fs8.closeSync(fd);
         return (0, exports.detect)(sample);
       }
-      return (0, exports.detect)(fs7.readFileSync(filepath));
+      return (0, exports.detect)(fs8.readFileSync(filepath));
     }, "detectFileSync");
     exports.detectFileSync = detectFileSync;
     exports.default = {
@@ -7395,11 +7396,11 @@ var require_lru_cache = __commonJS({
 // packages/core/src/tools/read-file.ts
 init_esbuild_shims();
 import path9 from "node:path";
-import fs6 from "node:fs/promises";
+import fs7 from "node:fs/promises";
 
 // packages/core/src/utils/fileUtils.ts
 init_esbuild_shims();
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import fsPromises from "node:fs/promises";
 import path2 from "node:path";
 
@@ -8862,6 +8863,19 @@ 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 CursorNotAtLineBoundaryError = class extends Error {
+  constructor(startOffset, maxSnapBytes) {
+    super(
+      `Byte offset ${startOffset} is not the start of a line, and no line break was found within ${maxSnapBytes} bytes after it. Resume from a cursor this reader returned.`
+    );
+    this.startOffset = startOffset;
+    this.maxSnapBytes = maxSnapBytes;
+    this.name = "CursorNotAtLineBoundaryError";
+  }
+  static {
+    __name(this, "CursorNotAtLineBoundaryError");
+  }
+};
 var LargeNonUtf8TextError = class extends Error {
   constructor(encoding, reason) {
     super(
@@ -8875,11 +8889,25 @@ var LargeNonUtf8TextError = class extends Error {
     __name(this, "LargeNonUtf8TextError");
   }
 };
+var TextScanBudgetExceededError = class extends Error {
+  constructor(scannedBytes, maxScanBytes) {
+    super(
+      `Locating the requested line window would read more than ${maxScanBytes} bytes (line offsets are resolved by scanning from the start of the file). Use a byte-offset read to reach this part of the file.`
+    );
+    this.scannedBytes = scannedBytes;
+    this.maxScanBytes = maxScanBytes;
+    this.name = "TextScanBudgetExceededError";
+  }
+  static {
+    __name(this, "TextScanBudgetExceededError");
+  }
+};
 async function readTextRange(request2) {
   request2.signal?.throwIfAborted();
   const stats = request2.stats ?? await stat(request2.path);
   const maxOutputBytes = normalizeMaxBytes(request2.maxOutputBytes);
-  if (stats.size < TEXT_RANGE_FAST_PATH_MAX_SIZE) {
+  const maxScanBytes = request2.maxScanBytes ?? Number.POSITIVE_INFINITY;
+  if (stats.size < TEXT_RANGE_FAST_PATH_MAX_SIZE && stats.size <= maxScanBytes) {
     const { content, encoding, bom } = await readFileWithEncodingInfo(
       request2.path,
       request2.signal
@@ -8898,9 +8926,193 @@ async function readTextRange(request2) {
       lineEnding: detectLineEndingFromContent(content)
     };
   }
-  return readLargeUtf8Range(request2, maxOutputBytes);
+  return readLargeUtf8Range(
+    request2.path,
+    request2,
+    maxOutputBytes,
+    maxScanBytes,
+    stats.size
+  );
 }
 __name(readTextRange, "readTextRange");
+async function readTextRangeFromHandle(fileHandle, request2) {
+  request2.signal?.throwIfAborted();
+  return readLargeUtf8Range(
+    fileHandle,
+    request2,
+    normalizeMaxBytes(request2.maxOutputBytes),
+    request2.maxScanBytes,
+    request2.fileSize
+  );
+}
+__name(readTextRangeFromHandle, "readTextRangeFromHandle");
+async function readTextCursorWindowFromHandle(fileHandle, request2) {
+  request2.signal?.throwIfAborted();
+  const encoding = await detectFileEncoding(fileHandle);
+  request2.signal?.throwIfAborted();
+  if (!isUtf8CompatibleEncoding(encoding)) {
+    throw new LargeNonUtf8TextError(encoding);
+  }
+  const bom = await hasUtf8Bom(fileHandle, request2.fileSize);
+  const maxOutputBytes = normalizeMaxBytes(request2.maxOutputBytes);
+  const startOffset = await snapToLineStart(fileHandle, request2);
+  if (startOffset >= request2.fileSize) {
+    return {
+      content: "",
+      startOffset,
+      encoding: "utf-8",
+      bom,
+      lineEnding: "lf",
+      truncatedByBytes: false
+    };
+  }
+  const decoder = new TextDecoder2("utf-8", { fatal: true, ignoreBOM: true });
+  const decode = /* @__PURE__ */ __name((chunk, options) => {
+    try {
+      return decoder.decode(chunk, options);
+    } catch {
+      throw new LargeNonUtf8TextError(encoding, "invalid-utf8");
+    }
+  }, "decode");
+  const lines = [];
+  let contentBytes = 0;
+  let consumedBytes = 0;
+  let truncatedByBytes = false;
+  let stop = false;
+  let skipRestOfLine = false;
+  let sawCrlf = false;
+  const emit = /* @__PURE__ */ __name((line, hadNewline) => {
+    const separator = lines.length > 0 ? 1 : 0;
+    const lineBytes = Buffer.byteLength(line, "utf8");
+    if (contentBytes + separator + lineBytes > maxOutputBytes) {
+      if (lines.length > 0) {
+        stop = true;
+        return;
+      }
+      const cut = truncateUtf8(line, maxOutputBytes);
+      lines.push(cut.content);
+      if (hadNewline && line.endsWith("\r")) sawCrlf = true;
+      contentBytes = Buffer.byteLength(cut.content, "utf8");
+      consumedBytes += contentBytes;
+      truncatedByBytes = true;
+      skipRestOfLine = true;
+      stop = true;
+      return;
+    }
+    lines.push(line);
+    if (hadNewline && line.endsWith("\r")) sawCrlf = true;
+    contentBytes += separator + lineBytes;
+    consumedBytes += lineBytes + (hadNewline ? 1 : 0);
+    if (request2.limit !== void 0 && lines.length >= request2.limit) {
+      stop = true;
+    }
+  }, "emit");
+  let pending = "";
+  let firstChunk = true;
+  let reachedEof = true;
+  for await (const raw of chunksFromHandle(
+    fileHandle,
+    startOffset,
+    request2.fileSize,
+    request2.signal
+  )) {
+    request2.signal?.throwIfAborted();
+    let text = decode(raw, { stream: true });
+    if (firstChunk) {
+      firstChunk = false;
+      if (startOffset === 0 && text.charCodeAt(0) === 65279) {
+        text = text.slice(1);
+        consumedBytes += UTF8_BOM_BYTES;
+      }
+    }
+    pending += text;
+    let newline = pending.indexOf("\n");
+    const pendingLine = newline === -1 ? pending : pending.slice(0, newline);
+    const pendingSeparator = lines.length > 0 ? 1 : 0;
+    if (contentBytes + pendingSeparator + Buffer.byteLength(pendingLine, "utf8") > maxOutputBytes) {
+      if (lines.length === 0) {
+        emit(pendingLine, newline !== -1);
+      } else {
+        stop = true;
+      }
+      reachedEof = false;
+      break;
+    }
+    while (newline !== -1) {
+      emit(pending.slice(0, newline), true);
+      pending = pending.slice(newline + 1);
+      if (stop) break;
+      newline = pending.indexOf("\n");
+    }
+    if (stop) {
+      reachedEof = false;
+      break;
+    }
+  }
+  if (reachedEof) {
+    decode();
+    if (!stop) emit(pending, false);
+  }
+  if (skipRestOfLine) {
+    const resumeAt = await snapToLineStart(
+      fileHandle,
+      {
+        ...request2,
+        startOffset: startOffset + Math.max(consumedBytes, 1),
+        // This offset was produced internally after returning a truncated prefix,
+        // so it must advance past the rest of that line. `maxSnapBytes` protects
+        // only client-supplied offsets.
+        maxSnapBytes: request2.fileSize
+      },
+      true
+    );
+    consumedBytes = resumeAt - startOffset;
+  }
+  const content = lines.join("\n");
+  const nextOffset = startOffset + consumedBytes;
+  return {
+    content,
+    startOffset,
+    ...nextOffset < request2.fileSize ? { nextOffset } : {},
+    encoding: "utf-8",
+    bom,
+    lineEnding: sawCrlf ? "crlf" : "lf",
+    truncatedByBytes
+  };
+}
+__name(readTextCursorWindowFromHandle, "readTextCursorWindowFromHandle");
+var UTF8_BOM_BYTES = 3;
+var LINE_FEED = 10;
+async function hasUtf8Bom(fileHandle, fileSize) {
+  if (fileSize < UTF8_BOM_BYTES) return false;
+  const probe = Buffer.alloc(UTF8_BOM_BYTES);
+  const { bytesRead } = await fileHandle.read(probe, 0, UTF8_BOM_BYTES, 0);
+  return bytesRead === UTF8_BOM_BYTES && probe[0] === 239 && probe[1] === 187 && probe[2] === 191;
+}
+__name(hasUtf8Bom, "hasUtf8Bom");
+async function snapToLineStart(fileHandle, request2, allowEof = false) {
+  const { startOffset, fileSize, maxSnapBytes, signal } = request2;
+  if (startOffset <= 0) return 0;
+  if (startOffset >= fileSize) return startOffset;
+  const previous = Buffer.alloc(1);
+  const { bytesRead } = await fileHandle.read(previous, 0, 1, startOffset - 1);
+  if (bytesRead === 1 && previous[0] === LINE_FEED) return startOffset;
+  let scanned = 0;
+  const snapEnd = Math.min(fileSize, startOffset + maxSnapBytes);
+  for await (const chunk of chunksFromHandle(
+    fileHandle,
+    startOffset,
+    snapEnd,
+    signal
+  )) {
+    const index = chunk.indexOf(LINE_FEED);
+    if (index !== -1) return startOffset + scanned + index + 1;
+    scanned += chunk.length;
+  }
+  if (allowEof) return fileSize;
+  throw new CursorNotAtLineBoundaryError(startOffset, maxSnapBytes);
+}
+__name(snapToLineStart, "snapToLineStart");
 function normalizeMaxBytes(maxOutputBytes) {
   if (maxOutputBytes === Number.POSITIVE_INFINITY) {
     return Number.POSITIVE_INFINITY;
@@ -8926,8 +9138,9 @@ function sliceDecodedContent(content, offset, limit, maxOutputBytes) {
   };
 }
 __name(sliceDecodedContent, "sliceDecodedContent");
-async function readLargeUtf8Range(request2, maxOutputBytes) {
-  const encoding = await detectFileEncoding(request2.path);
+async function readLargeUtf8Range(source, request2, maxOutputBytes, maxScanBytes, sourceSize) {
+  const encoding = await detectFileEncoding(source);
+  request2.signal?.throwIfAborted();
   if (!isUtf8CompatibleEncoding(encoding)) {
     throw new LargeNonUtf8TextError(encoding);
   }
@@ -8943,14 +9156,31 @@ async function readLargeUtf8Range(request2, maxOutputBytes) {
   let previousChunkEndedWithCR = false;
   let originalLineCountExact = true;
   let stoppedEarly = false;
+  let scannedBytes = 0;
+  let consumedBytes = 0;
   const decoder = new TextDecoder2("utf-8", {
     fatal: true,
     ignoreBOM: true
   });
-  const stream = createReadStream(request2.path, {
-    highWaterMark: 512 * 1024,
-    signal: request2.signal
-  });
+  let pathStream;
+  let chunks;
+  const sourceEnd = Math.min(
+    sourceSize ?? Number.POSITIVE_INFINITY,
+    maxScanBytes
+  );
+  if (sourceEnd <= 0 && (sourceSize ?? 0) > 0) {
+    throw new TextScanBudgetExceededError(0, maxScanBytes);
+  }
+  if (typeof source === "string") {
+    pathStream = createReadStream(source, {
+      highWaterMark: 512 * 1024,
+      signal: request2.signal,
+      ...Number.isFinite(sourceEnd) ? { end: Math.max(0, sourceEnd - 1) } : {}
+    });
+    chunks = pathStream;
+  } else {
+    chunks = chunksFromHandle(source, 0, sourceEnd, request2.signal);
+  }
   function appendSelected(fragment) {
     if (fragment.length === 0 || truncatedByBytes) {
       return;
@@ -8981,17 +9211,19 @@ async function readLargeUtf8Range(request2, maxOutputBytes) {
   }
   __name(decodeUtf8Chunk, "decodeUtf8Chunk");
   try {
-    for await (const rawChunk of stream) {
+    for await (const rawChunk of chunks) {
       request2.signal?.throwIfAborted();
+      scannedBytes += rawChunk.length;
       let chunk = decodeUtf8Chunk(rawChunk, { stream: true });
       if (firstChunk) {
         firstChunk = false;
         if (chunk.charCodeAt(0) === 65279) {
           chunk = chunk.slice(1);
           bom = true;
+          consumedBytes += 3;
         }
       }
-      if (previousChunkEndedWithCR && chunk.startsWith("\n") || chunk.includes("\r\n")) {
+      if (isSelectedLine() && previousChunkEndedWithCR && chunk.startsWith("\n")) {
         lineEnding = "crlf";
       }
       previousChunkEndedWithCR = chunk.endsWith("\r");
@@ -8999,11 +9231,14 @@ async function readLargeUtf8Range(request2, maxOutputBytes) {
       let newline = chunk.indexOf("\n", start);
       while (newline !== -1) {
         if (isSelectedLine()) {
-          appendSelected(chunk.slice(start, newline));
+          const fragment = chunk.slice(start, newline);
+          if (fragment.endsWith("\r")) lineEnding = "crlf";
+          appendSelected(fragment);
           if (currentLine + 1 < endLine) {
             appendSelected("\n");
           }
         }
+        consumedBytes += Buffer.byteLength(chunk.slice(start, newline), "utf8") + 1;
         currentLine++;
         start = newline + 1;
         if (currentLine >= endLine || truncatedByBytes) {
@@ -9013,8 +9248,12 @@ async function readLargeUtf8Range(request2, maxOutputBytes) {
         }
         newline = chunk.indexOf("\n", start);
       }
-      if (start < chunk.length && isSelectedLine()) {
-        appendSelected(chunk.slice(start));
+      if (!stoppedEarly && start < chunk.length) {
+        const tail = chunk.slice(start);
+        if (isSelectedLine()) {
+          appendSelected(tail);
+        }
+        consumedBytes += Buffer.byteLength(tail, "utf8");
       }
       if (currentLine >= endLine || truncatedByBytes) {
         originalLineCountExact = false;
@@ -9023,7 +9262,13 @@ async function readLargeUtf8Range(request2, maxOutputBytes) {
       }
     }
   } finally {
-    stream.destroy();
+    if (pathStream !== void 0 && !pathStream.destroyed) {
+      pathStream.destroy();
+    }
+  }
+  const budgetExhausted = !stoppedEarly && sourceSize !== void 0 && sourceSize > maxScanBytes && scannedBytes >= maxScanBytes;
+  if (budgetExhausted) {
+    throw new TextScanBudgetExceededError(scannedBytes, maxScanBytes);
   }
   if (!stoppedEarly) {
     decodeUtf8Chunk();
@@ -9031,6 +9276,7 @@ async function readLargeUtf8Range(request2, maxOutputBytes) {
   return {
     content: output,
     originalLineCount: currentLine + 1,
+    ...stoppedEarly && !truncatedByBytes && consumedBytes < (sourceSize ?? Number.POSITIVE_INFINITY) ? { nextByteOffset: consumedBytes } : {},
     encoding: "utf-8",
     bom,
     lineEnding,
@@ -9039,6 +9285,26 @@ async function readLargeUtf8Range(request2, maxOutputBytes) {
   };
 }
 __name(readLargeUtf8Range, "readLargeUtf8Range");
+async function* chunksFromHandle(fileHandle, from = 0, toExclusive = Number.POSITIVE_INFINITY, signal) {
+  const highWaterMark = 512 * 1024;
+  const buffer = Buffer.allocUnsafe(highWaterMark);
+  let position = from;
+  while (position < toExclusive) {
+    signal?.throwIfAborted();
+    const bytesToRead = Math.min(highWaterMark, toExclusive - position);
+    const { bytesRead } = await fileHandle.read(
+      buffer,
+      0,
+      bytesToRead,
+      position
+    );
+    signal?.throwIfAborted();
+    if (bytesRead === 0) return;
+    position += bytesRead;
+    yield buffer.subarray(0, bytesRead);
+  }
+}
+__name(chunksFromHandle, "chunksFromHandle");
 function truncateUtf8(content, maxBytes) {
   const bytes = Buffer.byteLength(content, "utf8");
   if (bytes <= maxBytes) {
@@ -9063,8 +9329,234 @@ function detectLineEndingFromContent(content) {
 }
 __name(detectLineEndingFromContent, "detectLineEndingFromContent");
 
+// packages/core/src/utils/image-view.ts
+init_esbuild_shims();
+import fs2 from "node:fs/promises";
+var IMAGE_VIEW_MAX_EDGE = 1568;
+var IMAGE_VIEW_MAX_PATCHES = 1568;
+var IMAGE_PATCH_SIZE = 28;
+var IMAGE_MAX_UPSCALE = 8;
+var IMAGE_JPEG_QUALITY = 92;
+var IMAGE_MAX_SOURCE_BYTES = 100 * 1024 * 1024;
+var IMAGE_MAX_OUTPUT_BYTES = 9 * 1024 * 1024;
+var SUPPORTED_IMAGE_FORMATS = /* @__PURE__ */ new Set(["jpeg", "png", "webp"]);
+var ImageViewError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  static {
+    __name(this, "ImageViewError");
+  }
+};
+function fitsVisualBudget({ width, height }) {
+  return width <= IMAGE_VIEW_MAX_EDGE && height <= IMAGE_VIEW_MAX_EDGE && Math.ceil(width / IMAGE_PATCH_SIZE) * Math.ceil(height / IMAGE_PATCH_SIZE) <= IMAGE_VIEW_MAX_PATCHES;
+}
+__name(fitsVisualBudget, "fitsVisualBudget");
+function boundedSize(width, height, maxUpscale) {
+  const widthIsLongEdge = width >= height;
+  const maxLongEdge = Math.min(
+    IMAGE_VIEW_MAX_EDGE,
+    Math.max(width, height) * maxUpscale
+  );
+  let low = 1;
+  let high = maxLongEdge;
+  let best = { width: 1, height: 1 };
+  while (low <= high) {
+    const longEdge = Math.floor((low + high) / 2);
+    const candidate = widthIsLongEdge ? {
+      width: longEdge,
+      height: Math.max(1, Math.round(height / width * longEdge))
+    } : {
+      width: Math.max(1, Math.round(width / height * longEdge)),
+      height: longEdge
+    };
+    if (fitsVisualBudget(candidate)) {
+      best = candidate;
+      low = longEdge + 1;
+    } else {
+      high = longEdge - 1;
+    }
+  }
+  return best;
+}
+__name(boundedSize, "boundedSize");
+async function prepareImage(filePath, signal) {
+  signal.throwIfAborted();
+  let sharp;
+  try {
+    sharp = (await import("sharp")).default;
+  } catch {
+    throw new ImageViewError(
+      "renderer_unavailable",
+      'Image rendering is unavailable because the "sharp" image module could not be loaded.'
+    );
+  }
+  let stats;
+  try {
+    stats = await fs2.stat(filePath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new ImageViewError(
+        "file_not_found",
+        `Image file not found: ${filePath}`
+      );
+    }
+    throw error;
+  }
+  if (stats.isDirectory()) {
+    throw new ImageViewError(
+      "target_is_directory",
+      `Image path is a directory: ${filePath}`
+    );
+  }
+  if (!stats.isFile()) {
+    throw new ImageViewError(
+      "target_not_regular_file",
+      `Image path is not a regular file: ${filePath}`
+    );
+  }
+  if (stats.size > IMAGE_MAX_SOURCE_BYTES) {
+    throw new ImageViewError(
+      "source_too_large",
+      `Image file exceeds the 100 MB source limit: ${filePath}`
+    );
+  }
+  const bytes = await fs2.readFile(filePath, { signal });
+  if (bytes.length > IMAGE_MAX_SOURCE_BYTES) {
+    throw new ImageViewError(
+      "source_too_large",
+      `Image file exceeds the 100 MB source limit: ${filePath}`
+    );
+  }
+  let metadata;
+  try {
+    metadata = await sharp(bytes, {
+      failOn: "error",
+      limitInputPixels: true
+    }).metadata();
+  } catch {
+    signal.throwIfAborted();
+    throw new ImageViewError(
+      "decode_failed",
+      `Failed to decode image (file may be corrupt or not a static PNG, JPEG, or WebP): ${filePath}`
+    );
+  }
+  signal.throwIfAborted();
+  if (!SUPPORTED_IMAGE_FORMATS.has(metadata.format)) {
+    throw new ImageViewError(
+      "unsupported_image",
+      `Unsupported image. Expected a static PNG, JPEG, or WebP file: ${filePath}`
+    );
+  }
+  if ((metadata.pages ?? 1) > 1) {
+    throw new ImageViewError(
+      "animated_image",
+      `Only static images are supported: ${filePath}`
+    );
+  }
+  return { bytes, metadata, sharp };
+}
+__name(prepareImage, "prepareImage");
+async function renderImageView(filePath, prepared, selection, outputSize, signal) {
+  const { bytes, metadata, sharp } = prepared;
+  let output;
+  try {
+    output = await sharp(bytes, {
+      autoOrient: true,
+      failOn: "error",
+      limitInputPixels: true
+    }).extract(selection).resize(outputSize.width, outputSize.height, {
+      fit: "fill",
+      kernel: sharp.kernel.lanczos3
+    }).flatten({ background: "#ffffff" }).jpeg({
+      quality: IMAGE_JPEG_QUALITY,
+      chromaSubsampling: "4:4:4"
+    }).toBuffer();
+  } catch {
+    signal.throwIfAborted();
+    throw new ImageViewError(
+      "decode_failed",
+      `Failed to render image overview: ${filePath}`
+    );
+  }
+  signal.throwIfAborted();
+  if (output.length > IMAGE_MAX_OUTPUT_BYTES) {
+    throw new ImageViewError(
+      "output_too_large",
+      `Rendered image exceeds the 9 MB output limit: ${filePath}`
+    );
+  }
+  return {
+    bytes: output,
+    mimeType: "image/jpeg",
+    sourceWidth: metadata.autoOrient.width,
+    sourceHeight: metadata.autoOrient.height,
+    selectedWidth: selection.width,
+    selectedHeight: selection.height,
+    outputWidth: outputSize.width,
+    outputHeight: outputSize.height
+  };
+}
+__name(renderImageView, "renderImageView");
+async function renderImageOverview(filePath, signal) {
+  const prepared = await prepareImage(filePath, signal);
+  const sourceWidth = prepared.metadata.autoOrient.width;
+  const sourceHeight = prepared.metadata.autoOrient.height;
+  const outputSize = boundedSize(sourceWidth, sourceHeight, 1);
+  return renderImageView(
+    filePath,
+    prepared,
+    { left: 0, top: 0, width: sourceWidth, height: sourceHeight },
+    outputSize,
+    signal
+  );
+}
+__name(renderImageOverview, "renderImageOverview");
+async function renderNormalizedImageCrop(filePath, region, signal) {
+  const prepared = await prepareImage(filePath, signal);
+  const sourceWidth = prepared.metadata.autoOrient.width;
+  const sourceHeight = prepared.metadata.autoOrient.height;
+  const left = Math.min(
+    sourceWidth - 1,
+    Math.max(0, Math.floor(region.x1 / 1e3 * sourceWidth))
+  );
+  const top = Math.min(
+    sourceHeight - 1,
+    Math.max(0, Math.floor(region.y1 / 1e3 * sourceHeight))
+  );
+  const right = Math.min(
+    sourceWidth,
+    Math.max(left + 1, Math.ceil(region.x2 / 1e3 * sourceWidth))
+  );
+  const bottom = Math.min(
+    sourceHeight,
+    Math.max(top + 1, Math.ceil(region.y2 / 1e3 * sourceHeight))
+  );
+  const selectedWidth = right - left;
+  const selectedHeight = bottom - top;
+  const outputSize = boundedSize(
+    selectedWidth,
+    selectedHeight,
+    IMAGE_MAX_UPSCALE
+  );
+  return renderImageView(
+    filePath,
+    prepared,
+    { left, top, width: selectedWidth, height: selectedHeight },
+    outputSize,
+    signal
+  );
+}
+__name(renderNormalizedImageCrop, "renderNormalizedImageCrop");
+
 // packages/core/src/utils/fileUtils.ts
 var debugLogger2 = createDebugLogger("FILE_UTILS");
+var CANONICAL_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/webp"
+]);
 var PDF_FULL_TEXT_EXTRACTION_MAX_MB = 100;
 var PDF_PAGED_TEXT_EXTRACTION_MAX_MB = 512;
 function detectBOM(buf) {
@@ -9196,7 +9688,7 @@ function bomEncodingToName(bomEncoding) {
 }
 __name(bomEncodingToName, "bomEncodingToName");
 async function readFileWithEncodingInfo(filePath, signal) {
-  const full = await fs2.promises.readFile(
+  const full = await fs3.promises.readFile(
     filePath,
     signal === void 0 ? void 0 : { signal }
   );
@@ -9215,7 +9707,7 @@ async function countFileLines(filePath) {
 __name(countFileLines, "countFileLines");
 async function readFileWithLineAndLimit(params) {
   const { path: filePath, limit, line, maxOutputBytes, signal } = params;
-  const stats = params.stats ?? await fs2.promises.stat(filePath);
+  const stats = params.stats ?? await fs3.promises.stat(filePath);
   if (line !== void 0 && line > 0 || Number.isFinite(limit) || maxOutputBytes !== void 0) {
     return readTextRange({
       path: filePath,
@@ -9238,19 +9730,22 @@ async function readFileWithLineAndLimit(params) {
   const endLine = Math.min(startLine + limit, originalLineCount);
   const actualStartLine = Math.min(startLine, originalLineCount);
   const selectedLines = lines.slice(actualStartLine, endLine);
+  const joined = selectedLines.join("\n");
   return {
-    content: selectedLines.join("\n"),
+    content: joined,
     bom,
     encoding,
     originalLineCount,
-    originalLineCountExact: true
+    originalLineCountExact: true,
+    truncatedByBytes: false,
+    lineEnding: detectLineEndingFromContent(joined)
   };
 }
 __name(readFileWithLineAndLimit, "readFileWithLineAndLimit");
-async function detectFileEncoding(filePath) {
-  let fh = null;
+async function detectFileEncoding(source) {
+  let opened = null;
   try {
-    fh = await fs2.promises.open(filePath, "r");
+    const fh = typeof source === "string" ? opened = await fs3.promises.open(source, "r") : source;
     const stats = await fh.stat();
     if (stats.size === 0) return "utf-8";
     const sampleSize = Math.min(8192, stats.size);
@@ -9259,22 +9754,7 @@ async function detectFileEncoding(filePath) {
     if (bytesRead === 0) return "utf-8";
     const sample = buf.subarray(0, bytesRead);
     const bom = detectBOM(sample);
-    if (bom) {
-      switch (bom.encoding) {
-        case "utf8":
-          return "utf-8";
-        case "utf16le":
-          return "utf-16le";
-        case "utf16be":
-          return "utf-16be";
-        case "utf32le":
-          return "utf-32le";
-        case "utf32be":
-          return "utf-32be";
-        default:
-          return "utf-8";
-      }
-    }
+    if (bom) return bomEncodingToName(bom.encoding);
     if (isValidUtf8(sample)) return "utf-8";
     const detected = detectEncodingFromBuffer(sample);
     if (detected && !isUtf8CompatibleEncoding(detected)) {
@@ -9284,9 +9764,9 @@ async function detectFileEncoding(filePath) {
   } catch {
     return "utf-8";
   } finally {
-    if (fh) {
+    if (opened) {
       try {
-        await fh.close();
+        await opened.close();
       } catch {
       }
     }
@@ -9308,7 +9788,7 @@ __name(isWithinRoot, "isWithinRoot");
 async function isBinaryFile(filePath) {
   let fh = null;
   try {
-    fh = await fs2.promises.open(filePath, "r");
+    fh = await fs3.promises.open(filePath, "r");
     const stats = await fh.stat();
     const fileSize = stats.size;
     if (fileSize === 0) return false;
@@ -9594,20 +10074,22 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
     preserveUnsupportedImage = false,
     preparePdfForVisionBridge = false,
     signal,
-    largePdfBehavior = "error"
+    largePdfBehavior = "error",
+    displayPath = filePath
   } = options;
   const rootDirectory = config.getTargetDir();
+  const relativePathForDisplay = (path2.isAbsolute(displayPath) ? path2.relative(rootDirectory, displayPath) : displayPath).replace(/\\/g, "/");
   try {
     signal?.throwIfAborted();
     let stats;
     try {
-      stats = await fs2.promises.stat(filePath);
+      stats = options.textFileStats ?? await fs3.promises.stat(filePath);
     } catch (error) {
       if (isNodeError(error) && error.code === "ENOENT") {
         return {
           llmContent: "Could not read file because no file was found at the specified path.",
           returnDisplay: "File not found.",
-          error: `File not found: ${filePath}`,
+          error: `File not found: ${displayPath}`,
           errorType: "file_not_found" /* FILE_NOT_FOUND */
         };
       }
@@ -9617,7 +10099,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       return {
         llmContent: "Could not read file because the provided path is a directory, not a file.",
         returnDisplay: "Path is a directory.",
-        error: `Path is a directory, not a file: ${filePath}`,
+        error: `Path is a directory, not a file: ${displayPath}`,
         errorType: "target_is_directory" /* TARGET_IS_DIRECTORY */
       };
     }
@@ -9625,13 +10107,14 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       return {
         llmContent: `Cannot read file: ${path2.basename(filePath)} is not a regular file (e.g. device, socket, or pipe).`,
         returnDisplay: "Not a regular file.",
-        error: `Not a regular file: ${filePath}`,
+        error: `Not a regular file: ${displayPath}`,
         errorType: "read_content_failure" /* READ_CONTENT_FAILURE */
       };
     }
-    const fileType = await detectFileType(filePath);
-    const relativePathForDisplay = path2.relative(rootDirectory, filePath).replace(/\\/g, "/");
-    const displayName = path2.basename(filePath);
+    const fileType = options.textFileHandle ? "text" : await detectFileType(filePath);
+    const mediaMimeType = index_lite_default.getType(filePath) ?? MIME_LITE_MISSING_VIDEO_TYPES.get(path2.extname(filePath).toLowerCase()) ?? "application/octet-stream";
+    const shouldRenderImageOverview = fileType === "image" && CANONICAL_IMAGE_MIME_TYPES.has(mediaMimeType);
+    const displayName = path2.basename(displayPath);
     const modalities = config.getContentGeneratorConfig?.()?.modalities ?? {};
     const willRenderPdfImages = fileType === "pdf" && !!modalities.image && largePdfBehavior !== "reference";
     const renderForBridge = fileType === "pdf" && !modalities.image && !modalities.pdf && (preserveUnsupportedImage || preparePdfForVisionBridge);
@@ -9670,7 +10153,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       return {
         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)`,
+        error: `PDF exceeds extraction size limit: ${displayPath} (${fileSizeInMB.toFixed(2)}MB)`,
         errorType: "file_too_large" /* FILE_TOO_LARGE */,
         stats
       };
@@ -9679,7 +10162,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       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)`,
+        error: `PDF exceeds page-range extraction size limit: ${displayPath} (${fileSizeInMB.toFixed(2)}MB)`,
         errorType: "file_too_large" /* FILE_TOO_LARGE */,
         stats
       };
@@ -9714,11 +10197,19 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
         };
       }
     }
-    if (fileSizeInMB > 9.9 && !willExtractPdfText && fileType !== "text") {
+    if (shouldRenderImageOverview && stats.size > IMAGE_MAX_SOURCE_BYTES) {
+      return {
+        llmContent: "Image file exceeds the 100 MB source limit.",
+        returnDisplay: "Image file exceeds the 100 MB source limit.",
+        error: `Image file exceeds the 100 MB source limit: ${displayPath}`,
+        errorType: "file_too_large" /* FILE_TOO_LARGE */
+      };
+    }
+    if (fileSizeInMB > 9.9 && !willExtractPdfText && fileType !== "text" && !shouldRenderImageOverview) {
       return {
         llmContent: "File size exceeds the 10MB limit.",
         returnDisplay: "File size exceeds the 10MB limit.",
-        error: `File size exceeds the 10MB limit: ${filePath} (${fileSizeInMB.toFixed(2)}MB)`,
+        error: `File size exceeds the 10MB limit: ${displayPath} (${fileSizeInMB.toFixed(2)}MB)`,
         errorType: "file_too_large" /* FILE_TOO_LARGE */
       };
     }
@@ -9768,11 +10259,22 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
         };
       }
       case "text": {
-        const { content, _meta } = await config.getFileSystemService().readTextFile({
+        const fileSystemService = config.getFileSystemService();
+        const maxOutputBytes = getRangeReadByteLimit(config);
+        const readTextFileFromHandle = fileSystemService.readTextFileFromHandle;
+        const { content, _meta } = options.textFileHandle ? await readTextFileFromHandle.call(fileSystemService, {
+          fileHandle: options.textFileHandle,
+          fileSize: stats.size,
+          limit: limit ?? config.getTruncateToolOutputLines(),
+          line: offset,
+          maxOutputBytes,
+          maxScanBytes: options.textFileMaxScanBytes ?? maxOutputBytes,
+          ...signal !== void 0 ? { signal } : {}
+        }) : await fileSystemService.readTextFile({
           path: filePath,
           limit: limit ?? config.getTruncateToolOutputLines(),
           line: offset,
-          maxOutputBytes: getRangeReadByteLimit(config),
+          maxOutputBytes,
           stats,
           ...signal !== void 0 ? { signal } : {}
         });
@@ -9846,17 +10348,77 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
           stats
         };
       }
-      case "image":
+      case "image": {
+        if (shouldRenderImageOverview) {
+          try {
+            const view = await renderImageOverview(
+              filePath,
+              signal ?? new AbortController().signal
+            );
+            return {
+              llmContent: [
+                {
+                  text: `Image overview: ${view.outputWidth}x${view.outputHeight}; oriented source: ${view.sourceWidth}x${view.sourceHeight}. If details are too small, use tool_search for "zoom image", then call zoom_image with coordinates normalized from 0 to 1000.`
+                },
+                {
+                  inlineData: {
+                    data: view.bytes.toString("base64"),
+                    mimeType: view.mimeType,
+                    displayName
+                  }
+                }
+              ],
+              returnDisplay: `Read image file: ${relativePathForDisplay}`
+            };
+          } catch (error) {
+            signal?.throwIfAborted();
+            if (error instanceof ImageViewError) {
+              if (error.code === "source_too_large" || error.code === "output_too_large") {
+                const userMessage = error.message.replace(`: ${filePath}`, "");
+                return {
+                  llmContent: userMessage,
+                  returnDisplay: userMessage,
+                  error: error.message,
+                  errorType: "file_too_large" /* FILE_TOO_LARGE */
+                };
+              }
+            } else {
+              throw error;
+            }
+          }
+        }
+        const contentBuffer = await fs3.promises.readFile(filePath);
+        const base64Data = contentBuffer.toString("base64");
+        const base64SizeInMB = base64Data.length / (1024 * 1024);
+        if (base64SizeInMB > 9.9) {
+          return {
+            llmContent: `File exceeds the 10MB data URI limit after base64 encoding (${base64SizeInMB.toFixed(2)}MB encoded).`,
+            returnDisplay: `File exceeds the 10MB data URI limit after base64 encoding.`,
+            error: `File exceeds the 10MB data URI limit after base64 encoding: ${displayPath} (${base64SizeInMB.toFixed(2)}MB encoded)`,
+            errorType: "file_too_large" /* FILE_TOO_LARGE */
+          };
+        }
+        return {
+          llmContent: {
+            inlineData: {
+              data: base64Data,
+              mimeType: mediaMimeType,
+              displayName
+            }
+          },
+          returnDisplay: `Read image file: ${relativePathForDisplay}`
+        };
+      }
       case "audio":
       case "video": {
-        const contentBuffer = await fs2.promises.readFile(filePath);
+        const contentBuffer = await fs3.promises.readFile(filePath);
         const base64Data = contentBuffer.toString("base64");
         const base64SizeInMB = base64Data.length / (1024 * 1024);
         if (base64SizeInMB > 9.9) {
           return {
             llmContent: `File exceeds the 10MB data URI limit after base64 encoding (${base64SizeInMB.toFixed(2)}MB encoded).`,
             returnDisplay: `File exceeds the 10MB data URI limit after base64 encoding.`,
-            error: `File exceeds the 10MB data URI limit after base64 encoding: ${filePath} (${base64SizeInMB.toFixed(2)}MB encoded)`,
+            error: `File exceeds the 10MB data URI limit after base64 encoding: ${displayPath} (${base64SizeInMB.toFixed(2)}MB encoded)`,
             errorType: "file_too_large" /* FILE_TOO_LARGE */
           };
         }
@@ -9864,9 +10426,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
           llmContent: {
             inlineData: {
               data: base64Data,
-              mimeType: index_lite_default.getType(filePath) ?? MIME_LITE_MISSING_VIDEO_TYPES.get(
-                path2.extname(filePath).toLowerCase()
-              ) ?? "application/octet-stream",
+              mimeType: mediaMimeType,
               displayName
             }
           },
@@ -9875,14 +10435,14 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       }
       case "pdf": {
         if (!pageRange && modalities.pdf) {
-          const contentBuffer = await fs2.promises.readFile(filePath);
+          const contentBuffer = await fs3.promises.readFile(filePath);
           const base64Data = contentBuffer.toString("base64");
           const base64SizeInMB = base64Data.length / (1024 * 1024);
           if (base64SizeInMB > 9.9) {
             return {
               llmContent: `File exceeds the 10MB data URI limit after base64 encoding (${base64SizeInMB.toFixed(2)}MB encoded).`,
               returnDisplay: `File exceeds the 10MB data URI limit after base64 encoding.`,
-              error: `File exceeds the 10MB data URI limit after base64 encoding: ${filePath} (${base64SizeInMB.toFixed(2)}MB encoded)`,
+              error: `File exceeds the 10MB data URI limit after base64 encoding: ${displayPath} (${base64SizeInMB.toFixed(2)}MB encoded)`,
               errorType: "file_too_large" /* FILE_TOO_LARGE */
             };
           }
@@ -10093,7 +10653,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
           return {
             llmContent: `Error parsing notebook ${relativePathForDisplay}: ${msg}`,
             returnDisplay: `Error reading notebook: ${relativePathForDisplay}`,
-            error: `Error parsing notebook ${filePath}: ${msg}`,
+            error: `Error parsing notebook ${displayPath}: ${msg}`,
             errorType: "read_content_failure" /* READ_CONTENT_FAILURE */
           };
         }
@@ -10103,7 +10663,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
         return {
           llmContent: `Unhandled file type: ${exhaustiveCheck}`,
           returnDisplay: `Skipped unhandled file type: ${relativePathForDisplay}`,
-          error: `Unhandled file type for ${filePath}`
+          error: `Unhandled file type for ${displayPath}`
         };
       }
     }
@@ -10112,11 +10672,10 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       throw error;
     }
     const errorMessage = getErrorMessage(error);
-    const displayPath = path2.relative(rootDirectory, filePath).replace(/\\/g, "/");
     return {
-      llmContent: `Error reading file ${displayPath}: ${errorMessage}`,
-      returnDisplay: `Error reading file ${displayPath}: ${errorMessage}`,
-      error: `Error reading file ${filePath}: ${errorMessage}`,
+      llmContent: `Error reading file ${relativePathForDisplay}: ${errorMessage}`,
+      returnDisplay: `Error reading file ${relativePathForDisplay}: ${errorMessage}`,
+      error: `Error reading file ${relativePathForDisplay}: ${errorMessage}`,
       errorType: "read_content_failure" /* READ_CONTENT_FAILURE */
     };
   }
@@ -10125,7 +10684,7 @@ __name(processSingleFileContent, "processSingleFileContent");
 function getRangeReadByteLimit(config) {
   const charLimit = config.getTruncateToolOutputThreshold();
   if (charLimit === Number.POSITIVE_INFINITY) {
-    return Number.POSITIVE_INFINITY;
+    return Number.MAX_SAFE_INTEGER;
   }
   if (!Number.isFinite(charLimit)) {
     return DEFAULT_RANGE_READ_BYTES;
@@ -10142,7 +10701,7 @@ function normalizeRangeReadByteLimit(maxOutputBytes) {
 __name(normalizeRangeReadByteLimit, "normalizeRangeReadByteLimit");
 async function fileExists(filePath) {
   try {
-    await fsPromises.access(filePath, fs2.constants.F_OK);
+    await fsPromises.access(filePath, fs3.constants.F_OK);
     return true;
   } catch (_) {
     return false;
@@ -10287,7 +10846,7 @@ var import_https_proxy_agent = __toESM(require_dist(), 1);
 import { Buffer as Buffer2 } from "buffer";
 import * as https from "https";
 import * as os2 from "node:os";
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 import path4 from "node:path";
 
 // packages/core/src/telemetry/sanitize.ts
@@ -10492,8 +11051,8 @@ var QwenLogger = class _QwenLogger {
       const legacyPath = path4.join(os2.homedir(), ".qwen", "source.json");
       const candidates = path4.normalize(sourceJsonPath) !== path4.normalize(legacyPath) ? [sourceJsonPath, legacyPath] : [sourceJsonPath];
       for (const candidate of candidates) {
-        if (fs3.existsSync(candidate)) {
-          const sourceJsonContent = fs3.readFileSync(candidate, "utf8");
+        if (fs4.existsSync(candidate)) {
+          const sourceJsonContent = fs4.readFileSync(candidate, "utf8");
           const sourceData = JSON.parse(sourceJsonContent);
           if (sourceData && typeof sourceData === "object" && sourceData.source && sourceData.source !== "unknown") {
             return sourceData.source;
@@ -10669,6 +11228,8 @@ var QwenLogger = class _QwenLogger {
           response_id: event.response_id,
           tool_name: event.function_name,
           permission: event.decision,
+          status: event.status,
+          tool_type: event.tool_type,
           success: event.success ? 1 : 0,
           duration_ms: event.duration_ms,
           error_type: event.error_type,
@@ -10966,6 +11527,24 @@ var QwenLogger = class _QwenLogger {
     this.enqueueLogEvent(rumEvent);
     this.flushIfNeeded();
   }
+  logRipgrepRuntimeRecoveryEvent(event) {
+    const rumEvent = this.createActionEvent(
+      "misc",
+      "ripgrep_runtime_recovery",
+      {
+        properties: {
+          platform: process.platform,
+          arch: process.arch,
+          selection_mode: event.selection_mode,
+          retry_triggered: event.retry_triggered,
+          ...event.retry_succeeded !== void 0 ? { retry_succeeded: event.retry_succeeded } : {},
+          failure_kind: event.failure_kind
+        }
+      }
+    );
+    this.enqueueLogEvent(rumEvent);
+    this.flushIfNeeded();
+  }
   logLoopDetectionDisabledEvent() {
     const rumEvent = this.createActionEvent(
       "misc",
@@ -11545,7 +12124,7 @@ import { randomUUID } from "node:crypto";
 
 // packages/core/src/utils/jsonl-utils.ts
 init_esbuild_shims();
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 import path5 from "node:path";
 import readline from "node:readline";
 import { finished } from "node:stream/promises";
@@ -11637,7 +12216,7 @@ async function readLines(filePath, count) {
   let fileStream;
   let rl;
   try {
-    fileStream = fs4.createReadStream(filePath);
+    fileStream = fs5.createReadStream(filePath);
     rl = readline.createInterface({
       input: fileStream,
       crlfDelay: Infinity
@@ -11670,7 +12249,7 @@ async function read(filePath, options = {}) {
   let fileStream;
   let rl;
   try {
-    fileStream = fs4.createReadStream(filePath);
+    fileStream = fs5.createReadStream(filePath);
     rl = readline.createInterface({
       input: fileStream,
       crlfDelay: Infinity
@@ -11705,10 +12284,10 @@ async function writeLine(filePath, data) {
 `;
     const dir = path5.dirname(filePath);
     if (!ensuredDirs.has(dir)) {
-      await fs4.promises.mkdir(dir, { recursive: true });
+      await fs5.promises.mkdir(dir, { recursive: true });
       ensuredDirs.add(dir);
     }
-    await fs4.promises.appendFile(filePath, Buffer.from(line, "utf8"), {
+    await fs5.promises.appendFile(filePath, Buffer.from(line, "utf8"), {
       flush: true
     });
   });
@@ -11718,15 +12297,15 @@ function writeLineSync(filePath, data) {
   const line = `${JSON.stringify(data)}
 `;
   const dir = path5.dirname(filePath);
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
   }
-  fs4.appendFileSync(filePath, Buffer.from(line, "utf8"), { flush: true });
+  fs5.appendFileSync(filePath, Buffer.from(line, "utf8"), { flush: true });
 }
 __name(writeLineSync, "writeLineSync");
 function exists(filePath) {
   try {
-    const stats = fs4.statSync(filePath);
+    const stats = fs5.statSync(filePath);
     return stats.isFile() && stats.size > 0;
   } catch {
     return false;
@@ -12217,42 +12796,55 @@ function logUserRetry(config, event) {
   logger.emit(logRecord);
 }
 __name(logUserRetry, "logUserRetry");
+function normalizeToolCallEvent(event) {
+  const isError = event.status === "error";
+  return {
+    ...event,
+    function_name: event.function_name.trim().length > 0 ? event.function_name : "unknown_tool",
+    success: event.status === "success",
+    error: isError ? event.error : void 0,
+    error_type: isError ? event.error_type?.trim() ? event.error_type : "unknown" /* UNKNOWN */ : void 0
+  };
+}
+__name(normalizeToolCallEvent, "normalizeToolCallEvent");
 function logToolCall(config, event) {
+  const normalizedEvent = normalizeToolCallEvent(event);
   const uiEvent = {
-    ...event,
+    ...normalizedEvent,
     "event.name": EVENT_TOOL_CALL,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
   uiTelemetryService.addEvent(uiEvent, config.getSessionId());
-  if (!isInternalPromptId(event.prompt_id)) {
+  if (!isInternalPromptId(normalizedEvent.prompt_id)) {
     recordUiTelemetryEventToChat(config, uiEvent);
   }
-  QwenLogger.getInstance(config)?.logToolCallEvent(event);
+  QwenLogger.getInstance(config)?.logToolCallEvent(normalizedEvent);
   if (!isTelemetrySdkInitialized()) return;
   const attributes = {
     ...getCommonAttributes(config),
-    ...event,
+    ...normalizedEvent,
     "event.name": EVENT_TOOL_CALL,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString(),
-    function_args: safeJsonStringify(event.function_args, 2)
+    function_args: safeJsonStringify(normalizedEvent.function_args, 2)
   };
-  if (event.error) {
-    attributes["error.message"] = event.error;
-    if (event.error_type) {
-      attributes["error.type"] = event.error_type;
-    }
+  if (normalizedEvent.error) {
+    attributes["error.message"] = normalizedEvent.error;
+  }
+  if (normalizedEvent.error_type) {
+    attributes["error.type"] = normalizedEvent.error_type;
   }
   const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
   const logRecord = {
-    body: `Tool call: ${event.function_name}${event.decision ? `. Decision: ${event.decision}` : ""}. Success: ${event.success}. Duration: ${event.duration_ms}ms.`,
+    body: `Tool call: ${normalizedEvent.function_name}${normalizedEvent.decision ? `. Decision: ${normalizedEvent.decision}` : ""}. Success: ${normalizedEvent.success}. Duration: ${normalizedEvent.duration_ms}ms.`,
     attributes
   };
   logger.emit(logRecord);
-  recordToolCallMetrics(config, event.duration_ms, {
-    function_name: event.function_name,
-    success: event.success,
-    decision: event.decision,
-    tool_type: event.tool_type
+  recordToolCallMetrics(config, normalizedEvent.duration_ms, {
+    function_name: normalizedEvent.function_name,
+    status: normalizedEvent.status,
+    success: normalizedEvent.success,
+    decision: normalizedEvent.decision,
+    tool_type: normalizedEvent.tool_type
   });
 }
 __name(logToolCall, "logToolCall");
@@ -12345,6 +12937,23 @@ function logRipgrepFallback(config, event) {
   logger.emit(logRecord);
 }
 __name(logRipgrepFallback, "logRipgrepFallback");
+function logRipgrepRuntimeRecovery(config, event) {
+  QwenLogger.getInstance(config)?.logRipgrepRuntimeRecoveryEvent(event);
+  if (!isTelemetrySdkInitialized()) return;
+  const attributes = {
+    ...getCommonAttributes(config),
+    ...event,
+    "event.name": EVENT_RIPGREP_RUNTIME_RECOVERY,
+    "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
+  const logRecord = {
+    body: `Ripgrep runtime recovery: ${event.failure_kind}.`,
+    attributes
+  };
+  logger.emit(logRecord);
+}
+__name(logRipgrepRuntimeRecovery, "logRipgrepRuntimeRecovery");
 function logApiError(config, event) {
   const uiEvent = {
     ...event,
@@ -13137,7 +13746,7 @@ init_esbuild_shims();
 
 // packages/core/src/utils/truncation.ts
 init_esbuild_shims();
-import * as fs5 from "node:fs/promises";
+import * as fs6 from "node:fs/promises";
 import * as path7 from "node:path";
 import * as crypto from "node:crypto";
 var debugLogger5 = createDebugLogger("TRUNCATION");
@@ -13220,8 +13829,8 @@ ${truncatedContent}`;
     return { content };
   }
   try {
-    await fs5.mkdir(projectTempDir, { recursive: true });
-    await fs5.writeFile(outputFile, content, { mode: 384 });
+    await fs6.mkdir(projectTempDir, { recursive: true });
+    await fs6.writeFile(outputFile, content, { mode: 384 });
     return {
       content: wrappedMessage,
       outputFile
@@ -13371,7 +13980,7 @@ async function persistAndTruncateToolResult(callId, toolName, content, config) {
   try {
     const toolResultsDir = config.storage.getToolResultsDir();
     const outputFile = path7.join(toolResultsDir, `${safeCallId}.txt`);
-    await fs5.mkdir(toolResultsDir, { recursive: true });
+    await fs6.mkdir(toolResultsDir, { recursive: true });
     await atomicWriteFile(outputFile, content, {
       mode: 384,
       forceMode: true,
@@ -14520,6 +15129,27 @@ var RipgrepFallbackEvent = class {
     this.error = error;
   }
 };
+var RipgrepRuntimeRecoveryEvent = class {
+  static {
+    __name(this, "RipgrepRuntimeRecoveryEvent");
+  }
+  "event.name";
+  "event.timestamp";
+  selection_mode;
+  retry_triggered;
+  retry_succeeded;
+  failure_kind;
+  constructor(params) {
+    this["event.name"] = "ripgrep_runtime_recovery";
+    this["event.timestamp"] = (/* @__PURE__ */ new Date()).toISOString();
+    this.selection_mode = params.selection_mode;
+    this.retry_triggered = params.retry_triggered;
+    if (params.retry_succeeded !== void 0) {
+      this.retry_succeeded = params.retry_succeeded;
+    }
+    this.failure_kind = params.failure_kind;
+  }
+};
 var LoopDetectedEvent = class {
   static {
     __name(this, "LoopDetectedEvent");
@@ -15926,7 +16556,7 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
     const isFullRead = this.params.offset === void 0 && this.params.limit === void 0 && this.params.pages === void 0;
     let stats;
     try {
-      stats = await fs6.stat(absPath);
+      stats = await fs7.stat(absPath);
     } catch (err) {
       debugLogger8.debug("stat-failed", {
         path: absPath,
@@ -15992,7 +16622,7 @@ ${result.llmContent}`;
     }
     if (typeof llmContent === "string" && isAutoMem) {
       try {
-        const memStat = stats ?? await fs6.stat(absPath);
+        const memStat = stats ?? await fs7.stat(absPath);
         const note = memoryFreshnessNote(memStat.mtimeMs);
         if (note) {
           llmContent = note + llmContent;
@@ -16305,6 +16935,7 @@ export {
   logFileOperation,
   logApiRequest,
   logRipgrepFallback,
+  logRipgrepRuntimeRecovery,
   logApiError,
   logApiCancel,
   logApiResponse,
@@ -16367,10 +16998,18 @@ export {
   inferInsertedCellSourceArrayStyle,
   toNotebookSource,
   normalizeEditedCell,
+  CursorNotAtLineBoundaryError,
+  LargeNonUtf8TextError,
+  TextScanBudgetExceededError,
+  readTextRangeFromHandle,
+  readTextCursorWindowFromHandle,
+  ImageViewError,
+  renderNormalizedImageCrop,
   decodeBufferWithEncodingInfoAsync,
   readFileWithLineAndLimit,
   getSpecificMimeType,
   isWithinRoot,
+  detectFileType,
   isCacheableReadResult,
   processSingleFileContent,
   fileExists,
@@ -16408,6 +17047,7 @@ export {
   ApiCancelEvent,
   ApiResponseEvent,
   RipgrepFallbackEvent,
+  RipgrepRuntimeRecoveryEvent,
   LoopDetectedEvent,
   LoopDetectionDisabledEvent,
   NextSpeakerCheckEvent,
@@ -16459,6 +17099,11 @@ export {
  * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Qwen Team