@qwen-code/qwen-code 0.21.0 → 0.21.1-nightly.20260731.702932cc7

package/chunks/{chunk-CIKQ7KKO.js → chunk-NVFSGPIF.js}

@@ -5,28 +5,34 @@ import {
 } from "./chunk-VGC4I5JJ.js";
 import {
   isAnyAutoMemPath
-} from "./chunk-MUP3T3AD.js";
+} from "./chunk-3I6DUGQD.js";
+import {
+  STRUCTURED_OUTPUT_REDACTED_ARGS
+} from "./chunk-7ULQIS27.js";
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  SchemaValidator,
+  ToolDisplayNames,
+  ToolNames
+} from "./chunk-MM7TH7ZM.js";
 import {
   DEFAULT_QWEN_MODEL
-} from "./chunk-IKCX4CCL.js";
+} from "./chunk-DKPJUF5F.js";
 import {
   estimateTextTokens,
   generateLegacyMcpToolName,
   normalizeToolNameForProvider
 } from "./chunk-46UV252V.js";
-import {
-  require_lib
-} from "./chunk-A4UCTEB5.js";
 import {
   normalize
-} from "./chunk-UW5EOVUN.js";
+} from "./chunk-ZBVS26BY.js";
 import {
   InstallationManager
-} from "./chunk-5I2IWRSH.js";
+} from "./chunk-R2XWGR75.js";
 import {
-  atomicWriteFile,
-  atomicWriteFileSync
-} from "./chunk-A5L3JMUA.js";
+  atomicWriteFile
+} from "./chunk-HC45LTEN.js";
 import {
   isTelemetrySdkInitialized,
   recordApiErrorMetrics,
@@ -47,10 +53,11 @@ import {
   recordSubagentExecutionMetrics,
   recordTokenUsageMetrics,
   recordToolCallMetrics
-} from "./chunk-MB4MZHMJ.js";
+} from "./chunk-QARJNL2V.js";
 import {
-  require_src
-} from "./chunk-HTR4WV6U.js";
+  require_src,
+  safeJsonStringify
+} from "./chunk-W4RQUHY3.js";
 import {
   EVENT_API_CANCEL,
   EVENT_API_ERROR,
@@ -72,7 +79,6 @@ import {
   EVENT_EXTENSION_UNINSTALL,
   EVENT_EXTENSION_UPDATE,
   EVENT_FILE_OPERATION,
-  EVENT_FLASH_FALLBACK,
   EVENT_IDE_CONNECTION,
   EVENT_MEMORY_DREAM,
   EVENT_MEMORY_EXTRACT,
@@ -83,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,
@@ -94,23 +101,8 @@ import {
   EVENT_USER_RETRY,
   EVENT_WORKFLOW_KEYWORD,
   EVENT_WORKFLOW_RUN,
-  SERVICE_NAME,
-  safeJsonStringify
-} from "./chunk-BULDBTYC.js";
-import {
-  SemanticAttributes,
-  init_esm
-} from "./chunk-U7ZFW55U.js";
-import {
-  STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-UUUTRMI2.js";
-import {
-  BaseDeclarativeTool,
-  BaseToolInvocation,
-  SchemaValidator,
-  ToolDisplayNames,
-  ToolNames
-} from "./chunk-PR75REBZ.js";
+  SERVICE_NAME
+} from "./chunk-G7XXKQYS.js";
 import {
   Storage,
   createDebugLogger,
@@ -121,7 +113,11 @@ import {
   makeRelative,
   shortenPath,
   unescapePath
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
+import {
+  SemanticAttributes,
+  init_esm
+} from "./chunk-VOQXFAY5.js";
 import {
   require_dist
 } from "./chunk-75DOP5OR.js";
@@ -5697,7 +5693,7 @@ var require_utils = __commonJS({
 });
 
 // node_modules/chardet/lib/index.js
-var require_lib2 = __commonJS({
+var require_lib = __commonJS({
   "node_modules/chardet/lib/index.js"(exports) {
     "use strict";
     init_esbuild_shims();
@@ -5818,10 +5814,10 @@ var require_lib2 = __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);
@@ -5830,26 +5826,26 @@ var require_lib2 = __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 = {
@@ -7399,12 +7395,12 @@ var require_lru_cache = __commonJS({
 
 // packages/core/src/tools/read-file.ts
 init_esbuild_shims();
-import path8 from "node:path";
-import fs6 from "node:fs/promises";
+import path9 from "node:path";
+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";
 
@@ -7830,12 +7826,12 @@ var Mime = class {
     }
     return this;
   }
-  getType(path9) {
-    if (typeof path9 !== "string")
+  getType(path10) {
+    if (typeof path10 !== "string")
       return null;
-    const last = path9.replace(/^.*[/\\]/s, "").toLowerCase();
+    const last = path10.replace(/^.*[/\\]/s, "").toLowerCase();
     const ext = last.replace(/^.*\./s, "").toLowerCase();
-    const hasPath = last.length < path9.length;
+    const hasPath = last.length < path10.length;
     const hasDot = ext.length < last.length - 1;
     if (!hasDot && hasPath)
       return null;
@@ -7875,28 +7871,34 @@ var Mime_default = Mime;
 // packages/core/node_modules/mime/dist/src/index_lite.js
 var index_lite_default = new Mime_default(standard_default)._freeze();
 
-// packages/core/src/utils/iconvHelper.ts
+// packages/core/src/utils/encoding.ts
 init_esbuild_shims();
-var import_iconv_lite = __toESM(require_lib(), 1);
-var iconvLite = import_iconv_lite.default;
-function iconvDecode(buffer, encoding) {
-  return iconvLite.decode(buffer, encoding);
-}
-__name(iconvDecode, "iconvDecode");
-function iconvEncode(content, encoding) {
-  return iconvLite.encode(content, encoding);
-}
-__name(iconvEncode, "iconvEncode");
-function iconvEncodingExists(encoding) {
-  return iconvLite.encodingExists(encoding);
-}
-__name(iconvEncodingExists, "iconvEncodingExists");
 function isUtf8CompatibleEncoding(encoding) {
   const lower = encoding.toLowerCase().replace(/[^a-z0-9]/g, "");
   return lower === "utf8" || lower === "ascii" || lower === "usascii";
 }
 __name(isUtf8CompatibleEncoding, "isUtf8CompatibleEncoding");
 
+// packages/core/src/utils/load-iconv-lite.ts
+init_esbuild_shims();
+var iconvLiteModulePromise;
+function isIconvLite(candidate) {
+  return "decode" in candidate && typeof candidate.decode === "function" && "encode" in candidate && typeof candidate.encode === "function" && "encodingExists" in candidate && typeof candidate.encodingExists === "function";
+}
+__name(isIconvLite, "isIconvLite");
+function loadIconvLite() {
+  iconvLiteModulePromise ??= import("./lib-RUF3WZA6.js").then((module) => {
+    const imported = module;
+    const candidate = "default" in imported && imported.default ? imported.default : imported;
+    if (!isIconvLite(candidate)) {
+      throw new Error("iconv-lite module does not match the expected API");
+    }
+    return candidate;
+  });
+  return iconvLiteModulePromise;
+}
+__name(loadIconvLite, "loadIconvLite");
+
 // packages/core/src/utils/ignorePatterns.ts
 init_esbuild_shims();
 import path from "node:path";
@@ -8106,16 +8108,12 @@ var BINARY_EXTENSIONS = [
 
 // packages/core/src/utils/systemEncoding.ts
 init_esbuild_shims();
-var import_chardet = __toESM(require_lib2(), 1);
+var import_chardet = __toESM(require_lib(), 1);
 import { isUtf8 } from "node:buffer";
 import { execSync } from "node:child_process";
 import os from "node:os";
 var debugLogger = createDebugLogger("ENCODING");
 var cachedSystemEncoding = void 0;
-function resetEncodingCache() {
-  cachedSystemEncoding = void 0;
-}
-__name(resetEncodingCache, "resetEncodingCache");
 function getCachedEncodingForBuffer(buffer) {
   if (isUtf8(buffer)) {
     return "utf-8";
@@ -8865,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(
@@ -8878,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
@@ -8901,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;
@@ -8929,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);
   }
@@ -8946,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;
@@ -8984,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");
@@ -9002,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) {
@@ -9016,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;
@@ -9026,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();
@@ -9034,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,
@@ -9042,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) {
@@ -9066,9 +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 DEFAULT_ENCODING = "utf-8";
+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) {
@@ -9127,7 +9615,7 @@ function isValidUtf8(buffer) {
   }
 }
 __name(isValidUtf8, "isValidUtf8");
-function decodeBufferWithEncodingInfo(full) {
+async function decodeBufferWithEncodingInfoAsync(full) {
   if (full.length === 0) {
     return { content: "", encoding: "utf-8", bom: false };
   }
@@ -9147,9 +9635,10 @@ function decodeBufferWithEncodingInfo(full) {
   const detected = detectEncodingFromBuffer(full);
   if (detected && !isUtf8CompatibleEncoding(detected)) {
     try {
-      if (iconvEncodingExists(detected)) {
+      const iconvLite = await loadIconvLite();
+      if (iconvLite.encodingExists(detected)) {
         return {
-          content: iconvDecode(full, detected),
+          content: iconvLite.decode(full, detected),
           encoding: detected,
           bom: false
         };
@@ -9162,7 +9651,7 @@ function decodeBufferWithEncodingInfo(full) {
   }
   return { content: full.toString("utf8"), encoding: "utf-8", bom: false };
 }
-__name(decodeBufferWithEncodingInfo, "decodeBufferWithEncodingInfo");
+__name(decodeBufferWithEncodingInfoAsync, "decodeBufferWithEncodingInfoAsync");
 function decodeBOMBuffer(buf, bomInfo) {
   const content = buf.subarray(bomInfo.bomLength);
   switch (bomInfo.encoding) {
@@ -9199,11 +9688,11 @@ 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 }
   );
-  return decodeBufferWithEncodingInfo(full);
+  return await decodeBufferWithEncodingInfoAsync(full);
 }
 __name(readFileWithEncodingInfo, "readFileWithEncodingInfo");
 async function readFileWithEncoding(filePath) {
@@ -9218,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,
@@ -9250,10 +9739,10 @@ async function readFileWithLineAndLimit(params) {
   };
 }
 __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);
@@ -9262,22 +9751,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)) {
@@ -9287,9 +9761,9 @@ async function detectFileEncoding(filePath) {
   } catch {
     return "utf-8";
   } finally {
-    if (fh) {
+    if (opened) {
       try {
-        await fh.close();
+        await opened.close();
       } catch {
       }
     }
@@ -9311,7 +9785,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;
@@ -9604,7 +10078,7 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
     signal?.throwIfAborted();
     let stats;
     try {
-      stats = await fs2.promises.stat(filePath);
+      stats = await fs3.promises.stat(filePath);
     } catch (error) {
       if (isNodeError(error) && error.code === "ENOENT") {
         return {
@@ -9633,6 +10107,8 @@ async function processSingleFileContent(filePath, config, optionsOrOffset, legac
       };
     }
     const fileType = 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 relativePathForDisplay = path2.relative(rootDirectory, filePath).replace(/\\/g, "/");
     const displayName = path2.basename(filePath);
     const modalities = config.getContentGeneratorConfig?.()?.modalities ?? {};
@@ -9717,7 +10193,15 @@ 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: ${filePath}`,
+        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.",
@@ -9849,10 +10333,70 @@ 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: ${filePath} (${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) {
@@ -9867,9 +10411,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
             }
           },
@@ -9878,7 +10420,7 @@ 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) {
@@ -10145,7 +10687,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;
@@ -10290,7 +10832,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
@@ -10495,8 +11037,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;
@@ -10969,6 +11511,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",
@@ -11232,6 +11792,12 @@ var createInitialSkillMetrics = /* @__PURE__ */ __name(() => ({
   totalFail: 0,
   byName: {}
 }), "createInitialSkillMetrics");
+var createInitialGenerationMetrics = /* @__PURE__ */ __name(() => ({
+  timedRequests: 0,
+  totalTtftMs: 0,
+  totalGenerationDurationMs: 0,
+  totalThroughputOutputTokens: 0
+}), "createInitialGenerationMetrics");
 var createInitialMetrics = /* @__PURE__ */ __name(() => ({
   models: {},
   tools: {
@@ -11376,6 +11942,23 @@ var UiTelemetryService = class _UiTelemetryService extends EventEmitter {
       bucket.tokens.cached += event.cached_content_token_count;
       bucket.tokens.thoughts += event.thoughts_token_count;
     }
+    if (event.ttft_ms === void 0 || !Number.isFinite(event.ttft_ms) || event.ttft_ms < 0 || isInternalPromptId(event.prompt_id)) {
+      return;
+    }
+    const generation = metrics.generation ?? (metrics.generation = createInitialGenerationMetrics());
+    const generationDurationMs = Math.max(0, event.duration_ms - event.ttft_ms);
+    generation.timedRequests++;
+    generation.totalTtftMs += event.ttft_ms;
+    if (generationDurationMs > 0) {
+      generation.totalGenerationDurationMs += generationDurationMs;
+      generation.totalThroughputOutputTokens += event.output_token_count;
+    }
+    generation.last = {
+      model: event.model,
+      ttftMs: event.ttft_ms,
+      generationDurationMs,
+      outputTokens: event.output_token_count
+    };
   }
   #accumulateApiError(metrics, event) {
     const modelMetrics = this.#getOrCreateModelMetrics(metrics, event.model);
@@ -11525,7 +12108,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";
@@ -11617,7 +12200,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
@@ -11650,7 +12233,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
@@ -11678,10 +12261,6 @@ async function read(filePath, options = {}) {
 }
 __name(read, "read");
 var ensuredDirs = /* @__PURE__ */ new Set();
-function _resetEnsuredDirsCacheForTest() {
-  ensuredDirs.clear();
-}
-__name(_resetEnsuredDirsCacheForTest, "_resetEnsuredDirsCacheForTest");
 async function writeLine(filePath, data) {
   const lock = getFileLock(filePath);
   await lock.runExclusive(async () => {
@@ -11689,10 +12268,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
     });
   });
@@ -11702,51 +12281,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 write(filePath, data) {
-  const lines = data.map((item) => `${JSON.stringify(item)}
-`).join("");
-  const dir = path5.dirname(filePath);
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
-  }
-  atomicWriteFileSync(filePath, lines, { encoding: "utf8" });
-}
-__name(write, "write");
-async function countLines(filePath) {
-  let fileStream;
-  let rl;
-  try {
-    fileStream = fs4.createReadStream(filePath);
-    rl = readline.createInterface({
-      input: fileStream,
-      crlfDelay: Infinity
-    });
-    let count = 0;
-    for await (const line of rl) {
-      if (line.trim().length > 0) {
-        count++;
-      }
-    }
-    return count;
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      debugLogger3.error(`Error counting lines in ${filePath}:`, error);
-    }
-    return 0;
-  } finally {
-    await closeLineReader(rl, fileStream);
-  }
-}
-__name(countLines, "countLines");
 function exists(filePath) {
   try {
-    const stats = fs4.statSync(filePath);
+    const stats = fs5.statSync(filePath);
     return stats.isFile() && stats.size > 0;
   } catch {
     return false;
@@ -11997,11 +12540,6 @@ function summarizeRecords(period, value, records) {
   };
 }
 __name(summarizeRecords, "summarizeRecords");
-async function recordTokenUsageFromApiResponse(config, event) {
-  const record = apiResponseEventToTokenUsageRecord(config, event);
-  await writeLine(getTokenUsageFilePath(record.localMonth), record);
-}
-__name(recordTokenUsageFromApiResponse, "recordTokenUsageFromApiResponse");
 var lastLoggedTimeByCode = /* @__PURE__ */ new Map();
 var suppressedCountByCode = /* @__PURE__ */ new Map();
 var TOKEN_USAGE_FAILURE_LOG_COOLDOWN_MS = 6e4;
@@ -12137,12 +12675,6 @@ function formatTokenUsageSummaryAsJson(summary) {
 `;
 }
 __name(formatTokenUsageSummaryAsJson, "formatTokenUsageSummaryAsJson");
-async function exportTokenUsageSummary(options) {
-  const summary = await queryTokenUsage(options);
-  return options.format === "json" ? formatTokenUsageSummaryAsJson(summary) : `${formatTokenUsageSummaryAsCsv(summary)}
-`;
-}
-__name(exportTokenUsageSummary, "exportTokenUsageSummary");
 
 // packages/core/src/utils/chat-recording-suppression-context.ts
 init_esbuild_shims();
@@ -12359,40 +12891,40 @@ function logApiRequest(config, event) {
   logger.emit(logRecord);
 }
 __name(logApiRequest, "logApiRequest");
-function logFlashFallback(config, event) {
-  QwenLogger.getInstance(config)?.logFlashFallbackEvent(event);
+function logRipgrepFallback(config, event) {
+  QwenLogger.getInstance(config)?.logRipgrepFallbackEvent(event);
   if (!isTelemetrySdkInitialized()) return;
   const attributes = {
     ...getCommonAttributes(config),
     ...event,
-    "event.name": EVENT_FLASH_FALLBACK,
+    "event.name": EVENT_RIPGREP_FALLBACK,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
   const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
   const logRecord = {
-    body: `Switching to flash as Fallback.`,
+    body: `Switching to grep as fallback.`,
     attributes
   };
   logger.emit(logRecord);
 }
-__name(logFlashFallback, "logFlashFallback");
-function logRipgrepFallback(config, event) {
-  QwenLogger.getInstance(config)?.logRipgrepFallbackEvent(event);
+__name(logRipgrepFallback, "logRipgrepFallback");
+function logRipgrepRuntimeRecovery(config, event) {
+  QwenLogger.getInstance(config)?.logRipgrepRuntimeRecoveryEvent(event);
   if (!isTelemetrySdkInitialized()) return;
   const attributes = {
     ...getCommonAttributes(config),
     ...event,
-    "event.name": EVENT_RIPGREP_FALLBACK,
+    "event.name": EVENT_RIPGREP_RUNTIME_RECOVERY,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
   const logger = import_api_logs.logs.getLogger(SERVICE_NAME);
   const logRecord = {
-    body: `Switching to grep as fallback.`,
+    body: `Ripgrep runtime recovery: ${event.failure_kind}.`,
     attributes
   };
   logger.emit(logRecord);
 }
-__name(logRipgrepFallback, "logRipgrepFallback");
+__name(logRipgrepRuntimeRecovery, "logRipgrepRuntimeRecovery");
 function logApiError(config, event) {
   const uiEvent = {
     ...event,
@@ -13185,7 +13717,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");
@@ -13217,22 +13749,26 @@ async function truncateAndSaveToFile(content, fileName, projectTempDir, threshol
   const separator = "\n\n---\n... [CONTENT TRUNCATED] ...\n---\n\n";
   const ellipsis = "...";
   const previewBudget = Math.max(0, previewChars);
-  const headBudget = keep === "head" ? previewBudget : keep === "tail" ? 0 : Math.floor(previewBudget / 5);
+  const sep = previewBudget > separator.length ? separator : "";
+  const contentBudget = previewBudget - sep.length;
+  const headBudget = keep === "head" ? contentBudget : keep === "tail" ? 0 : Math.floor(contentBudget / 5);
   const beginning = [];
   let headChars = 0;
   for (let i = 0; i < Math.min(headCount, lines.length); i++) {
     const remaining = headBudget - headChars;
     if (remaining <= 0) break;
     if (lines[i].length + 1 > remaining) {
-      const sliceLen = Math.max(remaining - ellipsis.length, 0);
-      beginning.push(lines[i].slice(0, sliceLen) + ellipsis);
+      if (remaining >= ellipsis.length) {
+        const sliceLen = remaining - ellipsis.length;
+        beginning.push(lines[i].slice(0, sliceLen) + ellipsis);
+      }
       headChars = headBudget;
       break;
     }
     beginning.push(lines[i]);
     headChars += lines[i].length + 1;
   }
-  const tailBudget = keep === "head" ? 0 : Math.max(previewBudget - headChars - separator.length, 0);
+  const tailBudget = keep === "head" ? 0 : Math.max(contentBudget - headChars, 0);
   const end = [];
   let tailChars = 0;
   const tailStart = Math.max(lines.length - tailCount, beginning.length);
@@ -13240,15 +13776,17 @@ async function truncateAndSaveToFile(content, fileName, projectTempDir, threshol
     const remaining = tailBudget - tailChars;
     if (remaining <= 0) break;
     if (lines[i].length + 1 > remaining) {
-      const sliceLen = Math.max(remaining - ellipsis.length, 0);
-      end.unshift(ellipsis + (sliceLen > 0 ? lines[i].slice(-sliceLen) : ""));
+      if (remaining >= ellipsis.length) {
+        const sliceLen = remaining - ellipsis.length;
+        end.unshift(ellipsis + (sliceLen > 0 ? lines[i].slice(-sliceLen) : ""));
+      }
       tailChars = tailBudget;
       break;
     }
     end.unshift(lines[i]);
     tailChars += lines[i].length + 1;
   }
-  const truncatedContent = keep === "head" ? beginning.join("\n") + separator : keep === "tail" ? separator + end.join("\n") : beginning.join("\n") + separator + end.join("\n");
+  const truncatedContent = keep === "head" ? beginning.join("\n") + sep : keep === "tail" ? sep + end.join("\n") : beginning.join("\n") + sep + end.join("\n");
   const safeFileName = `${path7.basename(fileName)}.output`;
   const outputFile = path7.join(projectTempDir, safeFileName);
   const wrappedMessage = `${TOOL_OUTPUT_TRUNCATED_PREFIX}.
@@ -13262,8 +13800,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
@@ -13413,7 +13951,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,
@@ -13478,12 +14016,6 @@ __name(buildStub, "buildStub");
 
 // packages/core/src/tools/mcp-status.ts
 init_esbuild_shims();
-var MCPServerStatus = /* @__PURE__ */ ((MCPServerStatus2) => {
-  MCPServerStatus2["DISCONNECTED"] = "disconnected";
-  MCPServerStatus2["CONNECTING"] = "connecting";
-  MCPServerStatus2["CONNECTED"] = "connected";
-  return MCPServerStatus2;
-})(MCPServerStatus || {});
 var serverStatuses = /* @__PURE__ */ new Map();
 var statusChangeListeners = [];
 function addMCPStatusChangeListener(listener) {
@@ -13575,6 +14107,75 @@ function getInvocationContext() {
 }
 __name(getInvocationContext, "getInvocationContext");
 
+// packages/core/src/services/visionBridge/image-part-utils.ts
+init_esbuild_shims();
+function normalizeParts(input) {
+  if (typeof input === "string") {
+    return [{ text: input }];
+  }
+  if (Array.isArray(input)) {
+    return input.map(
+      (part) => typeof part === "string" ? { text: part } : part
+    );
+  }
+  return [input];
+}
+__name(normalizeParts, "normalizeParts");
+function isImagePart(part) {
+  const mimeType = part.inlineData?.mimeType;
+  const data = part.inlineData?.data;
+  return typeof mimeType === "string" && mimeType.startsWith("image/") && typeof data === "string" && data.length > 0;
+}
+__name(isImagePart, "isImagePart");
+function hasImageParts(input) {
+  return normalizeParts(input).some(isImagePart);
+}
+__name(hasImageParts, "hasImageParts");
+function splitImageParts(input) {
+  const imageParts = [];
+  const nonImageParts = [];
+  for (const part of normalizeParts(input)) {
+    if (isImagePart(part)) {
+      imageParts.push(part);
+    } else {
+      nonImageParts.push(part);
+    }
+  }
+  return { imageParts, nonImageParts };
+}
+__name(splitImageParts, "splitImageParts");
+function replaceImagesWithText(input, text) {
+  const result = [];
+  let replaced = false;
+  for (const part of normalizeParts(input)) {
+    if (isImagePart(part)) {
+      if (!replaced) {
+        result.push({ text });
+        replaced = true;
+      }
+      continue;
+    }
+    result.push(part);
+  }
+  if (!replaced) {
+    result.push({ text });
+  }
+  return result;
+}
+__name(replaceImagesWithText, "replaceImagesWithText");
+function isUsableImagePart(part) {
+  const data = part.inlineData?.data;
+  if (typeof data !== "string" || data.length === 0) {
+    return false;
+  }
+  return data.length <= VISION_BRIDGE_MAX_IMAGE_BASE64_BYTES;
+}
+__name(isUsableImagePart, "isUsableImagePart");
+function collectText(parts) {
+  return parts.map((part) => typeof part.text === "string" ? part.text : "").filter((text) => text.length > 0).join("\n").trim();
+}
+__name(collectText, "collectText");
+
 // packages/core/src/tools/mcp-tool.ts
 var debugLogger6 = createDebugLogger("MCP_TOOL");
 var MCP_CONNECTION_ERROR_PATTERNS = [
@@ -13796,18 +14397,10 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
         callToolResult
       );
       if (this.isMCPToolError(rawResponseParts)) {
-        const errorMessage = `MCP tool '${this.serverToolName}' reported tool error for function call: ${safeJsonStringify({
+        return await this.buildMcpToolError(rawResponseParts, {
           name: this.serverToolName,
           args: this.params
-        })} with response: ${safeJsonStringify(rawResponseParts)}`;
-        return {
-          llmContent: errorMessage,
-          returnDisplay: `Error: MCP tool '${this.serverToolName}' reported an error.`,
-          error: {
-            message: errorMessage,
-            type: "mcp_tool_error" /* MCP_TOOL_ERROR */
-          }
-        };
+        });
       }
       const transformedParts = transformMcpContentToParts(rawResponseParts);
       const truncated = await this.truncateTextParts(transformedParts);
@@ -13865,17 +14458,7 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
         });
       });
       if (this.isMCPToolError(rawResponseParts)) {
-        const errorMessage = `MCP tool '${this.serverToolName}' reported tool error for function call: ${safeJsonStringify(
-          functionCalls[0]
-        )} with response: ${safeJsonStringify(rawResponseParts)}`;
-        return {
-          llmContent: errorMessage,
-          returnDisplay: `Error: MCP tool '${this.serverToolName}' reported an error.`,
-          error: {
-            message: errorMessage,
-            type: "mcp_tool_error" /* MCP_TOOL_ERROR */
-          }
-        };
+        return await this.buildMcpToolError(rawResponseParts, functionCalls[0]);
       }
       const transformedParts = transformMcpContentToParts(rawResponseParts);
       const truncated = await this.truncateTextParts(transformedParts);
@@ -13891,6 +14474,34 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
       return this.handleReconnectOnError(error, signal);
     }
   }
+  async buildMcpToolError(rawResponseParts, functionCall) {
+    const imageContent = getMcpErrorImageContent(rawResponseParts);
+    let llmContent;
+    let errorMessage;
+    let persistedOutputFiles;
+    if (imageContent) {
+      const truncatedContent = await this.truncateTextParts(imageContent);
+      llmContent = truncatedContent.parts;
+      persistedOutputFiles = truncatedContent.persistedOutputFiles;
+      errorMessage = `MCP tool '${this.serverToolName}' reported tool error for function call: ${safeJsonStringify(
+        functionCall
+      )} with response: ${getDisplayFromParts(truncatedContent.parts)}`;
+    } else {
+      errorMessage = `MCP tool '${this.serverToolName}' reported tool error for function call: ${safeJsonStringify(
+        functionCall
+      )} with response: ${safeJsonStringify(rawResponseParts)}`;
+      llmContent = errorMessage;
+    }
+    return {
+      llmContent,
+      returnDisplay: `Error: MCP tool '${this.serverToolName}' reported an error.`,
+      error: {
+        message: errorMessage,
+        type: "mcp_tool_error" /* MCP_TOOL_ERROR */
+      },
+      ...persistedOutputFiles !== void 0 ? { persistedOutputFiles } : {}
+    };
+  }
   /**
    * Truncates text parts in the transformed result if they exceed the
    * configured threshold. Non-text parts (images, audio, etc.) are preserved.
@@ -14145,6 +14756,11 @@ function transformMcpContentToParts(sdkResponse) {
   return transformed.filter((part) => part !== null);
 }
 __name(transformMcpContentToParts, "transformMcpContentToParts");
+function getMcpErrorImageContent(rawResponseParts) {
+  const transformedParts = transformMcpContentToParts(rawResponseParts);
+  return transformedParts.some(isImagePart) ? transformedParts : void 0;
+}
+__name(getMcpErrorImageContent, "getMcpErrorImageContent");
 function getDisplayFromParts(parts) {
   if (parts.length === 0) {
     return "";
@@ -14245,19 +14861,6 @@ var StartSessionEvent = class {
     }
   }
 };
-var EndSessionEvent = class {
-  static {
-    __name(this, "EndSessionEvent");
-  }
-  "event.name";
-  "event.timestamp";
-  session_id;
-  constructor(config) {
-    this["event.name"] = "end_session";
-    this["event.timestamp"] = (/* @__PURE__ */ new Date()).toISOString();
-    this.session_id = config?.getSessionId();
-  }
-};
 var UserPromptEvent = class {
   static {
     __name(this, "UserPromptEvent");
@@ -14454,12 +15057,14 @@ var ApiResponseEvent = class {
   response_text;
   prompt_id;
   auth_type;
+  /** Time from stream dispatch to first user-visible content. */
+  ttft_ms;
   /**
    * Name of the subagent that issued this request, or undefined when the
    * request originates from the main conversation.
    */
   subagent_name;
-  constructor(response_id, model, duration_ms, prompt_id, auth_type, usage_data, response_text, subagent_name) {
+  constructor(response_id, model, duration_ms, prompt_id, auth_type, usage_data, response_text, subagent_name, ttft_ms) {
     this["event.name"] = "api_response";
     this["event.timestamp"] = (/* @__PURE__ */ new Date()).toISOString();
     this.response_id = response_id;
@@ -14475,19 +15080,7 @@ var ApiResponseEvent = class {
     this.prompt_id = prompt_id;
     this.auth_type = auth_type;
     this.subagent_name = subagent_name;
-  }
-};
-var FlashFallbackEvent = class {
-  static {
-    __name(this, "FlashFallbackEvent");
-  }
-  "event.name";
-  "event.timestamp";
-  auth_type;
-  constructor(auth_type) {
-    this["event.name"] = "flash_fallback";
-    this["event.timestamp"] = (/* @__PURE__ */ new Date()).toISOString();
-    this.auth_type = auth_type;
+    this.ttft_ms = ttft_ms;
   }
 };
 var RipgrepFallbackEvent = class {
@@ -14507,19 +15100,27 @@ var RipgrepFallbackEvent = class {
     this.error = error;
   }
 };
-var LoopType = /* @__PURE__ */ ((LoopType2) => {
-  LoopType2["CONSECUTIVE_IDENTICAL_TOOL_CALLS"] = "consecutive_identical_tool_calls";
-  LoopType2["CHANTING_IDENTICAL_SENTENCES"] = "chanting_identical_sentences";
-  LoopType2["REPETITIVE_THOUGHTS"] = "repetitive_thoughts";
-  LoopType2["READ_FILE_LOOP"] = "read_file_loop";
-  LoopType2["ACTION_STAGNATION"] = "action_stagnation";
-  LoopType2["SHELL_COMMAND_STAGNATION"] = "shell_command_stagnation";
-  LoopType2["GLOBAL_TOOL_CALL_DUPLICATE"] = "global_tool_call_duplicate";
-  LoopType2["ALTERNATING_TOOL_CALL_PATTERN"] = "alternating_tool_call_pattern";
-  LoopType2["TURN_TOOL_CALL_CAP"] = "turn_tool_call_cap";
-  LoopType2["INVALID_TOOL_PARAMS_STAGNATION"] = "invalid_tool_params_stagnation";
-  return LoopType2;
-})(LoopType || {});
+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");
@@ -14579,11 +15180,6 @@ function makeSlashCommandEvent({
   };
 }
 __name(makeSlashCommandEvent, "makeSlashCommandEvent");
-var SlashCommandStatus = /* @__PURE__ */ ((SlashCommandStatus2) => {
-  SlashCommandStatus2["SUCCESS"] = "success";
-  SlashCommandStatus2["ERROR"] = "error";
-  return SlashCommandStatus2;
-})(SlashCommandStatus || {});
 function makeChatCompressionEvent({
   tokens_before,
   tokens_after,
@@ -14600,11 +15196,6 @@ function makeChatCompressionEvent({
   };
 }
 __name(makeChatCompressionEvent, "makeChatCompressionEvent");
-var IdeConnectionType = /* @__PURE__ */ ((IdeConnectionType2) => {
-  IdeConnectionType2["START"] = "start";
-  IdeConnectionType2["SESSION"] = "session";
-  return IdeConnectionType2;
-})(IdeConnectionType || {});
 var IdeConnectionEvent = class {
   static {
     __name(this, "IdeConnectionEvent");
@@ -14976,12 +15567,6 @@ var SkillLaunchEvent = class {
     this.prompt_id = prompt_id;
   }
 };
-var UserFeedbackRating = /* @__PURE__ */ ((UserFeedbackRating2) => {
-  UserFeedbackRating2[UserFeedbackRating2["BAD"] = 1] = "BAD";
-  UserFeedbackRating2[UserFeedbackRating2["FINE"] = 2] = "FINE";
-  UserFeedbackRating2[UserFeedbackRating2["GOOD"] = 3] = "GOOD";
-  return UserFeedbackRating2;
-})(UserFeedbackRating || {});
 var UserFeedbackEvent = class {
   static {
     __name(this, "UserFeedbackEvent");
@@ -15302,6 +15887,38 @@ function memoryFreshnessNote(mtimeMs) {
 }
 __name(memoryFreshnessNote, "memoryFreshnessNote");
 
+// packages/core/src/tools/file-read-permission.ts
+init_esbuild_shims();
+import path8 from "node:path";
+function getFileReadDefaultPermission(config, requestedPath) {
+  const filePath = path8.resolve(requestedPath);
+  const workspaceContext = config.getWorkspaceContext();
+  const allowedRoots = [
+    config.storage.getProjectTempDir(),
+    // Background subagent transcripts live under <projectDir>/subagents/ and
+    // are advertised to the model as polling targets via read_file.
+    path8.join(config.storage.getProjectDir(), "subagents"),
+    Storage.getGlobalTempDir(),
+    ...config.storage.getUserSkillsDirs(),
+    Storage.getUserExtensionsDir(),
+    // Approved plans are persisted here (default ~/.qwen/plans, outside
+    // the workspace) and after approval nothing re-injects the plan text,
+    // so the saved file is the model's only recovery route — reading it
+    // back must not stall on a confirmation prompt. The dir holds only
+    // session plan files, never credentials or settings.
+    config.getPlansDir()
+  ];
+  if (workspaceContext.isPathWithinWorkspace(filePath) || isSubpaths(allowedRoots, filePath) || // isAnyAutoMemPath narrows to the managed auto-memory roots
+  // (per-project + user-level under ~/.qwen/memories/) — never the
+  // broad getMemoryBaseDir() — to avoid exposing sensitive ~/.qwen
+  // files such as settings.json or OAuth credentials.
+  isAnyAutoMemPath(filePath, config.getTargetDir())) {
+    return "allow";
+  }
+  return "ask";
+}
+__name(getFileReadDefaultPermission, "getFileReadDefaultPermission");
+
 // packages/core/src/services/visionBridge/vision-bridge-service.ts
 init_esbuild_shims();
 
@@ -15503,77 +16120,9 @@ async function runSideQuery(config, options) {
 }
 __name(runSideQuery, "runSideQuery");
 
-// packages/core/src/services/visionBridge/image-part-utils.ts
-init_esbuild_shims();
-function normalizeParts(input) {
-  if (typeof input === "string") {
-    return [{ text: input }];
-  }
-  if (Array.isArray(input)) {
-    return input.map(
-      (part) => typeof part === "string" ? { text: part } : part
-    );
-  }
-  return [input];
-}
-__name(normalizeParts, "normalizeParts");
-function isImagePart(part) {
-  const mimeType = part.inlineData?.mimeType;
-  const data = part.inlineData?.data;
-  return typeof mimeType === "string" && mimeType.startsWith("image/") && typeof data === "string" && data.length > 0;
-}
-__name(isImagePart, "isImagePart");
-function hasImageParts(input) {
-  return normalizeParts(input).some(isImagePart);
-}
-__name(hasImageParts, "hasImageParts");
-function splitImageParts(input) {
-  const imageParts = [];
-  const nonImageParts = [];
-  for (const part of normalizeParts(input)) {
-    if (isImagePart(part)) {
-      imageParts.push(part);
-    } else {
-      nonImageParts.push(part);
-    }
-  }
-  return { imageParts, nonImageParts };
-}
-__name(splitImageParts, "splitImageParts");
-function replaceImagesWithText(input, text) {
-  const result = [];
-  let replaced = false;
-  for (const part of normalizeParts(input)) {
-    if (isImagePart(part)) {
-      if (!replaced) {
-        result.push({ text });
-        replaced = true;
-      }
-      continue;
-    }
-    result.push(part);
-  }
-  if (!replaced) {
-    result.push({ text });
-  }
-  return result;
-}
-__name(replaceImagesWithText, "replaceImagesWithText");
-function isUsableImagePart(part) {
-  const data = part.inlineData?.data;
-  if (typeof data !== "string" || data.length === 0) {
-    return false;
-  }
-  return data.length <= VISION_BRIDGE_MAX_IMAGE_BASE64_BYTES;
-}
-__name(isUsableImagePart, "isUsableImagePart");
-function collectText(parts) {
-  return parts.map((part) => typeof part.text === "string" ? part.text : "").filter((text) => text.length > 0).join("\n").trim();
-}
-__name(collectText, "collectText");
-
 // packages/core/src/services/visionBridge/vision-bridge-service.ts
 var debugLogger7 = createDebugLogger("VISION_BRIDGE");
+var turnImageCounts = /* @__PURE__ */ new WeakMap();
 var BRIDGE_MAX_OUTPUT_TOKENS = 2048;
 var VISION_BRIDGE_TIMEOUT_MS = 3e4;
 var VISION_BRIDGE_MAX_ATTEMPTS = 2;
@@ -15730,8 +16279,10 @@ function formatFullTurnVisionNotice(selection) {
   return `Routing this image turn to ${target}; retries and tool continuations will stay on that model until the turn ends.`;
 }
 __name(formatFullTurnVisionNotice, "formatFullTurnVisionNotice");
-function buildIntentPart(intentText, sourceContext) {
-  const sourceHint = sourceContext ? `The images are consecutive pages ${sourceContext.renderedRange.firstPage}-${sourceContext.renderedRange.lastPage} from PDF ${JSON.stringify(sourceContext.displayName)}. Transcribe each page separately and label each section with its original PDF page number.` : "";
+function buildIntentPart(intentText, sourceContext, imageParts = []) {
+  const sourceHint = sourceContext ? `The images are consecutive pages ${sourceContext.renderedRange.firstPage}-${sourceContext.renderedRange.lastPage} from PDF ${JSON.stringify(sourceContext.displayName)}. Transcribe each page separately and label each section with its original PDF page number.` : imageParts.length > 0 ? `Describe each image separately under these ordered labels: ${imageParts.map(
+    (part, index) => `${index + 1}. ${JSON.stringify(part.inlineData?.displayName?.trim() || `image ${index + 1}`)}`
+  ).join("; ")}.` : "";
   const focusHint = intentText.length > 0 ? `Focus hint \u2014 do NOT answer this, use it only to decide which details to transcribe thoroughly: ${intentText}` : "Describe the image(s) and transcribe any visible text, code, and errors.";
   return sourceHint ? `${sourceHint}
 ${focusHint}` : focusHint;
@@ -15779,7 +16330,7 @@ function failure(reason, parts, omittedCount, extra = {}) {
 }
 __name(failure, "failure");
 async function runVisionBridge(params) {
-  const { config, parts, signal, sourceContext } = params;
+  const { config, parts, signal, sourceContext, intentText } = params;
   const { imageParts, nonImageParts } = splitImageParts(parts);
   if (imageParts.length === 0) {
     return {
@@ -15790,9 +16341,14 @@ async function runVisionBridge(params) {
     };
   }
   const validImages = imageParts.filter(isUsableImagePart);
-  const toConvert = validImages.slice(0, VISION_BRIDGE_MAX_IMAGES);
+  const usedImages = turnImageCounts.get(signal) ?? 0;
+  const remainingImages = Math.max(0, VISION_BRIDGE_MAX_IMAGES - usedImages);
+  const toConvert = validImages.slice(0, remainingImages);
   const omittedCount = imageParts.length - toConvert.length;
-  const intent = collectText(nonImageParts).slice(0, BRIDGE_INTENT_MAX_CHARS);
+  const intent = (intentText ?? collectText(nonImageParts)).slice(
+    0,
+    BRIDGE_INTENT_MAX_CHARS
+  );
   const resolvedSourceContext = sourceContext ?? inferPdfSourceContext(toConvert);
   const selection = config.getDefaultVisionBridgeModel?.();
   const modelId = selection?.id;
@@ -15814,13 +16370,14 @@ async function runVisionBridge(params) {
       { modelId, ...modelEndpoint && { modelEndpoint } }
     );
   }
+  turnImageCounts.set(signal, usedImages + toConvert.length);
   const timeoutMs = config.getVisionBridgeTimeoutMs?.() ?? VISION_BRIDGE_TIMEOUT_MS;
   const requestContents = [
     {
       role: "user",
       parts: [
         ...toConvert,
-        { text: buildIntentPart(intent, resolvedSourceContext) }
+        { text: buildIntentPart(intent, resolvedSourceContext, toConvert) }
       ]
     }
   ];
@@ -15955,29 +16512,13 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
    * Returns 'ask' for paths outside the workspace/temp/userSkills directories,
    * so that external file reads require user confirmation.
    */
-  async getDefaultPermission() {
-    const filePath = path8.resolve(this.params.file_path);
-    const workspaceContext = this.config.getWorkspaceContext();
-    const allowedRoots = [
-      this.config.storage.getProjectTempDir(),
-      // Background subagent transcripts live under <projectDir>/subagents/ and
-      // are advertised to the model as polling targets via read_file.
-      path8.join(this.config.storage.getProjectDir(), "subagents"),
-      Storage.getGlobalTempDir(),
-      ...this.config.storage.getUserSkillsDirs(),
-      Storage.getUserExtensionsDir()
-    ];
-    if (workspaceContext.isPathWithinWorkspace(filePath) || isSubpaths(allowedRoots, filePath) || // isAnyAutoMemPath narrows to the managed auto-memory roots
-    // (per-project + user-level under ~/.qwen/memories/) — never the
-    // broad getMemoryBaseDir() — to avoid exposing sensitive ~/.qwen
-    // files such as settings.json or OAuth credentials.
-    isAnyAutoMemPath(filePath, this.config.getTargetDir())) {
-      return "allow";
-    }
-    return "ask";
+  getDefaultPermission() {
+    return Promise.resolve(
+      getFileReadDefaultPermission(this.config, this.params.file_path)
+    );
   }
   async execute(signal) {
-    const absPath = path8.resolve(this.params.file_path);
+    const absPath = path9.resolve(this.params.file_path);
     const projectRoot = this.config.getTargetDir();
     const isAutoMem = isAnyAutoMemPath(absPath, projectRoot);
     const cacheEnabled = !this.config.getFileReadCacheDisabled();
@@ -15986,7 +16527,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,
@@ -16003,7 +16544,7 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
       }
       debugLogger8.debug("miss", { path: absPath, state: status.state });
     }
-    const preparePdfForVisionBridge = shouldRunVisionBridge(this.config);
+    const prepareForVisionBridge = shouldRunVisionBridge(this.config);
     let result = await processSingleFileContent(
       this.params.file_path,
       this.config,
@@ -16011,7 +16552,8 @@ var ReadFileToolInvocation = class extends BaseToolInvocation {
         offset: this.params.offset,
         limit: this.params.limit,
         pages: this.params.pages,
-        preparePdfForVisionBridge,
+        preserveUnsupportedImage: prepareForVisionBridge,
+        preparePdfForVisionBridge: prepareForVisionBridge,
         signal
       }
     );
@@ -16051,7 +16593,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;
@@ -16071,7 +16613,7 @@ ${result.llmContent}`;
         "read" /* READ */,
         lines,
         mimetype,
-        path8.extname(this.params.file_path),
+        path9.extname(this.params.file_path),
         programming_language
       )
     );
@@ -16274,7 +16816,7 @@ var ReadFileTool = class _ReadFileTool extends BaseDeclarativeTool {
     if (!filePath) {
       return "The 'file_path' parameter must be non-empty.";
     }
-    if (!path8.isAbsolute(filePath)) {
+    if (!path9.isAbsolute(filePath)) {
       return `File path must be absolute, but was relative: ${filePath}. You must provide an absolute path.`;
     }
     if (params.offset !== void 0 && (!Number.isInteger(params.offset) || params.offset < 0)) {
@@ -16287,7 +16829,7 @@ var ReadFileTool = class _ReadFileTool extends BaseDeclarativeTool {
       const pages = params.pages.trim();
       params.pages = pages.length > 0 ? pages : void 0;
     }
-    const ext = path8.extname(filePath).toLowerCase();
+    const ext = path9.extname(filePath).toLowerCase();
     if ((params.offset !== void 0 || params.limit !== void 0) && ext === ".ipynb") {
       return "offset and limit are not supported for Jupyter notebook (.ipynb) files. Notebooks are always read in full with structured cell output.";
     }
@@ -16327,13 +16869,10 @@ export {
   isImagePart,
   hasImageParts,
   splitImageParts,
-  replaceImagesWithText,
-  isUsableImagePart,
   collectText,
   isImageCapable,
   isFullTurnVisionCapable,
   getQualifiedVisionModelId,
-  getVisionModelSelector,
   getFullTurnVisionModelSelector,
   selectVisionBridgeModel,
   shouldRunVisionBridge,
@@ -16344,41 +16883,30 @@ export {
   runVisionBridge,
   MAIN_SOURCE,
   subagentNameContext,
+  isInternalPromptId,
   UiTelemetryService,
   uiTelemetryService,
-  isInternalPromptId,
-  sanitizeHookName,
   import_lru_cache,
-  QwenLogger,
   apiActivityTracker,
   _recoverObjectsFromLine,
   parseLineTolerant,
   readLines,
   read,
-  _resetEnsuredDirsCacheForTest,
   writeLine,
   writeLineSync,
-  write,
-  countLines,
   exists,
-  getTokenUsageFilePath,
-  apiResponseEventToTokenUsageRecord,
-  recordTokenUsageFromApiResponse,
-  recordTokenUsageFromApiResponseBestEffort,
   queryTokenUsage,
   formatTokenUsageSummaryAsCsv,
   formatTokenUsageSummaryAsJson,
-  exportTokenUsageSummary,
   runWithChatRecordingSuppressed,
   logStartSession,
   logUserPrompt,
   logUserRetry,
   logToolCall,
-  logToolOutputTruncated,
   logFileOperation,
   logApiRequest,
-  logFlashFallback,
   logRipgrepFallback,
+  logRipgrepRuntimeRecovery,
   logApiError,
   logApiCancel,
   logApiResponse,
@@ -16417,31 +16945,16 @@ export {
   logMemoryDream,
   logMemoryRecall,
   logMemoryRecallDelivery,
-  iconvEncode,
-  iconvEncodingExists,
   isUtf8CompatibleEncoding,
-  DEFAULT_CONTEXT_FILENAME,
-  AGENT_CONTEXT_FILENAME,
+  loadIconvLite,
   LOCAL_CONTEXT_FILENAME,
   MEMORY_SECTION_HEADER,
   setGeminiMdFilename,
   getCurrentGeminiMdFilename,
   getAllGeminiMdFilenames,
-  COMMON_IGNORE_PATTERNS,
-  BINARY_FILE_PATTERNS,
-  MEDIA_FILE_PATTERNS,
-  COMMON_DIRECTORY_EXCLUDES,
-  PYTHON_EXCLUDES,
-  SYSTEM_FILE_EXCLUDES,
-  DEFAULT_FILE_EXCLUDES,
   FileExclusions,
-  extractExtensionsFromPatterns,
-  BINARY_EXTENSIONS,
-  resetEncodingCache,
   getCachedEncodingForBuffer,
   getSystemEncoding,
-  windowsCodePageToEncoding,
-  detectEncodingFromBuffer,
   extractPDFText,
   normalizeSource,
   parseNotebook,
@@ -16456,24 +16969,24 @@ export {
   inferInsertedCellSourceArrayStyle,
   toNotebookSource,
   normalizeEditedCell,
-  DEFAULT_ENCODING,
-  detectBOM,
-  decodeBufferWithEncodingInfo,
-  readFileWithEncodingInfo,
-  readFileWithEncoding,
-  countFileLines,
+  CursorNotAtLineBoundaryError,
+  LargeNonUtf8TextError,
+  TextScanBudgetExceededError,
+  readTextRangeFromHandle,
+  readTextCursorWindowFromHandle,
+  ImageViewError,
+  renderNormalizedImageCrop,
+  decodeBufferWithEncodingInfoAsync,
   readFileWithLineAndLimit,
-  detectFileEncoding,
   getSpecificMimeType,
   isWithinRoot,
-  isBinaryFile,
-  detectFileType,
   isCacheableReadResult,
   processSingleFileContent,
   fileExists,
   getLanguageFromFilePath,
   memoryAge,
   memoryFreshnessText,
+  getFileReadDefaultPermission,
   ReadFileTool,
   MAX_SESSION_BYTES,
   TOOL_OUTPUT_TRUNCATED_PREFIX,
@@ -16482,7 +16995,6 @@ export {
   isAlreadyTruncated,
   normalizeToolResultCallId,
   persistAndTruncateToolResult,
-  MCPServerStatus,
   addMCPStatusChangeListener,
   removeMCPStatusChangeListener,
   updateMCPServerStatus,
@@ -16496,9 +17008,7 @@ export {
   runWithInvocationContext,
   getInvocationContext,
   DiscoveredMCPTool,
-  generateValidName,
   StartSessionEvent,
-  EndSessionEvent,
   UserPromptEvent,
   UserRetryEvent,
   ToolCallEvent,
@@ -16506,16 +17016,13 @@ export {
   ApiErrorEvent,
   ApiCancelEvent,
   ApiResponseEvent,
-  FlashFallbackEvent,
   RipgrepFallbackEvent,
-  LoopType,
+  RipgrepRuntimeRecoveryEvent,
   LoopDetectedEvent,
   LoopDetectionDisabledEvent,
   NextSpeakerCheckEvent,
   makeSlashCommandEvent,
-  SlashCommandStatus,
   makeChatCompressionEvent,
-  IdeConnectionType,
   IdeConnectionEvent,
   ConversationFinishedEvent,
   KittySequenceOverflowEvent,
@@ -16525,7 +17032,6 @@ export {
   ApiRetryEvent,
   ContentRetryFailureEvent,
   ExtensionInstallEvent,
-  ToolOutputTruncatedEvent,
   ExtensionUninstallEvent,
   ExtensionUpdateEvent,
   ExtensionEnableEvent,
@@ -16534,7 +17040,6 @@ export {
   AuthEvent,
   HookCallEvent,
   SkillLaunchEvent,
-  UserFeedbackRating,
   UserFeedbackEvent,
   makeArenaSessionStartedEvent,
   makeArenaAgentCompletedEvent,
@@ -16549,6 +17054,11 @@ export {
   MemoryRecallEvent,
   MemoryRecallDeliveryEvent
 };
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -16561,7 +17071,7 @@ export {
  */
 /**
  * @license
- * Copyright 2026 Qwen Team
+ * Copyright 2026 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
 /**