@iowarp/clio-coder 0.4.3 → 0.4.5

package/dist/{chunk-W6RRQCPQ.js → chunk-UTUNT5QL.js}

@@ -2,49 +2,70 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   canonicalJson,
   sha256
-} from "./chunk-IWT4SF4R.js";
+} from "./chunk-6CDNRHWH.js";
 import {
   addResponseModelIdObservationCount,
   emptyResponseModelIdObservationCounts,
   responseModelIdObservationFromRecord
-} from "./chunk-JKKCYP3C.js";
+} from "./chunk-F34AR6O3.js";
 import {
   uncachedPrefillTokens
-} from "./chunk-3DPEIQKN.js";
+} from "./chunk-QH3ZTUOA.js";
 import {
   ToolNames
-} from "./chunk-K6BSR66V.js";
+} from "./chunk-EHOSNVVM.js";
 import {
   ceilChars,
   extractReasoningTokens
-} from "./chunk-NZMNUPZZ.js";
+} from "./chunk-77CZRFTE.js";
 import {
   settingsPath
-} from "./chunk-GHS5EBTQ.js";
-import {
-  expandConfigPath
-} from "./chunk-336NSSKI.js";
+} from "./chunk-FKIOX6DS.js";
 import {
   isEngineContextOverflow
-} from "./chunk-YPC6ZR5L.js";
+} from "./chunk-5CMARGPF.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/cli/steer-channel.ts
 init_esm_shims();
 import * as fs from "node:fs";
