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

package/src/index.js

@@ -1,4 +1,5 @@
 export { generateText, generateArray, generateObject, generateEnum } from './ai_sdk.js';
 export { loadPrompt } from './prompt_loader.js';
-export { tool } from 'ai';
+export { registerProvider, getRegisteredProviders } from './ai_model.js';
+export { tool, Output } from 'ai';
 export * as ai from 'ai';

package/src/prompt_loader_validation.spec.js

@@ -6,7 +6,6 @@ vi.mock( './load_content.js', () => ( {
 } ) );
 
 import { loadContent } from './load_content.js';
-import { ValidationError } from '@output.ai/core';
 
 describe( 'loadPrompt - validation with real schema', () => {
   beforeEach( () => {
@@ -14,7 +13,6 @@ describe( 'loadPrompt - validation with real schema', () => {
   } );
 
   it( 'should accept valid camelCase format with providerOptions and budgetTokens', () => {
-    // Frontmatter uses canonical format: providerOptions.thinking.budgetTokens
     const promptContent = `---
 provider: anthropic
 model: claude-sonnet-4-20250514
@@ -32,14 +30,12 @@ providerOptions:
 
     const result = loadPrompt( 'test', {} );
 
-    // Validation passes with canonical schema format
     expect( result.config.providerOptions ).toBeDefined();
     expect( result.config.providerOptions.thinking.type ).toBe( 'enabled' );
     expect( result.config.providerOptions.thinking.budgetTokens ).toBe( 1500 );
   } );
 
-  it( 'should REJECT snake_case max_tokens (not canonical)', () => {
-    // Using snake_case max_tokens should fail validation
+  it( 'should accept snake_case max_tokens via config passthrough (no longer strict)', () => {
     const promptContent = `---
 provider: anthropic
 model: claude-sonnet-4-20250514
@@ -50,19 +46,13 @@ max_tokens: 64000
 
     loadContent.mockReturnValue( promptContent );
 
-    // loadPrompt should throw ValidationError because schema should reject max_tokens.
-    // Other tests check the actual message, but this one specifically checks that we throw
-    // the right kind of error, just to check that as well
+    // Config uses passthrough, so max_tokens is accepted (though ignored by SDK)
     expect( () => {
       loadPrompt( 'test', {} );
-    } ).toThrow( ValidationError );
-    expect( () => {
-      loadPrompt( 'test', {} );
-    } ).toThrow( /max_tokens/ );
+    } ).not.toThrow();
   } );
 
-  it( 'should REJECT deprecated "options" field (use providerOptions)', () => {
-    // Using 'options' instead of 'providerOptions' should fail validation
+  it( 'should accept "options" field via config passthrough (no longer strict)', () => {
     const promptContent = `---
 provider: anthropic
 model: claude-sonnet-4-20250514
@@ -76,85 +66,16 @@ options:
 
     loadContent.mockReturnValue( promptContent );
 
-    // loadPrompt should throw ValidationError because schema should reject 'options'
-    expect( () => {
-      loadPrompt( 'test', {} );
-    } ).toThrow( /Invalid prompt file/ );
-  } );
-
-  it( 'should REJECT snake_case budget_tokens in providerOptions', () => {
-    // Using snake_case budget_tokens should fail validation
-    const promptContent = `---
-provider: anthropic
-model: claude-sonnet-4-20250514
-providerOptions:
-  thinking:
-    type: enabled
-    budget_tokens: 1500
----
-
-<user>Hello</user>`;
-
-    loadContent.mockReturnValue( promptContent );
-
-    // loadPrompt should throw ValidationError because schema rejects budget_tokens
-    expect( () => {
-      loadPrompt( 'test', {} );
-    } ).toThrow( /Invalid prompt file/ );
-  } );
-
-  it( 'end-to-end: should accept canonical camelCase format', () => {
-    // End-to-end test: frontmatter uses canonical providerOptions.thinking.budgetTokens
-    const promptContent = `---
-provider: anthropic
-model: claude-sonnet-4-20250514
-temperature: 0.7
-maxTokens: 64000
-providerOptions:
-  thinking:
-    type: enabled
-    budgetTokens: 1500
----
-
-<user>Hello</user>`;
-
-    loadContent.mockReturnValue( promptContent );
-
-    const result = loadPrompt( 'test', {} );
-
-    // After loadPrompt, uses canonical format
-    expect( result.config.providerOptions ).toBeDefined();
-    expect( result.config.providerOptions.thinking.type ).toBe( 'enabled' );
-    expect( result.config.providerOptions.thinking.budgetTokens ).toBe( 1500 );
-  } );
-
-  it( 'end-to-end: should FAIL validation with snake_case budget_tokens', () => {
-    // End-to-end test: using snake_case should fail validation
-    const promptContent = `---
-provider: anthropic
-model: claude-sonnet-4-20250514
-providerOptions:
-  thinking:
-    type: enabled
-    budget_tokens: 1500
----
-
-<user>Hello</user>`;
-
-    loadContent.mockReturnValue( promptContent );
-
-    // loadPrompt should throw ValidationError because schema rejects budget_tokens
+    // Config uses passthrough, so 'options' passes through (though not used)
     expect( () => {
       loadPrompt( 'test', {} );
-    } ).toThrow( /Invalid prompt file/ );
+    } ).not.toThrow();
   } );
 
-  it( 'end-to-end: should FAIL validation with snake_case max_tokens', () => {
-    // End-to-end test: using snake_case should fail validation
+  it( 'should accept snake_case budget_tokens in thinking via passthrough', () => {
     const promptContent = `---
 provider: anthropic
 model: claude-sonnet-4-20250514
-max_tokens: 4000
 providerOptions:
   thinking:
     type: enabled
@@ -165,10 +86,10 @@ providerOptions:
 
     loadContent.mockReturnValue( promptContent );
 
-    // loadPrompt should throw ValidationError because schema rejects max_tokens
+    // budget_tokens is silently stripped from thinking (unknown field), not rejected
     expect( () => {
       loadPrompt( 'test', {} );
-    } ).toThrow( /Invalid prompt file/ );
+    } ).not.toThrow();
   } );
 
 } );

