@anuma/sdk 6.25.3 → 6.26.1

package/dist/server/index.cjs

@@ -15422,7 +15422,7 @@ var init_portalLlm = __esm({
     RESPONSE_FORMAT_OK = /* @__PURE__ */ new Set(["openai", "inclusionai", "deepseek"]);
     RESPONSE_SCHEMA_OK = /* @__PURE__ */ new Set(["openai"]);
     JSON_CONTRACT_REMINDER = "Output ONLY the strict JSON object requested. No prose, no explanation, no markdown.";
-    RESPONSES_ONLY_MODEL_PREFIXES = ["gpt-5.6"];
+    RESPONSES_ONLY_MODEL_PREFIXES = ["gpt-5.6", "gpt-6-sol", "gpt-6-luna", "gpt-6-astra"];
     CHAT_TO_RESPONSES_FIELDS = {
       max_completion_tokens: "max_output_tokens"
     };
@@ -16461,6 +16461,7 @@ __export(index_exports, {
   extractEntitiesForMemories: () => extractEntitiesForMemories,
   extractFacts: () => extractFacts,
   findMatchingTools: () => findMatchingTools,
+  formatFileProcessingNotes: () => formatFileProcessingNotes,
   generateConversationId: () => generateConversationId,
   generateEmbedding: () => generateEmbedding,
   generateEmbeddings: () => generateEmbeddings,
@@ -20216,6 +20217,15 @@ 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);
+}
+
 // src/lib/chat/useChat/strategies/types.ts
 function isChatCompletionResponse(r) {
   if (r.object === "response") return false;
@@ -33902,14 +33912,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");
@@ -33924,31 +33957,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) {
@@ -33977,6 +34030,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");
@@ -33987,46 +34043,126 @@ 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 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 };
+  });
 }
 
 // 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";
@@ -34035,43 +34171,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
+      }
+    };
   }
 };
 
@@ -34113,6 +34271,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";
@@ -34122,7 +34295,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;
       }
@@ -34145,7 +34318,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";
@@ -34203,6 +34376,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";
@@ -34237,14 +34416,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);
@@ -34258,9 +34458,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 = {
@@ -34270,23 +34481,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) {
@@ -34388,9 +34612,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;
         }
       }
@@ -34457,9 +34682,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 truncationMarker(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)}${truncationMarker(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 registry = new ProcessorRegistry();
   registry.register(new PdfProcessor());
@@ -34509,10 +34780,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;
@@ -34522,23 +34794,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 registry;
@@ -34556,28 +34828,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 = registry.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 = registry.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 = {
@@ -34586,40 +34868,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 - truncationMarker(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 - truncationMarker(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 }
   };
 }
@@ -36777,7 +37095,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 "";
 }
@@ -38452,6 +38770,7 @@ function buildSystemPrompt(ctx, options) {
   extractEntitiesForMemories,
   extractFacts,
   findMatchingTools,
+  formatFileProcessingNotes,
   generateConversationId,
   generateEmbedding,
   generateEmbeddings,