@lobehub/chat 1.84.27 → 1.85.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 # Changelog
 
+## [Version 1.85.0](https://github.com/lobehub/lobe-chat/compare/v1.84.27...v1.85.0)
+
+<sup>Released on **2025-05-09**</sup>
+
+#### ✨ Features
+
+- **misc**: Support upload files direct into chat context.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### What's improved
+
+- **misc**: Support upload files direct into chat context, closes [#7751](https://github.com/lobehub/lobe-chat/issues/7751) ([39b790e](https://github.com/lobehub/lobe-chat/commit/39b790e))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ### [Version 1.84.27](https://github.com/lobehub/lobe-chat/compare/v1.84.26...v1.84.27)
 
 <sup>Released on **2025-05-09**</sup>

package/changelog/v1.json

@@ -1,4 +1,13 @@
 [
+  {
+    "children": {
+      "features": [
+        "Support upload files direct into chat context."
+      ]
+    },
+    "date": "2025-05-09",
+    "version": "1.85.0"
+  },
   {
     "children": {
       "improvements": [

package/docs/development/database-schema.dbml

@@ -115,6 +115,45 @@ table async_tasks {
   updated_at "timestamp with time zone" [not null, default: `now()`]
 }
 
+table document_chunks {
+  document_id varchar(30) [not null]
+  chunk_id uuid [not null]
+  page_index integer
+  user_id text [not null]
+  created_at "timestamp with time zone" [not null, default: `now()`]
+
+  indexes {
+    (document_id, chunk_id) [pk]
+  }
+}
+
+table documents {
+  id varchar(30) [pk, not null]
+  title text
+  content text
+  file_type varchar(255) [not null]
+  filename text
+  total_char_count integer [not null]
+  total_line_count integer [not null]
+  metadata jsonb
+  pages jsonb
+  source_type text [not null]
+  source text [not null]
+  file_id text
+  user_id text [not null]
+  client_id text
+  accessed_at "timestamp with time zone" [not null, default: `now()`]
+  created_at "timestamp with time zone" [not null, default: `now()`]
+  updated_at "timestamp with time zone" [not null, default: `now()`]
+
+  indexes {
+    source [name: 'documents_source_idx']
+    file_type [name: 'documents_file_type_idx']
+    file_id [name: 'documents_file_id_idx']
+    (client_id, user_id) [name: 'documents_client_id_user_id_unique', unique]
+  }
+}
+
 table files {
   id text [pk, not null]
   user_id text [not null]
@@ -670,6 +709,17 @@ table threads {
   }
 }
 
+table topic_documents {
+  document_id text [not null]
+  topic_id text [not null]
+  user_id text [not null]
+  created_at "timestamp with time zone" [not null, default: `now()`]
+
+  indexes {
+    (document_id, topic_id) [pk]
+  }
+}
+
 table topics {
   id text [pk, not null]
   title text
@@ -744,6 +794,10 @@ ref: agents_to_sessions.agent_id > agents.id
 
 ref: unstructured_chunks.file_id - files.id
 
+ref: document_chunks.document_id > documents.id
+
+ref: documents.file_id > files.id
+
 ref: files.embedding_task_id - async_tasks.id
 
 ref: messages.session_id - sessions.id
@@ -756,4 +810,8 @@ ref: threads.source_message_id - messages.id
 
 ref: sessions.group_id - session_groups.id
 
-ref: topics.session_id - sessions.id
+ref: topic_documents.document_id > documents.id
+
+ref: topic_documents.topic_id > topics.id
+
+ref: topics.session_id - sessions.id

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/chat",
-  "version": "1.84.27",
+  "version": "1.85.0",
   "description": "Lobe Chat - an open-source, high-performance chatbot framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",
@@ -143,6 +143,7 @@
     "@langchain/community": "^0.3.38",
     "@lobechat/electron-client-ipc": "workspace:*",
     "@lobechat/electron-server-ipc": "workspace:*",
+    "@lobechat/file-loaders": "workspace:*",
     "@lobechat/web-crawler": "workspace:*",
     "@lobehub/charts": "^2.0.0",
     "@lobehub/chat-plugin-sdk": "^1.32.4",

package/packages/file-loaders/package.json

@@ -20,6 +20,9 @@
   "author": "LobeHub <i@lobehub.com>",
   "sideEffects": false,
   "main": "./src/index.ts",
+  "scripts": {
+    "test": "vitest"
+  },
   "dependencies": {
     "@langchain/community": "^0.3.41",
     "@langchain/core": "^0.3.45",
@@ -27,13 +30,14 @@
     "concat-stream": "^2.0.0",
     "mammoth": "^1.8.0",
     "officeparser": "^5.1.1",
-    "pdfjs-dist": "4.8.69",
+    "pdfjs-dist": "4.10.38",
     "xlsx": "^0.18.5",
     "yauzl": "^3.2.0"
   },
   "devDependencies": {
     "@types/concat-stream": "^2.0.3",
     "@types/yauzl": "^2.10.3",
+    "canvas": "^3.1.0",
     "typescript": "^5"
   },
   "peerDependencies": {

package/packages/file-loaders/src/loadFile.ts

@@ -1,3 +1,4 @@
+import debug from 'debug';
 import { stat } from 'node:fs/promises';
 import * as path from 'node:path';
 
@@ -7,37 +8,52 @@ import { FileDocument, FileMetadata, SupportedFileType } from './types';
 import type { DocumentPage, FileLoaderInterface } from './types';
 import { isTextReadableFile } from './utils/isTextReadableFile';
 
+const log = debug('file-loaders:loadFile');
+
 /**
  * Determines the file type based on the filename extension.
  * @param filePath The path to the file.
  * @returns The determined file type or 'txt' if text-readable, undefined otherwise.
  */
 const getFileType = (filePath: string): SupportedFileType | undefined => {
+  log('Determining file type for:', filePath);
   const extension = path.extname(filePath).toLowerCase().replace('.', '');
 
-  if (!extension) return 'txt'; // Treat files without extension as text?
+  if (!extension) {
+    log('No extension found, treating as txt');
+    return 'txt'; // Treat files without extension as text?
+  }
 
   // Prioritize checking if it's a generally text-readable type
   if (isTextReadableFile(extension)) {
+    log(`Extension '${extension}' is text-readable, treating as txt`);
     return 'txt';
   }
 
   // Handle specific non-text or complex types
+  log(`Checking specific types for extension: '${extension}'`);
   switch (extension) {
     case 'pdf': {
+      log('File type identified as pdf');
       return 'pdf';
     }
     case 'docx': {
+      log('File type identified as docx');
       return 'docx';
     }
     case 'xlsx':
     case 'xls': {
+      log('File type identified as excel');
       return 'excel';
     }
     case 'pptx': {
+      log('File type identified as pptx');
       return 'pptx';
     }
     default: {
+      log(
+        `Extension '${extension}' is not a specifically handled type and not text-readable. Unsupported.`,
+      );
       // If not text-readable and not a specific known type, it's unsupported
       return undefined;
     }
@@ -59,18 +75,23 @@ export const loadFile = async (
   filePath: string,
   fileMetadata?: FileMetadata,
 ): Promise<FileDocument> => {
+  log('Starting to load file:', filePath, 'with metadata:', fileMetadata);
   let stats;
   let fsError: string | undefined;
 
   try {
+    log('Attempting to get file stats for:', filePath);
     stats = await stat(filePath);
+    log('Successfully retrieved file stats:', stats);
   } catch (e) {
     const error = e as Error;
+    log('Error getting file stats for %s: %s', filePath, error.message);
     console.error(`Error getting file stats for ${filePath}: ${error.message}`);
     fsError = `Failed to access file stats: ${error.message}`;
   }
 
   // Determine base file info from path and stats (if available)
+  log('Determining base file info');
   const fileExtension = path.extname(filePath).slice(1).toLowerCase();
   const baseFilename = path.basename(filePath);
 
@@ -80,13 +101,22 @@ export const loadFile = async (
   const fileType = fileMetadata?.fileType ?? fileExtension;
   const createdTime = fileMetadata?.createdTime ?? stats?.ctime ?? new Date();
   const modifiedTime = fileMetadata?.modifiedTime ?? stats?.mtime ?? new Date();
+  log('File info determined/overridden: %O', {
+    createdTime,
+    fileType,
+    filename,
+    modifiedTime,
+    source,
+  });
 
   const paserType = getFileType(filePath);
+  log('Parser type determined as:', paserType);
 
   // Select the loader CLASS based on the determined fileType, fallback to DefaultLoader
   const LoaderClass: new () => FileLoaderInterface = paserType
     ? fileLoaders[paserType]
     : DefaultLoader;
+  log('Selected loader class:', LoaderClass.name);
 
   if (!paserType) {
     console.warn(
@@ -102,17 +132,23 @@ export const loadFile = async (
   let loaderSpecificMetadata: any | undefined;
 
   // Instantiate the loader
+  log('Instantiating loader:', LoaderClass.name);
   const loaderInstance = new LoaderClass();
 
   // If we couldn't even get stats, skip loader execution
   if (!fsError) {
+    log('File stats available, proceeding with loader execution.');
     try {
       // 1. Load pages using the instance
+      log('Loading pages with loader:', LoaderClass.name, 'for file:', filePath);
       pages = await loaderInstance.loadPages(filePath);
+      log('Pages loaded successfully, count:', pages.length);
 
       try {
         // 2. Aggregate content using the instance
+        log('Aggregating content with loader:', LoaderClass.name);
         aggregatedContent = await loaderInstance.aggregateContent(pages);
+        log('Content aggregated successfully, length:', aggregatedContent.length);
       } catch (aggError) {
         const error = aggError as Error;
         console.error(
@@ -124,8 +160,10 @@ export const loadFile = async (
 
       // 3. Attach document-specific metadata if loader supports it
       if (typeof loaderInstance.attachDocumentMetadata === 'function') {
+        log('Loader supports attachDocumentMetadata. Attaching...');
         try {
           loaderSpecificMetadata = await loaderInstance.attachDocumentMetadata(filePath);
+          log('Document-specific metadata attached:', loaderSpecificMetadata);
         } catch (metaErr) {
           const error = metaErr as Error;
           console.error(
@@ -133,6 +171,8 @@ export const loadFile = async (
           );
           metadataError = `Metadata attachment failed: ${error.message}`;
         }
+      } else {
+        log('Loader does not support attachDocumentMetadata.');
       }
     } catch (loadErr) {
       const error = loadErr as Error;
@@ -152,6 +192,7 @@ export const loadFile = async (
       // Aggregated content remains empty
     }
   } else {
+    log('File stats access failed (fsError: %s). Creating minimal error page.', fsError);
     // If stats failed, create a minimal error page
     pages = [
       {
@@ -167,16 +208,20 @@ export const loadFile = async (
   // Calculate totals from the loaded pages
   let totalCharCount = 0;
   let totalLineCount = 0;
+  log('Calculating total char and line counts from pages.');
   for (const page of pages) {
     totalCharCount += page.charCount;
     totalLineCount += page.lineCount;
   }
+  log('Totals calculated:', { totalCharCount, totalLineCount });
 
   // Combine all potential errors
   const combinedError =
     [fsError, loaderError, aggregationError, metadataError].filter(Boolean).join('; ') || undefined;
+  if (combinedError) log('Combined errors:', combinedError);
 
   // Construct the final FileDocument
+  log('Constructing final FileDocument.');
   const fileDocument: FileDocument = {
     content: aggregatedContent, // Use content from aggregateContent
     createdTime,
@@ -202,5 +247,10 @@ export const loadFile = async (
     delete fileDocument.metadata.error;
   }
 
+  log('File loading process completed for:', filePath, 'Returning document:', {
+    fileType: fileDocument.fileType,
+    filename: fileDocument.filename,
+    pages: fileDocument.pages?.length,
+  });
   return fileDocument;
 };

package/packages/file-loaders/src/loaders/docx/index.ts

@@ -1,15 +1,21 @@
 import { DocxLoader as LangchainDocxLoader } from '@langchain/community/document_loaders/fs/docx';
+import debug from 'debug';
 
 import type { DocumentPage, FileLoaderInterface } from '../../types';
 
+const log = debug('file-loaders:docx');
+
 /**
  * Loads Word documents (.docx) using the LangChain Community DocxLoader.
  */
 export class DocxLoader implements FileLoaderInterface {
   async loadPages(filePath: string): Promise<DocumentPage[]> {
+    log('Loading DOCX file:', filePath);
     try {
       const loader = new LangchainDocxLoader(filePath);
+      log('LangChain DocxLoader created');
       const docs = await loader.load(); // Langchain DocxLoader typically loads the whole doc as one
+      log('DOCX document loaded, parts:', docs.length);
 
       const pages: DocumentPage[] = docs.map((doc) => {
         const pageContent = doc.pageContent || '';
@@ -27,6 +33,8 @@ export class DocxLoader implements FileLoaderInterface {
         // @ts-expect-error Remove source if present, as it's handled at the FileDocument level
         delete metadata.source;
 
+        log('DOCX document processed, lines:', lineCount, 'chars:', charCount);
+
         return {
           charCount,
           lineCount,
@@ -37,6 +45,7 @@ export class DocxLoader implements FileLoaderInterface {
 
       // If docs array is empty (e.g., empty file), create an empty page
       if (pages.length === 0) {
+        log('No content in DOCX document, creating empty page');
         pages.push({
           charCount: 0,
           lineCount: 0,
@@ -45,9 +54,11 @@ export class DocxLoader implements FileLoaderInterface {
         });
       }
 
+      log('DOCX loading completed, total pages:', pages.length);
       return pages;
     } catch (e) {
       const error = e as Error;
+      log('Error encountered while loading DOCX file');
       console.error(`Error loading DOCX file ${filePath} using LangChain loader: ${error.message}`);
       const errorPage: DocumentPage = {
         charCount: 0,
@@ -57,6 +68,7 @@ export class DocxLoader implements FileLoaderInterface {
         },
         pageContent: '',
       };
+      log('Created error page for failed DOCX loading');
       return [errorPage];
     }
   }
@@ -68,6 +80,9 @@ export class DocxLoader implements FileLoaderInterface {
    * @returns Aggregated content as a string.
    */
   async aggregateContent(pages: DocumentPage[]): Promise<string> {
-    return pages.map((page) => page.pageContent).join('\n\n');
+    log('Aggregating content from', pages.length, 'DOCX pages');
+    const result = pages.map((page) => page.pageContent).join('\n\n');
+    log('DOCX content aggregated successfully, length:', result.length);
+    return result;
   }
 }

package/packages/file-loaders/src/loaders/excel/index.ts

@@ -1,26 +1,34 @@
+import debug from 'debug';
 import { readFile } from 'node:fs/promises';
 import * as xlsx from 'xlsx';
 
 import type { DocumentPage, FileLoaderInterface } from '../../types';
 
+const log = debug('file-loaders:excel');
+
 /**
  * Converts sheet data (array of objects) to a Markdown table string.
  * Handles empty sheets and escapes pipe characters.
  */
 function sheetToMarkdownTable(jsonData: Record<string, any>[]): string {
+  log('Converting sheet data to Markdown table, rows:', jsonData?.length || 0);
   if (!jsonData || jsonData.length === 0) {
+    log('Sheet is empty, returning placeholder message');
     return '*Sheet is empty or contains no data.*';
   }
 
   // Ensure all rows have the same keys based on the first row, handle potentially sparse data
   const headers = Object.keys(jsonData[0] || {});
+  log('Sheet headers:', headers);
   if (headers.length === 0) {
+    log('Sheet has no headers, returning placeholder message');
     return '*Sheet has headers but no data.*';
   }
 
   const headerRow = `| ${headers.join(' | ')} |`;
   const separatorRow = `| ${headers.map(() => '---').join(' | ')} |`;
 
+  log('Building data rows for Markdown table');
   const dataRows = jsonData
     .map((row) => {
       const cells = headers.map((header) => {
@@ -34,7 +42,9 @@ function sheetToMarkdownTable(jsonData: Record<string, any>[]): string {
     })
     .join('\n');
 
-  return `${headerRow}\n${separatorRow}\n${dataRows}`;
+  const result = `${headerRow}\n${separatorRow}\n${dataRows}`;
+  log('Markdown table created, length:', result.length);
+  return result;
 }
 
 /**
@@ -43,13 +53,20 @@ function sheetToMarkdownTable(jsonData: Record<string, any>[]): string {
  */
 export class ExcelLoader implements FileLoaderInterface {
   async loadPages(filePath: string): Promise<DocumentPage[]> {
+    log('Loading Excel file:', filePath);
     const pages: DocumentPage[] = [];
     try {
       // Use readFile for async operation compatible with other loaders
+      log('Reading Excel file as buffer');
       const dataBuffer = await readFile(filePath);
+      log('Excel file read successfully, size:', dataBuffer.length, 'bytes');
+
+      log('Parsing Excel workbook');
       const workbook = xlsx.read(dataBuffer, { type: 'buffer' });
+      log('Excel workbook parsed successfully, sheets:', workbook.SheetNames.length);
 
       for (const sheetName of workbook.SheetNames) {
+        log(`Processing sheet: ${sheetName}`);
         const worksheet = workbook.Sheets[sheetName];
         // Use sheet_to_json to get array of objects for our custom markdown function
         const jsonData = xlsx.utils.sheet_to_json<Record<string, any>>(worksheet, {
@@ -57,6 +74,7 @@ export class ExcelLoader implements FileLoaderInterface {
           defval: '',
           raw: false, // Use empty string for blank cells
         });
+        log(`Sheet ${sheetName} converted to JSON, rows:`, jsonData.length);
 
         // Convert to markdown using YOUR helper function
         const tableMarkdown = sheetToMarkdownTable(jsonData);
@@ -64,6 +82,7 @@ export class ExcelLoader implements FileLoaderInterface {
         const lines = tableMarkdown.split('\n');
         const lineCount = lines.length;
         const charCount = tableMarkdown.length;
+        log(`Sheet ${sheetName} converted to Markdown, lines: ${lineCount}, chars: ${charCount}`);
 
         pages.push({
           // Trim whitespace
@@ -74,9 +93,11 @@ export class ExcelLoader implements FileLoaderInterface {
           },
           pageContent: tableMarkdown.trim(),
         });
+        log(`Added sheet ${sheetName} as page`);
       }
 
       if (pages.length === 0) {
+        log('Excel file contains no sheets, creating empty page with error');
         pages.push({
           charCount: 0,
           lineCount: 0,
@@ -87,9 +108,11 @@ export class ExcelLoader implements FileLoaderInterface {
         });
       }
 
+      log('Excel loading completed, total pages:', pages.length);
       return pages;
     } catch (e) {
       const error = e as Error;
+      log('Error encountered while loading Excel file');
       console.error(`Error loading Excel file ${filePath}: ${error.message}`);
       const errorPage: DocumentPage = {
         charCount: 0,
@@ -99,6 +122,7 @@ export class ExcelLoader implements FileLoaderInterface {
         },
         pageContent: '',
       };
+      log('Created error page for failed Excel loading');
       return [errorPage];
     }
   }
@@ -110,12 +134,16 @@ export class ExcelLoader implements FileLoaderInterface {
    * @returns Aggregated content as a string.
    */
   async aggregateContent(pages: DocumentPage[]): Promise<string> {
-    return pages
+    log('Aggregating content from', pages.length, 'Excel pages');
+    const result = pages
       .map((page) => {
         const sheetName = page.metadata.sheetName;
         const header = sheetName ? `## Sheet: ${sheetName}\n\n` : '';
         return header + page.pageContent;
       })
       .join('\n\n---\n\n'); // Separator between sheets
+
+    log('Excel content aggregated successfully, length:', result.length);
+    return result;
   }
 }

package/packages/file-loaders/src/loaders/pdf/__snapshots__/index.test.ts.snap

@@ -48,7 +48,7 @@ exports[`PdfLoader > should attach document metadata correctly 1`] = `
     "Title": "test",
   },
   "pdfMetadata": null,
-  "pdfVersion": "4.8.69",
+  "pdfVersion": "4.10.38",
 }
 `;