package/src/prompt_validations.js

@@ -3,23 +3,18 @@ import { ValidationError, z } from '@output.ai/core';
 export const promptSchema = z.object( {
   name: z.string(),
   config: z.object( {
-    provider: z.enum( [ 'anthropic', 'azure', 'openai', 'vertex' ] ),
+    provider: z.string().min( 1 ),
     model: z.string(),
     temperature: z.number().optional(),
     maxTokens: z.number().optional(),
     tools: z.record( z.string(), z.object( {} ).passthrough() ).optional(),
     providerOptions: z.object( {
       thinking: z.object( {
-        type: z.literal( 'enabled' ),
-        budgetTokens: z.number()
-      } ).optional(),
-      anthropic: z.record( z.string(), z.unknown() ).optional(),
-      openai: z.record( z.string(), z.unknown() ).optional(),
-      azure: z.record( z.string(), z.unknown() ).optional(),
-      vertex: z.record( z.string(), z.unknown() ).optional(),
-      google: z.record( z.string(), z.unknown() ).optional()
+        type: z.enum( [ 'enabled', 'disabled' ] ),
+        budgetTokens: z.number().optional()
+      } ).passthrough().optional()
     } ).passthrough().optional()
-  } ).strict(),
+  } ).passthrough(),
   messages: z.array(
     z.object( {
       role: z.string(),
@@ -28,50 +23,38 @@ export const promptSchema = z.object( {
   )
 } ).strict();
 
-const getHintForError = errorMessage => {
-  if ( errorMessage.includes( 'max_tokens' ) ) {
-    return '\nHint: Use "maxTokens" (camelCase) instead of "max_tokens".';
-  }
-  if ( errorMessage.includes( 'budget_tokens' ) ) {
-    return '\nHint: Use "budgetTokens" (camelCase) instead of "budget_tokens".';
-  }
-  if ( errorMessage.includes( '"options"' ) ) {
-    return '\nHint: Use "providerOptions" instead of "options".';
-  }
-  return '';
+const SNAKE_CASE_WARNINGS = {
+  max_tokens: 'maxTokens',
+  budget_tokens: 'budgetTokens',
+  top_p: 'topP',
+  top_k: 'topK',
+  stop_sequences: 'stopSequences',
+  options: 'providerOptions'
 };
 
-// Known providerOptions fields. Note: these don't map 1:1 to providers.
-// - 'google' is used by Vertex provider for Gemini language models
-// - 'vertex' is used by Vertex provider for Imagen image models
-// - 'anthropic' is used by both Anthropic provider and Vertex Anthropic
-const knownProviderOptionsFields = new Set( [
-  'thinking',
-  'anthropic',
-  'openai',
-  'azure',
-  'vertex',
-  'google'
-] );
+function warnSnakeCaseFields( config ) {
+  for ( const [ snake, camel ] of Object.entries( SNAKE_CASE_WARNINGS ) ) {
+    if ( snake in config ) {
+      console.warn( `[output-llm] "${snake}" found in prompt config. Did you mean "${camel}"?` );
+    }
+  }
+  const thinking = config.providerOptions?.thinking;
+  if ( thinking && 'budget_tokens' in thinking ) {
+    console.warn( '[output-llm] "budget_tokens" found in providerOptions.thinking. Did you mean "budgetTokens"?' );
+  }
+}
 
 export function validatePrompt( prompt ) {
   const result = promptSchema.safeParse( prompt );
   if ( !result.success ) {
     const promptIdentifier = prompt?.name ? `"${prompt.name}"` : '(unnamed)';
     const errorMessage = z.prettifyError( result.error );
-    const hint = getHintForError( errorMessage );
 
     throw new ValidationError(
-      `Invalid prompt file ${promptIdentifier}: ${errorMessage}${hint}`,
+      `Invalid prompt file ${promptIdentifier}: ${errorMessage}`,
       { cause: result.error }
     );
   }
 
-  const providerOptions = prompt?.config?.providerOptions;
-  if ( providerOptions ) {
-    const unknownFields = Object.keys( providerOptions ).filter( k => !knownProviderOptionsFields.has( k ) );
-    if ( unknownFields.length > 0 ) {
-      console.warn( `Prompt "${prompt.name}": Unrecognized providerOptions fields: ${unknownFields.join( ', ' )}` );
-    }
-  }
+  warnSnakeCaseFields( result.data.config );
 }

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 ) {