@outputai/llm 0.11.0 → 0.11.1-next.2223fa5.0

package/src/prompt/validations.spec.js

@@ -1,8 +1,10 @@
 import { describe, it, expect } from 'vitest';
 import { ValidationError } from '@outputai/core';
-import { validatePrompt } from './validations.js';
+import { parsePromptSchema } from './validations.js';
 
-describe( 'validatePrompt', () => {
+const parse = prompt => parsePromptSchema( { fileDir: '/prompts', ...prompt } );
+
+describe( 'parsePromptSchema', () => {
   it( 'should validate a correct prompt with all required fields', () => {
     const validPrompt = {
       name: 'test-prompt',
@@ -10,7 +12,13 @@ describe( 'validatePrompt', () => {
         provider: 'anthropic',
         model: 'claude-3-opus-20240229',
         temperature: 0.7,
-        maxTokens: 1000
+        maxOutputTokens: 1000,
+        topP: 0.9,
+        topK: 40,
+        presencePenalty: 0.2,
+        frequencyPenalty: 0.3,
+        stopSequences: [ 'END' ],
+        seed: 42
       },
       messages: [
         {
@@ -20,7 +28,19 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( validPrompt ) ).not.toThrow();
+    expect( () => parse( validPrompt ) ).not.toThrow();
+  } );
+
+  it.each( [ 'temperature', 'topK', 'topP' ] )( 'should reject a negative %s', field => {
+    expect( () => parse( {
+      name: `negative-${field}`,
+      config: {
+        provider: 'anthropic',
+        model: 'claude-3-opus-20240229',
+        [field]: -0.1
+      },
+      messages: [ { role: 'user', content: 'Hello' } ]
+    } ) ).toThrow( ValidationError );
   } );
 
   it( 'should validate a minimal prompt with only required fields', () => {
@@ -38,7 +58,40 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( minimalPrompt ) ).not.toThrow();
+    expect( parse( minimalPrompt ).config.skills ).toEqual( [] );
+    expect( parse( minimalPrompt ).config.maxSteps ).toBe( 10 );
+    expect( parse( minimalPrompt ).variables ).toEqual( {} );
+  } );
+
+  it( 'should copy deprecated maxTokens to maxOutputTokens', () => {
+    const result = parse( {
+      name: 'deprecated-max-tokens',
+      config: {
+        provider: 'openai',
+        model: 'gpt-4',
+        maxTokens: 1000
+      },
+      messages: [ { role: 'user', content: 'Hello' } ]
+    } );
+
+    expect( result.config.maxTokens ).toBe( 1000 );
+    expect( result.config.maxOutputTokens ).toBe( 1000 );
+  } );
+
+  it( 'should keep maxOutputTokens when both token limit keys are set', () => {
+    const result = parse( {
+      name: 'both-token-limits',
+      config: {
+        provider: 'openai',
+        model: 'gpt-4',
+        maxTokens: 1000,
+        maxOutputTokens: 2000
+      },
+      messages: [ { role: 'user', content: 'Hello' } ]
+    } );
+
+    expect( result.config.maxTokens ).toBe( 1000 );
+    expect( result.config.maxOutputTokens ).toBe( 2000 );
   } );
 
   it( 'should validate a prompt with thinking providerOptions', () => {
@@ -62,7 +115,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( promptWithThinking ) ).not.toThrow();
+    expect( () => parse( promptWithThinking ) ).not.toThrow();
   } );
 
   it( 'should validate a prompt with thinking type disabled', () => {
@@ -85,7 +138,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( promptWithThinkingDisabled ) ).not.toThrow();
+    expect( () => parse( promptWithThinkingDisabled ) ).not.toThrow();
   } );
 
   it( 'should validate a prompt with thinking without budgetTokens', () => {
@@ -108,7 +161,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( promptWithThinkingNoBudget ) ).not.toThrow();
+    expect( () => parse( promptWithThinkingNoBudget ) ).not.toThrow();
   } );
 
   it( 'should validate a prompt with anthropic-specific providerOptions', () => {
@@ -136,7 +189,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( promptWithAnthropicOptions ) ).not.toThrow();
+    expect( () => parse( promptWithAnthropicOptions ) ).not.toThrow();
   } );
 
   it( 'should validate a prompt with openai-specific providerOptions', () => {
@@ -161,7 +214,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( promptWithOpenAIOptions ) ).not.toThrow();
+    expect( () => parse( promptWithOpenAIOptions ) ).not.toThrow();
   } );
 
   it( 'should validate a prompt with azure-specific providerOptions', () => {
@@ -185,7 +238,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( promptWithAzureOptions ) ).not.toThrow();
+    expect( () => parse( promptWithAzureOptions ) ).not.toThrow();
   } );
 
   it( 'should validate a prompt with mixed providerOptions including unknown fields', () => {
@@ -217,7 +270,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( promptWithMixedOptions ) ).not.toThrow();
+    expect( () => parse( promptWithMixedOptions ) ).not.toThrow();
   } );
 
   it( 'should accept custom provider names for dynamic providers', () => {
@@ -235,7 +288,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( customProviderPrompt ) ).not.toThrow();
+    expect( () => parse( customProviderPrompt ) ).not.toThrow();
   } );
 
   it( 'should validate image generation config fields', () => {
@@ -263,7 +316,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( imagePrompt ) ).not.toThrow();
+    expect( () => parse( imagePrompt ) ).not.toThrow();
   } );
 
   it( 'should validate a plain-instructions prompt without messages', () => {
@@ -277,7 +330,7 @@ describe( 'validatePrompt', () => {
       instructions: 'Generate an image of a mountain.'
     };
 
-    expect( () => validatePrompt( instructionsPrompt ) ).not.toThrow();
+    expect( () => parse( instructionsPrompt ) ).not.toThrow();
   } );
 
   it( 'should validate role messages with null instructions', () => {
@@ -296,7 +349,7 @@ describe( 'validatePrompt', () => {
       instructions: null
     };
 
-    expect( () => validatePrompt( messagesPrompt ) ).not.toThrow();
+    expect( () => parse( messagesPrompt ) ).not.toThrow();
   } );
 
   it( 'should throw ValidationError when instructions are only whitespace', () => {
@@ -310,7 +363,7 @@ describe( 'validatePrompt', () => {
       instructions: '   '
     };
 
-    expect( () => validatePrompt( whitespaceInstructionsPrompt ) ).toThrow( ValidationError );
+    expect( () => parse( whitespaceInstructionsPrompt ) ).toThrow( ValidationError );
   } );
 
   it( 'should throw ValidationError when both messages and instructions are present', () => {
@@ -329,7 +382,7 @@ describe( 'validatePrompt', () => {
       instructions: 'Plain instructions should not be mixed with messages.'
     };
 
-    expect( () => validatePrompt( mixedPrompt ) ).toThrow( ValidationError );
+    expect( () => parse( mixedPrompt ) ).toThrow( ValidationError );
   } );
 
   it( 'should throw ValidationError when neither messages nor instructions are present', () => {
@@ -343,7 +396,7 @@ describe( 'validatePrompt', () => {
       instructions: null
     };
 
-    expect( () => validatePrompt( emptyPrompt ) ).toThrow( ValidationError );
+    expect( () => parse( emptyPrompt ) ).toThrow( ValidationError );
   } );
 
   it( 'should validate a prompt with skill path config', () => {
@@ -362,10 +415,10 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( promptWithSkills ) ).not.toThrow();
+    expect( parse( promptWithSkills ).config.skills ).toEqual( [ './skills', './review.md' ] );
   } );
 
-  it( 'should validate a prompt with a single skill path config', () => {
+  it( 'coerces a single skill path to an array', () => {
     const promptWithSkill = {
       name: 'skill-prompt',
       config: {
@@ -381,7 +434,109 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( promptWithSkill ) ).not.toThrow();
+    expect( parse( promptWithSkill ).config.skills ).toEqual( [ './skills' ] );
+  } );
+
+  it( 'coerces null skills to an empty array', () => {
+    const promptWithNullSkills = {
+      name: 'null-skills-prompt',
+      config: {
+        provider: 'anthropic',
+        model: 'claude-3-opus-20240229',
+        skills: null
+      },
+      messages: [
+        {
+          role: 'user',
+          content: 'Review this.'
+        }
+      ]
+    };
+
+    expect( parse( promptWithNullSkills ).config.skills ).toEqual( [] );
+  } );
+
+  it( 'should validate prompt maxSteps', () => {
+    const promptWithMaxSteps = {
+      name: 'max-steps-prompt',
+      config: {
+        provider: 'anthropic',
+        model: 'claude-3-opus-20240229',
+        maxSteps: 4
+      },
+      messages: [
+        {
+          role: 'user',
+          content: 'Hello'
+        }
+      ]
+    };
+
+    expect( parse( promptWithMaxSteps ).config.maxSteps ).toBe( 4 );
+  } );
+
+  it( 'should throw ValidationError for invalid maxSteps', () => {
+    for ( const maxSteps of [ 0, -1, 1.5 ] ) {
+      expect( () => parse( {
+        name: 'invalid-max-steps',
+        config: {
+          provider: 'anthropic',
+          model: 'claude-3-opus-20240229',
+          maxSteps
+        },
+        messages: [
+          {
+            role: 'user',
+            content: 'Hello'
+          }
+        ]
+      } ) ).toThrow( ValidationError );
+    }
+  } );
+
+  it( 'throws ValidationError when fileDir is missing', () => {
+    expect( () => parsePromptSchema( {
+      name: 'no-file-dir',
+      config: {
+        provider: 'anthropic',
+        model: 'claude-3-opus-20240229'
+      },
+      messages: [
+        {
+          role: 'user',
+          content: 'Hello'
+        }
+      ]
+    } ) ).toThrow( ValidationError );
+  } );
+
+  it( 'accepts scalar, object, and array variables', () => {
+    expect( parse( {
+      name: 'typed-variables',
+      config: {
+        provider: 'anthropic',
+        model: 'claude-3-opus-20240229'
+      },
+      messages: [
+        {
+          role: 'user',
+          content: 'Hello'
+        }
+      ],
+      variables: {
+        name: 'Acme',
+        size: 250,
+        active: true,
+        company: { name: 'Acme' },
+        industries: [ 'SaaS', 'AI' ]
+      }
+    } ).variables ).toEqual( {
+      name: 'Acme',
+      size: 250,
+      active: true,
+      company: { name: 'Acme' },
+      industries: [ 'SaaS', 'AI' ]
+    } );
   } );
 
   it( 'should validate provider tool config records', () => {
@@ -406,7 +561,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( promptWithTools ) ).not.toThrow();
+    expect( () => parse( promptWithTools ) ).not.toThrow();
   } );
 
   it( 'should throw ValidationError when tools config is not a record', () => {
@@ -425,7 +580,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( invalidToolsPrompt ) ).toThrow( ValidationError );
+    expect( () => parse( invalidToolsPrompt ) ).toThrow( ValidationError );
   } );
 
   it( 'should throw ValidationError when a tool config is not a record', () => {
@@ -446,7 +601,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( invalidToolConfigPrompt ) ).toThrow( ValidationError );
+    expect( () => parse( invalidToolConfigPrompt ) ).toThrow( ValidationError );
   } );
 
   it( 'should throw ValidationError for invalid skill path config', () => {
@@ -465,7 +620,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( invalidSkillsPrompt ) ).toThrow( ValidationError );
+    expect( () => parse( invalidSkillsPrompt ) ).toThrow( ValidationError );
   } );
 
   it( 'should throw ValidationError for invalid image generation config fields', () => {
@@ -488,18 +643,16 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( invalidImagePrompt ) ).toThrow( ValidationError );
+    expect( () => parse( invalidImagePrompt ) ).toThrow( ValidationError );
   } );
 
-  it( 'should accept extra config fields via passthrough', () => {
+  it( 'should reject unrecognized config fields', () => {
     const extraFieldsPrompt = {
       name: 'extra-fields-prompt',
       config: {
         provider: 'openai',
         model: 'gpt-4',
-        topP: 0.9,
-        seed: 42,
-        stopSequences: [ 'END' ]
+        unsupportedOption: true
       },
       messages: [
         {
@@ -509,7 +662,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( extraFieldsPrompt ) ).not.toThrow();
+    expect( () => parse( extraFieldsPrompt ) ).toThrow( /unrecognized key/i );
   } );
 
   it( 'should throw ValidationError when provider is empty string', () => {
@@ -527,7 +680,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( emptyProviderPrompt ) ).toThrow( ValidationError );
+    expect( () => parse( emptyProviderPrompt ) ).toThrow( ValidationError );
   } );
 
   it( 'should throw ValidationError when required fields are missing', () => {
@@ -544,7 +697,7 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( missingNamePrompt ) ).toThrow( ValidationError );
+    expect( () => parse( missingNamePrompt ) ).toThrow( ValidationError );
   } );
 
   it( 'should pass through budget_tokens in thinking and warn about snake_case', () => {
@@ -568,10 +721,10 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( promptWithBudgetTokensSnake ) ).not.toThrow();
+    expect( () => parse( promptWithBudgetTokensSnake ) ).not.toThrow();
   } );
 
-  it( 'should allow snake_case fields in config via passthrough (no longer strict)', () => {
+  it( 'should suggest camelCase when a snake_case config key matches a known field', () => {
     const maxTokensSnakeCase = {
       name: 'test-prompt',
       config: {
@@ -587,11 +740,11 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( maxTokensSnakeCase ) ).not.toThrow();
+    expect( () => parse( maxTokensSnakeCase ) ).toThrow( /"max_tokens" is not valid; use "maxTokens"/ );
   } );
 
-  it( 'should validate the options attribute referencing messageOptions sets', () => {
-    const promptWithMessageOptions = {
+  it( 'should validate per-message providerOptions', () => {
+    const promptWithMessageProviderOptions = {
       name: 'message-options-prompt',
       config: {
         provider: 'anthropic',
@@ -601,27 +754,31 @@ describe( 'validatePrompt', () => {
         }
       },
       messages: [
-        { role: 'system', content: 'Docs.', attributes: { options: 'cached' } },
+        {
+          role: 'system',
+          content: 'Docs.',
+          providerOptions: { anthropic: { cacheControl: { type: 'ephemeral' } } }
+        },
         { role: 'user', content: 'Question' }
       ]
     };
 
-    expect( () => validatePrompt( promptWithMessageOptions ) ).not.toThrow();
+    expect( () => parse( promptWithMessageProviderOptions ) ).not.toThrow();
   } );
 
-  it( 'should reject the removed cache shorthand as an unknown block attribute', () => {
-    const cacheShorthandPrompt = {
-      name: 'cache-shorthand-prompt',
+  it( 'should reject leftover attributes on a message', () => {
+    const leftoverAttributesPrompt = {
+      name: 'leftover-attributes-prompt',
       config: {
         provider: 'anthropic',
         model: 'claude-sonnet-4-5'
       },
       messages: [
-        { role: 'system', content: 'Static.', attributes: { cache: true } }
+        { role: 'system', content: 'Static.', attributes: { options: 'cached' } }
       ]
     };
 
-    expect( () => validatePrompt( cacheShorthandPrompt ) ).toThrow( ValidationError );
+    expect( () => parse( leftoverAttributesPrompt ) ).toThrow( ValidationError );
   } );
 
   it( 'should throw ValidationError for unknown top-level message fields', () => {
@@ -636,6 +793,6 @@ describe( 'validatePrompt', () => {
       ]
     };
 
-    expect( () => validatePrompt( unknownFieldPrompt ) ).toThrow( ValidationError );
+    expect( () => parse( unknownFieldPrompt ) ).toThrow( ValidationError );
   } );
 } );

package/src/{prompt/load_content.js → utils/file.js}

@@ -1,6 +1,5 @@
 import { join } from 'path';
 import { readdirSync, readFileSync } from 'node:fs';
-import { Path } from '@outputai/core/sdk/helpers';
 import { FatalError } from '@outputai/core';
 
 const scanDir = dir => {
@@ -11,7 +10,7 @@ const scanDir = dir => {
   }
 };
 
-const loadFile = path => {
+const readFile = path => {
   try {
     return readFileSync( path, 'utf-8' );
   } catch ( error ) {
@@ -19,13 +18,21 @@ const loadFile = path => {
   }
 };
 
-const findContent = ( name, dir ) => {
+/**
+ * Recursively search for a file by name and return both its content and containing directory.
+ *
+ * @param {string} dir - Directory to search
+ * @param {string} name - File name to find
+ * @returns {{ content: string, dir: string } | null}
+ */
+export const searchAndReadFile = ( dir, name ) => {
   for ( const entry of scanDir( dir ) ) {
+    const path = join( dir, entry.name );
     if ( entry.name === name ) {
-      return { dir, content: loadFile( join( dir, entry.name ) ) };
+      return { dir, content: readFile( path ) };
     }
     if ( entry.isDirectory() && !entry.isSymbolicLink() ) {
-      const result = findContent( name, join( dir, entry.name ) );
+      const result = searchAndReadFile( path, name );
       if ( result ) {
         return result;
       }
@@ -33,13 +40,3 @@ const findContent = ( name, dir ) => {
   }
   return null;
 };
-
-/**
- * Recursively search for a file by name and return both its content and containing directory.
- *
- * @param {string} name - File name to find
- * @param {string} [dir] - Directory to search, defaults to invocation directory
- * @returns {{ content: string, dir: string } | null}
- */
-export const loadContent = ( name, dir = Path.resolveInvocationDir() ) =>
-  findContent( name, dir ) ?? null;

package/src/utils/file.spec.js

@@ -0,0 +1,89 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { FatalError } from '@outputai/core';
+import { searchAndReadFile } from './file.js';
+
+const dirs = [];
+
+const tempDir = () => {
+  const dir = mkdtempSync( join( tmpdir(), 'search-and-read-' ) );
+  dirs.push( dir );
+  return dir;
+};
+
+afterEach( () => {
+  for ( const dir of dirs.splice( 0 ) ) {
+    rmSync( dir, { recursive: true, force: true } );
+  }
+} );
+
+describe( 'searchAndReadFile', () => {
+  it( 'reads a file in the search directory', () => {
+    const dir = tempDir();
+    writeFileSync( join( dir, 'notes.txt' ), 'hello' );
+
+    expect( searchAndReadFile( dir, 'notes.txt' ) ).toEqual( {
+      dir,
+      content: 'hello'
+    } );
+  } );
+
+  it( 'reads a file from a nested subdirectory and returns that directory', () => {
+    const dir = tempDir();
+    const nested = join( dir, 'prompts' );
+    mkdirSync( nested );
+    writeFileSync( join( nested, 'writer@v1.prompt' ), 'Write it.' );
+
+    expect( searchAndReadFile( dir, 'writer@v1.prompt' ) ).toEqual( {
+      dir: nested,
+      content: 'Write it.'
+    } );
+  } );
+
+  it( 'continues into later siblings after a subdirectory miss', () => {
+    const dir = tempDir();
+    mkdirSync( join( dir, 'empty' ) );
+    const found = join( dir, 'found' );
+    mkdirSync( found );
+    writeFileSync( join( found, 'target.txt' ), 'here' );
+
+    expect( searchAndReadFile( dir, 'target.txt' ) ).toEqual( {
+      dir: found,
+      content: 'here'
+    } );
+  } );
+
+  it( 'skips symbolic-link directories', () => {
+    const dir = tempDir();
+    const hidden = join( dir, 'hidden' );
+    const search = join( dir, 'search' );
+    mkdirSync( hidden );
+    mkdirSync( search );
+    writeFileSync( join( hidden, 'secret.txt' ), 'nope' );
+    symlinkSync( hidden, join( search, 'link' ) );
+
+    expect( searchAndReadFile( search, 'secret.txt' ) ).toBeNull();
+  } );
+
+  it( 'returns null when the file is not found', () => {
+    const dir = tempDir();
+    writeFileSync( join( dir, 'other.txt' ), 'x' );
+
+    expect( searchAndReadFile( dir, 'missing.txt' ) ).toBeNull();
+  } );
+
+  it( 'returns null for an empty directory', () => {
+    expect( searchAndReadFile( tempDir(), 'missing.txt' ) ).toBeNull();
+  } );
+
+  it( 'throws FatalError when the search directory cannot be scanned', () => {
+    const missing = join( tempDir(), 'gone' );
+
+    expect( () => searchAndReadFile( missing, 'notes.txt' ) ).toThrow( FatalError );
+    expect( () => searchAndReadFile( missing, 'notes.txt' ) ).toThrow(
+      `Error scanning directory "${missing}"`
+    );
+  } );
+} );

package/src/utils/models.js

@@ -0,0 +1,15 @@
+import { ValidationError } from '@outputai/core';
+import { getProvider } from '../ai_provider.js';
+
+/** Load a model from a prompt */
+export const loadTextModel = prompt => getProvider( prompt.config.provider )( prompt.config.model );
+
+/** Load an image model from a prompt. */
+export const loadImageModel = prompt => {
+  const provider = getProvider( prompt.config.provider );
+  const imageModelFactory = provider.image ?? provider.imageModel;
+  if ( typeof imageModelFactory !== 'function' ) {
+    throw new ValidationError( `Provider "${prompt.config.provider}" used by prompt "${prompt.name}" does not support image models.` );
+  }
+  return imageModelFactory( prompt.config.model );
+};