@anuma/sdk 6.26.0 → 6.26.2

package/dist/react/index.cjs

@@ -1504,8 +1504,10 @@ __export(index_exports, {
   appFileToStored: () => appFileToStored,
   archiveVaultMemoryOp: () => archiveVaultMemoryOp,
   assembleMemoryContext: () => assembleMemoryContext,
+  attachFileContextToLastUserMessage: () => attachFileContextToLastUserMessage,
   backfillMemoryEntityUserIdsOp: () => backfillMemoryEntityUserIdsOp,
   backfillMemoryTopicsOp: () => backfillMemoryTopicsOp,
+  buildAttachedFilesText: () => buildAttachedFilesText,
   capHopsForDensity: () => capHopsForDensity,
   chatStorageMigrations: () => chatStorageMigrations,
   chatStorageSchema: () => chatStorageSchema,
@@ -1611,6 +1613,7 @@ __export(index_exports, {
   findById: () => findById,
   findMatchingTools: () => findMatchingTools,
   findParentOfId: () => findParentOfId,
+  formatFileProcessingNotes: () => formatFileProcessingNotes,
   generateConversationId: () => generateConversationId,
   generateEmbedding: () => generateEmbedding,
   generateEmbeddings: () => generateEmbeddings,
@@ -1710,6 +1713,7 @@ __export(index_exports, {
   insertAfterId: () => insertAfterId,
   insertChild: () => insertChild,
   isAnumaTag: () => isAnumaTag,
+  isAttachedFilesText: () => isAttachedFilesText,
   isCalendarCallback: () => isCalendarCallback,
   isDegradedTopicSkip: () => isDegradedTopicSkip,
   isDriveCallback: () => isDriveCallback,
@@ -3359,6 +3363,46 @@ async function assembleDecryptedMessage(message, address) {
 // src/lib/db/chat/types.ts
 var import_uuid = require("uuid");
 
+// src/lib/chat/fileContext.ts
+var ATTACHED_FILES_OPEN_TAG = "<attached_files>";
+var ATTACHED_FILES_CLOSE_TAG = "</attached_files>";
+var ATTACHED_FILES_PREFIX = `${ATTACHED_FILES_OPEN_TAG}
+The user attached the following file(s) to this message. Their extracted contents are below; when the user refers to "the attached file", "this file" or "the document", they mean these.`;
+function isAttachedFilesText(text12) {
+  return typeof text12 === "string" && text12.startsWith(ATTACHED_FILES_PREFIX) && text12.endsWith(ATTACHED_FILES_CLOSE_TAG);
+}
+function buildAttachedFilesText(fileContext) {
+  return `${ATTACHED_FILES_PREFIX}
+
+${fileContext}
+${ATTACHED_FILES_CLOSE_TAG}`;
+}
+function attachFileContextToLastUserMessage(messages, fileContext) {
+  if (!fileContext.trim()) return messages;
+  let lastUserIndex = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user") {
+      lastUserIndex = i;
+      break;
+    }
+  }
+  if (lastUserIndex === -1) return messages;
+  const message = messages[lastUserIndex];
+  const existing = message.content ?? [];
+  let insertAt = 0;
+  existing.forEach((part, index) => {
+    if (part.type === "text") insertAt = index + 1;
+  });
+  const filePart = {
+    type: "text",
+    text: buildAttachedFilesText(fileContext)
+  };
+  const content = [...existing.slice(0, insertAt), filePart, ...existing.slice(insertAt)];
+  const result = [...messages];
+  result[lastUserIndex] = { ...message, content };
+  return result;
+}
+
 // src/lib/chat/useChat/strategies/types.ts
 function isChatCompletionResponse(r) {
   if (r.object === "response") return false;
@@ -3480,7 +3524,7 @@ function extractUserMessageFromMessages(messages) {
   const textParts = [];
   const files = [];
   for (const part of lastUserMessage.content) {
-    if (part.type === "text" && part.text) {
+    if (part.type === "text" && part.text && !isAttachedFilesText(part.text)) {
       textParts.push(part.text);
     } else if (part.type === "image_url" && part.image_url?.url) {
       files.push({
@@ -7926,7 +7970,7 @@ function extractLastUserText(messages) {
   const content = lastUserMsg.content;
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
-    return content.filter((c) => c?.type === "text").map((c) => c.text ?? "").join(" ");
+    return content.filter((c) => c?.type === "text" && !isAttachedFilesText(c.text)).map((c) => c.text ?? "").join(" ");
   }
   return "";
 }
@@ -21459,14 +21503,37 @@ init_logger();
 if (typeof process !== "undefined" && typeof process.umask !== "function") {
   process.umask = (_mask) => 18;
 }
+var MAX_ROWS_PER_SHEET = 2e3;
+function csvField(value) {
+  return /[",\r\n]/.test(value) ? `"${value.replace(/"/g, '""')}"` : value;
+}
+function uniqueHeaders(raw, columnCount) {
+  const bases = [];
+  for (let col = 1; col <= columnCount; col++) bases.push(raw[col]?.trim() || `Column${col}`);
+  const taken = new Set(bases);
+  const emitted = /* @__PURE__ */ new Set();
+  return bases.map((base) => {
+    if (!emitted.has(base)) {
+      emitted.add(base);
+      return base;
+    }
+    let n = 2;
+    while (taken.has(`${base}_${n}`)) n++;
+    const name = `${base}_${n}`;
+    taken.add(name);
+    emitted.add(name);
+    return name;
+  });
+}
 var ExcelProcessor = class {
-  constructor() {
+  constructor(options = {}) {
     this.name = "excel";
     this.supportedMimeTypes = [
       "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
       // .xlsx
     ];
     this.supportedExtensions = [".xlsx"];
+    this.maxRowsPerSheet = options.maxRowsPerSheet ?? MAX_ROWS_PER_SHEET;
   }
   async loadExcelJS() {
     const mod = await import("exceljs");
@@ -21481,31 +21548,51 @@ var ExcelProcessor = class {
       if (workbook.worksheets.length === 0) {
         return null;
       }
-      const jsonData = {};
+      let truncated = false;
+      const sections = [];
       for (const worksheet of workbook.worksheets) {
-        const rows = [];
-        const headerRow = worksheet.getRow(1);
-        const headers = [];
-        headerRow.eachCell({ includeEmpty: true }, (cell, colNumber) => {
-          headers[colNumber] = cell.text || `Column${colNumber}`;
+        const rawHeaders = [];
+        let columnCount = 0;
+        worksheet.getRow(1).eachCell({ includeEmpty: true }, (cell, colNumber) => {
+          rawHeaders[colNumber] = cell.text;
+          columnCount = Math.max(columnCount, colNumber);
         });
+        const rows = [];
+        let totalRows = 0;
         worksheet.eachRow({ includeEmpty: false }, (row, rowNumber) => {
           if (rowNumber === 1) return;
-          const rowData = {};
+          totalRows++;
+          if (rows.length >= this.maxRowsPerSheet) return;
+          const values = [];
           row.eachCell({ includeEmpty: true }, (cell, colNumber) => {
-            const key = headers[colNumber] || `Column${colNumber}`;
-            rowData[key] = this.resolveCellValue(cell.value);
+            values[colNumber - 1] = String(this.resolveCellValue(cell.value));
+            columnCount = Math.max(columnCount, colNumber);
           });
-          rows.push(rowData);
+          rows.push(values);
         });
-        jsonData[worksheet.name] = rows;
+        const headers = uniqueHeaders(rawHeaders, columnCount);
+        const lines = [headers, ...rows].map(
+          (values) => headers.map((_, i) => csvField(values[i] ?? "")).join(",")
+        );
+        let section = `## Sheet: ${worksheet.name}
+
+\`\`\`csv
+${lines.join("\n")}
+\`\`\``;
+        if (totalRows > rows.length) {
+          truncated = true;
+          section += `
+[truncated: showing the first ${rows.length} of ${totalRows} data rows of sheet "${worksheet.name}"]`;
+        }
+        sections.push(section);
       }
       return {
-        extractedText: JSON.stringify(jsonData, null, 2),
-        format: "json",
+        extractedText: sections.join("\n\n"),
+        format: "markdown",
         metadata: {
           sheetCount: workbook.worksheets.length,
-          sheetNames: workbook.worksheets.map((ws) => ws.name)
+          sheetNames: workbook.worksheets.map((ws) => ws.name),
+          truncated
         }
       };
     } catch (error) {
@@ -21534,6 +21621,9 @@ init_logger();
 // src/lib/pdf.ts
 var pdfjsModule = null;
 var workerConfigured = false;
+var RENDER_SCALE = 1.5;
+var MAX_RENDER_SIDE_PX = 1600;
+var JPEG_QUALITY = 0.8;
 async function getPdfjs() {
   if (!pdfjsModule) {
     pdfjsModule = await import("pdfjs-dist");
@@ -21544,46 +21634,134 @@ async function getPdfjs() {
   }
   return pdfjsModule;
 }
-async function extractTextFromPdf(pdfDataUrl) {
+async function withPdfDocument(pdfDataUrl, fn) {
   const pdfjs = await getPdfjs();
   const loadingTask = pdfjs.getDocument(pdfDataUrl);
-  const pdf = await loadingTask.promise;
-  const textParts = [];
-  for (let i = 1; i <= pdf.numPages; i++) {
-    const page = await pdf.getPage(i);
-    const textContent = await page.getTextContent();
-    const pageText = textContent.items.map((item) => "str" in item ? item.str : "").join(" ");
-    if (pageText.trim()) {
-      textParts.push(pageText);
-    }
+  let pdf;
+  try {
+    pdf = await loadingTask.promise;
+  } catch (error) {
+    await loadingTask.destroy().catch(() => void 0);
+    throw error;
+  }
+  try {
+    return await fn(pdf);
+  } finally {
+    await pdf.destroy().catch(() => void 0);
   }
-  return textParts.join("\n\n");
 }
-async function convertPdfToImages(pdfDataUrl, maxPages) {
-  const images = [];
-  const pdfjs = await getPdfjs();
-  const loadingTask = pdfjs.getDocument(pdfDataUrl);
-  const pdf = await loadingTask.promise;
-  const pageLimit = maxPages !== void 0 ? Math.min(maxPages, pdf.numPages) : pdf.numPages;
-  for (let i = 1; i <= pageLimit; i++) {
-    const page = await pdf.getPage(i);
-    const viewport = page.getViewport({ scale: 1.5 });
-    const canvas = document.createElement("canvas");
-    const context = canvas.getContext("2d");
-    if (!context) continue;
-    canvas.height = viewport.height;
-    canvas.width = viewport.width;
-    await page.render({
-      canvasContext: context,
-      viewport
-    }).promise;
-    images.push(canvas.toDataURL("image/png"));
-  }
-  return images;
+function joinPdfTextItems(items) {
+  let text12 = "";
+  for (const item of items) {
+    if (!("str" in item)) continue;
+    const { str, hasEOL } = item;
+    text12 += str + (hasEOL ? "\n" : " ");
+  }
+  return text12.replace(/[ \t]+\n/g, "\n").trim();
+}
+function computeRenderScale(width, height) {
+  const longest = Math.max(width, height);
+  if (!(longest > 0)) return RENDER_SCALE;
+  return Math.min(RENDER_SCALE, MAX_RENDER_SIDE_PX / longest);
+}
+async function extractPdfPageTexts(pdfDataUrl) {
+  return withPdfDocument(pdfDataUrl, async (pdf) => {
+    const pageTexts = [];
+    for (let i = 1; i <= pdf.numPages; i++) {
+      const page = await pdf.getPage(i);
+      const textContent = await page.getTextContent();
+      pageTexts.push(joinPdfTextItems(textContent.items));
+    }
+    return pageTexts;
+  });
+}
+async function extractTextFromPdf(pdfDataUrl) {
+  const pageTexts = await extractPdfPageTexts(pdfDataUrl);
+  return pageTexts.filter((text12) => text12.trim()).join("\n\n");
+}
+async function renderPdfPages(pdfDataUrl, maxPages, pageNumbers) {
+  return withPdfDocument(pdfDataUrl, async (pdf) => {
+    const requested = pageNumbers?.filter((n) => n >= 1 && n <= pdf.numPages) ?? Array.from(
+      { length: maxPages !== void 0 ? Math.min(maxPages, pdf.numPages) : pdf.numPages },
+      (_, i) => i + 1
+    );
+    const pages = [];
+    for (const pageNumber of requested) {
+      const page = await pdf.getPage(pageNumber);
+      const base = page.getViewport({ scale: 1 });
+      const viewport = page.getViewport({ scale: computeRenderScale(base.width, base.height) });
+      const canvas = document.createElement("canvas");
+      const context = canvas.getContext("2d");
+      if (!context) continue;
+      canvas.height = Math.floor(viewport.height);
+      canvas.width = Math.floor(viewport.width);
+      context.fillStyle = "#ffffff";
+      context.fillRect(0, 0, canvas.width, canvas.height);
+      await page.render({
+        canvasContext: context,
+        viewport,
+        background: "#ffffff"
+      }).promise;
+      pages.push({ pageNumber, dataUrl: canvas.toDataURL("image/jpeg", JPEG_QUALITY) });
+      canvas.width = 0;
+      canvas.height = 0;
+    }
+    return { pages, pageCount: pdf.numPages };
+  });
+}
+async function convertPdfToImages(pdfDataUrl, maxPages, pageNumbers) {
+  const { pages } = await renderPdfPages(pdfDataUrl, maxPages, pageNumbers);
+  return pages.map((p) => p.dataUrl);
 }
 
 // src/lib/processors/PdfProcessor.ts
 var MAX_IMAGE_PAGES = 20;
+var MIN_PAGE_TEXT_CHARS = 20;
+function selectPdfImagePages(pageTexts, maxImagePages = MAX_IMAGE_PAGES) {
+  const needImage = [];
+  pageTexts.forEach((text12, index) => {
+    if (text12.trim().length < MIN_PAGE_TEXT_CHARS) needImage.push(index + 1);
+  });
+  const limit = Math.max(0, maxImagePages);
+  return { rendered: needImage.slice(0, limit), omitted: needImage.slice(limit) };
+}
+function formatPageList(pages) {
+  const ranges = [];
+  for (let i = 0; i < pages.length; i++) {
+    const start = pages[i];
+    let end = start;
+    while (i + 1 < pages.length && pages[i + 1] === end + 1) end = pages[++i];
+    ranges.push(start === end ? `${start}` : `${start}-${end}`);
+  }
+  return `${pages.length === 1 ? "page" : "pages"} ${ranges.join(", ")}`;
+}
+function buildPdfImageNote(fileName, includedPages, omittedPages, pageCount) {
+  const imageOnlyCount = includedPages.length + omittedPages.length;
+  const allPages = [...includedPages, ...omittedPages].sort((a, b) => a - b);
+  const subject = pageCount === void 0 || imageOnlyCount >= pageCount ? `${fileName}: scanned/image-based PDF (no extractable text)` : `${fileName}: ${imageOnlyCount} of ${pageCount} pages have no extractable text (${formatPageList(allPages)})`;
+  if (includedPages.length === 0) {
+    return `[${subject} \u2014 ${formatPageList(omittedPages)} could not be included as images because of the image limit, so their content is not available]`;
+  }
+  const included = `${formatPageList(includedPages)} rendered as images and included in this message for visual analysis`;
+  if (omittedPages.length === 0) return `[${subject} \u2014 ${included}]`;
+  return `[${subject} \u2014 ${included}; ${formatPageList(omittedPages)} not included because of the image limit, so their content is not available]`;
+}
+function rewriteImageNote(result, fileName, keptImages) {
+  const images = result.imageDataUrls ?? [];
+  const note = result.metadata?.imageNote;
+  if (!note || keptImages >= images.length) return result.extractedText;
+  const imagePages = result.metadata?.imagePages ?? [];
+  const omittedPages = result.metadata?.omittedImagePages ?? [];
+  const pageCount = result.metadata?.pageCount;
+  const kept = Math.max(0, keptImages);
+  const newNote = buildPdfImageNote(
+    fileName,
+    imagePages.slice(0, kept),
+    [...imagePages.slice(kept), ...omittedPages].sort((a, b) => a - b),
+    pageCount
+  );
+  return result.extractedText.replace(note, () => newNote);
+}
 var PdfProcessor = class {
   constructor() {
     this.name = "pdf";
@@ -21592,43 +21770,65 @@ var PdfProcessor = class {
   }
   async process(file) {
     const logger = getLogger();
+    let pageTexts = null;
     try {
-      const text12 = await extractTextFromPdf(file.dataUrl);
-      if (text12 && text12.trim().length > 0) {
-        return {
-          extractedText: text12,
-          format: "plain"
-        };
-      }
-      logger.info(
-        `[PdfProcessor] Text extraction returned empty for "${file.name}" \u2014 falling back to image conversion`
-      );
+      pageTexts = await extractPdfPageTexts(file.dataUrl);
     } catch (textError) {
       logger.warn(
-        `[PdfProcessor] Text extraction failed for "${file.name}" \u2014 falling back to image conversion:`,
+        "[PdfProcessor] Text extraction failed \u2014 falling back to image conversion:",
         textError
       );
     }
+    const text12 = (pageTexts ?? []).filter((t) => t.trim()).join("\n\n");
+    const { rendered, omitted } = pageTexts ? selectPdfImagePages(pageTexts) : { rendered: [], omitted: [] };
+    if (pageTexts && rendered.length === 0 && omitted.length === 0) {
+      return text12.trim() ? { extractedText: text12, format: "plain" } : null;
+    }
+    let renderedPages;
+    let pageCount = pageTexts?.length;
     try {
-      const images = await convertPdfToImages(file.dataUrl, MAX_IMAGE_PAGES);
-      if (images.length === 0) {
-        logger.warn(`[PdfProcessor] Image conversion also returned empty for "${file.name}"`);
-        return null;
+      if (pageTexts) {
+        renderedPages = (await renderPdfPages(file.dataUrl, void 0, rendered)).pages;
+      } else {
+        const result = await renderPdfPages(file.dataUrl, MAX_IMAGE_PAGES);
+        renderedPages = result.pages;
+        pageCount = result.pageCount;
       }
-      logger.info(`[PdfProcessor] Converted ${images.length} page(s) of "${file.name}" to images`);
-      return {
-        // Contextual note for the LLM — keep it self-contained since the
-        // images are only injected in the current request and not persisted
-        // for follow-up turns.
-        extractedText: `[${file.name}: scanned/image-based PDF \u2014 ${images.length} page(s) rendered as images and included in this message for visual analysis]`,
-        format: "plain",
-        imageDataUrls: images,
-        metadata: { pageCount: images.length }
-      };
     } catch (imageError) {
-      logger.error(`[PdfProcessor] Image conversion also failed for "${file.name}":`, imageError);
-      throw imageError;
+      if (!text12.trim()) {
+        logger.error("[PdfProcessor] Image conversion also failed:", imageError);
+        throw imageError;
+      }
+      logger.warn("[PdfProcessor] Image conversion failed \u2014 keeping text only:", imageError);
+      renderedPages = [];
+    }
+    const images = renderedPages.map((p) => p.dataUrl);
+    const imagePages = renderedPages.map((p) => p.pageNumber);
+    const included = new Set(imagePages);
+    const needImage = pageTexts ? [...rendered, ...omitted] : Array.from({ length: pageCount ?? 0 }, (_, i) => i + 1);
+    const omittedPages = needImage.filter((n) => !included.has(n)).sort((a, b) => a - b);
+    if (images.length === 0 && !text12.trim()) {
+      logger.warn("[PdfProcessor] Image conversion also returned empty");
+      return null;
     }
+    logger.info(
+      `[PdfProcessor] Rendered ${images.length} page(s) as images, ${omittedPages.length} image-only page(s) omitted`
+    );
+    const imageNote = buildPdfImageNote(file.name, imagePages, omittedPages, pageCount);
+    return {
+      extractedText: text12.trim() ? `${imageNote}
+
+${text12}` : imageNote,
+      format: "plain",
+      imageDataUrls: images.length > 0 ? images : void 0,
+      metadata: {
+        pageCount,
+        imageNote,
+        imagePages,
+        omittedImagePages: omittedPages,
+        truncated: omittedPages.length > 0
+      }
+    };
   }
 };
 
@@ -21670,6 +21870,21 @@ var EXT = {
   CFG: ".cfg",
   CONF: ".conf"
 };
+function decodeText(bytes) {
+  if (bytes[0] === 255 && bytes[1] === 254) {
+    return new TextDecoder("utf-16le", { fatal: false }).decode(bytes.subarray(2));
+  }
+  if (bytes[0] === 254 && bytes[1] === 255) {
+    const swapped = new Uint8Array(bytes.length - 2);
+    for (let i = 2; i + 1 < bytes.length; i += 2) {
+      swapped[i - 2] = bytes[i + 1];
+      swapped[i - 1] = bytes[i];
+    }
+    return new TextDecoder("utf-16le", { fatal: false }).decode(swapped);
+  }
+  const hasUtf8Bom = bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191;
+  return new TextDecoder("utf-8", { fatal: false }).decode(hasUtf8Bom ? bytes.subarray(3) : bytes);
+}
 var TextProcessor = class {
   constructor() {
     this.name = "text";
@@ -21679,7 +21894,7 @@ var TextProcessor = class {
   async process(file) {
     try {
       const arrayBuffer = await dataUrlToArrayBuffer(file.dataUrl);
-      const text12 = new TextDecoder("utf-8", { fatal: false }).decode(arrayBuffer);
+      const text12 = decodeText(new Uint8Array(arrayBuffer));
       if (!text12.trim()) {
         return null;
       }
@@ -21702,7 +21917,7 @@ var TextProcessor = class {
    * rather than prose).
    */
   resolveFormat(file) {
-    const type = file.type?.toLowerCase() ?? "";
+    const type = file.type?.split(";")[0].trim().toLowerCase() ?? "";
     const name = file.name?.toLowerCase() ?? "";
     if (type === MIME.MARKDOWN || type === MIME.X_MARKDOWN || name.endsWith(EXT.MD) || name.endsWith(EXT.MARKDOWN)) {
       return "markdown";
@@ -21760,6 +21975,12 @@ var WordProcessor = class {
 // src/lib/processors/ZipProcessor.ts
 var import_jszip = __toESM(require("jszip"));
 init_logger();
+var MAX_ZIP_ENTRIES = 1e3;
+var MAX_TOTAL_UNCOMPRESSED_BYTES = 50 * 1024 * 1024;
+function declaredUncompressedSize(zipObject) {
+  const size = zipObject._data?.uncompressedSize;
+  return typeof size === "number" ? size : void 0;
+}
 var ZipProcessor = class {
   constructor(options = {}) {
     this.name = "zip";
@@ -21794,14 +22015,35 @@ var ZipProcessor = class {
           zipObject: zipEntry
         });
       });
-      const filteredEntries = this.includeHidden ? entries : entries.filter((entry) => !this.isHidden(entry.path));
-      filteredEntries.sort((a, b) => {
+      const visibleEntries = this.includeHidden ? entries : entries.filter((entry) => !this.isHidden(entry.path));
+      visibleEntries.sort((a, b) => {
         if (a.isDirectory !== b.isDirectory) {
           return a.isDirectory ? -1 : 1;
         }
         return a.path.localeCompare(b.path);
       });
-      for (const entry of filteredEntries) {
+      const visibleDirs = visibleEntries.filter((e) => e.isDirectory);
+      const visibleFiles = visibleEntries.filter((e) => !e.isDirectory);
+      const listedDirs = visibleDirs.slice(0, MAX_ZIP_ENTRIES);
+      const listedFiles = visibleFiles.slice(0, MAX_ZIP_ENTRIES);
+      const filteredEntries = [...listedDirs, ...listedFiles];
+      const notes = [];
+      if (visibleFiles.length > listedFiles.length) {
+        notes.push(
+          `[truncated: the archive has ${visibleFiles.length} files; only the first ${listedFiles.length} were listed and considered for extraction, the other ${visibleFiles.length - listedFiles.length} files were dropped]`
+        );
+      }
+      if (visibleDirs.length > listedDirs.length) {
+        notes.push(
+          `[truncated: listing the first ${listedDirs.length} of ${visibleDirs.length} directories]`
+        );
+      }
+      let totalBytes = 0;
+      let byteBudgetHit = false;
+      let truncated = notes.length > 0;
+      const logger = getLogger();
+      for (let index = 0; index < filteredEntries.length; index++) {
+        const entry = filteredEntries[index];
         if (entry.isDirectory) continue;
         const fileName = entry.path.split("/").pop() || entry.path;
         const extension = this.getFileExtension(fileName);
@@ -21815,9 +22057,20 @@ var ZipProcessor = class {
         };
         const processor = this.registry?.findProcessor(fileMetadata);
         if (!processor || processor.name === "zip") continue;
+        const declared = declaredUncompressedSize(entry.zipObject);
+        if (declared !== void 0 && declared > this.maxFileSize) continue;
+        if (totalBytes + (declared ?? 0) > MAX_TOTAL_UNCOMPRESSED_BYTES) {
+          byteBudgetHit = true;
+          break;
+        }
         try {
           const data = await entry.zipObject.async("uint8array");
+          totalBytes += data.length;
           if (data.length > this.maxFileSize) continue;
+          if (totalBytes > MAX_TOTAL_UNCOMPRESSED_BYTES) {
+            byteBudgetHit = true;
+            break;
+          }
           const base64 = uint8ArrayToBase64(data);
           const dataUrl = `data:${mimeType};base64,${base64}`;
           const fileWithData = {
@@ -21827,23 +22080,36 @@ var ZipProcessor = class {
           };
           const result = await processor.process(fileWithData);
           if (result && result.extractedText.trim()) {
+            if (result.metadata?.truncated || result.imageDataUrls?.length) truncated = true;
             processedContents.push({
               path: entry.path,
               processorName: processor.name,
-              result
+              // Page images of nested files are not forwarded, so their note must not claim them.
+              result: { ...result, extractedText: rewriteImageNote(result, fileName, 0) }
             });
           }
-        } catch {
+        } catch (error) {
+          logger.warn(
+            `[ZipProcessor] Failed to process archive entry #${index + 1} (${processor.name}, ${mimeType})`,
+            error
+          );
         }
       }
-      const output = this.formatOutput(filteredEntries, processedContents);
+      if (byteBudgetHit) {
+        truncated = true;
+        notes.push(
+          `[truncated: stopped reading the archive after ${Math.round(MAX_TOTAL_UNCOMPRESSED_BYTES / 1024 / 1024)} MB of decompressed content; later files were not extracted]`
+        );
+      }
+      const output = [this.formatOutput(filteredEntries, processedContents), ...notes].join("\n");
       return {
         extractedText: output,
         format: "markdown",
         metadata: {
           fileCount: filteredEntries.filter((e) => !e.isDirectory).length,
           directoryCount: filteredEntries.filter((e) => e.isDirectory).length,
-          processedFiles: processedContents.length
+          processedFiles: processedContents.length,
+          truncated
         }
       };
     } catch (error) {
@@ -21945,9 +22211,10 @@ var ProcessorRegistry = class {
    * @returns The matching processor, or null if none found
    */
   findProcessor(file) {
-    if (file.type) {
+    const mimeType = file.type?.split(";")[0].trim().toLowerCase();
+    if (mimeType) {
       for (const processor of this.processors.values()) {
-        if (processor.supportedMimeTypes.includes(file.type)) {
+        if (processor.supportedMimeTypes.includes(mimeType)) {
           return processor;
         }
       }
@@ -22014,9 +22281,55 @@ var ProcessorRegistry = class {
   }
 };
 
+// src/lib/processors/fileStatusNotes.ts
+var DEFAULT_MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024;
+function formatMegabytes(bytes) {
+  const mb = bytes / (1024 * 1024);
+  return `${Number.isInteger(mb) ? mb : mb.toFixed(1)} MB`;
+}
+function formatFileProcessingNotes(statuses, options = {}) {
+  const maxFileSizeBytes = options.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE_BYTES;
+  const why = {
+    too_large: `the file is larger than ${formatMegabytes(maxFileSizeBytes)}`,
+    unsupported_type: "its file type is not supported for reading",
+    no_data: "its contents were not available to the app",
+    empty: "no text or images could be extracted from it (it may be blank)",
+    timeout: "reading it took too long and was stopped",
+    error: "its text could not be extracted (it may be password-protected or damaged)"
+  };
+  const lines = statuses.filter((s) => s.status === "skipped" || s.status === "failed").map((s) => `[${s.fileName} could not be read: ${why[s.reason ?? "error"]}]`);
+  return lines.length > 0 ? lines.join("\n") : null;
+}
+
 // src/lib/processors/preprocessor.ts
 init_logger();
 var MAX_TOTAL_IMAGES = 20;
+var DEFAULT_MAX_EXTRACTED_CHARS_PER_FILE = 1e5;
+var DEFAULT_MAX_EXTRACTED_CHARS_TOTAL = 2e5;
+var ProcessingTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`Timed out processing file after ${timeoutMs}ms`);
+    this.name = "ProcessingTimeoutError";
+  }
+};
+function truncationMarker2(kept, total, fileName) {
+  return `
+[truncated: showing the first ${kept} of ${total} characters of ${fileName}]`;
+}
+function truncateText(text12, limit, fileName) {
+  if (text12.length <= limit) return { text: text12, truncated: false };
+  let end = Math.max(0, limit);
+  const code = text12.charCodeAt(end - 1);
+  if (end > 0 && code >= 55296 && code <= 56319) end--;
+  return {
+    text: `${text12.slice(0, end)}${truncationMarker2(end, text12.length, fileName)}`,
+    truncated: true
+  };
+}
+var FILE_SEPARATOR = "\n\n---\n\n";
+function isImageFile(file) {
+  return (file.type ?? "").trim().toLowerCase().startsWith("image/");
+}
 function createDefaultRegistry() {
   const registry2 = new ProcessorRegistry();
   registry2.register(new PdfProcessor());
@@ -22066,10 +22379,11 @@ async function preprocessFiles(files, options = {}) {
     processors = void 0,
     // undefined means use defaults
     keepOriginalFiles = true,
-    maxFileSizeBytes = 10 * 1024 * 1024,
-    // 10MB
+    maxFileSizeBytes = DEFAULT_MAX_FILE_SIZE_BYTES,
     timeoutMs = 3e4,
     // 30s per file
+    maxExtractedCharsPerFile = DEFAULT_MAX_EXTRACTED_CHARS_PER_FILE,
+    maxExtractedCharsTotal = DEFAULT_MAX_EXTRACTED_CHARS_TOTAL,
     onProgress,
     onError
   } = options;
@@ -22079,23 +22393,23 @@ async function preprocessFiles(files, options = {}) {
       extractedContent: null,
       originalFiles: files,
       preprocessedFileIds: [],
+      fileStatuses: [],
       metadata: { processedCount: 0, skippedCount: 0, errorCount: 0 }
     };
   }
-  if (processors !== void 0 && processors !== null && processors.length === 0) {
-    return {
-      extractedContent: null,
-      originalFiles: files,
-      preprocessedFileIds: [],
-      metadata: { processedCount: 0, skippedCount: 0, errorCount: 0 }
-    };
-  }
-  if (processors === null) {
+  if (processors === null || processors?.length === 0) {
+    const fileStatuses2 = files.filter((file) => !isImageFile(file)).map((file) => ({
+      fileId: file.id,
+      fileName: file.name,
+      status: "skipped",
+      reason: "unsupported_type"
+    }));
     return {
       extractedContent: null,
       originalFiles: files,
       preprocessedFileIds: [],
-      metadata: { processedCount: 0, skippedCount: 0, errorCount: 0 }
+      fileStatuses: fileStatuses2,
+      metadata: { processedCount: 0, skippedCount: fileStatuses2.length, errorCount: 0 }
     };
   }
   let registry2;
@@ -22113,28 +22427,38 @@ async function preprocessFiles(files, options = {}) {
   const extractedTexts = [];
   const allImageUrls = [];
   const preprocessedFileIds = [];
+  const fileStatuses = [];
   let processedCount = 0;
   let skippedCount = 0;
   let errorCount = 0;
+  let totalChars = 0;
+  const overBudgetFiles = [];
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
+    const label = `#${i + 1} (${file.type || "unknown type"}, ${file.size} bytes)`;
+    const skip = (reason) => {
+      skippedCount++;
+      fileStatuses.push({ fileId: file.id, fileName: file.name, status: "skipped", reason });
+    };
     onProgress?.(i + 1, files.length, file.name);
+    const processor = registry2.findProcessor(file);
+    if (!processor && isImageFile(file)) continue;
     if (file.size > maxFileSizeBytes) {
       logger.info(
-        `[preprocessFiles] Skipping "${file.name}" \u2014 exceeds ${maxFileSizeBytes} byte limit`
+        `[preprocessFiles] Skipping file ${label} \u2014 exceeds ${maxFileSizeBytes} byte limit`
       );
-      skippedCount++;
+      skip("too_large");
       continue;
     }
-    const processor = registry2.findProcessor(file);
     if (!processor) {
-      skippedCount++;
+      skip("unsupported_type");
       continue;
     }
+    let timer;
     try {
       if (!file.url) {
-        logger.info(`[preprocessFiles] Skipping "${file.name}" \u2014 no data URL available`);
-        skippedCount++;
+        logger.info(`[preprocessFiles] Skipping file ${label} \u2014 no data URL available`);
+        skip("no_data");
         continue;
       }
       const fileWithData = {
@@ -22143,40 +22467,76 @@ async function preprocessFiles(files, options = {}) {
       };
       const result = await Promise.race([
         processor.process(fileWithData),
-        new Promise(
-          (_, reject) => setTimeout(() => reject(new Error(`Timed out processing ${file.name}`)), timeoutMs)
-        )
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new ProcessingTimeoutError(timeoutMs)), timeoutMs);
+        })
       ]);
       if (result && result.extractedText.trim()) {
-        const formattedContent = formatExtractedContent(
-          file.name,
-          result.extractedText,
-          result.format
-        );
-        extractedTexts.push(formattedContent);
+        const separatorLength = extractedTexts.length > 0 ? FILE_SEPARATOR.length : 0;
+        const remaining = maxExtractedCharsTotal - totalChars - separatorLength - formatExtractedContent(file.name, "", result.format).length;
         preprocessedFileIds.push(file.id);
         processedCount++;
-        if (result.imageDataUrls && result.imageDataUrls.length > 0) {
-          const remaining = MAX_TOTAL_IMAGES - allImageUrls.length;
-          if (remaining > 0) {
-            allImageUrls.push(...result.imageDataUrls.slice(0, remaining));
-          }
+        const fullLength = result.extractedText.length;
+        if (fullLength > remaining && remaining - truncationMarker2(fullLength, fullLength, file.name).length <= 0) {
+          overBudgetFiles.push(file.name);
+          fileStatuses.push({ fileId: file.id, fileName: file.name, status: "truncated" });
+          continue;
         }
+        const images = result.imageDataUrls ?? [];
+        const keptImages = Math.min(
+          images.length,
+          Math.max(0, MAX_TOTAL_IMAGES - allImageUrls.length)
+        );
+        allImageUrls.push(...images.slice(0, keptImages));
+        const text12 = rewriteImageNote(result, file.name, keptImages);
+        const fitsWhole = text12.length <= Math.min(maxExtractedCharsPerFile, remaining);
+        const limit = fitsWhole ? text12.length : Math.min(
+          maxExtractedCharsPerFile,
+          remaining - truncationMarker2(text12.length, text12.length, file.name).length
+        );
+        const capped = truncateText(text12, Math.max(0, limit), file.name);
+        const formattedContent = formatExtractedContent(file.name, capped.text, result.format);
+        totalChars += separatorLength + formattedContent.length;
+        extractedTexts.push(formattedContent);
+        const truncated = capped.truncated || keptImages < images.length || result.metadata?.truncated === true;
+        fileStatuses.push({
+          fileId: file.id,
+          fileName: file.name,
+          status: truncated ? "truncated" : keptImages > 0 ? "rendered_as_images" : "extracted"
+        });
       } else {
-        skippedCount++;
+        skip("empty");
       }
     } catch (error) {
       errorCount++;
-      logger.error(`[preprocessFiles] Error processing "${file.name}":`, error);
+      const timedOut = error instanceof ProcessingTimeoutError;
+      fileStatuses.push({
+        fileId: file.id,
+        fileName: file.name,
+        status: "failed",
+        reason: timedOut ? "timeout" : "error"
+      });
+      logger.error(
+        `[preprocessFiles] Error processing file ${label} with ${processor.name}:`,
+        error
+      );
       onError?.(file.name, error instanceof Error ? error : new Error(String(error)));
+    } finally {
+      clearTimeout(timer);
     }
   }
-  const extractedContent = extractedTexts.length > 0 ? extractedTexts.join("\n\n---\n\n") : null;
+  if (overBudgetFiles.length > 0) {
+    extractedTexts.push(
+      `[truncated: the attachment text limit (${maxExtractedCharsTotal} characters) was reached; the contents of ${overBudgetFiles.join(", ")} were not included]`
+    );
+  }
+  const extractedContent = extractedTexts.length > 0 ? extractedTexts.join(FILE_SEPARATOR) : null;
   return {
     extractedContent,
     imageContentUrls: allImageUrls.length > 0 ? allImageUrls : void 0,
     originalFiles: keepOriginalFiles ? files : void 0,
     preprocessedFileIds,
+    fileStatuses,
     metadata: { processedCount, skippedCount, errorCount }
   };
 }
@@ -23533,7 +23893,7 @@ async function storedToLlmapiMessage(stored, encryptionKey, resolveMediaByIds) {
       } else if (encryptionKey && isOPFSSupported()) {
         try {
           const result = await readEncryptedFile(file.id, encryptionKey);
-          if (result) {
+          if (result && result.blob.type.startsWith("image/")) {
             const dataUri = await blobToDataUri(result.blob);
             imageParts.push({
               type: "image_url",
@@ -23706,6 +24066,7 @@ function useChatStorage(options) {
     minContentLength = DEFAULT_MIN_CONTENT_LENGTH,
     mcpR2Domain = MCP_R2_DOMAIN,
     preProcessors,
+    smoothing,
     piiRedaction,
     onPiiRedacted,
     nerDetector,
@@ -24253,6 +24614,7 @@ function useChatStorage(options) {
     onToolCallArgumentsDelta,
     apiType,
     preProcessors,
+    smoothing,
     piiRedaction: resolvedPiiRedaction,
     onPiiRedacted
   });
@@ -24474,7 +24836,8 @@ function useChatStorage(options) {
         conversationId: explicitConversationId,
         parentMessageId,
         assistantUniqueId,
-        piiRedaction: requestPiiRedaction
+        piiRedaction: requestPiiRedaction,
+        onFileProcessingResult
       } = args;
       const resolvePiiForCall = (conversationIdForCall) => {
         const { redactor, forInnerSend } = resolveCallPii(
@@ -24670,9 +25033,12 @@ function useChatStorage(options) {
       const contentForStorage = resolveStoredUserContent(storedUserContent, extracted.content);
       const filesForStorage = files ?? extracted.files;
       let fileContextForRequest;
+      let fileContextIsCurrentTurn = false;
       let preprocessedFileIds = [];
       let imageContentUrls;
+      let fileProcessingNotes = null;
       if (filesForStorage && filesForStorage.length > 0) {
+        let fileStatuses;
         try {
           const preprocessingResult = await preprocessFiles(filesForStorage, {
             processors: fileProcessors,
@@ -24680,16 +25046,27 @@ function useChatStorage(options) {
           });
           if (preprocessingResult.extractedContent) {
             fileContextForRequest = preprocessingResult.extractedContent;
+            fileContextIsCurrentTurn = true;
             preprocessedFileIds = preprocessingResult.preprocessedFileIds;
           }
           if (preprocessingResult.imageContentUrls?.length) {
             imageContentUrls = preprocessingResult.imageContentUrls;
           }
+          fileStatuses = preprocessingResult.fileStatuses;
         } catch (err) {
           getLogger().error(
             "[sendMessage] File preprocessing failed \u2014 continuing without file context:",
             err
           );
+          fileStatuses = filesForStorage.filter((f) => !(f.type ?? "").toLowerCase().startsWith("image/")).map((f) => ({ fileId: f.id, fileName: f.name, status: "failed", reason: "error" }));
+        }
+        fileProcessingNotes = formatFileProcessingNotes(fileStatuses, {
+          maxFileSizeBytes: fileProcessingOptions?.maxFileSizeBytes
+        });
+        try {
+          onFileProcessingResult?.(fileStatuses);
+        } catch (err) {
+          getLogger().warn("[sendMessage] onFileProcessingResult threw \u2014 ignoring:", err);
         }
       }
       let convId;
@@ -24863,7 +25240,11 @@ function useChatStorage(options) {
                 if (part.type === "text") return true;
                 if (part.type === "input_file" && part.file) {
                   const fileId = part.file.file_id;
-                  return !fileId || !preprocessedFileIds.includes(fileId);
+                  if (fileId) return !preprocessedFileIds.includes(fileId);
+                  const { file_data: fileData, file_url: fileUrl } = part.file;
+                  return !filesForStorage?.some(
+                    (f) => preprocessedFileIds.includes(f.id) && !!f.url && (f.url === fileData || f.url === fileUrl)
+                  );
                 }
                 if (part.type === "image_url" && part.image_url?.url) {
                   const matchesPreprocessed = filesForStorage?.some(
@@ -24898,6 +25279,13 @@ function useChatStorage(options) {
           };
         }
       }
+      const currentTurnFileText = [
+        fileContextIsCurrentTurn ? fileContextForRequest : void 0,
+        fileProcessingNotes
+      ].filter(Boolean).join("\n\n");
+      if (currentTurnFileText) {
+        messagesToSend = attachFileContextToLastUserMessage(messagesToSend, currentTurnFileText);
+      }
       let userFileIds = [];
       if (filesForStorage && filesForStorage.length > 0 && walletAddress && isEncryptionReady()) {
         userFileIds = await storeUserFilesInOPFS(filesForStorage, walletAddress, convId);
@@ -24908,7 +25296,11 @@ function useChatStorage(options) {
         content: contentForStorage,
         fileIds: userFileIds.length > 0 ? userFileIds : void 0,
         model,
-        // Store extracted file content in thinking field for retrieval in follow-up messages
+        // Store the file context — this turn's, or the one recalled from an earlier row — in the
+        // thinking field for retrieval in follow-up messages. Re-storing recalled context is the
+        // carry-forward: recall only scans the last `maxHistoryMessages` rows, so without it a
+        // file's text is lost once the turn that attached it scrolls out of the window. Failure
+        // notes are never stored: only `[Extracted content from …]` text, which recall keys on.
         thinking: fileContextForRequest,
         parentMessageId
       };
@@ -25066,7 +25458,7 @@ function useChatStorage(options) {
         headers,
         memoryContext,
         searchContext,
-        fileContext: fileContextForRequest,
+        fileContext: fileContextIsCurrentTurn ? void 0 : fileContextForRequest,
         toolGuidance: computeToolGuidance(
           filteredServerTools,
           filteredClientTools,
@@ -36339,8 +36731,10 @@ function renderAnumaJsx(jsx3) {
   appFileToStored,
   archiveVaultMemoryOp,
   assembleMemoryContext,
+  attachFileContextToLastUserMessage,
   backfillMemoryEntityUserIdsOp,
   backfillMemoryTopicsOp,
+  buildAttachedFilesText,
   capHopsForDensity,
   chatStorageMigrations,
   chatStorageSchema,
@@ -36446,6 +36840,7 @@ function renderAnumaJsx(jsx3) {
   findById,
   findMatchingTools,
   findParentOfId,
+  formatFileProcessingNotes,
   generateConversationId,
   generateEmbedding,
   generateEmbeddings,
@@ -36545,6 +36940,7 @@ function renderAnumaJsx(jsx3) {
   insertAfterId,
   insertChild,
   isAnumaTag,
+  isAttachedFilesText,
   isCalendarCallback,
   isDegradedTopicSkip,
   isDriveCallback,