@output.ai/llm 0.2.13 → 0.3.0-dev.pr341-daa6878

package/src/ai_sdk.spec.js

@@ -15,9 +15,15 @@ vi.mock( './ai_model.js', () => ( {
   loadTools: ( ...values ) => loadToolsImpl( ...values )
 } ) );
 
+const OutputMock = {
+  object: vi.fn( opts => ( { _type: 'object', ...opts } ) ),
+  array: vi.fn( opts => ( { _type: 'array', ...opts } ) ),
+  choice: vi.fn( opts => ( { _type: 'choice', ...opts } ) )
+};
+
 const aiFns = {
   generateText: vi.fn(),
-  generateObject: vi.fn()
+  Output: OutputMock
 };
 vi.mock( 'ai', () => ( aiFns ) );
 
@@ -47,10 +53,6 @@ const basePrompt = {
 };
 
 beforeEach( () => {
-  tracingSpies.addEventStart.mockClear();
-  tracingSpies.addEventEnd.mockClear();
-  tracingSpies.addEventError.mockClear();
-
   loadModelImpl.mockReset().mockReturnValue( 'MODEL' );
   loadPromptImpl.mockReset().mockReturnValue( basePrompt );
 
@@ -60,16 +62,6 @@ beforeEach( () => {
     usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
     finishReason: 'stop'
   } );
-  aiFns.generateObject.mockReset().mockResolvedValue( {
-    object: 'OBJECT',
-    usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
-    finishReason: 'stop'
-  } );
-
-  validators.validateGenerateTextArgs.mockClear();
-  validators.validateGenerateObjectArgs.mockClear();
-  validators.validateGenerateArrayArgs.mockClear();
-  validators.validateGenerateEnumArgs.mockClear();
 } );
 
 afterEach( async () => {
@@ -100,10 +92,11 @@ describe( 'ai_sdk', () => {
     expect( result.finishReason ).toBe( 'stop' );
   } );
 
-  it( 'generateObject: validates, traces, calls AI with output object and returns object', async () => {
+  it( 'generateObject: validates, traces, calls generateText with Output.object', async () => {
     const { generateObject } = await importSut();
-    aiFns.generateObject.mockResolvedValueOnce( {
-      object: { a: 1 },
+    aiFns.generateText.mockResolvedValueOnce( {
+      output: { a: 1 },
+      text: '',
       usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
       finishReason: 'stop'
     } );
@@ -121,23 +114,30 @@ describe( 'ai_sdk', () => {
     expect( tracingSpies.addEventStart ).toHaveBeenCalledTimes( 1 );
     expect( tracingSpies.addEventEnd ).toHaveBeenCalledTimes( 1 );
 
-    expect( aiFns.generateObject ).toHaveBeenCalledWith( {
-      output: 'object',
+    expect( OutputMock.object ).toHaveBeenCalledWith( {
       schema,
-      schemaName: 'Thing',
-      schemaDescription: 'A thing',
-      model: 'MODEL',
-      messages: basePrompt.messages,
-      temperature: 0.3,
-      providerOptions: basePrompt.config.providerOptions
+      name: 'Thing',
+      description: 'A thing'
     } );
+    expect( aiFns.generateText ).toHaveBeenCalledWith(
+      expect.objectContaining( {
+        output: expect.objectContaining( { _type: 'object' } ),
+        model: 'MODEL',
+        messages: basePrompt.messages,
+        temperature: 0.3,
+        providerOptions: basePrompt.config.providerOptions
+      } )
+    );
+    expect( result.output ).toEqual( { a: 1 } );
+    // Backward compat: .object still works via Proxy
     expect( result.object ).toEqual( { a: 1 } );
   } );
 
-  it( 'generateArray: validates, traces, calls AI (item schema) and returns array', async () => {
+  it( 'generateArray: validates, traces, calls generateText with Output.array', async () => {
     const { generateArray } = await importSut();
-    aiFns.generateObject.mockResolvedValueOnce( {
-      object: [ 1, 2 ],
+    aiFns.generateText.mockResolvedValueOnce( {
+      output: [ 1, 2 ],
+      text: '',
       usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
       finishReason: 'stop'
     } );
@@ -155,23 +155,30 @@ describe( 'ai_sdk', () => {
     expect( tracingSpies.addEventStart ).toHaveBeenCalledTimes( 1 );
     expect( tracingSpies.addEventEnd ).toHaveBeenCalledTimes( 1 );
 
-    expect( aiFns.generateObject ).toHaveBeenCalledWith( {
-      output: 'array',
-      schema,
-      schemaName: 'Numbers',
-      schemaDescription: 'Two numbers',
-      model: 'MODEL',
-      messages: basePrompt.messages,
-      temperature: 0.3,
-      providerOptions: basePrompt.config.providerOptions
+    expect( OutputMock.array ).toHaveBeenCalledWith( {
+      element: schema,
+      name: 'Numbers',
+      description: 'Two numbers'
     } );
+    expect( aiFns.generateText ).toHaveBeenCalledWith(
+      expect.objectContaining( {
+        output: expect.objectContaining( { _type: 'array' } ),
+        model: 'MODEL',
+        messages: basePrompt.messages,
+        temperature: 0.3,
+        providerOptions: basePrompt.config.providerOptions
+      } )
+    );
+    expect( result.output ).toEqual( [ 1, 2 ] );
+    // Backward compat: .object still works via Proxy
     expect( result.object ).toEqual( [ 1, 2 ] );
   } );
 
-  it( 'generateEnum: validates, traces, calls AI with output enum and returns value', async () => {
+  it( 'generateEnum: validates, traces, calls generateText with Output.choice', async () => {
     const { generateEnum } = await importSut();
-    aiFns.generateObject.mockResolvedValueOnce( {
-      object: 'B',
+    aiFns.generateText.mockResolvedValueOnce( {
+      output: 'B',
+      text: '',
       usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
       finishReason: 'stop'
     } );
@@ -183,14 +190,20 @@ describe( 'ai_sdk', () => {
     expect( tracingSpies.addEventStart ).toHaveBeenCalledTimes( 1 );
     expect( tracingSpies.addEventEnd ).toHaveBeenCalledTimes( 1 );
 
-    expect( aiFns.generateObject ).toHaveBeenCalledWith( {
-      output: 'enum',
-      enum: [ 'A', 'B', 'C' ],
-      model: 'MODEL',
-      messages: basePrompt.messages,
-      temperature: 0.3,
-      providerOptions: basePrompt.config.providerOptions
+    expect( OutputMock.choice ).toHaveBeenCalledWith( {
+      options: [ 'A', 'B', 'C' ]
     } );
+    expect( aiFns.generateText ).toHaveBeenCalledWith(
+      expect.objectContaining( {
+        output: expect.objectContaining( { _type: 'choice' } ),
+        model: 'MODEL',
+        messages: basePrompt.messages,
+        temperature: 0.3,
+        providerOptions: basePrompt.config.providerOptions
+      } )
+    );
+    expect( result.output ).toBe( 'B' );
+    // Backward compat: .object still works via Proxy
     expect( result.object ).toBe( 'B' );
   } );
 
@@ -257,21 +270,20 @@ describe( 'ai_sdk', () => {
     const schema = z.object( { result: z.string() } );
     await generateObject( { prompt: 'test_prompt@v1', schema } );
 
-    expect( aiFns.generateObject ).toHaveBeenCalledWith( {
-      output: 'object',
-      schema,
-      schemaName: undefined,
-      schemaDescription: undefined,
-      model: 'MODEL',
-      messages: promptWithOpenAIOptions.messages,
-      temperature: 0.8,
-      providerOptions: {
-        openai: {
-          reasoningEffort: 'high',
-          reasoningSummary: 'detailed'
+    expect( aiFns.generateText ).toHaveBeenCalledWith(
+      expect.objectContaining( {
+        output: expect.objectContaining( { _type: 'object' } ),
+        model: 'MODEL',
+        messages: promptWithOpenAIOptions.messages,
+        temperature: 0.8,
+        providerOptions: {
+          openai: {
+            reasoningEffort: 'high',
+            reasoningSummary: 'detailed'
+          }
         }
-      }
-    } );
+      } )
+    );
   } );
 
   it( 'generateArray: passes azure-specific options to AI SDK', async () => {
@@ -295,21 +307,20 @@ describe( 'ai_sdk', () => {
     const schema = z.string();
     await generateArray( { prompt: 'test_prompt@v1', schema } );
 
-    expect( aiFns.generateObject ).toHaveBeenCalledWith( {
-      output: 'array',
-      schema,
-      schemaName: undefined,
-      schemaDescription: undefined,
-      model: 'MODEL',
-      messages: promptWithAzureOptions.messages,
-      maxOutputTokens: 2000,
-      providerOptions: {
-        azure: {
-          deploymentName: 'my-deployment',
-          apiVersion: '2023-12-01-preview'
+    expect( aiFns.generateText ).toHaveBeenCalledWith(
+      expect.objectContaining( {
+        output: expect.objectContaining( { _type: 'array' } ),
+        model: 'MODEL',
+        messages: promptWithAzureOptions.messages,
+        maxOutputTokens: 2000,
+        providerOptions: {
+          azure: {
+            deploymentName: 'my-deployment',
+            apiVersion: '2023-12-01-preview'
+          }
         }
-      }
-    } );
+      } )
+    );
   } );
 
   it( 'generateEnum: passes mixed provider options to AI SDK', async () => {
@@ -335,23 +346,24 @@ describe( 'ai_sdk', () => {
     const { generateEnum } = await importSut();
     await generateEnum( { prompt: 'test_prompt@v1', enum: [ 'A', 'B', 'C' ] } );
 
-    expect( aiFns.generateObject ).toHaveBeenCalledWith( {
-      output: 'enum',
-      enum: [ 'A', 'B', 'C' ],
-      model: 'MODEL',
-      messages: promptWithMixedOptions.messages,
-      maxOutputTokens: 64000,
-      providerOptions: {
-        thinking: {
-          type: 'enabled',
-          budgetTokens: 3000
-        },
-        anthropic: {
-          effort: 'high'
-        },
-        customField: { nested: 'value' }
-      }
-    } );
+    expect( aiFns.generateText ).toHaveBeenCalledWith(
+      expect.objectContaining( {
+        output: expect.objectContaining( { _type: 'choice' } ),
+        model: 'MODEL',
+        messages: promptWithMixedOptions.messages,
+        maxOutputTokens: 64000,
+        providerOptions: {
+          thinking: {
+            type: 'enabled',
+            budgetTokens: 3000
+          },
+          anthropic: {
+            effort: 'high'
+          },
+          customField: { nested: 'value' }
+        }
+      } )
+    );
   } );
 
   it( 'generateText: passes through providerMetadata', async () => {
@@ -394,10 +406,11 @@ describe( 'ai_sdk', () => {
     expect( response.result ).toBe( response.text );
   } );
 
-  it( 'generateObject: includes unified result field that matches object', async () => {
+  it( 'generateObject: includes unified result field that matches output', async () => {
     const { generateObject } = await importSut();
-    aiFns.generateObject.mockResolvedValueOnce( {
-      object: { a: 1, b: 'test' },
+    aiFns.generateText.mockResolvedValueOnce( {
+      output: { a: 1, b: 'test' },
+      text: '',
       usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
       finishReason: 'stop'
     } );
@@ -406,13 +419,16 @@ describe( 'ai_sdk', () => {
     const response = await generateObject( { prompt: 'test_prompt@v1', schema } );
 
     expect( response.result ).toEqual( { a: 1, b: 'test' } );
-    expect( response.result ).toEqual( response.object );
+    expect( response.result ).toEqual( response.output );
+    // Backward compat
+    expect( response.object ).toEqual( response.output );
   } );
 
-  it( 'generateArray: includes unified result field that matches object', async () => {
+  it( 'generateArray: includes unified result field that matches output', async () => {
     const { generateArray } = await importSut();
-    aiFns.generateObject.mockResolvedValueOnce( {
-      object: [ 'item1', 'item2', 'item3' ],
+    aiFns.generateText.mockResolvedValueOnce( {
+      output: [ 'item1', 'item2', 'item3' ],
+      text: '',
       usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
       finishReason: 'stop'
     } );
@@ -421,13 +437,16 @@ describe( 'ai_sdk', () => {
     const response = await generateArray( { prompt: 'test_prompt@v1', schema } );
 
     expect( response.result ).toEqual( [ 'item1', 'item2', 'item3' ] );
-    expect( response.result ).toEqual( response.object );
+    expect( response.result ).toEqual( response.output );
+    // Backward compat
+    expect( response.object ).toEqual( response.output );
   } );
 
-  it( 'generateEnum: includes unified result field that matches object', async () => {
+  it( 'generateEnum: includes unified result field that matches output', async () => {
     const { generateEnum } = await importSut();
-    aiFns.generateObject.mockResolvedValueOnce( {
-      object: 'yes',
+    aiFns.generateText.mockResolvedValueOnce( {
+      output: 'yes',
+      text: '',
       usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
       finishReason: 'stop'
     } );
@@ -435,7 +454,9 @@ describe( 'ai_sdk', () => {
     const response = await generateEnum( { prompt: 'test_prompt@v1', enum: [ 'yes', 'no' ] } );
 
     expect( response.result ).toBe( 'yes' );
-    expect( response.result ).toBe( response.object );
+    expect( response.result ).toBe( response.output );
+    // Backward compat
+    expect( response.object ).toBe( response.output );
   } );
 
   it( 'generateText: traces error and rethrows when AI SDK fails', async () => {
@@ -451,7 +472,7 @@ describe( 'ai_sdk', () => {
 
   it( 'generateObject: traces error and rethrows when AI SDK fails', async () => {
     const error = new Error( 'Invalid schema' );
-    aiFns.generateObject.mockRejectedValueOnce( error );
+    aiFns.generateText.mockRejectedValueOnce( error );
     const { generateObject } = await importSut();
 
     const schema = z.object( { a: z.number() } );
@@ -482,21 +503,24 @@ describe( 'ai_sdk', () => {
 
   it( 'generateObject: Proxy correctly handles AI SDK response with getter', async () => {
     const responseWithGetter = {
-      _internalObject: { value: 42 },
-      get object() {
-        return this._internalObject;
+      _internalOutput: { value: 42 },
+      get output() {
+        return this._internalOutput;
       },
+      text: '',
       usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
       finishReason: 'stop'
     };
-    aiFns.generateObject.mockResolvedValueOnce( responseWithGetter );
+    aiFns.generateText.mockResolvedValueOnce( responseWithGetter );
 
     const { generateObject } = await importSut();
     const schema = z.object( { value: z.number() } );
     const response = await generateObject( { prompt: 'test_prompt@v1', schema } );
 
-    expect( response.object ).toEqual( { value: 42 } );
+    expect( response.output ).toEqual( { value: 42 } );
     expect( response.result ).toEqual( { value: 42 } );
+    // Backward compat via Proxy
+    expect( response.object ).toEqual( { value: 42 } );
   } );
 
   it( 'generateText: passes through AI SDK options like tools and maxRetries', async () => {
@@ -561,6 +585,13 @@ describe( 'ai_sdk', () => {
     const { generateObject } = await importSut();
     const schema = z.object( { a: z.number() } );
 
+    aiFns.generateText.mockResolvedValueOnce( {
+      output: { a: 1 },
+      text: '',
+      usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+      finishReason: 'stop'
+    } );
+
     await generateObject( {
       prompt: 'test_prompt@v1',
       schema,
@@ -569,7 +600,7 @@ describe( 'ai_sdk', () => {
       topP: 0.9
     } );
 
-    expect( aiFns.generateObject ).toHaveBeenCalledWith(
+    expect( aiFns.generateText ).toHaveBeenCalledWith(
       expect.objectContaining( {
         maxRetries: 3,
         seed: 123,
@@ -583,6 +614,13 @@ describe( 'ai_sdk', () => {
     const schema = z.string();
     const controller = new AbortController();
 
+    aiFns.generateText.mockResolvedValueOnce( {
+      output: [ 'a' ],
+      text: '',
+      usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+      finishReason: 'stop'
+    } );
+
     await generateArray( {
       prompt: 'test_prompt@v1',
       schema,
@@ -590,7 +628,7 @@ describe( 'ai_sdk', () => {
       headers: { 'X-Custom': 'value' }
     } );
 
-    expect( aiFns.generateObject ).toHaveBeenCalledWith(
+    expect( aiFns.generateText ).toHaveBeenCalledWith(
       expect.objectContaining( {
         abortSignal: controller.signal,
         headers: { 'X-Custom': 'value' }
@@ -601,6 +639,13 @@ describe( 'ai_sdk', () => {
   it( 'generateEnum: passes through AI SDK options', async () => {
     const { generateEnum } = await importSut();
 
+    aiFns.generateText.mockResolvedValueOnce( {
+      output: 'A',
+      text: '',
+      usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+      finishReason: 'stop'
+    } );
+
     await generateEnum( {
       prompt: 'test_prompt@v1',
       enum: [ 'A', 'B' ],
@@ -608,7 +653,7 @@ describe( 'ai_sdk', () => {
       presencePenalty: 0.5
     } );
 
-    expect( aiFns.generateObject ).toHaveBeenCalledWith(
+    expect( aiFns.generateText ).toHaveBeenCalledWith(
       expect.objectContaining( {
         stopSequences: [ 'END' ],
         presencePenalty: 0.5
@@ -616,6 +661,15 @@ describe( 'ai_sdk', () => {
     );
   } );
 
+  it( 'generateText: .object returns undefined instead of leaking text', async () => {
+    const { generateText } = await importSut();
+    const result = await generateText( { prompt: 'test_prompt@v1' } );
+
+    expect( result.object ).toBeUndefined();
+    expect( result.text ).toBe( 'TEXT' );
+    expect( result.result ).toBe( 'TEXT' );
+  } );
+
   it( 'generateText: passes through unknown future options for forward compatibility', async () => {
     const { generateText } = await importSut();