@lobehub/chat 1.136.12 → 1.136.13

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

@@ -1,70 +1,61 @@
-import { DocxLoader as LangchainDocxLoader } from '@langchain/community/document_loaders/fs/docx';
 import debug from 'debug';
+import fs from 'node:fs/promises';
+import mammoth from 'mammoth';
 
 import type { DocumentPage, FileLoaderInterface } from '../../types';
 
 const log = debug('file-loaders:docx');
 
 /**
- * Loads Word documents (.docx) using the LangChain Community DocxLoader.
+ * Loads Word documents (.docx) using mammoth library.
+ * Extracts text content and basic metadata from DOCX files.
  */
 export class DocxLoader implements FileLoaderInterface {
   async loadPages(filePath: string): Promise<DocumentPage[]> {
     log('Loading DOCX file:', filePath);
     try {
-      let loader: LangchainDocxLoader;
-      if (filePath.endsWith('.doc')) {
-        loader = new LangchainDocxLoader(filePath, { type: 'doc' });
-      } else {
-        loader = new LangchainDocxLoader(filePath, { type: 'docx' });
-      }
-      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 || '';
-        const lines = pageContent.split('\n');
-        const lineCount = lines.length;
-        const charCount = pageContent.length;
+      // Read file as buffer
+      const buffer = await fs.readFile(filePath);
+      log('File buffer read, size:', buffer.length);
 
-        // Langchain DocxLoader doesn't usually provide page numbers in metadata
-        // We treat it as a single page
-        const metadata = {
-          ...doc.metadata, // Include any other metadata Langchain provides
-          pageNumber: 1,
-        };
+      // Extract text using mammoth
+      const result = await mammoth.extractRawText({ buffer });
+      const pageContent = result.value;
+      log('Text extracted, length:', pageContent.length);
 
-        // @ts-expect-error Remove source if present, as it's handled at the FileDocument level
-        delete metadata.source;
+      // Count lines and characters
+      const lines = pageContent.split('\n');
+      const lineCount = lines.length;
+      const charCount = pageContent.length;
 
-        log('DOCX document processed, lines:', lineCount, 'chars:', charCount);
+      log('DOCX document processed, lines:', lineCount, 'chars:', charCount);
 
-        return {
-          charCount,
-          lineCount,
-          metadata,
-          pageContent,
-        };
-      });
+      // Create single page with extracted content
+      const page: DocumentPage = {
+        charCount,
+        lineCount,
+        metadata: {
+          pageNumber: 1,
+        },
+        pageContent,
+      };
 
-      // 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,
-          metadata: { pageNumber: 1 },
-          pageContent: '',
-        });
+      // Handle warnings if any
+      if (result.messages.length > 0) {
+        const warnings = result.messages.filter((msg) => msg.type === 'warning');
+        if (warnings.length > 0) {
+          log('Extraction warnings:', warnings.length);
+          warnings.forEach((warning) => log('Warning:', warning.message));
+        }
       }
 
