@lobehub/chat 1.138.3 → 1.138.4

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

@@ -2,145 +2,174 @@
 import { Type as SchemaType } from '@google/genai';
 import { describe, expect, it, vi } from 'vitest';
 
-import { convertOpenAISchemaToGoogleSchema, createGoogleGenerateObject } from './generateObject';
+import {
+  convertOpenAISchemaToGoogleSchema,
+  createGoogleGenerateObject,
+  createGoogleGenerateObjectWithTools,
+} from './generateObject';
 
 describe('Google generateObject', () => {
   describe('convertOpenAISchemaToGoogleSchema', () => {
     it('should convert basic types correctly', () => {
       const openAISchema = {
-        type: 'object',
-        properties: {
-          name: { type: 'string' },
-          age: { type: 'number' },
-          isActive: { type: 'boolean' },
-          count: { type: 'integer' },
+        name: 'person',
+        schema: {
+          properties: {
+            age: { type: 'number' },
+            count: { type: 'integer' },
+            isActive: { type: 'boolean' },
+            name: { type: 'string' },
+          },
+          type: 'object' as const,
         },
       };
 
       const result = convertOpenAISchemaToGoogleSchema(openAISchema);
 
       expect(result).toEqual({
-        type: SchemaType.OBJECT,
         properties: {
-          name: { type: SchemaType.STRING },
           age: { type: SchemaType.NUMBER },
-          isActive: { type: SchemaType.BOOLEAN },
           count: { type: SchemaType.INTEGER },
+          isActive: { type: SchemaType.BOOLEAN },
+          name: { type: SchemaType.STRING },
         },
+        type: SchemaType.OBJECT,
       });
     });
 
     it('should convert array schemas correctly', () => {
       const openAISchema = {
-        type: 'array',
-        items: {
-          type: 'object',
+        name: 'recipes',
+        schema: {
           properties: {
-            recipeName: { type: 'string' },
-            ingredients: {
+            recipes: {
+              items: {
+                properties: {
+                  ingredients: {
+                    items: { type: 'string' },
+                    type: 'array',
+                  },
+                  recipeName: { type: 'string' },
+                },
+                propertyOrdering: ['recipeName', 'ingredients'],
+                type: 'object',
+              },
               type: 'array',
-              items: { type: 'string' },
             },
           },
-          propertyOrdering: ['recipeName', 'ingredients'],
+          type: 'object' as const,
         },
       };
 
       const result = convertOpenAISchemaToGoogleSchema(openAISchema);
 
       expect(result).toEqual({
-        type: SchemaType.ARRAY,
-        items: {
-          type: SchemaType.OBJECT,
-          properties: {
-            recipeName: { type: SchemaType.STRING },
-            ingredients: {
-              type: SchemaType.ARRAY,
-              items: { type: SchemaType.STRING },
+        properties: {
+          recipes: {
+            items: {
+              properties: {
+                ingredients: {
+                  items: { type: SchemaType.STRING },
+                  type: SchemaType.ARRAY,
+                },
+                recipeName: { type: SchemaType.STRING },
+              },
+              propertyOrdering: ['recipeName', 'ingredients'],
+              type: SchemaType.OBJECT,
             },
+            type: SchemaType.ARRAY,
           },
-          propertyOrdering: ['recipeName', 'ingredients'],
         },
+        type: SchemaType.OBJECT,
       });
     });
 
     it('should handle nested objects', () => {
       const openAISchema = {
-        type: 'object',
-        properties: {
-          user: {
-            type: 'object',
-            properties: {
-              profile: {
-                type: 'object',
-                properties: {
-                  preferences: {
-                    type: 'array',
-                    items: { type: 'string' },
+        name: 'user_data',
+        schema: {
+          properties: {
+            user: {
+              properties: {
+                profile: {
+                  properties: {
+                    preferences: {
+                      items: { type: 'string' },
+                      type: 'array',
+                    },
                   },
+                  type: 'object',
                 },
               },
+              type: 'object',
             },
           },
+          type: 'object' as const,
         },
       };
 
       const result = convertOpenAISchemaToGoogleSchema(openAISchema);
 
       expect(result).toEqual({
-        type: SchemaType.OBJECT,
         properties: {
           user: {
-            type: SchemaType.OBJECT,
             properties: {
               profile: {
-                type: SchemaType.OBJECT,
                 properties: {
                   preferences: {
-                    type: SchemaType.ARRAY,
                     items: { type: SchemaType.STRING },
+                    type: SchemaType.ARRAY,
                   },
                 },
+                type: SchemaType.OBJECT,
               },
             },
+            type: SchemaType.OBJECT,
           },
         },
+        type: SchemaType.OBJECT,
       });
     });
 
     it('should preserve additional properties like description, enum, required', () => {
       const openAISchema = {
-        type: 'object',
-        description: 'A person object',
-        properties: {
-          status: {
-            type: 'string',
-            enum: ['active', 'inactive'],
-            description: 'The status of the person',
+        name: 'person',
+        schema: {
+          description: 'A person object',
+          properties: {
+            status: {
+              description: 'The status of the person',
+              enum: ['active', 'inactive'],
+              type: 'string',
+            },
           },
-        },
-        required: ['status'],
+          required: ['status'],
+          type: 'object' as const,
+        } as any,
       };
 
       const result = convertOpenAISchemaToGoogleSchema(openAISchema);
 
       expect(result).toEqual({
-        type: SchemaType.OBJECT,
         description: 'A person object',
         properties: {
           status: {
-            type: SchemaType.STRING,
-            enum: ['active', 'inactive'],
             description: 'The status of the person',
+            enum: ['active', 'inactive'],
+            type: SchemaType.STRING,
           },
         },
         required: ['status'],
+        type: SchemaType.OBJECT,
       });
     });
 
     it('should handle unknown types by defaulting to STRING', () => {
       const openAISchema = {
-        type: 'unknown-type',
+        name: 'test',
+        schema: {
+          type: 'unknown-type' as any,
+        } as any,
       };
 
       const result = convertOpenAISchemaToGoogleSchema(openAISchema);
@@ -161,15 +190,18 @@ describe('Google generateObject', () => {
         },
       };
 
-      const contents = [{ role: 'user', parts: [{ text: 'Generate a person object' }] }];
+      const contents = [{ parts: [{ text: 'Generate a person object' }], role: 'user' }];
 
       const payload = {
         contents,
+        model: 'gemini-2.5-flash',
         schema: {
-          type: 'object',
-          properties: { name: { type: 'string' }, age: { type: 'number' } },
+          name: 'person',
+          schema: {
+            properties: { age: { type: 'number' }, name: { type: 'string' } },
+            type: 'object' as const,
+          },
         },
-        model: 'gemini-2.5-flash',
       };
 
       const result = await createGoogleGenerateObject(mockClient as any, payload);
@@ -178,11 +210,11 @@ describe('Google generateObject', () => {
         config: expect.objectContaining({
           responseMimeType: 'application/json',
           responseSchema: expect.objectContaining({
-            type: SchemaType.OBJECT,
             properties: expect.objectContaining({
-              name: { type: SchemaType.STRING },
               age: { type: SchemaType.NUMBER },
+              name: { type: SchemaType.STRING },
             }),
+            type: SchemaType.OBJECT,
           }),
           safetySettings: expect.any(Array),
         }),
@@ -190,7 +222,7 @@ describe('Google generateObject', () => {
         model: 'gemini-2.5-flash',
       });
 
-      expect(result).toEqual({ name: 'John', age: 30 });
+      expect(result).toEqual({ age: 30, name: 'John' });
     });
 
     it('should handle options correctly', async () => {
@@ -202,12 +234,18 @@ describe('Google generateObject', () => {
         },
       };
 
-      const contents = [{ role: 'user', parts: [{ text: 'Generate status' }] }];
+      const contents = [{ parts: [{ text: 'Generate status' }], role: 'user' }];
 
       const payload = {
         contents,
-        schema: { type: 'object', properties: { status: { type: 'string' } } },
         model: 'gemini-2.5-flash',
+        schema: {
+          name: 'status',
+          schema: {
+            properties: { status: { type: 'string' } },
+            type: 'object' as const,
+          },
+        },
       };
 
       const options = {
@@ -221,10 +259,10 @@ describe('Google generateObject', () => {
           abortSignal: options.signal,
           responseMimeType: 'application/json',
           responseSchema: expect.objectContaining({
-            type: SchemaType.OBJECT,
             properties: expect.objectContaining({
               status: { type: SchemaType.STRING },
             }),
+            type: SchemaType.OBJECT,
           }),
         }),
         contents,
@@ -248,8 +286,14 @@ describe('Google generateObject', () => {
 
       const payload = {
         contents,
-        schema: { type: 'object' },
         model: 'gemini-2.5-flash',
+        schema: {
+          name: 'test',
+          schema: {
+            properties: {},
+            type: 'object' as const,
+          },
+        },
       };
 
       const result = await createGoogleGenerateObject(mockClient as any, payload);
@@ -273,31 +317,37 @@ describe('Google generateObject', () => {
 
       const payload = {
         contents,
+        model: 'gemini-2.5-flash',
         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_data',
+          schema: {
+            properties: {
+              metadata: { type: 'object' },
+              user: {
+                properties: {
+                  name: { type: 'string' },
+                  profile: {
+                    properties: {
+                      age: { type: 'number' },
+                      preferences: { items: { type: 'string' }, type: 'array' },
+                    },
+                    type: 'object',
                   },
                 },
+                type: 'object',
               },
             },
-            metadata: { type: 'object' },
+            type: 'object' as const,
           },
         },
-        model: 'gemini-2.5-flash',
       };
 
       const result = await createGoogleGenerateObject(mockClient as any, payload);
 
       expect(result).toEqual({
+        metadata: {
+          created: '2024-01-01',
+        },
         user: {
           name: 'Alice',
           profile: {
@@ -305,9 +355,6 @@ describe('Google generateObject', () => {
             preferences: ['music', 'sports'],
           },
         },
-        metadata: {
-          created: '2024-01-01',
-        },
       });
     });
 
@@ -324,8 +371,14 @@ describe('Google generateObject', () => {
 
       const payload = {
         contents,
-        schema: { type: 'object' },
         model: 'gemini-2.5-flash',
+        schema: {
+          name: 'test',
+          schema: {
+            properties: {},
+            type: 'object' as const,
+          },
+        },
       };
 
       await expect(createGoogleGenerateObject(mockClient as any, payload)).rejects.toThrow();
@@ -345,8 +398,14 @@ describe('Google generateObject', () => {
 
       const payload = {
         contents,
-        schema: { type: 'object' },
         model: 'gemini-2.5-flash',
+        schema: {
+          name: 'test',
+          schema: {
+            properties: {},
+            type: 'object' as const,
+          },
+        },
       };
 
       const options = {
@@ -358,4 +417,450 @@ describe('Google generateObject', () => {
       ).rejects.toThrow();
     });
   });
+
+  describe('createGoogleGenerateObjectWithTools', () => {
+    it('should return function calls on successful API call with tools', async () => {
+      const mockClient = {
+        models: {
+          generateContent: vi.fn().mockResolvedValue({
+            candidates: [
+              {
+                content: {
+                  parts: [
+                    {
+                      functionCall: {
+                        args: { city: 'New York', unit: 'celsius' },
+                        name: 'get_weather',
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+          }),
+        },
+      };
+
+      const contents = [{ parts: [{ text: 'What is the weather in New York?' }], role: 'user' }];
+
+      const payload = {
+        contents,
+        model: 'gemini-2.5-flash',
+        tools: [
+          {
+            function: {
+              description: 'Get weather information',
+              name: 'get_weather',
+              parameters: {
+                properties: {
+                  city: { type: 'string' },
+                  unit: { type: 'string' },
+                },
+                required: ['city'],
+                type: 'object' as const,
+              },
+            },
+            type: 'function' as const,
+          },
+        ],
+      };
+
+      const result = await createGoogleGenerateObjectWithTools(mockClient as any, payload);
+
+      expect(mockClient.models.generateContent).toHaveBeenCalledWith({
+        config: expect.objectContaining({
+          safetySettings: expect.any(Array),
+          toolConfig: {
+            functionCallingConfig: {
+              mode: 'ANY',
+            },
+          },
+          tools: [
+            {
+              functionDeclarations: [
+                {
+                  description: 'Get weather information',
+                  name: 'get_weather',
+                  parameters: {
+                    description: undefined,
+                    properties: {
+                      city: { type: 'string' },
+                      unit: { type: 'string' },
+                    },
+                    required: ['city'],
+                    type: SchemaType.OBJECT,
+                  },
+                },
+              ],
+            },
+          ],
+        }),
+        contents,
+        model: 'gemini-2.5-flash',
+      });
+
+      expect(result).toEqual([
+        { arguments: { city: 'New York', unit: 'celsius' }, name: 'get_weather' },
+      ]);
+    });
+
+    it('should handle multiple function calls', async () => {
+      const mockClient = {
+        models: {
+          generateContent: vi.fn().mockResolvedValue({
+            candidates: [
+              {
+                content: {
+                  parts: [
+                    {
+                      functionCall: {
+                        args: { city: 'New York', unit: 'celsius' },
+                        name: 'get_weather',
+                      },
+                    },
+                    {
+                      functionCall: {
+                        args: { timezone: 'America/New_York' },
+                        name: 'get_time',
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+          }),
+        },
+      };
+
+      const contents: any[] = [];
+
+      const payload = {
+        contents,
+        model: 'gemini-2.5-flash',
+        tools: [
+          {
+            function: {
+              description: 'Get weather information',
+              name: 'get_weather',
+              parameters: {
+                properties: {
+                  city: { type: 'string' },
+                  unit: { type: 'string' },
+                },
+                required: ['city'],
+                type: 'object' as const,
+              },
+            },
+            type: 'function' as const,
+          },
+          {
+            function: {
+              description: 'Get current time',
+              name: 'get_time',
+              parameters: {
+                properties: {
+                  timezone: { type: 'string' },
+                },
+                required: ['timezone'],
+                type: 'object' as const,
+              },
+            },
+            type: 'function' as const,
+          },
+        ],
+      };
+
+      const result = await createGoogleGenerateObjectWithTools(mockClient as any, payload);
+
+      expect(result).toEqual([
+        { arguments: { city: 'New York', unit: 'celsius' }, name: 'get_weather' },
+        { arguments: { timezone: 'America/New_York' }, name: 'get_time' },
+      ]);
+    });
+
+    it('should handle options correctly', async () => {
+      const mockClient = {
+        models: {
+          generateContent: vi.fn().mockResolvedValue({
+            candidates: [
+              {
+                content: {
+                  parts: [
+                    {
+                      functionCall: {
+                        args: { a: 5, b: 3, operation: 'add' },
+                        name: 'calculate',
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+          }),
+        },
+      };
+
+      const contents: any[] = [];
+
+      const payload = {
+        contents,
+        model: 'gemini-2.5-flash',
+        tools: [
+          {
+            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,
+              },
+            },
+            type: 'function' as const,
+          },
+        ],
+      };
+
+      const options = {
+        signal: new AbortController().signal,
+      };
+
+      const result = await createGoogleGenerateObjectWithTools(mockClient as any, payload, options);
+
+      expect(mockClient.models.generateContent).toHaveBeenCalledWith({
+        config: expect.objectContaining({
+          abortSignal: options.signal,
+        }),
+        contents,
+        model: 'gemini-2.5-flash',
+      });
+
+      expect(result).toEqual([{ arguments: { a: 5, b: 3, operation: 'add' }, name: 'calculate' }]);
+    });
+
+    it('should return undefined when no function calls in response', async () => {
+      const mockClient = {
+        models: {
+          generateContent: vi.fn().mockResolvedValue({
+            candidates: [
+              {
+                content: {
+                  parts: [
+                    {
+                      text: 'Some text response without function call',
+                    },
+                  ],
+                },
+              },
+            ],
+          }),
+        },
+      };
+
+      const contents: any[] = [];
+
+      const payload = {
+        contents,
+        model: 'gemini-2.5-flash',
+        tools: [
+          {
+            function: {
+              description: 'Test function',
+              name: 'test_function',
+              parameters: {
+                properties: {},
+                type: 'object' as const,
+              },
+            },
+            type: 'function' as const,
+          },
+        ],
+      };
+
+      const result = await createGoogleGenerateObjectWithTools(mockClient as any, payload);
+
+      expect(result).toBeUndefined();
+    });
+
+    it('should return undefined when no content parts in response', async () => {
+      const mockClient = {
+        models: {
+          generateContent: vi.fn().mockResolvedValue({
+            candidates: [
+              {
+                content: {},
+              },
+            ],
+          }),
+        },
+      };
+
+      const contents: any[] = [];
+
+      const payload = {
+        contents,
+        model: 'gemini-2.5-flash',
+        tools: [
+          {
+            function: {
+              description: 'Test function',
+              name: 'test_function',
+              parameters: {
+                properties: {},
+                type: 'object' as const,
+              },
+            },
+            type: 'function' as const,
+          },
+        ],
+      };
+
+      const result = await createGoogleGenerateObjectWithTools(mockClient as any, payload);
+
+      expect(result).toBeUndefined();
+    });
+
+    it('should propagate API errors correctly', async () => {
+      const apiError = new Error('API Error: Model not found');
+
+      const mockClient = {
+        models: {
+          generateContent: vi.fn().mockRejectedValue(apiError),
+        },
+      };
+
+      const contents: any[] = [];
+
+      const payload = {
+        contents,
+        model: 'gemini-2.5-flash',
+        tools: [
+          {
+            function: {
+              description: 'Test function',
+              name: 'test_function',
+              parameters: {
+                properties: {},
+                type: 'object' as const,
+              },
+            },
+            type: 'function' as const,
+          },
+        ],
+      };
+
+      await expect(createGoogleGenerateObjectWithTools(mockClient as any, payload)).rejects.toThrow(
+        'API Error: Model not found',
+      );
+    });
+
+    it('should handle abort signals correctly', async () => {
+      const apiError = new Error('Request was cancelled');
+      apiError.name = 'AbortError';
+
+      const mockClient = {
+        models: {
+          generateContent: vi.fn().mockRejectedValue(apiError),
+        },
+      };
+
+      const contents: any[] = [];
+
+      const payload = {
+        contents,
+        model: 'gemini-2.5-flash',
+        tools: [
+          {
+            function: {
+              description: 'Test function',
+              name: 'test_function',
+              parameters: {
+                properties: {},
+                type: 'object' as const,
+              },
+            },
+            type: 'function' as const,
+          },
+        ],
+      };
+
+      const options = {
+        signal: new AbortController().signal,
+      };
+
+      await expect(
+        createGoogleGenerateObjectWithTools(mockClient as any, payload, options),
+      ).rejects.toThrow();
+    });
+
+    it('should handle tools with empty parameters', async () => {
+      const mockClient = {
+        models: {
+          generateContent: vi.fn().mockResolvedValue({
+            candidates: [
+              {
+                content: {
+                  parts: [
+                    {
+                      functionCall: {
+                        args: {},
+                        name: 'simple_function',
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+          }),
+        },
+      };
+
+      const contents: any[] = [];
+
+      const payload = {
+        contents,
+        model: 'gemini-2.5-flash',
+        tools: [
+          {
+            function: {
+              description: 'A simple function with no parameters',
+              name: 'simple_function',
+              parameters: {
+                properties: {},
+                type: 'object' as const,
+              },
+            },
+            type: 'function' as const,
+          },
+        ],
+      };
+
+      const result = await createGoogleGenerateObjectWithTools(mockClient as any, payload);
+
+      // Should use dummy property for empty parameters
+      expect(mockClient.models.generateContent).toHaveBeenCalledWith({
+        config: expect.objectContaining({
+          tools: [
+            {
+              functionDeclarations: [
+                expect.objectContaining({
+                  parameters: expect.objectContaining({
+                    properties: { dummy: { type: 'string' } },
+                  }),
+                }),
+              ],
+            },
+          ],
+        }),
+        contents,
+        model: 'gemini-2.5-flash',
+      });
+
+      expect(result).toEqual([{ arguments: {}, name: 'simple_function' }]);
+    });
+  });
 });