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

package/src/prompt_validations.spec.js

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import { ValidationError } from '@output.ai/core';
 import { validatePrompt } from './prompt_validations.js';
 
@@ -65,6 +65,52 @@ describe( 'validatePrompt', () => {
     expect( () => validatePrompt( promptWithThinking ) ).not.toThrow();
   } );
 
+  it( 'should validate a prompt with thinking type disabled', () => {
+    const promptWithThinkingDisabled = {
+      name: 'thinking-disabled-prompt',
+      config: {
+        provider: 'anthropic',
+        model: 'claude-3-5-sonnet-20241022',
+        providerOptions: {
+          thinking: {
+            type: 'disabled'
+          }
+        }
+      },
+      messages: [
+        {
+          role: 'user',
+          content: 'Simple task.'
+        }
+      ]
+    };
+
+    expect( () => validatePrompt( promptWithThinkingDisabled ) ).not.toThrow();
+  } );
+
+  it( 'should validate a prompt with thinking without budgetTokens', () => {
+    const promptWithThinkingNoBudget = {
+      name: 'thinking-no-budget',
+      config: {
+        provider: 'anthropic',
+        model: 'claude-3-5-sonnet-20241022',
+        providerOptions: {
+          thinking: {
+            type: 'enabled'
+          }
+        }
+      },
+      messages: [
+        {
+          role: 'user',
+          content: 'Think about this.'
+        }
+      ]
+    };
+
+    expect( () => validatePrompt( promptWithThinkingNoBudget ) ).not.toThrow();
+  } );
+
   it( 'should validate a prompt with anthropic-specific providerOptions', () => {
     const promptWithAnthropicOptions = {
       name: 'anthropic-options-prompt',
@@ -174,11 +220,50 @@ describe( 'validatePrompt', () => {
     expect( () => validatePrompt( promptWithMixedOptions ) ).not.toThrow();
   } );
 
-  it( 'should throw ValidationError when provider is invalid', () => {
-    const invalidPrompt = {
-      name: 'invalid-provider',
+  it( 'should accept custom provider names for dynamic providers', () => {
+    const customProviderPrompt = {
+      name: 'custom-provider-prompt',
+      config: {
+        provider: 'my-custom-provider',
+        model: 'custom-model-v1'
+      },
+      messages: [
+        {
+          role: 'user',
+          content: 'Test'
+        }
+      ]
+    };
+
+    expect( () => validatePrompt( customProviderPrompt ) ).not.toThrow();
+  } );
+
+  it( 'should accept extra config fields via passthrough', () => {
+    const extraFieldsPrompt = {
+      name: 'extra-fields-prompt',
+      config: {
+        provider: 'openai',
+        model: 'gpt-4',
+        topP: 0.9,
+        seed: 42,
+        stopSequences: [ 'END' ]
+      },
+      messages: [
+        {
+          role: 'user',
+          content: 'Test'
+        }
+      ]
+    };
+
+    expect( () => validatePrompt( extraFieldsPrompt ) ).not.toThrow();
+  } );
+
+  it( 'should throw ValidationError when provider is empty string', () => {
+    const emptyProviderPrompt = {
+      name: 'empty-provider',
       config: {
-        provider: 'invalid-provider',
+        provider: '',
         model: 'some-model'
       },
       messages: [
@@ -189,7 +274,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( invalidPrompt ) ).toThrow( ValidationError );
+    expect( () => validatePrompt( emptyProviderPrompt ) ).toThrow( ValidationError );
   } );
 
   it( 'should throw ValidationError when required fields are missing', () => {
@@ -209,7 +294,38 @@ describe( 'validatePrompt', () => {
     expect( () => validatePrompt( missingNamePrompt ) ).toThrow( ValidationError );
   } );
 
-  it( 'should throw ValidationError when max tokens is snake_case', () => {
+  it( 'should pass through budget_tokens in thinking and warn about snake_case', () => {
+    const warnSpy = vi.spyOn( console, 'warn' ).mockImplementation( () => {} );
+
+    const promptWithBudgetTokensSnake = {
+      name: 'thinking-budget-snake',
+      config: {
+        provider: 'anthropic',
+        model: 'claude-sonnet-4-20250514',
+        providerOptions: {
+          thinking: {
+            type: 'enabled',
+            budget_tokens: 10000
+          }
+        }
+      },
+      messages: [
+        {
+          role: 'user',
+          content: 'Think hard.'
+        }
+      ]
+    };
+
+    expect( () => validatePrompt( promptWithBudgetTokensSnake ) ).not.toThrow();
+    expect( warnSpy ).toHaveBeenCalledWith(
+      '[output-llm] "budget_tokens" found in providerOptions.thinking. Did you mean "budgetTokens"?'
+    );
+
+    warnSpy.mockRestore();
+  } );
+
+  it( 'should allow snake_case fields in config via passthrough (no longer strict)', () => {
     const maxTokensSnakeCase = {
       name: 'test-prompt',
       config: {
@@ -225,6 +341,6 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( maxTokensSnakeCase ) ).toThrow( ValidationError );
+    expect( () => validatePrompt( maxTokensSnakeCase ) ).not.toThrow();
   } );
 } );

package/src/validations.js

@@ -5,17 +5,7 @@ const generateTextArgsSchema = z.object( {
   variables: z.any().optional()
 } );
 
-const generateObjectArgsSchema = z.object( {
-  prompt: z.string(),
-  variables: z.any().optional(),
-  schema: z.custom( v => v instanceof z.ZodObject, {
-    message: 'schema must be a ZodObject'
-  } ),
-  schemaName: z.string().optional(),
-  schemaDescription: z.string().optional()
-} );
-
-const generateArrayArgsSchema = z.object( {
+const generateSchemaArgsSchema = z.object( {
   prompt: z.string(),
   variables: z.any().optional(),
   schema: z.custom( v => v instanceof z.ZodType, {
@@ -43,11 +33,11 @@ export function validateGenerateTextArgs( args ) {
 }
 
 export function validateGenerateObjectArgs( args ) {
-  validateSchema( generateObjectArgsSchema, args, 'Invalid generateObject() arguments' );
+  validateSchema( generateSchemaArgsSchema, args, 'Invalid generateObject() arguments' );
 }
 
 export function validateGenerateArrayArgs( args ) {
-  validateSchema( generateArrayArgsSchema, args, 'Invalid generateArray() arguments' );
+  validateSchema( generateSchemaArgsSchema, args, 'Invalid generateArray() arguments' );
 }
 
 export function validateGenerateEnumArgs( args ) {