-      log('DOCX loading completed, total pages:', pages.length);
-      return pages;
+      log('DOCX loading completed');
+      return [page];
     } 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}`);
+      console.error(`Error loading DOCX file ${filePath}: ${error.message}`);
+
       const errorPage: DocumentPage = {
         charCount: 0,
         lineCount: 0,

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

@@ -1,4 +1,5 @@
 import { FileLoaderInterface, SupportedFileType } from '../types';
+import { DocLoader } from './doc';
 import { DocxLoader } from './docx';
 // import { EpubLoader } from './epub';
 import { ExcelLoader } from './excel';
@@ -10,6 +11,7 @@ import { TextLoader } from './text';
 // Key: file extension (lowercase, without leading dot) or specific type name
 // Value: Loader Class implementing FileLoaderInterface
 export const fileLoaders: Record<SupportedFileType, new () => FileLoaderInterface> = {
+  doc: DocLoader,
   docx: DocxLoader,
   // epub: EpubLoader,
   excel: ExcelLoader,

package/packages/file-loaders/src/types/word-extractor.d.ts

@@ -0,0 +1,9 @@
+declare module 'word-extractor' {
+  export default class WordExtractor {
+    extract(filePath: string): Promise<{
+      getBody: () => string;
+      getHeaders?: () => Record<string, string> | undefined;
+      text?: string;
+    }>;
+  }
+}

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

@@ -1,5 +1,5 @@
 // Define supported file types - consider using an enum or const assertion
-export type SupportedFileType = 'pdf' | 'docx' | 'txt' | 'excel' | 'pptx'; // | 'pptx' | 'latex' | 'epub' | 'code' | 'markdown';
+export type SupportedFileType = 'pdf' | 'doc' | 'docx' | 'txt' | 'excel' | 'pptx'; // | 'pptx' | 'latex' | 'epub' | 'code' | 'markdown';
 
 /**
  * 代表一个完整的已加载文件，包含文件级信息和其所有页面/块。

package/packages/model-runtime/src/core/openaiCompatibleFactory/index.test.ts

@@ -649,7 +649,6 @@ describe('LobeOpenAICompatibleFactory', () => {
       it('should return bizErrorType with the cause when OpenAI.APIError is thrown with cause', async () => {
         // Arrange
         const errorInfo = {
-          stack: 'abc',
           cause: {
             message: 'api is undefined',
           },
@@ -670,7 +669,6 @@ describe('LobeOpenAICompatibleFactory', () => {
             endpoint: defaultBaseURL,
             error: {
               cause: { message: 'api is undefined' },
-              stack: 'abc',
             },
             errorType: bizErrorType,
             provider,
@@ -681,7 +679,6 @@ describe('LobeOpenAICompatibleFactory', () => {
       it('should return bizErrorType with an cause response with desensitize Url', async () => {
         // Arrange
         const errorInfo = {
-          stack: 'abc',
           cause: { message: 'api is undefined' },
         };
         const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
@@ -706,7 +703,6 @@ describe('LobeOpenAICompatibleFactory', () => {
             endpoint: 'https://api.***.com/v1',
             error: {
               cause: { message: 'api is undefined' },
-              stack: 'abc',
             },
             errorType: bizErrorType,
             provider,
@@ -780,7 +776,6 @@ describe('LobeOpenAICompatibleFactory', () => {
               name: genericError.name,
               cause: genericError.cause,
               message: genericError.message,
-              stack: genericError.stack,
             },
           });
         }
@@ -1444,8 +1439,13 @@ describe('LobeOpenAICompatibleFactory', () => {
       const payload = {
         messages: [{ content: 'Generate a person object', role: 'user' as const }],
         schema: {
-          type: 'object',
-          properties: { name: { type: 'string' }, age: { type: 'number' } },
+          name: 'person_extractor',
+          description: 'Extract person information',
+          schema: {
+            type: 'object' as const,
+            properties: { name: { type: 'string' }, age: { type: 'number' } },
+          },
+          strict: true,
         },
         model: 'gpt-4o',
         responseApi: true,
@@ -1476,7 +1476,10 @@ describe('LobeOpenAICompatibleFactory', () => {
 
       const payload = {
         messages: [{ content: 'Generate status', role: 'user' as const }],
-        schema: { type: 'object', properties: { status: { type: 'string' } } },
+        schema: {
+          name: 'status_extractor',
+          schema: { type: 'object' as const, properties: { status: { type: 'string' } } },
+        },
         model: 'gpt-4o',
         responseApi: true,
       };
@@ -1513,7 +1516,10 @@ describe('LobeOpenAICompatibleFactory', () => {
 
       const payload = {
         messages: [{ content: 'Generate data', role: 'user' as const }],
-        schema: { type: 'object' },
+        schema: {
+          name: 'test_tool',
+          schema: { type: 'object' as const, properties: {} },
+        },
         model: 'gpt-4o',
         responseApi: true,
       };
@@ -1536,7 +1542,10 @@ describe('LobeOpenAICompatibleFactory', () => {
 
       const payload = {
         messages: [{ content: 'Generate data', role: 'user' as const }],
-        schema: { type: 'object' },
+        schema: {
+          name: 'test_tool',
+          schema: { type: 'object' as const, properties: {} },
+        },
         model: 'gpt-4o',
         responseApi: true,
       };
@@ -1560,22 +1569,25 @@ describe('LobeOpenAICompatibleFactory', () => {
       const payload = {
         messages: [{ content: 'Generate complex user data', role: 'user' as const }],
         schema: {
-          type: 'object',
-          properties: {
-            user: {
-              type: 'object',
-              properties: {
-                name: { type: 'string' },
-                profile: {
-                  type: 'object',
-                  properties: {
-                    age: { type: 'number' },
-                    preferences: { type: 'array', items: { type: 'string' } },
+          name: 'user_extractor',
+          schema: {
+            type: 'object' as const,
+            properties: {
+              user: {
+                type: 'object',
+                properties: {
+                  name: { type: 'string' },
+                  profile: {
+                    type: 'object',
+                    properties: {
+                      age: { type: 'number' },
+                      preferences: { type: 'array', items: { type: 'string' } },
+                    },
                   },
                 },
               },
+              metadata: { type: 'object' },
             },
-            metadata: { type: 'object' },
           },
         },
         model: 'gpt-4o',
@@ -1605,7 +1617,10 @@ describe('LobeOpenAICompatibleFactory', () => {
 
       const payload = {
         messages: [{ content: 'Generate data', role: 'user' as const }],
-        schema: { type: 'object' },
+        schema: {
+          name: 'test_tool',
+          schema: { type: 'object' as const, properties: {} },
+        },
         model: 'gpt-4o',
         responseApi: true,
       };
@@ -1634,8 +1649,11 @@ describe('LobeOpenAICompatibleFactory', () => {
         const payload = {
           messages: [{ content: 'Generate a person object', role: 'user' as const }],
           schema: {
-            type: 'object',
-            properties: { name: { type: 'string' }, age: { type: 'number' } },
+            name: 'person_extractor',
+            schema: {
+              type: 'object' as const,
+              properties: { name: { type: 'string' }, age: { type: 'number' } },
+            },
           },
           model: 'gpt-4o',
           // responseApi: false or undefined - uses chat completions API
@@ -1673,7 +1691,10 @@ describe('LobeOpenAICompatibleFactory', () => {
 
         const payload = {
           messages: [{ content: 'Generate status', role: 'user' as const }],
-          schema: { type: 'object', properties: { status: { type: 'string' } } },
+          schema: {
+            name: 'status_extractor',
+            schema: { type: 'object' as const, properties: { status: { type: 'string' } } },
+          },
           model: 'gpt-4o',
           responseApi: false,
         };
@@ -1717,7 +1738,10 @@ describe('LobeOpenAICompatibleFactory', () => {
 
         const payload = {
           messages: [{ content: 'Generate data', role: 'user' as const }],
-          schema: { type: 'object' },
+          schema: {
+            name: 'test_tool',
+            schema: { type: 'object' as const, properties: {} },
+          },
           model: 'gpt-4o',
           responseApi: false,
         };
@@ -1748,7 +1772,10 @@ describe('LobeOpenAICompatibleFactory', () => {
 
         const payload = {
           messages: [{ content: 'Generate data', role: 'user' as const }],
-          schema: { type: 'object' },
+          schema: {
+            name: 'test_tool',
+            schema: { type: 'object' as const, properties: {} },
+          },
           model: 'gpt-4o',
           responseApi: false,
         };
@@ -1780,19 +1807,22 @@ describe('LobeOpenAICompatibleFactory', () => {
         const payload = {
           messages: [{ content: 'Generate items list', role: 'user' as const }],
           schema: {
-            type: 'object',
-            properties: {
-              items: {
-                type: 'array',
+            name: 'abc',
+            schema: {
+              type: 'object' as const,
+              properties: {
                 items: {
-                  type: 'object',
-                  properties: {
-                    id: { type: 'number' },
-                    name: { type: 'string' },
+                  type: 'array',
+                  items: {
+                    type: 'object',
+                    properties: {
+                      id: { type: 'number' },
+                      name: { type: 'string' },
+                    },
                   },
                 },
+                total: { type: 'number' },
               },
-              total: { type: 'number' },
             },
           },
           model: 'gpt-4o',
@@ -1816,7 +1846,7 @@ describe('LobeOpenAICompatibleFactory', () => {
 
         const payload = {
           messages: [{ content: 'Generate data', role: 'user' as const }],
-          schema: { type: 'object' },
+          schema: { name: 'abc', schema: { type: 'object' } as any },
           model: 'gpt-4o',
           responseApi: false,
         };
@@ -1826,6 +1856,205 @@ describe('LobeOpenAICompatibleFactory', () => {
         );
       });
     });
+
+    describe('tool calling fallback', () => {
+      let instanceWithToolCalling: any;
+
+      beforeEach(() => {
+        const RuntimeClass = createOpenAICompatibleRuntime({
+          baseURL: 'https://api.test.com',
+          generateObject: {
+            useToolsCalling: true,
+          },
+          provider: 'test-provider',
+        });
+
+        instanceWithToolCalling = new RuntimeClass({ apiKey: 'test-key' });
+      });
+
+      it('should use tool calling when configured', async () => {
+        const mockResponse = {
+          choices: [
+            {
+              message: {
+                tool_calls: [
+                  {
+                    type: 'function' as const,
+                    function: {
+                      name: 'person_extractor',
+                      arguments: '{"name":"Alice","age":28}',
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+        };
+
+        vi.spyOn(instanceWithToolCalling['client'].chat.completions, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+
+        const payload = {
+          messages: [{ content: 'Extract person info', role: 'user' as const }],
+          schema: {
+            name: 'person_extractor',
+            description: 'Extract person information',
+            schema: {
+              type: 'object' as const,
+              properties: { name: { type: 'string' }, age: { type: 'number' } },
+            },
+          },
+          model: 'test-model',
+        };
+
+        const result = await instanceWithToolCalling.generateObject(payload);
+
+        expect(instanceWithToolCalling['client'].chat.completions.create).toHaveBeenCalledWith(
+          {
+            messages: payload.messages,
+            model: payload.model,
+            tools: [
+              {
+                type: 'function',
+                function: {
+                  name: 'person_extractor',
+                  description: 'Extract person information',
+                  parameters: payload.schema.schema,
+                },
+              },
+            ],
+            tool_choice: { type: 'function', function: { name: 'person_extractor' } },
+            user: undefined,
+          },
+          { headers: undefined, signal: undefined },
+        );
+
+        expect(result).toEqual({ name: 'Alice', age: 28 });
+      });
+
+      it('should return undefined when no tool call found', async () => {
+        const mockResponse = {
+          choices: [
+            {
+              message: {
+                content: 'Some text response',
+              },
+            },
+          ],
+        };
+
+        vi.spyOn(instanceWithToolCalling['client'].chat.completions, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+        const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+        const payload = {
+          messages: [{ content: 'Generate data', role: 'user' as const }],
+          schema: {
+            name: 'test_tool',
+            schema: { type: 'object' as const, properties: {} },
+          },
+          model: 'test-model',
+        };
+
+        const result = await instanceWithToolCalling.generateObject(payload);
+
+        expect(consoleSpy).toHaveBeenCalledWith('No tool call found in response');
+        expect(result).toBeUndefined();
+
+        consoleSpy.mockRestore();
+      });
+
+      it('should return undefined when tool call arguments parsing fails', async () => {
+        const mockResponse = {
+          choices: [
+            {
+              message: {
+                tool_calls: [
+                  {
+                    type: 'function' as const,
+                    function: {
+                      name: 'test_tool',
+                      arguments: 'invalid json',
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+        };
+
+        vi.spyOn(instanceWithToolCalling['client'].chat.completions, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+        const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+        const payload = {
+          messages: [{ content: 'Generate data', role: 'user' as const }],
+          schema: {
+            name: 'test_tool',
+            schema: { type: 'object' as const, properties: {} },
+          },
+          model: 'test-model',
+        };
+
+        const result = await instanceWithToolCalling.generateObject(payload);
+
+        expect(consoleSpy).toHaveBeenCalledWith('parse tool call arguments error:', 'invalid json');
+        expect(result).toBeUndefined();
+
+        consoleSpy.mockRestore();
+      });
+
+      it('should handle options correctly with tool calling', async () => {
+        const mockResponse = {
+          choices: [
+            {
+              message: {
+                tool_calls: [
+                  {
+                    type: 'function' as const,
+                    function: {
+                      name: 'data_extractor',
+                      arguments: '{"data":"test"}',
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+        };
+
+        vi.spyOn(instanceWithToolCalling['client'].chat.completions, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+
+        const payload = {
+          messages: [{ content: 'Extract data', role: 'user' as const }],
+          schema: {
+            name: 'data_extractor',
+            schema: { type: 'object' as const, properties: { data: { type: 'string' } } },
+          },
+          model: 'test-model',
+        };
+
+        const options = {
+          headers: { 'X-Custom': 'header' },
+          user: 'test-user',
+          signal: new AbortController().signal,
+        };
+
+        const result = await instanceWithToolCalling.generateObject(payload, options);
+
+        expect(instanceWithToolCalling['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.any(Object),
+          { headers: options.headers, signal: options.signal },
+        );
+
+        expect(result).toEqual({ data: 'test' });
+      });
+    });
   });
 
   describe('models', () => {

package/packages/model-runtime/src/core/openaiCompatibleFactory/index.ts

@@ -116,6 +116,12 @@ interface OpenAICompatibleFactoryOptions<T extends Record<string, any> = any> {
     bizError: ILobeAgentRuntimeErrorType;
     invalidAPIKey: ILobeAgentRuntimeErrorType;
   };
+  generateObject?: {
+    /**
+     * Use tool calling to simulate structured output for providers that don't support native structured output
+     */
+    useToolsCalling?: boolean;
+  };
   models?:
     | ((params: { client: OpenAI }) => Promise<ChatModelCard[]>)
     | {
@@ -142,6 +148,7 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
   customClient,
   responses,
   createImage: customCreateImage,
+  generateObject: generateObjectConfig,
 }: OpenAICompatibleFactoryOptions<T>) => {
   const ErrorType = {
     bizError: errorType?.bizError || AgentRuntimeErrorType.ProviderBizError,
@@ -391,6 +398,44 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
     async generateObject(payload: GenerateObjectPayload, options?: GenerateObjectOptions) {
       const { messages, schema, model, responseApi } = payload;
 
+      // Use tool calling fallback if configured
+      if (generateObjectConfig?.useToolsCalling) {
+        const tool: ChatCompletionTool = {
+          function: {
+            description:
+              schema.description || 'Generate structured output according to the provided schema',
+            name: schema.name || 'structured_output',
+            parameters: schema.schema,
+          },
+          type: 'function',
+        };
+
+        const res = await this.client.chat.completions.create(
+          {
+            messages,
+            model,
+            tool_choice: { function: { name: tool.function.name }, type: 'function' },
+            tools: [tool],
+            user: options?.user,
+          },
+          { headers: options?.headers, signal: options?.signal },
+        );
+
+        const toolCall = res.choices[0].message.tool_calls?.[0];
+
+        if (!toolCall || toolCall.type !== 'function') {
+          console.error('No tool call found in response');
+          return undefined;
+        }
+
+        try {
+          return JSON.parse(toolCall.function.arguments);
+        } catch {
+          console.error('parse tool call arguments error:', toolCall.function.arguments);
+          return undefined;
+        }
+      }
+
       if (responseApi) {
         const res = await this.client!.responses.create(
           {

package/packages/model-runtime/src/providerTestUtils.ts

@@ -160,7 +160,6 @@ export const testProvider = ({
             cause: {
               message: 'api is undefined',
             },
-            stack: 'abc',
           };
           const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
 
@@ -178,7 +177,6 @@ export const testProvider = ({
               endpoint: defaultBaseURL,
               error: {
                 cause: { message: 'api is undefined' },
-                stack: 'abc',
               },
               errorType: bizErrorType,
               provider,
@@ -190,7 +188,6 @@ export const testProvider = ({
           // Arrange
           const errorInfo = {
             cause: { message: 'api is undefined' },
-            stack: 'abc',
           };
           const apiError = new OpenAI.APIError(400, errorInfo, 'module error', {});
 
@@ -214,7 +211,6 @@ export const testProvider = ({
               endpoint: 'https://api.***.com/v1',
               error: {
                 cause: { message: 'api is undefined' },
-                stack: 'abc',
               },
               errorType: bizErrorType,
               provider,
@@ -265,7 +261,6 @@ export const testProvider = ({
                 cause: genericError.cause,
                 message: genericError.message,
                 name: genericError.name,
-                stack: genericError.stack,
               },
               errorType: 'AgentRuntimeError',
               provider,