@lobehub/chat 1.136.13 → 1.137.1

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

@@ -1857,6 +1857,185 @@ describe('LobeOpenAICompatibleFactory', () => {
       });
     });
 
+    describe('tools parameter support', () => {
+      it('should handle tools parameter with multiple tools', async () => {
+        const mockResponse = {
+          choices: [
+            {
+              message: {
+                tool_calls: [
+                  {
+                    type: 'function' as const,
+                    function: {
+                      name: 'get_weather',
+                      arguments: '{"city":"Tokyo","unit":"celsius"}',
+                    },
+                  },
+                  {
+                    type: 'function' as const,
+                    function: {
+                      name: 'get_time',
+                      arguments: '{"timezone":"Asia/Tokyo"}',
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+        };
+
+        vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+
+        const payload = {
+          messages: [{ content: 'What is the weather and time in Tokyo?', role: 'user' as const }],
+          tools: [
+            {
+              name: 'get_weather',
+              description: 'Get weather information',
+              parameters: {
+                type: 'object' as const,
+                properties: {
+                  city: { type: 'string' },
+                  unit: { type: 'string' },
+                },
+                required: ['city'],
+              },
+            },
+            {
+              name: 'get_time',
+              description: 'Get current time',
+              parameters: {
+                type: 'object' as const,
+                properties: {
+                  timezone: { type: 'string' },
+                },
+                required: ['timezone'],
+              },
+            },
+          ],
+          model: 'gpt-4o',
+        };
+
+        const result = await instance.generateObject(payload);
+
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          {
+            messages: payload.messages,
+            model: payload.model,
+            tool_choice: 'required',
+            tools: [
+              {
+                type: 'function',
+                function: {
+                  name: 'get_weather',
+                  description: 'Get weather information',
+                  parameters: {
+                    type: 'object',
+                    properties: {
+                      city: { type: 'string' },
+                      unit: { type: 'string' },
+                    },
+                    required: ['city'],
+                  },
+                },
+              },
+              {
+                type: 'function',
+                function: {
+                  name: 'get_time',
+                  description: 'Get current time',
+                  parameters: {
+                    type: 'object',
+                    properties: {
+                      timezone: { type: 'string' },
+                    },
+                    required: ['timezone'],
+                  },
+                },
+              },
+            ],
+            user: undefined,
+          },
+          { headers: undefined, signal: undefined },
+        );
+
+        expect(result).toEqual([
+          { arguments: { city: 'Tokyo', unit: 'celsius' }, name: 'get_weather' },
+          { arguments: { timezone: 'Asia/Tokyo' }, name: 'get_time' },
+        ]);
+      });
+
+      it('should handle tools parameter with systemRole', async () => {
+        const mockResponse = {
+          choices: [
+            {
+              message: {
+                tool_calls: [
+                  {
+                    type: 'function' as const,
+                    function: {
+                      name: 'calculate',
+                      arguments: '{"result":8}',
+                    },
+                  },
+                ],
+              },
+            },
+          ],
+        };
+
+        vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+
+        const payload = {
+          messages: [{ content: 'Add 5 and 3', role: 'user' as const }],
+          tools: [
+            {
+              name: 'calculate',
+              description: 'Perform calculation',
+              parameters: {
+                type: 'object' as const,
+                properties: {
+                  result: { type: 'number' },
+                },
+                required: ['result'],
+              },
+            },
+          ],
+          systemRole: 'You are a helpful calculator',
+          model: 'gpt-4o',
+        };
+
+        const result = await instance.generateObject(payload);
+
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            messages: [
+              { content: 'Add 5 and 3', role: 'user' },
+              { content: 'You are a helpful calculator', role: 'system' },
+            ],
+          }),
+          expect.any(Object),
+        );
+
+        expect(result).toEqual([{ arguments: { result: 8 }, name: 'calculate' }]);
+      });
+
+      it('should throw error when neither tools nor schema is provided', async () => {
+        const payload = {
+          messages: [{ content: 'Generate data', role: 'user' as const }],
+          model: 'gpt-4o',
+        };
+
+        await expect(instance.generateObject(payload as any)).rejects.toThrow(
+          'tools or schema is required',
+        );
+      });
+    });
+
     describe('tool calling fallback', () => {
       let instanceWithToolCalling: any;
 
@@ -1930,7 +2109,9 @@ describe('LobeOpenAICompatibleFactory', () => {
           { headers: undefined, signal: undefined },
         );
 
-        expect(result).toEqual({ name: 'Alice', age: 28 });
+        expect(result).toEqual([
+          { arguments: { name: 'Alice', age: 28 }, name: 'person_extractor' },
+        ]);
       });
 
       it('should return undefined when no tool call found', async () => {
@@ -1960,7 +2141,7 @@ describe('LobeOpenAICompatibleFactory', () => {
 
         const result = await instanceWithToolCalling.generateObject(payload);
 
-        expect(consoleSpy).toHaveBeenCalledWith('No tool call found in response');
+        expect(consoleSpy).toHaveBeenCalledWith('parse tool call arguments error:', undefined);
         expect(result).toBeUndefined();
 
         consoleSpy.mockRestore();
@@ -2001,7 +2182,10 @@ describe('LobeOpenAICompatibleFactory', () => {
 
         const result = await instanceWithToolCalling.generateObject(payload);
 
-        expect(consoleSpy).toHaveBeenCalledWith('parse tool call arguments error:', 'invalid json');
+        expect(consoleSpy).toHaveBeenCalledWith(
+          'parse tool call arguments error:',
+          mockResponse.choices[0].message.tool_calls,
+        );
         expect(result).toBeUndefined();
 
         consoleSpy.mockRestore();
@@ -2052,7 +2236,7 @@ describe('LobeOpenAICompatibleFactory', () => {
           { headers: options.headers, signal: options.signal },
         );
 
-        expect(result).toEqual({ data: 'test' });
+        expect(result).toEqual([{ arguments: { data: 'test' }, name: 'data_extractor' }]);
       });
     });
   });

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

@@ -67,7 +67,7 @@ export interface CustomClientOptions<T extends Record<string, any> = any> {
   createClient?: (options: ConstructorOptions<T>) => any;
 }
 
-interface OpenAICompatibleFactoryOptions<T extends Record<string, any> = any> {
+export interface OpenAICompatibleFactoryOptions<T extends Record<string, any> = any> {
   apiKey?: string;
   baseURL?: string;
   chatCompletion?: {
@@ -396,7 +396,40 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
     }
 
     async generateObject(payload: GenerateObjectPayload, options?: GenerateObjectOptions) {
-      const { messages, schema, model, responseApi } = payload;
+      const { messages, schema, model, responseApi, tools, systemRole } = payload;
+
+      if (tools) {
+        const msgs = messages;
+
+        if (!!systemRole) {
+          msgs.push({ content: systemRole, role: 'system' });
+        }
+
+        const res = await this.client.chat.completions.create(
+          {
+            messages: msgs,
+            model,
+            tool_choice: 'required',
+            tools: tools.map((tool) => ({ function: tool, type: 'function' })),
+            user: options?.user,
+          },
+          { headers: options?.headers, signal: options?.signal },
+        );
+
+        const toolCalls = res.choices[0].message.tool_calls!;
+
+        try {
+          return toolCalls.map((item) => ({
+            arguments: JSON.parse(item.function.arguments),
+            name: item.function.name,
+          }));
+        } catch {
+          console.error('parse tool call arguments error:', res);
+          return undefined;
+        }
+      }
+
+      if (!schema) throw new Error('tools or schema is required');
 
       // Use tool calling fallback if configured
       if (generateObjectConfig?.useToolsCalling) {
@@ -421,17 +454,15 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
           { 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;
-        }
+        const toolCalls = res.choices[0].message.tool_calls!;
 
         try {
-          return JSON.parse(toolCall.function.arguments);
+          return toolCalls.map((item) => ({
+            arguments: JSON.parse(item.function.arguments),
+            name: item.function.name,
+          }));
         } catch {
-          console.error('parse tool call arguments error:', toolCall.function.arguments);
+          console.error('parse tool call arguments error:', toolCalls);
           return undefined;
         }
       }