+import { Socket } from "node:net";
 import * as readline from "node:readline";
 function setupSteerChannel(filePath, onLine) {
   let closed = false;
   let watcher = null;
   let stream = null;
   let rl = null;
+  const cleanup = () => {
+    if (closed) return;
+    closed = true;
+    watcher?.close();
+    rl?.close();
+    stream?.destroy();
+  };
+  const reportError = (err) => {
+    if (closed) return;
+    process.stderr.write(
+      `clio-coder run: failed to setup steer channel: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    cleanup();
+  };
   try {
     const stats = fs.statSync(filePath);
     if (stats.isFIFO()) {
-      stream = fs.createReadStream(filePath);
+      const fd = fs.openSync(filePath, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
+      try {
+        stream = new Socket({ fd, readable: true, writable: false });
+      } catch (err) {
+        fs.closeSync(fd);
+        throw err;
+      }
+      stream.on("error", reportError);
       rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+      rl.on("error", reportError);
       rl.on("line", (line) => {
         if (closed) return;
         const trimmed = line.trim();
@@ -91,23 +112,9 @@ function setupSteerChannel(filePath, onLine) {
       });
     }
   } catch (err) {
-    process.stderr.write(
-      `clio-coder run: failed to setup steer channel: ${err instanceof Error ? err.message : String(err)}
-`
-    );
+    reportError(err);
   }
-  return () => {
-    closed = true;
-    if (watcher) {
-      watcher.close();
-    }
-    if (rl) {
-      rl.close();
-    }
-    if (stream) {
-      stream.destroy();
-    }
-  };
+  return cleanup;
 }
 
 // src/cli/modes/json-stream.ts
@@ -256,8 +263,14 @@ function isEmptyAbortedAssistantMessage(message) {
   }
   if (message.stopReason !== "aborted") return false;
   if (extractText(message).trim().length > 0) return false;
+  if (extractThinking(message).trim().length > 0) return false;
   return !hasStructuredToolCall(message);
 }
+function explainInterruptedAssistant(message, reason) {
+  if (reason === null || message.role !== "assistant" || message.stopReason !== "aborted") return false;
+  message.errorMessage = reason;
+  return true;
+}
 function lengthStopMetadata(message) {
   const usage = message.usage;
   const metadata = {
@@ -433,6 +446,7 @@ function assistantSessionPayload(message, failure) {
     "model",
     "responseModel",
     "responseId",
+    "providerThinkingLevel",
     "gatewayRouting",
     "diagnostics"
   ]) {
@@ -491,9 +505,9 @@ function textFromToolResultContent(content) {
     return item.text;
   }).join("");
 }
-function toolResultSummary(result2) {
-  const obj = recordValue(result2);
-  const text = textFromToolResultContent(obj?.content) || (typeof result2 === "string" ? result2 : "");
+function toolResultSummary(result) {
+  const obj = recordValue(result);
+  const text = textFromToolResultContent(obj?.content) || (typeof result === "string" ? result : "");
   const bytes = Buffer.byteLength(text, "utf8");
   const details = recordValue(obj?.details);
   const size = recordValue(details?.resultSize);
@@ -613,550 +627,6 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-// src/core/file-references.ts
-init_esm_shims();
-import { existsSync, readFileSync, statSync as statSync2 } from "node:fs";
-import path2 from "node:path";
-
-// src/utils/image-resize.ts
-init_esm_shims();
-
-// src/utils/exif-orientation.ts
-init_esm_shims();
-function byte(bytes, offset) {
-  return bytes[offset] ?? 0;
-}
-function readOrientationFromTiff(bytes, tiffStart) {
-  if (tiffStart + 8 > bytes.length) return 1;
-  const byteOrder = byte(bytes, tiffStart) << 8 | byte(bytes, tiffStart + 1);
-  const le = byteOrder === 18761;
-  const read16 = (pos) => {
-    if (le) return byte(bytes, pos) | byte(bytes, pos + 1) << 8;
-    return byte(bytes, pos) << 8 | byte(bytes, pos + 1);
-  };
-  const read32 = (pos) => {
-    if (le) {
-      return byte(bytes, pos) | byte(bytes, pos + 1) << 8 | byte(bytes, pos + 2) << 16 | byte(bytes, pos + 3) << 24;
-    }
-    return (byte(bytes, pos) << 24 | byte(bytes, pos + 1) << 16 | byte(bytes, pos + 2) << 8 | byte(bytes, pos + 3)) >>> 0;
-  };
-  const ifdOffset = read32(tiffStart + 4);
-  const ifdStart = tiffStart + ifdOffset;
-  if (ifdStart + 2 > bytes.length) return 1;
-  const entryCount = read16(ifdStart);
-  for (let i = 0; i < entryCount; i++) {
-    const entryPos = ifdStart + 2 + i * 12;
-    if (entryPos + 12 > bytes.length) return 1;
-    if (read16(entryPos) === 274) {
-      const value = read16(entryPos + 8);
-      return value >= 1 && value <= 8 ? value : 1;
-    }
-  }
-  return 1;
-}
-function hasExifHeader(bytes, offset) {
-  return byte(bytes, offset) === 69 && byte(bytes, offset + 1) === 120 && byte(bytes, offset + 2) === 105 && byte(bytes, offset + 3) === 102 && byte(bytes, offset + 4) === 0 && byte(bytes, offset + 5) === 0;
-}
-function findJpegTiffOffset(bytes) {
-  let offset = 2;
-  while (offset < bytes.length - 1) {
-    if (byte(bytes, offset) !== 255) return -1;
-    const marker = byte(bytes, offset + 1);
-    if (marker === 255) {
-      offset++;
-      continue;
-    }
-    if (marker === 225) {
-      if (offset + 4 >= bytes.length) return -1;
-      const segmentStart = offset + 4;
-      if (segmentStart + 6 > bytes.length) return -1;
-      if (!hasExifHeader(bytes, segmentStart)) return -1;
-      return segmentStart + 6;
-    }
-    if (offset + 4 > bytes.length) return -1;
-    const length = byte(bytes, offset + 2) << 8 | byte(bytes, offset + 3);
-    offset += 2 + length;
-  }
-  return -1;
-}
-function findWebpTiffOffset(bytes) {
-  let offset = 12;
-  while (offset + 8 <= bytes.length) {
-    const chunkId = String.fromCharCode(
-      byte(bytes, offset),
-      byte(bytes, offset + 1),
-      byte(bytes, offset + 2),
-      byte(bytes, offset + 3)
-    );
-    const chunkSize = byte(bytes, offset + 4) | byte(bytes, offset + 5) << 8 | byte(bytes, offset + 6) << 16 | byte(bytes, offset + 7) << 24;
-    const dataStart = offset + 8;
-    if (chunkId === "EXIF") {
-      if (dataStart + chunkSize > bytes.length) return -1;
-      return chunkSize >= 6 && hasExifHeader(bytes, dataStart) ? dataStart + 6 : dataStart;
-    }
-    offset = dataStart + chunkSize + chunkSize % 2;
-  }
-  return -1;
-}
-function getExifOrientation(bytes) {
-  let tiffOffset = -1;
-  if (bytes.length >= 2 && byte(bytes, 0) === 255 && byte(bytes, 1) === 216) {
-    tiffOffset = findJpegTiffOffset(bytes);
-  } else if (bytes.length >= 12 && byte(bytes, 0) === 82 && byte(bytes, 1) === 73 && byte(bytes, 2) === 70 && byte(bytes, 3) === 70 && byte(bytes, 8) === 87 && byte(bytes, 9) === 69 && byte(bytes, 10) === 66 && byte(bytes, 11) === 80) {
-    tiffOffset = findWebpTiffOffset(bytes);
-  }
-  if (tiffOffset === -1) return 1;
-  return readOrientationFromTiff(bytes, tiffOffset);
-}
-function rotate90(photon, image, dstIndex) {
-  const w = image.get_width();
-  const h = image.get_height();
-  const src = image.get_raw_pixels();
-  const dst = new Uint8Array(src.length);
-  for (let y = 0; y < h; y++) {
-    for (let x = 0; x < w; x++) {
-      const srcIdx = (y * w + x) * 4;
-      const dstIdx = dstIndex(x, y, w, h) * 4;
-      dst[dstIdx] = src[srcIdx] ?? 0;
-      dst[dstIdx + 1] = src[srcIdx + 1] ?? 0;
-      dst[dstIdx + 2] = src[srcIdx + 2] ?? 0;
-      dst[dstIdx + 3] = src[srcIdx + 3] ?? 0;
-    }
-  }
-  return new photon.PhotonImage(dst, h, w);
-}
-function applyExifOrientation(photon, image, originalBytes) {
-  const orientation = getExifOrientation(originalBytes);
-  if (orientation === 1) return image;
-  switch (orientation) {
-    case 2:
-      photon.fliph(image);
-      return image;
-    case 3:
-      photon.fliph(image);
-      photon.flipv(image);
-      return image;
-    case 4:
-      photon.flipv(image);
-      return image;
-    case 5: {
-      const rotated = rotate90(photon, image, (x, y, _w, h) => x * h + (h - 1 - y));
-      photon.fliph(rotated);
-      return rotated;
-    }
-    case 6:
-      return rotate90(photon, image, (x, y, _w, h) => x * h + (h - 1 - y));
-    case 7: {
-      const rotated = rotate90(photon, image, (x, y, w, h) => (w - 1 - x) * h + y);
-      photon.fliph(rotated);
-      return rotated;
-    }
-    case 8:
-      return rotate90(photon, image, (x, y, w, h) => (w - 1 - x) * h + y);
-    default:
-      return image;
-  }
-}
-
-// src/utils/photon.ts
-init_esm_shims();
-import { createRequire } from "node:module";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-var require2 = createRequire(import.meta.url);
-var fs2 = require2("node:fs");
-var WASM_FILENAME = "photon_rs_bg.wasm";
-var photonModule = null;
-var loadPromise = null;
-function pathOrNull(file) {
-  if (typeof file === "string") return file;
-  if (file instanceof URL) return fileURLToPath(file);
-  return null;
-}
-function getFallbackWasmPaths() {
-  const execDir = path.dirname(process.execPath);
-  return [
-    path.join(execDir, WASM_FILENAME),
-    path.join(execDir, "photon", WASM_FILENAME),
-    path.join(process.cwd(), WASM_FILENAME)
-  ];
-}
-function patchPhotonWasmRead() {
-  const originalReadFileSync = fs2.readFileSync.bind(fs2);
-  const fallbackPaths = getFallbackWasmPaths();
-  const mutableFs = fs2;
-  const patchedReadFileSync = ((...args) => {
-    const [file, options] = args;
-    const resolvedPath = pathOrNull(file);
-    if (resolvedPath?.endsWith(WASM_FILENAME)) {
-      try {
-        return originalReadFileSync(...args);
-      } catch (error) {
-        const err = error;
-        if (err?.code && err.code !== "ENOENT") throw error;
-        for (const fallbackPath of fallbackPaths) {
-          if (!fs2.existsSync(fallbackPath)) continue;
-          if (options === void 0) return originalReadFileSync(fallbackPath);
-          return originalReadFileSync(fallbackPath, options);
-        }
-        throw error;
-      }
-    }
-    return originalReadFileSync(...args);
-  });
-  try {
-    mutableFs.readFileSync = patchedReadFileSync;
-  } catch {
-    Object.defineProperty(fs2, "readFileSync", {
-      value: patchedReadFileSync,
-      writable: true,
-      configurable: true
-    });
-  }
-  return () => {
-    try {
-      mutableFs.readFileSync = originalReadFileSync;
-    } catch {
-      Object.defineProperty(fs2, "readFileSync", {
-        value: originalReadFileSync,
-        writable: true,
-        configurable: true
-      });
-    }
-  };
-}
-async function loadPhoton() {
-  if (photonModule) return photonModule;
-  if (loadPromise) return loadPromise;
-  loadPromise = (async () => {
-    const restoreReadFileSync = patchPhotonWasmRead();
-    try {
-      photonModule = await import("@silvia-odwyer/photon-node");
-      return photonModule;
-    } catch {
-      photonModule = null;
-      return photonModule;
-    } finally {
-      restoreReadFileSync();
-    }
-  })();
-  return loadPromise;
-}
-
-// src/utils/image-resize.ts
-var DEFAULT_MAX_BYTES = 4.5 * 1024 * 1024;
-var DEFAULT_OPTIONS = {
-  maxWidth: 2e3,
-  maxHeight: 2e3,
-  maxBytes: DEFAULT_MAX_BYTES,
-  jpegQuality: 80
-};
-function encodeCandidate(buffer, mimeType) {
-  const data = Buffer.from(buffer).toString("base64");
-  return {
-    data,
-    encodedSize: Buffer.byteLength(data, "utf-8"),
-    mimeType
-  };
-}
-async function resizeImage(img, options) {
-  const opts = { ...DEFAULT_OPTIONS, ...options };
-  const inputBuffer = Buffer.from(img.data, "base64");
-  const inputBase64Size = Buffer.byteLength(img.data, "utf-8");
-  const photon = await loadPhoton();
-  if (!photon) return null;
-  const loadedPhoton = photon;
-  let image;
-  try {
-    let tryEncodings2 = function(width, height, jpegQualities) {
-      const resized = loadedPhoton.resize(loadedImage, width, height, loadedPhoton.SamplingFilter.Lanczos3);
-      try {
-        const candidates = [encodeCandidate(resized.get_bytes(), "image/png")];
-        for (const quality of jpegQualities) {
-          candidates.push(encodeCandidate(resized.get_bytes_jpeg(quality), "image/jpeg"));
-        }
-        return candidates;
-      } finally {
-        resized.free();
-      }
-    };
-    var tryEncodings = tryEncodings2;
-    const inputBytes = new Uint8Array(inputBuffer);
-    const rawImage = photon.PhotonImage.new_from_byteslice(inputBytes);
-    image = applyExifOrientation(photon, rawImage, inputBytes);
-    if (image !== rawImage) rawImage.free();
-    const originalWidth = image.get_width();
-    const originalHeight = image.get_height();
-    const format = img.mimeType?.split("/")[1] ?? "png";
-    if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && inputBase64Size < opts.maxBytes) {
-      return {
-        data: img.data,
-        mimeType: img.mimeType ?? `image/${format}`,
-        originalWidth,
-        originalHeight,
-        width: originalWidth,
-        height: originalHeight,
-        wasResized: false
-      };
-    }
-    let targetWidth = originalWidth;
-    let targetHeight = originalHeight;
-    if (targetWidth > opts.maxWidth) {
-      targetHeight = Math.round(targetHeight * opts.maxWidth / targetWidth);
-      targetWidth = opts.maxWidth;
-    }
-    if (targetHeight > opts.maxHeight) {
-      targetWidth = Math.round(targetWidth * opts.maxHeight / targetHeight);
-      targetHeight = opts.maxHeight;
-    }
-    const loadedImage = image;
-    const qualitySteps = Array.from(/* @__PURE__ */ new Set([opts.jpegQuality, 85, 70, 55, 40]));
-    let currentWidth = targetWidth;
-    let currentHeight = targetHeight;
-    while (true) {
-      const candidates = tryEncodings2(currentWidth, currentHeight, qualitySteps);
-      for (const candidate of candidates) {
-        if (candidate.encodedSize < opts.maxBytes) {
-          return {
-            data: candidate.data,
-            mimeType: candidate.mimeType,
-            originalWidth,
-            originalHeight,
-            width: currentWidth,
-            height: currentHeight,
-            wasResized: true
-          };
-        }
-      }
-      if (currentWidth === 1 && currentHeight === 1) break;
-      const nextWidth = currentWidth === 1 ? 1 : Math.max(1, Math.floor(currentWidth * 0.75));
-      const nextHeight = currentHeight === 1 ? 1 : Math.max(1, Math.floor(currentHeight * 0.75));
-      if (nextWidth === currentWidth && nextHeight === currentHeight) break;
-      currentWidth = nextWidth;
-      currentHeight = nextHeight;
-    }
-    return null;
-  } catch {
-    return null;
-  } finally {
-    if (image) image.free();
-  }
-}
-function formatDimensionNote(result2) {
-  if (!result2.wasResized) return void 0;
-  const scale = result2.originalWidth / result2.width;
-  return `[Image: original ${result2.originalWidth}x${result2.originalHeight}, displayed at ${result2.width}x${result2.height}. Multiply coordinates by ${scale.toFixed(2)} to map to original image.]`;
-}
-
-// src/core/file-references.ts
-var DEFAULT_IMAGE_MAX_BASE64_BYTES = 4.5 * 1024 * 1024;
-function decodeQuotedFileArg(input, start, quote) {
-  let value = "";
-  let escaped = false;
-  for (let index = start; index < input.length; index += 1) {
-    const character = input[index] ?? "";
-    if (escaped) {
-      value += character;
-      escaped = false;
-      continue;
-    }
-    if (character === "\\") {
-      escaped = true;
-      continue;
-    }
-    if (character === quote) return { value, end: index + 1 };
-    value += character;
-  }
-  return null;
-}
-function inlineFileReferences(input) {
-  const references = [];
-  for (let start = 0; start < input.length; start += 1) {
-    if (input[start] !== "@" || start > 0 && !/\s/u.test(input[start - 1] ?? "")) continue;
-    const next = input[start + 1];
-    if (next === '"' || next === "'") {
-      const decoded = decodeQuotedFileArg(input, start + 2, next);
-      if (!decoded || decoded.value.length === 0) continue;
-      references.push({
-        start,
-        end: decoded.end,
-        raw: input.slice(start, decoded.end),
-        fileArg: decoded.value,
-        quoted: true
-      });
-      start = decoded.end - 1;
-      continue;
-    }
-    let end = start + 1;
-    while (end < input.length && !/\s/u.test(input[end] ?? "")) end += 1;
-    if (end === start + 1) continue;
-    references.push({
-      start,
-      end,
-      raw: input.slice(start, end),
-      fileArg: input.slice(start + 1, end),
-      quoted: false
-    });
-    start = end - 1;
-  }
-  return references;
-}
-function renderTextFile(filePath, content) {
-  return `<file name="${filePath}">
-${content}
-</file>
-`;
-}
-function renderImageFile(filePath, content = "") {
-  return `<file name="${filePath}">${content}</file>
-`;
-}
-function result(text, diagnostics = [], images = [], referencedPaths = []) {
-  return { text, diagnostics, images, referencedPaths };
-}
-function detectSupportedImageMimeType(bytes) {
-  if (bytes.length >= 8 && bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
-    return "image/png";
-  }
-  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
-    return "image/jpeg";
-  }
-  const signature = bytes.subarray(0, 6).toString("ascii");
-  if (signature === "GIF87a" || signature === "GIF89a") return "image/gif";
-  if (bytes.length >= 12 && bytes.subarray(0, 4).toString("ascii") === "RIFF" && bytes.subarray(8, 12).toString("ascii") === "WEBP") {
-    return "image/webp";
-  }
-  return null;
-}
-async function readFileReferenceAsync(fileArg, options) {
-  const filePath = expandConfigPath(fileArg, options.cwd === void 0 ? void 0 : { cwd: options.cwd });
-  if (!existsSync(filePath)) {
-    if (options.missing === "leave") return result(`@${fileArg}`);
-    return result("", [{ type: "error", message: `file not found: ${filePath}`, path: filePath }]);
-  }
-  let stat;
-  try {
-    stat = statSync2(filePath);
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    return result("", [{ type: "error", message: `file could not be stat'ed: ${reason}`, path: filePath }]);
-  }
-  if (!stat.isFile()) {
-    return result("", [{ type: "error", message: `not a file: ${filePath}`, path: filePath }]);
-  }
-  if (stat.size === 0) return result("", [], [], [filePath]);
-  try {
-    const bytes = readFileSync(filePath);
-    const imageMimeType = detectSupportedImageMimeType(bytes);
-    if (imageMimeType) {
-      if (options.includeImages !== true) return result(`@${fileArg}`);
-      const originalImage = {
-        type: "image",
-        mimeType: imageMimeType,
-        data: bytes.toString("base64")
-      };
-      if (options.autoResizeImages === false) {
-        return result(renderImageFile(filePath), [], [originalImage], [filePath]);
-      }
-      const resized = await resizeImage(originalImage);
-      if (!resized) {
-        if (Buffer.byteLength(originalImage.data, "utf-8") < DEFAULT_IMAGE_MAX_BASE64_BYTES) {
-          return result(renderImageFile(filePath), [], [originalImage], [filePath]);
-        }
-        return result(
-          renderImageFile(filePath, "[Image omitted: could not be resized below the inline image size limit.]"),
-          [],
-          [],
-          [filePath]
-        );
-      }
-      return result(
-        renderImageFile(filePath, formatDimensionNote(resized)),
-        [],
-        [{ type: "image", mimeType: resized.mimeType, data: resized.data }],
-        [filePath]
-      );
-    }
-    return result(renderTextFile(filePath, bytes.toString("utf8")), [], [], [filePath]);
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    return result("", [{ type: "error", message: `file could not be read: ${reason}`, path: filePath }]);
-  }
-}
-async function readFileArgsAsync(fileArgs, options = {}) {
-  const diagnostics = [];
-  const images = [];
-  const referencedPaths = [];
-  let text = "";
-  for (const fileArg of fileArgs) {
-    const ref = await readFileReferenceAsync(fileArg, {
-      ...options,
-      missing: options.missing ?? "error",
-      includeImages: true
-    });
-    text += ref.text;
-    images.push(...ref.images);
-    diagnostics.push(...ref.diagnostics);
-    referencedPaths.push(...ref.referencedPaths);
-  }
-  return { text, images, diagnostics, referencedPaths };
-}
-function splitTrailingPunctuation(token) {
-  const match = token.match(/^(.+?)([),.;:!?]+)$/);
-  if (!match?.[1] || !match[2]) return { fileArg: token, suffix: "" };
-  const candidate = match[1];
-  const suffix = match[2];
-  const ext = path2.extname(candidate);
-  if (ext.length === 0 && suffix.startsWith(".")) return { fileArg: token, suffix: "" };
-  return { fileArg: candidate, suffix };
-}
-async function expandInlineFileReferencesAsync(input, options = {}) {
-  const diagnostics = [];
-  const images = [];
-  const referencedPaths = [];
-  let text = "";
-  let lastIndex = 0;
-  for (const reference of inlineFileReferences(input)) {
-    text += input.slice(lastIndex, reference.start);
-    const direct = await readFileReferenceAsync(reference.fileArg, {
-      ...options,
-      missing: "leave",
-      includeImages: options.includeImages === true
-    });
-    if (direct.text !== `@${reference.fileArg}`) {
-      diagnostics.push(...direct.diagnostics);
-      images.push(...direct.images);
-      referencedPaths.push(...direct.referencedPaths);
-      text += direct.text;
-      lastIndex = reference.end;
-      continue;
-    }
-    const { fileArg, suffix } = reference.quoted ? { fileArg: reference.fileArg, suffix: "" } : splitTrailingPunctuation(reference.fileArg);
-    if (fileArg === reference.fileArg) {
-      text += reference.raw;
-      lastIndex = reference.end;
-      continue;
-    }
-    const stripped = await readFileReferenceAsync(fileArg, {
-      ...options,
-      missing: "leave",
-      includeImages: options.includeImages === true
-    });
-    if (stripped.text === `@${fileArg}`) {
-      text += reference.raw;
-      lastIndex = reference.end;
-      continue;
-    }
-    diagnostics.push(...stripped.diagnostics);
-    images.push(...stripped.images);
-    referencedPaths.push(...stripped.referencedPaths);
-    text += `${stripped.text}${suffix}`;
-    lastIndex = reference.end;
-  }
-  text += input.slice(lastIndex);
-  return { text, images, diagnostics, referencedPaths };
-}
-
 export {
   toContextOverflowError,
   attachedToolSchemasFromState,
@@ -1169,6 +639,7 @@ export {
   isSelfExplainingAbort,
   isLengthStopAssistantMessage,
   isEmptyAbortedAssistantMessage,
+  explainInterruptedAssistant,
   hasStructuredToolCall,
   toolNamesFromAgentState,
   noticeMessage,
@@ -1190,8 +661,6 @@ export {
   detectOverflowFromState,
   setupSteerChannel,
   projectHeadlessJsonEvent,
-  projectDispatchJsonEvent,
-  readFileArgsAsync,
-  expandInlineFileReferencesAsync
+  projectDispatchJsonEvent
 };
-//# sourceMappingURL=chunk-W6RRQCPQ.js.map
+//# sourceMappingURL=chunk-UTUNT5QL.js.map