feat!: Support invoke with structured output in VercelAI provider

packages/ai-providers/server-ai-vercel/__tests__/VercelProvider.test.ts

@@ -1,10 +1,11 @@
-import { generateText } from 'ai';
+import { generateObject, generateText } from 'ai';
 
 import { VercelProvider } from '../src/VercelProvider';
 
 // Mock Vercel AI SDK
 jest.mock('ai', () => ({
   generateText: jest.fn(),
+  generateObject: jest.fn(),
 }));
 
 describe('VercelProvider', () => {
@@ -116,6 +117,76 @@ describe('VercelProvider', () => {
     });
   });
 
+  describe('convertToZodSchema', () => {
+    it('converts simple object structure to Zod schema', () => {
+      const responseStructure = {
+        name: 'string',
+        age: 0,
+        isActive: true,
+      };
+
+      const schema = VercelProvider.convertToZodSchema(responseStructure);
+
+      expect(schema).toBeDefined();
+      expect(typeof schema.parse).toBe('function');
+    });
+
+    it('converts nested object structure to Zod schema', () => {
+      const responseStructure = {
+        user: {
+          name: 'string',
+          age: 0,
+        },
+        settings: {
+          theme: 'string',
+          notifications: true,
+        },
+      };
+
+      const schema = VercelProvider.convertToZodSchema(responseStructure);
+
+      expect(schema).toBeDefined();
+      expect(typeof schema.parse).toBe('function');
+    });
+
+    it('converts array structure to Zod schema', () => {
+      const responseStructure = {
+        items: ['string'],
+        numbers: [0],
+        booleans: [true],
+      };
+
+      const schema = VercelProvider.convertToZodSchema(responseStructure);
+
+      expect(schema).toBeDefined();
+      expect(typeof schema.parse).toBe('function');
+    });
+
+    it('handles empty array structure', () => {
+      const responseStructure = {
+        items: [],
+      };
+
+      const schema = VercelProvider.convertToZodSchema(responseStructure);
+
+      expect(schema).toBeDefined();
+      expect(typeof schema.parse).toBe('function');
+    });
+
+    it('handles null and undefined values', () => {
+      const responseStructure = {
+        nullable: null,
+        undefined,
+        string: 'string',
+      };
+
+      const schema = VercelProvider.convertToZodSchema(responseStructure);
+
+      expect(schema).toBeDefined();
+      expect(typeof schema.parse).toBe('function');
+    });
+  });
+
   describe('invokeModel', () => {
     it('invokes Vercel AI generateText and returns response', async () => {
       const mockResponse = {
@@ -178,6 +249,91 @@ describe('VercelProvider', () => {
     });
   });
 
+  describe('invokeStructuredModel', () => {
+    it('invokes Vercel AI generateObject and returns structured response', async () => {
+      const mockResponse = {
+        object: {
+          name: 'John Doe',
+          age: 30,
+          isActive: true,
+        },
+        usage: {
+          promptTokens: 10,
+          completionTokens: 15,
+          totalTokens: 25,
+        },
+      };
+
+      (generateObject as jest.Mock).mockResolvedValue(mockResponse);
+
+      const messages = [{ role: 'user' as const, content: 'Generate user data' }];
+      const responseStructure = {
+        name: 'string',
+        age: 0,
+        isActive: true,
+      };
+
+      const result = await provider.invokeStructuredModel(messages, responseStructure);
+
+      expect(generateObject).toHaveBeenCalledWith({
+        model: mockModel,
+        messages: [{ role: 'user', content: 'Generate user data' }],
+        schema: expect.any(Object), // Zod schema
+      });
+
+      expect(result).toEqual({
+        data: {
+          name: 'John Doe',
+          age: 30,
+          isActive: true,
+        },
+        rawResponse: JSON.stringify({
+          name: 'John Doe',
+          age: 30,
+          isActive: true,
+        }),
+        metrics: {
+          success: true,
+          usage: {
+            total: 25,
+            input: 10,
+            output: 15,
+          },
+        },
+      });
+    });
+
+    it('handles structured response without usage data', async () => {
+      const mockResponse = {
+        object: {
+          result: 'success',
+        },
+      };
+
+      (generateObject as jest.Mock).mockResolvedValue(mockResponse);
+
+      const messages = [{ role: 'user' as const, content: 'Generate result' }];
+      const responseStructure = {
+        result: 'string',
+      };
+
+      const result = await provider.invokeStructuredModel(messages, responseStructure);
+
+      expect(result).toEqual({
+        data: {
+          result: 'success',
+        },
+        rawResponse: JSON.stringify({
+          result: 'success',
+        }),
+        metrics: {
+          success: true,
+          usage: undefined,
+        },
+      });
+    });
+  });
+
   describe('getModel', () => {
     it('returns the underlying Vercel AI model', () => {
       const model = provider.getModel();

packages/ai-providers/server-ai-vercel/src/VercelProvider.ts

@@ -1,4 +1,4 @@
-import { generateText, LanguageModel } from 'ai';
+import { generateObject, generateText, jsonSchema, LanguageModel } from 'ai';
 
 import { AIProvider } from '@launchdarkly/server-sdk-ai';
 import type {
@@ -8,6 +8,7 @@ import type {
   LDLogger,
   LDMessage,
   LDTokenUsage,
+  StructuredResponse,
 } from '@launchdarkly/server-sdk-ai';
 
 /**
@@ -45,28 +46,75 @@ export class VercelProvider extends AIProvider {
    * Invoke the Vercel AI model with an array of messages.
    */
   async invokeModel(messages: LDMessage[]): Promise<ChatResponse> {
-    // Call Vercel AI generateText
-    // Type assertion: our MinLanguageModel is compatible with the expected LanguageModel interface
-    // The generateText function will work with any object that has the required properties
-    const result = await generateText({
-      model: this._model,
-      messages,
-      ...this._parameters,
-    });
-
-    // Create the assistant message
-    const assistantMessage: LDMessage = {
-      role: 'assistant',
-      content: result.text,
-    };
+    try {
+      // Call Vercel AI generateText
+      const result = await generateText({
+        model: this._model,
+        messages,
+        ...this._parameters,
+      });
+
+      // Create the assistant message
+      const assistantMessage: LDMessage = {
+        role: 'assistant',
+        content: result.text,
+      };
 
-    // Extract metrics including token usage and success status
-    const metrics = VercelProvider.createAIMetrics(result);
+      // Extract metrics including token usage and success status
+      const metrics = VercelProvider.createAIMetrics(result);
 
-    return {
-      message: assistantMessage,
-      metrics,
-    };
+      return {
+        message: assistantMessage,
+        metrics,
+      };
+    } catch (error) {
+      this.logger?.warn('Vercel AI model invocation failed:', error);
+
+      return {
+        message: {
+          role: 'assistant',
+          content: '',
+        },
+        metrics: {
+          success: false,
+        },
+      };
+    }
+  }
+
+  /**
+   * Invoke the Vercel AI model with structured output support.
+   */
+  async invokeStructuredModel(
+    messages: LDMessage[],
+    responseStructure: Record<string, unknown>,
+  ): Promise<StructuredResponse> {
+    try {
+      const result = await generateObject({
+        model: this._model,
+        messages,
+        schema: jsonSchema(responseStructure),
+        ...this._parameters,
+      });
+
+      const metrics = VercelProvider.createAIMetrics(result);
+
+      return {
+        data: result.object as Record<string, unknown>,
+        rawResponse: JSON.stringify(result.object),
+        metrics,
+      };
+    } catch (error) {
+      this.logger?.warn('Vercel AI structured model invocation failed:', error);
+
+      return {
+        data: {},
+        rawResponse: '',
+        metrics: {
+          success: false,
+        },
+      };
+    }
   }
 
   /**