@lobehub/chat 1.140.0 → 1.141.1

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

@@ -2048,6 +2048,319 @@ describe('LobeOpenAICompatibleFactory', () => {
       });
     });
 
+    describe('handleSchema option', () => {
+      let instanceWithSchemaHandler: any;
+      const mockSchemaHandler = vi.fn((schema: any) => {
+        const filtered: any = {};
+        for (const [key, value] of Object.entries(schema)) {
+          if (key !== 'maxLength' && key !== 'pattern') {
+            filtered[key] = value;
+          }
+        }
+        return filtered;
+      });
+
+      beforeEach(() => {
+        mockSchemaHandler.mockClear();
+        const RuntimeClass = createOpenAICompatibleRuntime({
+          baseURL: 'https://api.test.com',
+          generateObject: {
+            handleSchema: mockSchemaHandler,
+          },
+          provider: 'test-provider',
+        });
+
+        instanceWithSchemaHandler = new RuntimeClass({ apiKey: 'test-key' });
+      });
+
+      it('should apply schema transformation with Responses API', async () => {
+        const mockResponse = {
+          output_text: '{"name":"Alice","age":30}',
+        };
+
+        vi.spyOn(instanceWithSchemaHandler['client'].responses, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+
+        const payload = {
+          messages: [{ content: 'Extract person', role: 'user' as const }],
+          model: 'gpt-4o',
+          responseApi: true,
+          schema: {
+            name: 'person',
+            schema: {
+              maxLength: 100,
+              pattern: '^[a-z]+$',
+              properties: {
+                age: { type: 'number' },
+                name: { type: 'string' },
+              },
+              type: 'object' as const,
+            },
+          },
+        };
+
+        await instanceWithSchemaHandler.generateObject(payload);
+
+        expect(mockSchemaHandler).toHaveBeenCalledWith(payload.schema.schema);
+        expect(instanceWithSchemaHandler['client'].responses.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            text: expect.objectContaining({
+              format: expect.objectContaining({
+                schema: {
+                  properties: {
+                    age: { type: 'number' },
+                    name: { type: 'string' },
+                  },
+                  type: 'object',
+                },
+              }),
+            }),
+          }),
+          expect.any(Object),
+        );
+      });
+
+      it('should apply schema transformation with Chat Completions API', async () => {
+        const mockResponse = {
+          choices: [
+            {
+              message: {
+                content: '{"name":"Bob","age":25}',
+              },
+            },
+          ],
+        };
+
+        vi.spyOn(instanceWithSchemaHandler['client'].chat.completions, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+
+        const payload = {
+          messages: [{ content: 'Extract person', role: 'user' as const }],
+          model: 'test-model',
+          schema: {
+            name: 'person',
+            schema: {
+              maxLength: 100,
+              pattern: '^[a-z]+$',
+              properties: {
+                age: { type: 'number' },
+                name: { type: 'string' },
+              },
+              type: 'object' as const,
+            },
+          },
+        };
+
+        await instanceWithSchemaHandler.generateObject(payload);
+
+        expect(mockSchemaHandler).toHaveBeenCalledWith(payload.schema.schema);
+        expect(instanceWithSchemaHandler['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            response_format: expect.objectContaining({
+              json_schema: expect.objectContaining({
+                schema: {
+                  properties: {
+                    age: { type: 'number' },
+                    name: { type: 'string' },
+                  },
+                  type: 'object',
+                },
+              }),
+            }),
+          }),
+          expect.any(Object),
+        );
+      });
+
+      it('should apply schema transformation with tool calling fallback', async () => {
+        const RuntimeClass = createOpenAICompatibleRuntime({
+          baseURL: 'https://api.test.com',
+          generateObject: {
+            handleSchema: mockSchemaHandler,
+            useToolsCalling: true,
+          },
+          provider: 'test-provider',
+        });
+
+        const instance = new RuntimeClass({ apiKey: 'test-key' });
+
+        const mockResponse = {
+          choices: [
+            {
+              message: {
+                tool_calls: [
+                  {
+                    function: {
+                      arguments: '{"name":"Charlie","age":35}',
+                      name: 'person',
+                    },
+                    type: 'function' as const,
+                  },
+                ],
+              },
+            },
+          ],
+        };
+
+        vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+
+        const payload = {
+          messages: [{ content: 'Extract person', role: 'user' as const }],
+          model: 'test-model',
+          schema: {
+            name: 'person',
+            schema: {
+              maxLength: 100,
+              pattern: '^[a-z]+$',
+              properties: {
+                age: { type: 'number' },
+                name: { type: 'string' },
+              },
+              type: 'object' as const,
+            },
+          },
+        };
+
+        await instance.generateObject(payload);
+
+        expect(mockSchemaHandler).toHaveBeenCalledWith(payload.schema.schema);
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            tools: [
+              expect.objectContaining({
+                function: expect.objectContaining({
+                  parameters: {
+                    properties: {
+                      age: { type: 'number' },
+                      name: { type: 'string' },
+                    },
+                    type: 'object',
+                  },
+                }),
+              }),
+            ],
+          }),
+          expect.any(Object),
+        );
+      });
+
+      it('should not apply schema transformation when handleSchema is not configured', async () => {
+        const RuntimeClass = createOpenAICompatibleRuntime({
+          baseURL: 'https://api.test.com',
+          provider: 'test-provider',
+        });
+
+        const instance = new RuntimeClass({ apiKey: 'test-key' });
+
+        const mockResponse = {
+          choices: [
+            {
+              message: {
+                content: '{"name":"Test"}',
+              },
+            },
+          ],
+        };
+
+        vi.spyOn(instance['client'].chat.completions, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+
+        const payload = {
+          messages: [{ content: 'Extract data', role: 'user' as const }],
+          model: 'test-model',
+          schema: {
+            name: 'test',
+            schema: {
+              maxLength: 100,
+              properties: {
+                name: { type: 'string' },
+              },
+              type: 'object' as const,
+            },
+          },
+        };
+
+        await instance.generateObject(payload);
+
+        expect(instance['client'].chat.completions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            response_format: expect.objectContaining({
+              json_schema: expect.objectContaining({
+                schema: {
+                  maxLength: 100,
+                  properties: {
+                    name: { type: 'string' },
+                  },
+                  type: 'object',
+                },
+              }),
+            }),
+          }),
+          expect.any(Object),
+        );
+      });
+
+      it('should preserve original schema properties while filtering', async () => {
+        const mockResponse = {
+          output_text: '{"result":"success"}',
+        };
+
+        vi.spyOn(instanceWithSchemaHandler['client'].responses, 'create').mockResolvedValue(
+          mockResponse as any,
+        );
+
+        const payload = {
+          messages: [{ content: 'Test', role: 'user' as const }],
+          model: 'gpt-4o',
+          responseApi: true,
+          schema: {
+            description: 'Test schema',
+            name: 'test',
+            schema: {
+              description: 'Inner schema description',
+              maxLength: 100,
+              pattern: '^test$',
+              properties: {
+                result: { type: 'string' },
+              },
+              required: ['result'],
+              type: 'object' as const,
+            },
+            strict: true,
+          },
+        };
+
+        await instanceWithSchemaHandler.generateObject(payload);
+
+        expect(mockSchemaHandler).toHaveBeenCalledWith(payload.schema.schema);
+        expect(instanceWithSchemaHandler['client'].responses.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            text: expect.objectContaining({
+              format: expect.objectContaining({
+                description: 'Test schema',
+                name: 'test',
+                schema: {
+                  description: 'Inner schema description',
+                  properties: {
+                    result: { type: 'string' },
+                  },
+                  required: ['result'],
+                  type: 'object',
+                },
+                strict: true,
+              }),
+            }),
+          }),
+          expect.any(Object),
+        );
+      });
+    });
+
     describe('tool calling fallback', () => {
       let instanceWithToolCalling: any;
 

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

@@ -119,6 +119,10 @@ export interface OpenAICompatibleFactoryOptions<T extends Record<string, any> =
     invalidAPIKey: ILobeAgentRuntimeErrorType;
   };
   generateObject?: {
+    /**
+     * Transform schema before sending to the provider (e.g., filter unsupported properties)
+     */
+    handleSchema?: (schema: any) => any;
     /**
      * If true, route generateObject requests to Responses API path directly
      */
@@ -454,12 +458,19 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
       // Use tool calling fallback if configured
       if (generateObjectConfig?.useToolsCalling) {
         log('using tool calling fallback for structured output');
+
+        // Apply schema transformation if configured
+        const processedSchema = generateObjectConfig.handleSchema
+          ? { ...schema, schema: generateObjectConfig.handleSchema(schema.schema) }
+          : schema;
+
         const tool: ChatCompletionTool = {
           function: {
             description:
-              schema.description || 'Generate structured output according to the provided schema',
-            name: schema.name || 'structured_output',
-            parameters: schema.schema,
+              processedSchema.description ||
+              'Generate structured output according to the provided schema',
+            name: processedSchema.name || 'structured_output',
+            parameters: processedSchema.schema,
           },
           type: 'function',
         };
@@ -531,13 +542,18 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
         return false;
       })();
 
+      // Apply schema transformation if configured
+      const processedSchema = generateObjectConfig?.handleSchema
+        ? { ...schema, schema: generateObjectConfig.handleSchema(schema.schema) }
+        : schema;
+
       if (shouldUseResponses) {
         log('calling responses.create for structured output');
         const res = await this.client!.responses.create(
           {
             input: messages,
             model,
-            text: { format: { strict: true, type: 'json_schema', ...schema } },
+            text: { format: { strict: true, type: 'json_schema', ...processedSchema } },
             user: options?.user,
           },
           { headers: options?.headers, signal: options?.signal },
@@ -561,7 +577,7 @@ export const createOpenAICompatibleRuntime = <T extends Record<string, any> = an
         {
           messages,
           model,
-          response_format: { json_schema: schema, type: 'json_schema' },
+          response_format: { json_schema: processedSchema, type: 'json_schema' },
           user: options?.user,
         },
         { headers: options?.headers, signal: options?.signal },

package/packages/model-runtime/src/providers/azureai/index.test.ts

@@ -57,8 +57,12 @@ describe('LobeAzureAI', () => {
         model: 'gpt-4',
       };
 
-      vi.spyOn(instance.client.path('/chat/completions'), 'post').mockResolvedValue({
+      const mockPost = vi.fn().mockResolvedValue({
         body: mockResponse,
+      });
+
+      vi.spyOn(instance.client, 'path').mockReturnValue({
+        post: mockPost,
       } as any);
 
       const result = await instance.chat({
@@ -68,12 +72,18 @@ describe('LobeAzureAI', () => {
       });
 
       expect(result).toBeDefined();
+      expect(instance.client.path).toHaveBeenCalledWith('/chat/completions');
+      expect(mockPost).toHaveBeenCalled();
     });
 
     it('should handle generic errors', async () => {
       const mockError = new Error('Network error');
 
-      vi.spyOn(instance.client.path('/chat/completions'), 'post').mockRejectedValue(mockError);
+      const mockPost = vi.fn().mockRejectedValue(mockError);
+
+      vi.spyOn(instance.client, 'path').mockReturnValue({
+        post: mockPost,
+      } as any);
 
       try {
         await instance.chat({