@memori.ai/memori-react 8.38.5 → 8.38.7

package/src/components/UploadButton/UploadButton.tsx

@@ -9,6 +9,7 @@ import UploadDocuments from './UploadDocuments/UploadDocuments';
 import UploadImages from './UploadImages/UploadImages';
 import { useTranslation } from 'react-i18next';
 import memoriApiClient from '@memori.ai/memori-api-client';
+import { officeNativeExtensions } from '../../helpers/constants';
 import Tooltip from '../ui/Tooltip';
 // Props interface
 interface UploadManagerProps {
@@ -108,6 +109,7 @@ const UploadButton: React.FC<UploadManagerProps> = ({
       '.csv',
       '.md',
       '.html',
+      ...officeNativeExtensions,
     ];
     const fileExt = `.${file.name.split('.').pop()?.toLowerCase()}`;
     return documentExtensions.includes(fileExt);
@@ -401,18 +403,29 @@ const UploadButton: React.FC<UploadManagerProps> = ({
     const processedDocuments = files.map(file => {
       const escapedFileName = escapeAttributeValue(file.name);
 
-      // Truncate only the content that gets inlined inside the message
-      // <document_attachment> tag. The full text is still available via
-      // textAssetUrl as an uploaded asset.
-      const inlinedContent =
-        file.content.length > effectivePerDocumentLimit
-          ? file.content.substring(0, effectivePerDocumentLimit) +
-            '\n\n[Content truncated due to size limits]'
-          : file.content;
+      let formattedContent: string;
 
-      const formattedContent = `<document_attachment filename="${escapedFileName}" type="${
-        file.mimeType
-      }">
+      if (!file.content) {
+        // Office native format: metadata-only attachment tag + asset link (no text body)
+        formattedContent = `<document_attachment filename="${escapedFileName}" type="${file.mimeType}">
+</document_attachment>
+
+<attachment_link>
+${file.textAssetUrl || ''}
+</attachment_link>`;
+      } else {
+        // Truncate only the content that gets inlined inside the message
+        // <document_attachment> tag. The full text is still available via
+        // textAssetUrl as an uploaded asset.
+        const inlinedContent =
+          file.content.length > effectivePerDocumentLimit
+            ? file.content.substring(0, effectivePerDocumentLimit) +
+              '\n\n[Content truncated due to size limits]'
+            : file.content;
+
+        formattedContent = `<document_attachment filename="${escapedFileName}" type="${
+          file.mimeType
+        }">
 
 ${inlinedContent}
 
@@ -421,6 +434,7 @@ ${inlinedContent}
 <attachment_link>
 ${file.textAssetUrl || ''}
 </attachment_link>`;
+      }
 
       return {
         name: file.name,
@@ -428,6 +442,7 @@ ${file.textAssetUrl || ''}
         content: formattedContent,
         type: 'document',
         mimeType: file.mimeType,
+        url: file.textAssetUrl,
       };
     });
 
@@ -446,6 +461,7 @@ ${file.textAssetUrl || ''}
       '.csv',
       '.md',
       '.html',
+      ...officeNativeExtensions,
     ];
     const MAX_FILE_SIZE = 15 * 1024 * 1024; // 15MB
 
@@ -562,7 +578,7 @@ ${file.textAssetUrl || ''}
       <input
         ref={unifiedInputRef}
         type="file"
-        accept=".jpg,.jpeg,.png,.pdf,.txt,.json,.xlsx,.csv,.md,.html"
+        accept={`.jpg,.jpeg,.png,.pdf,.txt,.json,.xlsx,.csv,.md,.html,${officeNativeExtensions.join(',')}`}
         multiple
         className="memori--upload-file-input"
         onChange={handleFileInputChange}

package/src/components/UploadButton/UploadDocuments/UploadDocuments.tsx

@@ -5,6 +5,8 @@ import { DocumentIcon } from '../../icons/Document';
 import Modal from '../../ui/Modal';
 import { useTranslation } from 'react-i18next';
 import memoriApiClient from '@memori.ai/memori-api-client';
+import { officeNativeExtensions } from '../../../helpers/constants';
+import { isOfficeNativeFilename } from '../../../helpers/utils';
 // Types
 type PreviewFile = {
   name: string;
@@ -235,17 +237,20 @@ const UploadDocuments: React.FC<UploadDocumentsProps> = ({
 
   const processDocumentFile = async (
     file: File
-  ): Promise<{ text: string | null }> => {
-    const fileExt = file.name.split('.').pop()?.toLowerCase() || '';
+  ): Promise<{ text: string | null; uploadAsOriginal?: boolean }> => {
+    if (isOfficeNativeFilename(file.name)) {
+      return { text: null, uploadAsOriginal: true };
+    }
 
+    const ext = file.name.split('.').pop()?.toLowerCase() || '';
     try {
       let text: string | null = null;
 
-      if (fileExt === 'pdf') {
+      if (ext === 'pdf') {
         text = await extractTextFromPDF(file);
-      } else if (['txt', 'md', 'json', 'csv', 'html'].includes(fileExt)) {
+      } else if (['txt', 'md', 'json', 'csv', 'html'].includes(ext)) {
         text = await file.text();
-      } else if (fileExt === 'xlsx') {
+      } else if (ext === 'xlsx') {
         text = await extractTextFromXLSX(file);
       }
 
@@ -295,7 +300,12 @@ const UploadDocuments: React.FC<UploadDocumentsProps> = ({
       throw new Error(response.resultMessage || 'Upload failed');
     }
 
-    return response.asset?.assetURL;
+    const assetURL = response.asset?.assetURL;
+    if (!assetURL) {
+      throw new Error('Upload failed: missing asset URL');
+    }
+
+    return assetURL;
   };
 
   const handleDocumentUpload = async (
@@ -360,9 +370,38 @@ const UploadDocuments: React.FC<UploadDocumentsProps> = ({
         const fileId = Math.random().toString(36).substr(2, 9);
 
         try {
-          const { text } = await processDocumentFile(file);
+          const { text, uploadAsOriginal } = await processDocumentFile(file);
+
+          if (uploadAsOriginal) {
+            // Office native format: upload the original file as asset, no text extraction
+            let assetUrl: string | undefined;
+            try {
+              assetUrl = await uploadAssetFile(file);
+            } catch (uploadError) {
+              console.error('Office asset upload failed:', uploadError);
+              onDocumentError?.({
+                message: t('upload.officeAssetUploadFailed', {
+                  fileName: file.name,
+                  defaultValue: `"${file.name}" could not be uploaded and was not added.`,
+                }),
+                severity: 'error',
+              });
+            }
 
-          if (text) {
+            if (!assetUrl) {
+              activeCount--;
+              onLoadingChange?.(true, activeCount);
+              continue;
+            }
+
+            processedFiles.push({
+              name: file.name,
+              id: fileId,
+              content: '',
+              mimeType: file.type,
+              textAssetUrl: assetUrl,
+            });
+          } else if (text) {
             const baseName = file.name.replace(/\.[^/.]+$/, '') || file.name;
             const textFile = new File([text], `${baseName}.txt`, {
               type: 'text/plain',
@@ -429,7 +468,7 @@ const UploadDocuments: React.FC<UploadDocumentsProps> = ({
       <input
         ref={documentInputRef}
         type="file"
-        accept=".pdf,.txt,.md,.json,.xlsx,.csv,.html"
+        accept={`.pdf,.txt,.md,.json,.xlsx,.csv,.html,${officeNativeExtensions.join(',')}`}
         multiple
         className="memori--upload-file-input"
         onChange={handleDocumentUpload}

package/src/components/UploadButton/__snapshots__/UploadButton.test.tsx.snap

@@ -6,7 +6,7 @@ exports[`renders UploadButton unchanged 1`] = `
     class="memori--unified-upload-wrapper"
   >
     <input
-      accept=".jpg,.jpeg,.png,.pdf,.txt,.json,.xlsx,.csv,.md,.html"
+      accept=".jpg,.jpeg,.png,.pdf,.txt,.json,.xlsx,.csv,.md,.html,.doc,.docx,.xls,.xltx,.potx"
       class="memori--upload-file-input"
       multiple=""
       style="display: none;"
@@ -52,7 +52,7 @@ exports[`renders UploadButton unchanged 1`] = `
         class="memori--document-upload-wrapper"
       >
         <input
-          accept=".pdf,.txt,.md,.json,.xlsx,.csv,.html"
+          accept=".pdf,.txt,.md,.json,.xlsx,.csv,.html,.doc,.docx,.xls,.xltx,.potx"
           class="memori--upload-file-input"
           multiple=""
           type="file"

package/src/helpers/constants.ts

@@ -35,7 +35,7 @@ export const getGroupedChatLanguages = () => {
     popularLanguageCodes.includes(lang.value)
   );
   const all = chatLanguages.filter(lang => !popularLanguageCodes.includes(lang.value));
-  return {  
+  return {
     popular,
     all,
   };
@@ -43,6 +43,15 @@ export const getGroupedChatLanguages = () => {
 
 export const uiLanguages = ['en', 'it', 'fr', 'es', 'de'];
 
+/** Extensions uploaded as original Office binaries (no text extraction) */
+export const officeNativeExtensions = [
+  '.doc',
+  '.docx',
+  '.xls',
+  '.xltx',
+  '.potx',
+] as const;
+
 export const allowedMediaTypes = [
   'image/jpeg',
   'image/png',
@@ -62,6 +71,25 @@ export const allowedMediaTypes = [
   'model/gltf-binary',
 ];
 
+/** Short badge labels for Office document cards */
+export const officeMimeShortLabels: Record<string, string> = {
+  'application/msword': 'Word',
+  'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'Word',
+  'application/vnd.ms-excel': 'Excel',
+  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'Excel',
+  'application/vnd.openxmlformats-officedocument.spreadsheetml.template': 'Excel',
+  'application/vnd.openxmlformats-officedocument.presentationml.template': 'PPT',
+};
+
+export const officeExtensionShortLabels: Record<string, string> = {
+  DOC: 'Word',
+  DOCX: 'Word',
+  XLS: 'Excel',
+  XLSX: 'Excel',
+  XLTX: 'Excel',
+  POTX: 'PPT',
+};
+
 export const anonTag = '👤';
 
 export const prismSyntaxLangs = [

package/src/helpers/utils.test.ts

@@ -4,6 +4,11 @@ import {
   stripMarkdown,
   stripOutputTags,
   escapeHTML,
+  extractAttachmentLinks,
+  extractAttachmentLink,
+  isAssetOnlyDocumentAttachment,
+  isOfficeNativeFilename,
+  parseDocumentAttachmentsFromMessage,
 } from './utils';
 
 describe('Utils/difference', () => {
@@ -141,6 +146,114 @@ describe('utils/stripOutputTags', () => {
   });
 });
 
+describe('utils/attachment helpers', () => {
+  it('extracts multiple attachment links in order', () => {
+    const input = [
+      '<document_attachment filename="a.docx" type="application/vnd.openxmlformats-officedocument.wordprocessingml.document">',
+      '</document_attachment>',
+      '<attachment_link>',
+      'https://assets.example.com/a.docx',
+      '</attachment_link>',
+      '<document_attachment filename="b.pdf" type="application/pdf">',
+      'pdf text',
+      '</document_attachment>',
+      '<attachment_link>https://assets.example.com/b.txt</attachment_link>',
+    ].join('\n');
+
+    expect(extractAttachmentLinks(input)).toEqual([
+      'https://assets.example.com/a.docx',
+      'https://assets.example.com/b.txt',
+    ]);
+  });
+
+  it('extracts a single attachment link', () => {
+    const input =
+      '<attachment_link>\nhttps://assets.example.com/file.docx\n</attachment_link>';
+    expect(extractAttachmentLink(input)).toBe(
+      'https://assets.example.com/file.docx'
+    );
+  });
+
+  it('detects office native filenames', () => {
+    expect(isOfficeNativeFilename('report.doc')).toBe(true);
+    expect(isOfficeNativeFilename('report.docx')).toBe(true);
+    expect(isOfficeNativeFilename('budget.xls')).toBe(true);
+    expect(isOfficeNativeFilename('template.XLTX')).toBe(true);
+    expect(isOfficeNativeFilename('slides.potx')).toBe(true);
+    expect(isOfficeNativeFilename('notes.pdf')).toBe(false);
+    expect(isOfficeNativeFilename('data.xlsx')).toBe(false);
+  });
+
+  it('detects asset-only document attachments', () => {
+    expect(
+      isAssetOnlyDocumentAttachment({
+        title: 'report.docx',
+        content: '',
+        url: 'https://assets.example.com/file.docx',
+      })
+    ).toBe(true);
+    expect(
+      isAssetOnlyDocumentAttachment({
+        title: 'report.docx',
+        content: [
+          '<document_attachment filename="report.docx" type="application/vnd.openxmlformats-officedocument.wordprocessingml.document">',
+          '</document_attachment>',
+          '<attachment_link>https://assets.example.com/file.docx</attachment_link>',
+        ].join('\n'),
+        url: '',
+      })
+    ).toBe(true);
+    expect(
+      isAssetOnlyDocumentAttachment({
+        content: 'extracted text',
+        url: 'https://assets.example.com/file.txt',
+      })
+    ).toBe(false);
+  });
+
+  it('pairs each document attachment with its adjacent link', () => {
+    const input = [
+      '<attachment_link>https://assets.example.com/orphan.txt</attachment_link>',
+      '<document_attachment filename="a.docx" type="application/vnd.openxmlformats-officedocument.wordprocessingml.document">',
+      '</document_attachment>',
+      '<attachment_link>https://assets.example.com/a.docx</attachment_link>',
+      '<document_attachment filename="b.pdf" type="application/pdf">',
+      'pdf text',
+      '</document_attachment>',
+      '<attachment_link>https://assets.example.com/b.txt</attachment_link>',
+    ].join('\n');
+
+    expect(parseDocumentAttachmentsFromMessage(input)).toEqual([
+      {
+        filename: 'a.docx',
+        type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        content: '',
+        url: 'https://assets.example.com/a.docx',
+      },
+      {
+        filename: 'b.pdf',
+        type: 'application/pdf',
+        content: 'pdf text',
+        url: 'https://assets.example.com/b.txt',
+      },
+    ]);
+  });
+
+  it('returns an empty url when no adjacent attachment link exists', () => {
+    const input =
+      '<document_attachment filename="a.docx" type="application/vnd.openxmlformats-officedocument.wordprocessingml.document"></document_attachment>';
+
+    expect(parseDocumentAttachmentsFromMessage(input)).toEqual([
+      {
+        filename: 'a.docx',
+        type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        content: '',
+        url: '',
+      },
+    ]);
+  });
+});
+
 describe('utils/parsing combined', () => {
   it('should remove output tag from real message', () => {
     const result = escapeHTML(

package/src/helpers/utils.ts

@@ -1,6 +1,7 @@
 import { useState, useEffect, useRef, useMemo } from 'react';
 import { Material, MeshStandardMaterial, SkinnedMesh } from 'three';
 import * as THREE from 'three';
+import { officeNativeExtensions } from './constants';
 
 export const hasTouchscreen = (): boolean => {
   let hasTouchScreen = false;
@@ -237,6 +238,67 @@ export const stripMarkdown = (text: string) => {
   return text;
 };
 
+export const OFFICE_NATIVE_EXTENSIONS = officeNativeExtensions;
+
+export const isOfficeNativeFilename = (filename: string): boolean => {
+  const ext = `.${filename.split('.').pop()?.toLowerCase() || ''}`;
+  return (officeNativeExtensions as readonly string[]).includes(ext);
+};
+
+export type ParsedDocumentAttachment = {
+  filename: string;
+  type: string;
+  content: string;
+  url: string;
+};
+
+const DOCUMENT_ATTACHMENT_REGEX =
+  /<document_attachment filename="([^"]+)" type="([^"]+)">([\s\S]*?)<\/document_attachment>/g;
+
+const ATTACHMENT_LINK_AFTER_REGEX =
+  /<attachment_link>\s*([\s\S]*?)\s*<\/attachment_link>/;
+
+export const parseDocumentAttachmentsFromMessage = (
+  text: string
+): ParsedDocumentAttachment[] => {
+  if (!text) return [];
+
+  const attachments: ParsedDocumentAttachment[] = [];
+  const regex = new RegExp(DOCUMENT_ATTACHMENT_REGEX.source, 'g');
+  let match;
+
+  while ((match = regex.exec(text)) !== null) {
+    const [, filename, type, content] = match;
+    const afterTag = text.slice(match.index + match[0].length);
+    const linkMatch = afterTag.match(ATTACHMENT_LINK_AFTER_REGEX);
+    const rawUrl = linkMatch?.[1]?.trim() || '';
+    const url = /^https?:\/\//.test(rawUrl) ? rawUrl : '';
+
+    attachments.push({
+      filename,
+      type,
+      content: content.trim(),
+      url,
+    });
+  }
+
+  return attachments;
+};
+
+export const extractAttachmentLinks = (content: string): string[] => {
+  return parseDocumentAttachmentsFromMessage(content).map(
+    attachment => attachment.url
+  );
+};
+
+export const extractAttachmentLink = (content: string): string | null => {
+  const match = content?.match(
+    /<attachment_link>\s*([\s\S]*?)\s*<\/attachment_link>/
+  );
+  const rawUrl = match?.[1]?.trim() || '';
+  return /^https?:\/\//.test(rawUrl) ? rawUrl : null;
+};
+
 export const stripDocumentAttachmentTags = (text: string): string => {
   const documentAttachmentTagRegex = /<document_attachment filename="([^"]+)" type="([^"]+)">([\s\S]*?)<\/document_attachment>/g;
   return text
@@ -245,6 +307,36 @@ export const stripDocumentAttachmentTags = (text: string): string => {
     .replace(/<attachment_link>\s*[\s\S]*?\s*<\/attachment_link>/g, '');
 };
 
+export const getDocumentAttachmentAssetUrl = (attachment: {
+  content?: string | null;
+  url?: string | null;
+}): string =>
+  attachment.url?.trim() ||
+  extractAttachmentLink(attachment.content || '') ||
+  '';
+
+export const isAssetOnlyDocumentAttachment = (attachment: {
+  title?: string;
+  name?: string;
+  content?: string | null;
+  url?: string | null;
+}): boolean => {
+  const filename = attachment.title || attachment.name || '';
+  const assetUrl = getDocumentAttachmentAssetUrl(attachment);
+
+  if (!assetUrl) return false;
+
+  if (isOfficeNativeFilename(filename)) {
+    return true;
+  }
+
+  const strippedContent = attachment.content
+    ? stripDocumentAttachmentTags(attachment.content).trim()
+    : '';
+
+  return !strippedContent;
+};
+
 export const stripOutputTags = (text: string): string => {
   const outputTagRegex = /<output.*?<\/output>/gs;
 

package/src/version.ts

@@ -1,2 +1,2 @@
 // This file is auto-generated. Do not edit manually.
-export const version = '8.38.5';
+export const version = '8.38.7';