@lobehub/chat 1.138.3 → 1.138.5

package/packages/model-runtime/src/providers/anthropic/generateObject.test.ts

@@ -28,9 +28,9 @@ describe('Anthropic generateObject', () => {
           create: vi.fn().mockResolvedValue({
             content: [
               {
-                type: 'tool_use',
+                input: { age: 30, name: 'John' },
                 name: 'person_extractor',
-                input: { name: 'John', age: 30 },
+                type: 'tool_use',
               },
             ],
           }),
@@ -39,48 +39,48 @@ describe('Anthropic generateObject', () => {
 
       const payload = {
         messages: [{ content: 'Generate a person object', role: 'user' as const }],
+        model: 'claude-3-5-sonnet-20241022',
         schema: {
-          name: 'person_extractor',
           description: 'Extract person information',
+          name: 'person_extractor',
           schema: {
-            type: 'object' as const,
-            properties: { name: { type: 'string' }, age: { type: 'number' } },
+            properties: { age: { type: 'number' }, name: { type: 'string' } },
             required: ['name', 'age'],
+            type: 'object' as const,
           },
         },
-        model: 'claude-3-5-sonnet-20241022',
       };
 
       const result = await createAnthropicGenerateObject(mockClient as any, payload);
 
       expect(mockClient.messages.create).toHaveBeenCalledWith(
         expect.objectContaining({
-          model: 'claude-3-5-sonnet-20241022',
           max_tokens: 8192,
           messages: [{ content: 'Generate a person object', role: 'user' }],
+          model: 'claude-3-5-sonnet-20241022',
+          tool_choice: {
+            name: 'person_extractor',
+            type: 'tool',
+          },
           tools: [
             {
-              name: 'person_extractor',
               description: 'Extract person information',
               input_schema: {
-                type: 'object',
                 properties: {
-                  name: { type: 'string' },
                   age: { type: 'number' },
+                  name: { type: 'string' },
                 },
                 required: ['name', 'age'],
+                type: 'object',
               },
+              name: 'person_extractor',
             },
           ],
-          tool_choice: {
-            type: 'tool',
-            name: 'person_extractor',
-          },
         }),
         expect.objectContaining({}),
       );
 
-      expect(result).toEqual({ name: 'John', age: 30 });
+      expect(result).toEqual({ age: 30, name: 'John' });
     });
 
     it('should handle system messages correctly', async () => {
@@ -89,9 +89,9 @@ describe('Anthropic generateObject', () => {
           create: vi.fn().mockResolvedValue({
             content: [
               {
-                type: 'tool_use',
-                name: 'status_extractor',
                 input: { status: 'success' },
+                name: 'status_extractor',
+                type: 'tool_use',
               },
             ],
           }),
@@ -103,19 +103,19 @@ describe('Anthropic generateObject', () => {
           { content: 'You are a helpful assistant', role: 'system' as const },
           { content: 'Generate status', role: 'user' as const },
         ],
+        model: 'claude-3-5-sonnet-20241022',
         schema: {
           name: 'status_extractor',
-          schema: { type: 'object' as const, properties: { status: { type: 'string' } } },
+          schema: { properties: { status: { type: 'string' } }, type: 'object' as const },
         },
-        model: 'claude-3-5-sonnet-20241022',
       };
 
       const result = await createAnthropicGenerateObject(mockClient as any, payload);
 
       expect(mockClient.messages.create).toHaveBeenCalledWith(
         expect.objectContaining({
-          system: [{ text: 'You are a helpful assistant', type: 'text' }],
           messages: expect.any(Array),
+          system: [{ text: 'You are a helpful assistant', type: 'text' }],
         }),
         expect.any(Object),
       );
@@ -129,9 +129,9 @@ describe('Anthropic generateObject', () => {
           create: vi.fn().mockResolvedValue({
             content: [
               {
-                type: 'tool_use',
-                name: 'data_extractor',
                 input: { data: 'test' },
+                name: 'data_extractor',
+                type: 'tool_use',
               },
             ],
           }),
@@ -140,11 +140,11 @@ describe('Anthropic generateObject', () => {
 
       const payload = {
         messages: [{ content: 'Generate data', role: 'user' as const }],
+        model: 'claude-3-5-sonnet-20241022',
         schema: {
           name: 'data_extractor',
-          schema: { type: 'object' as const, properties: { data: { type: 'string' } } },
+          schema: { properties: { data: { type: 'string' } }, type: 'object' as const },
         },
-        model: 'claude-3-5-sonnet-20241022',
       };
 
       const options = {
@@ -169,8 +169,8 @@ describe('Anthropic generateObject', () => {
           create: vi.fn().mockResolvedValue({
             content: [
               {
-                type: 'text',
                 text: 'Some text response without tool use',
+                type: 'text',
               },
             ],
           }),
@@ -179,11 +179,11 @@ describe('Anthropic generateObject', () => {
 
       const payload = {
         messages: [{ content: 'Generate data', role: 'user' as const }],
+        model: 'claude-3-5-sonnet-20241022',
         schema: {
           name: 'test_tool',
           schema: { type: 'object' },
         },
-        model: 'claude-3-5-sonnet-20241022',
       };
 
       const result = await createAnthropicGenerateObject(mockClient as any, payload as any);
@@ -197,9 +197,10 @@ describe('Anthropic generateObject', () => {
           create: vi.fn().mockResolvedValue({
             content: [
               {
-                type: 'tool_use',
-                name: 'user_extractor',
                 input: {
+                  metadata: {
+                    created: '2024-01-01',
+                  },
                   user: {
                     name: 'Alice',
                     profile: {
@@ -207,10 +208,9 @@ describe('Anthropic generateObject', () => {
                       preferences: ['music', 'sports'],
                     },
                   },
-                  metadata: {
-                    created: '2024-01-01',
-                  },
                 },
+                name: 'user_extractor',
+                type: 'tool_use',
               },
             ],
           }),
@@ -219,35 +219,38 @@ describe('Anthropic generateObject', () => {
 
       const payload = {
         messages: [{ content: 'Generate complex user data', role: 'user' as const }],
+        model: 'claude-3-5-sonnet-20241022',
         schema: {
-          name: 'user_extractor',
           description: 'Extract complex user information',
+          name: 'user_extractor',
           schema: {
-            type: 'object' as const,
             properties: {
+              metadata: { type: 'object' },
               user: {
-                type: 'object',
                 properties: {
                   name: { type: 'string' },
                   profile: {
-                    type: 'object',
                     properties: {
                       age: { type: 'number' },
-                      preferences: { type: 'array', items: { type: 'string' } },
+                      preferences: { items: { type: 'string' }, type: 'array' },
                     },
+                    type: 'object',
                   },
                 },
+                type: 'object',
               },
-              metadata: { type: 'object' },
             },
+            type: 'object' as const,
           },
         },
-        model: 'claude-3-5-sonnet-20241022',
       };
 
       const result = await createAnthropicGenerateObject(mockClient as any, payload);
 
       expect(result).toEqual({
+        metadata: {
+          created: '2024-01-01',
+        },
         user: {
           name: 'Alice',
           profile: {
@@ -255,9 +258,6 @@ describe('Anthropic generateObject', () => {
             preferences: ['music', 'sports'],
           },
         },
-        metadata: {
-          created: '2024-01-01',
-        },
       });
     });
   });
@@ -269,14 +269,14 @@ describe('Anthropic generateObject', () => {
           create: vi.fn().mockResolvedValue({
             content: [
               {
-                type: 'tool_use',
-                name: 'get_weather',
                 input: { city: 'New York', unit: 'celsius' },
+                name: 'get_weather',
+                type: 'tool_use',
               },
               {
-                type: 'tool_use',
-                name: 'get_time',
                 input: { timezone: 'America/New_York' },
+                name: 'get_time',
+                type: 'tool_use',
               },
             ],
           }),
@@ -285,69 +285,75 @@ describe('Anthropic generateObject', () => {
 
       const payload = {
         messages: [{ content: 'What is the weather and time in New York?', role: 'user' as const }],
+        model: 'claude-3-5-sonnet-20241022',
         tools: [
           {
-            name: 'get_weather',
-            description: 'Get weather information',
-            parameters: {
-              type: 'object' as const,
-              properties: {
-                city: { type: 'string' },
-                unit: { type: 'string' },
+            function: {
+              description: 'Get weather information',
+              name: 'get_weather',
+              parameters: {
+                properties: {
+                  city: { type: 'string' },
+                  unit: { type: 'string' },
+                },
+                required: ['city'],
+                type: 'object' as const,
               },
-              required: ['city'],
             },
+            type: 'function' as const,
           },
           {
-            name: 'get_time',
-            description: 'Get current time',
-            parameters: {
-              type: 'object' as const,
-              properties: {
-                timezone: { type: 'string' },
+            function: {
+              description: 'Get current time',
+              name: 'get_time',
+              parameters: {
+                properties: {
+                  timezone: { type: 'string' },
+                },
+                required: ['timezone'],
+                type: 'object' as const,
               },
-              required: ['timezone'],
             },
+            type: 'function' as const,
           },
         ],
-        model: 'claude-3-5-sonnet-20241022',
       };
 
       const result = await createAnthropicGenerateObject(mockClient as any, payload as any);
 
       expect(mockClient.messages.create).toHaveBeenCalledWith(
         expect.objectContaining({
-          model: 'claude-3-5-sonnet-20241022',
           max_tokens: 8192,
           messages: [{ content: 'What is the weather and time in New York?', role: 'user' }],
+          model: 'claude-3-5-sonnet-20241022',
+          tool_choice: {
+            type: 'any',
+          },
           tools: [
             {
-              name: 'get_weather',
               description: 'Get weather information',
               input_schema: {
-                type: 'object',
                 properties: {
                   city: { type: 'string' },
                   unit: { type: 'string' },
                 },
                 required: ['city'],
+                type: 'object',
               },
+              name: 'get_weather',
             },
             {
-              name: 'get_time',
               description: 'Get current time',
               input_schema: {
-                type: 'object',
                 properties: {
                   timezone: { type: 'string' },
                 },
                 required: ['timezone'],
+                type: 'object',
               },
+              name: 'get_time',
             },
           ],
-          tool_choice: {
-            type: 'any',
-          },
         }),
         expect.objectContaining({}),
       );
@@ -364,9 +370,9 @@ describe('Anthropic generateObject', () => {
           create: vi.fn().mockResolvedValue({
             content: [
               {
-                type: 'tool_use',
+                input: { a: 5, b: 3, operation: 'add' },
                 name: 'calculate',
-                input: { operation: 'add', a: 5, b: 3 },
+                type: 'tool_use',
               },
             ],
           }),
@@ -375,27 +381,30 @@ describe('Anthropic generateObject', () => {
 
       const payload = {
         messages: [{ content: 'Add 5 and 3', role: 'user' as const }],
+        model: 'claude-3-5-sonnet-20241022',
         tools: [
           {
-            name: 'calculate',
-            description: 'Perform mathematical calculation',
-            parameters: {
-              type: 'object' as const,
-              properties: {
-                operation: { type: 'string' },
-                a: { type: 'number' },
-                b: { type: 'number' },
+            function: {
+              description: 'Perform mathematical calculation',
+              name: 'calculate',
+              parameters: {
+                properties: {
+                  a: { type: 'number' },
+                  b: { type: 'number' },
+                  operation: { type: 'string' },
+                },
+                required: ['operation', 'a', 'b'],
+                type: 'object' as const,
               },
-              required: ['operation', 'a', 'b'],
             },
+            type: 'function' as const,
           },
         ],
-        model: 'claude-3-5-sonnet-20241022',
       };
 
       const result = await createAnthropicGenerateObject(mockClient as any, payload as any);
 
-      expect(result).toEqual([{ arguments: { operation: 'add', a: 5, b: 3 }, name: 'calculate' }]);
+      expect(result).toEqual([{ arguments: { a: 5, b: 3, operation: 'add' }, name: 'calculate' }]);
     });
   });
 
@@ -410,11 +419,11 @@ describe('Anthropic generateObject', () => {
 
     const payload = {
       messages: [{ content: 'Generate data', role: 'user' as const }],
+      model: 'claude-3-5-sonnet-20241022',
       schema: {
         name: 'test_tool',
         schema: { type: 'object' },
       },
-      model: 'claude-3-5-sonnet-20241022',
     };
 
     await expect(createAnthropicGenerateObject(mockClient as any, payload as any)).rejects.toThrow(
@@ -434,11 +443,11 @@ describe('Anthropic generateObject', () => {
 
     const payload = {
       messages: [{ content: 'Generate data', role: 'user' as const }],
+      model: 'claude-3-5-sonnet-20241022',
       schema: {
         name: 'test_tool',
         schema: { type: 'object' },
       },
-      model: 'claude-3-5-sonnet-20241022',
     };
 
     const options = {

package/packages/model-runtime/src/providers/anthropic/generateObject.ts

@@ -14,14 +14,14 @@ export const createAnthropicGenerateObject = async (
   payload: GenerateObjectPayload,
   options?: GenerateObjectOptions,
 ) => {
-  const { schema, messages, systemRole, model, tools } = payload;
+  const { schema, messages, model, tools } = payload;
 
   log('generateObject called with model: %s', model);
   log('schema: %O', schema);
   log('messages count: %d', messages.length);
 
   // Convert messages to Anthropic format
-  const system_message = systemRole || messages.find((m) => m.role === 'system')?.content;
+  const system_message = messages.find((m) => m.role === 'system')?.content;
   const user_messages = messages.filter((m) => m.role !== 'system');
   const anthropicMessages = await buildAnthropicMessages(user_messages);
 
@@ -39,7 +39,7 @@ export const createAnthropicGenerateObject = async (
   let finalTools;
   let tool_choice: Anthropic.ToolChoiceAny | Anthropic.ToolChoiceTool;
   if (tools) {
-    finalTools = buildAnthropicTools(tools.map((item) => ({ function: item, type: 'function' })));
+    finalTools = buildAnthropicTools(tools);
     tool_choice = { type: 'any' };
   } else if (schema) {
     // Convert OpenAI-style schema to Anthropic tool format