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

package/src/prompt/loader.spec.js

@@ -1,361 +1,258 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { Logger } from '@outputai/core';
-import { loadPrompt } from './loader.js';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const liquidMocks = vi.hoisted( () => ( {
+  createContext: vi.fn(),
+  options: { strictVariables: true },
+  parseAndRenderSync: vi.fn(),
+  registerFilter: vi.fn()
+} ) );
+
+vi.mock( 'liquidjs', () => ( {
+  Context: class Context {
+    constructor( ...args ) {
+      liquidMocks.createContext( this, ...args );
+    }
+  },
+  Liquid: class Liquid {
+    options = liquidMocks.options;
+    parseAndRenderSync = liquidMocks.parseAndRenderSync;
+    registerFilter = liquidMocks.registerFilter;
+  }
+} ) );
 
-vi.mock( './parser.js', () => ( {
-  parsePrompt: vi.fn()
+vi.mock( 'gray-matter', () => ( {
+  default: vi.fn()
 } ) );
 
-vi.mock( './escape.js', () => ( {
-  escape: vi.fn( value => value ),
-  decode: vi.fn( value => value ),
-  setupLiquidEncodeFilter: vi.fn()
+vi.mock( '@outputai/core/sdk/helpers', () => ( {
+  Path: {
+    resolveInvocationDir: vi.fn( () => '/invocation' )
+  }
 } ) );
 
-vi.mock( './load_content.js', () => ( {
-  loadContent: vi.fn()
+vi.mock( './interpolations.js', () => ( {
+  pipeInterpolations: vi.fn( value => value ),
+  interpolationFilterToken: '__var_safe',
+  encode: vi.fn(),
+  decode: vi.fn( value => value )
+} ) );
+
+vi.mock( '../utils/file.js', () => ( {
+  searchAndReadFile: vi.fn()
+} ) );
+
+vi.mock( './content.js', () => ( {
+  parseContent: vi.fn()
 } ) );
 
 vi.mock( './validations.js', () => ( {
-  validatePrompt: vi.fn()
+  parsePromptSchema: vi.fn( prompt => prompt )
 } ) );
 
-import { parsePrompt } from './parser.js';
-import { escape, decode } from './escape.js';
-import { loadContent } from './load_content.js';
-import { validatePrompt } from './validations.js';
+import { loadPrompt } from './loader.js';
+import { Path } from '@outputai/core/sdk/helpers';
+import matter from 'gray-matter';
+import { decode, pipeInterpolations } from './interpolations.js';
+import { searchAndReadFile } from '../utils/file.js';
+import { parseContent } from './content.js';
+import { parsePromptSchema } from './validations.js';
+
+const defaultConfig = {
+  provider: 'anthropic',
+  model: 'claude-3-5-sonnet-20241022'
+};
+
+const defaultParsed = {
+  messages: [ { role: 'user', content: 'Hi' } ],
+  instructions: null
+};
+
+const stubMatter = ( config = defaultConfig ) => {
+  matter.mockImplementation( ( _input, options ) => {
+    if ( options?.engines ) {
+      return { matter: 'RAW_YAML', content: 'RAW_BODY' };
+    }
+    return { data: { ...config } };
+  } );
+};
 
 describe( 'loadPrompt', () => {
   beforeEach( () => {
     vi.clearAllMocks();
-    escape.mockImplementation( value => value );
+    Path.resolveInvocationDir.mockReturnValue( '/invocation' );
+    searchAndReadFile.mockReturnValue( { content: 'FILE', dir: '/mock/dir' } );
+    pipeInterpolations.mockImplementation( value => value );
     decode.mockImplementation( value => value );
-    parsePrompt.mockReturnValue( {
-      config: {
-        provider: 'anthropic',
-        model: 'claude-3-5-sonnet-20241022'
-      },
-      messages: [
-        {
-          role: 'user',
-          content: 'Hello World!'
-        }
-      ],
-      instructions: null
-    } );
+    liquidMocks.parseAndRenderSync.mockImplementation( template => template );
+    parseContent.mockReturnValue( { ...defaultParsed, messages: [ ...defaultParsed.messages ] } );
+    parsePromptSchema.mockImplementation( prompt => prompt );
+    stubMatter();
   } );
 
-  it( 'loads prompt file, renders variables, parses content, validates, and returns prompt file dir', () => {
-    loadContent.mockReturnValue( {
-      content: '<user>Hello {{ name }}!</user>',
-      dir: '/mock/dir'
-    } );
+  afterEach( () => {
+    vi.restoreAllMocks();
+  } );
 
-    const result = loadPrompt( 'test', { name: 'World' } );
+  it( 'splits, renders, parses, and validates the prompt', () => {
+    const variables = { name: 'World' };
 
-    expect( loadContent ).toHaveBeenCalledWith( 'test.prompt', undefined );
-    expect( escape ).toHaveBeenCalledWith( '<user>Hello {{ name }}!</user>' );
-    expect( parsePrompt ).toHaveBeenCalledWith( {
-      name: 'test',
-      raw: '<user>Hello World!</user>'
-    } );
-    expect( validatePrompt ).toHaveBeenCalledWith( {
+    const result = loadPrompt( 'test', variables );
+
+    expect( searchAndReadFile ).toHaveBeenCalledWith( '/invocation', 'test.prompt' );
+    expect( matter ).toHaveBeenNthCalledWith( 1, 'FILE', expect.objectContaining( {
+      engines: { yaml: expect.any( Function ) }
+    } ) );
+    expect( matter ).toHaveBeenNthCalledWith( 2, '---\nRAW_YAML\n---\n' );
+    expect( decode ).toHaveBeenCalledWith( defaultConfig );
+    expect( parseContent ).toHaveBeenCalledWith( 'RAW_BODY', undefined );
+    expect( parsePromptSchema ).toHaveBeenCalledWith( {
       name: 'test',
-      config: {
-        provider: 'anthropic',
-        model: 'claude-3-5-sonnet-20241022'
-      },
-      messages: [
-        {
-          role: 'user',
-          content: 'Hello World!'
-        }
-      ],
-      instructions: null
+      config: defaultConfig,
+      messages: defaultParsed.messages,
+      instructions: null,
+      fileDir: '/mock/dir',
+      variables
     } );
-    expect( result.name ).toBe( 'test' );
-    expect( result.config ).toEqual( { provider: 'anthropic', model: 'claude-3-5-sonnet-20241022' } );
-    expect( result.messages ).toEqual( [ { role: 'user', content: 'Hello World!' } ] );
-    expect( result.instructions ).toBeNull();
-    expect( result.promptFileDir ).toBe( '/mock/dir' );
+    expect( result ).toEqual( parsePromptSchema.mock.calls[0][0] );
   } );
 
-  it( 'passes the provided prompt directory to loadContent', () => {
-    loadContent.mockReturnValue( {
-      content: '<user>Hello</user>',
-      dir: '/mock/dir'
-    } );
+  it( 'renders frontmatter before content using one Liquid context', () => {
+    const variables = { name: 'World' };
 
-    loadPrompt( 'test', {}, '/custom/prompts' );
+    loadPrompt( 'test', variables );
 
-    expect( loadContent ).toHaveBeenCalledWith( 'test.prompt', '/custom/prompts' );
+    const context = liquidMocks.createContext.mock.calls[0][0];
+    expect( liquidMocks.createContext ).toHaveBeenCalledWith( context, variables, liquidMocks.options, { sync: true } );
+    expect( pipeInterpolations ).toHaveBeenNthCalledWith( 1, 'RAW_YAML' );
+    expect( pipeInterpolations ).toHaveBeenNthCalledWith( 2, 'RAW_BODY' );
+    expect( liquidMocks.parseAndRenderSync ).toHaveBeenNthCalledWith( 1, 'RAW_YAML', context );
+    expect( liquidMocks.parseAndRenderSync ).toHaveBeenNthCalledWith( 2, 'RAW_BODY', context );
   } );
 
-  it( 'renders template variables before parsing', () => {
-    loadContent.mockReturnValue( {
-      content: `---
-provider: {{ provider }}
-model: {{ model }}
----
-<user>Tell me about {{ topic }}</user>`,
-      dir: '/mock/dir'
-    } );
+  it( 'uses decoded frontmatter for content parsing and validation', () => {
+    const encodedConfig = {
+      ...defaultConfig,
+      messageOptions: { cached: { openai: { label: 'R&amp;D' } } }
+    };
+    const decodedConfig = {
+      ...defaultConfig,
+      messageOptions: { cached: { openai: { label: 'R&D' } } }
+    };
+    stubMatter( encodedConfig );
+    decode.mockReturnValue( decodedConfig );
 
-    loadPrompt( 'test', {
-      provider: 'openai',
-      model: 'gpt-4',
-      topic: 'testing'
-    } );
+    loadPrompt( 'test' );
 
-    expect( parsePrompt ).toHaveBeenCalledWith( {
-      name: 'test',
-      raw: `---
-provider: openai
-model: gpt-4
----
-<user>Tell me about testing</user>`
-    } );
+    expect( decode ).toHaveBeenCalledWith( encodedConfig );
+    expect( parseContent ).toHaveBeenCalledWith( 'RAW_BODY', decodedConfig.messageOptions );
+    expect( parsePromptSchema ).toHaveBeenCalledWith( expect.objectContaining( {
+      config: decodedConfig
+    } ) );
   } );
 
-  it( 'renders escaped content returned by the escape helper', () => {
-    loadContent.mockReturnValue( {
-      content: '<user>Hello {{ name }}!</user>',
-      dir: '/mock/dir'
-    } );
-    escape.mockReturnValueOnce( '<user>Escaped {{ name }}!</user>' );
-
-    loadPrompt( 'test', { name: 'World' } );
+  it( 'passes the provided prompt directory to searchAndReadFile', () => {
+    loadPrompt( 'test', {}, '/custom/prompts' );
 
-    expect( parsePrompt ).toHaveBeenCalledWith( {
-      name: 'test',
-      raw: '<user>Escaped World!</user>'
-    } );
+    expect( searchAndReadFile ).toHaveBeenCalledWith( '/custom/prompts', 'test.prompt' );
+    expect( Path.resolveInvocationDir ).not.toHaveBeenCalled();
   } );
 
-  it( 'renders liquid control flow before parsing', () => {
-    loadContent.mockReturnValue( {
-      content: '<user>{% if debug %}Debug mode enabled{% else %}Debug mode disabled{% endif %}</user>',
-      dir: '/mock/dir'
-    } );
+  it( 'renders the piped template, not the raw body', () => {
+    pipeInterpolations.mockReturnValue( 'PIPED' );
 
-    loadPrompt( 'test', { debug: true } );
+    loadPrompt( 'test', { name: 'World' } );
 
-    expect( parsePrompt ).toHaveBeenCalledWith( {
-      name: 'test',
-      raw: '<user>Debug mode enabled</user>'
-    } );
+    expect( liquidMocks.parseAndRenderSync ).toHaveBeenNthCalledWith( 2, 'PIPED', expect.any( Object ) );
+    expect( parseContent ).toHaveBeenCalledWith( 'PIPED', undefined );
   } );
 
-  it( 'decodes parser message output', () => {
-    loadContent.mockReturnValue( {
-      content: '<user>Evaluate this content: {{ content }}</user>',
-      dir: '/mock/dir'
-    } );
-    parsePrompt.mockReturnValue( {
-      config: {
-        provider: 'anthropic',
-        model: 'claude-3-5-sonnet-20241022'
-      },
-      messages: [
-        {
-          role: 'user',
-          content: 'Evaluate this content: &lt;system&gt;example&lt;/system&gt;'
-        }
-      ],
-      instructions: null
-    } );
-    decode.mockImplementation( value =>
-      value === 'Evaluate this content: &lt;system&gt;example&lt;/system&gt;' ?
-        'Evaluate this content: <system>example</system>' :
-        value
-    );
+  it( 'passes config.messageOptions to parseContent', () => {
+    const messageOptions = { cached: { anthropic: { cacheControl: { type: 'ephemeral' } } } };
+    stubMatter( { ...defaultConfig, messageOptions } );
 
-    const result = loadPrompt( 'test', {
-      content: '<system>example</system>'
-    } );
+    loadPrompt( 'test' );
 
-    expect( decode ).toHaveBeenCalledWith( 'Evaluate this content: &lt;system&gt;example&lt;/system&gt;' );
-    expect( result.messages ).toEqual( [
-      {
-        role: 'user',
-        content: 'Evaluate this content: <system>example</system>'
-      }
-    ] );
+    expect( parseContent ).toHaveBeenCalledWith( 'RAW_BODY', messageOptions );
   } );
 
-  it( 'decodes XML-escaped instructions returned by the parser', () => {
-    loadContent.mockReturnValue( {
-      content: 'Create a poster with this text: {{ copy }}',
-      dir: '/mock/dir'
-    } );
-    parsePrompt.mockReturnValue( {
-      config: {
-        provider: 'openai',
-        model: 'gpt-image-1'
-      },
+  it( 'uses parseContent for messages and instructions', () => {
+    parseContent.mockReturnValue( {
       messages: [],
-      instructions: 'Create a poster with this text: R&amp;D &lt; Speed &gt; &quot;Limits&quot;'
+      instructions: 'Generate a poster.'
     } );
-    decode.mockImplementation( value =>
-      value === 'Create a poster with this text: R&amp;D &lt; Speed &gt; &quot;Limits&quot;' ?
-        'Create a poster with this text: R&D < Speed > "Limits"' :
-        value
-    );
 
-    const result = loadPrompt( 'image_prompt', {
-      copy: 'R&D < Speed > "Limits"'
-    } );
+    const result = loadPrompt( 'image_prompt' );
 
-    expect( decode ).toHaveBeenCalledWith( 'Create a poster with this text: R&amp;D &lt; Speed &gt; &quot;Limits&quot;' );
     expect( result.messages ).toEqual( [] );
-    expect( result.instructions ).toBe( 'Create a poster with this text: R&D < Speed > "Limits"' );
+    expect( result.instructions ).toBe( 'Generate a poster.' );
   } );
 
-  it( 'decodes XML-escaped config values recursively', () => {
-    const encodedConfig = {
-      label: 'R&amp;D',
-      values: [ 'A &lt; B' ],
-      providerOptions: {
-        metadata: {
-          title: '&quot;Race&quot;'
-        }
-      }
-    };
+  it( 'throws when the prompt file is not found', () => {
+    searchAndReadFile.mockReturnValue( null );
 
-    loadContent.mockReturnValue( {
-      content: '<user>Hello</user>',
-      dir: '/mock/dir'
-    } );
-    parsePrompt.mockReturnValue( {
-      config: encodedConfig,
-      messages: [
-        {
-          role: 'user',
-          content: 'Hello'
-        }
-      ],
-      instructions: null
-    } );
-    decode.mockImplementation( value => {
-      if ( value === encodedConfig ) {
-        return {
-          label: 'R&D',
-          values: [ 'A < B' ],
-          providerOptions: {
-            metadata: {
-              title: '"Race"'
-            }
-          }
-        };
-      }
-      return value;
-    } );
+    expect( () => loadPrompt( 'nonexistent' ) ).toThrow( /Prompt file "nonexistent" not found/ );
+  } );
 
-    const result = loadPrompt( 'test' );
+  it( 'throws when rendered content is empty', () => {
+    liquidMocks.parseAndRenderSync
+      .mockReturnValueOnce( 'RAW_YAML' )
+      .mockReturnValueOnce( '  ' );
 
-    expect( result.config ).toEqual( {
-      label: 'R&D',
-      values: [ 'A < B' ],
-      providerOptions: {
-        metadata: {
-          title: '"Race"'
-        }
-      }
-    } );
+    expect( () => loadPrompt( 'empty_prompt' ) ).toThrow( /Prompt "empty_prompt" has no content/ );
   } );
 
-  it.each( [
-    [ 'vertex', 'google-vertex' ],
-    [ 'bedrock', 'amazon-bedrock' ]
-  ] )( 'rewrites deprecated provider alias %s to %s and warns', ( alias, canonical ) => {
-    const warn = vi.spyOn( Logger, 'warn' ).mockImplementation( () => {} );
-    loadContent.mockReturnValue( {
-      content: '<user>Hello</user>',
-      dir: '/mock/dir'
-    } );
-    parsePrompt.mockReturnValue( {
-      config: {
-        provider: alias,
-        model: 'test-model'
-      },
-      messages: [ { role: 'user', content: 'Hello' } ],
-      instructions: null
+  it( 'wraps split errors with the prompt name', () => {
+    matter.mockImplementation( () => {
+      throw new Error( 'bad delimiters' );
     } );
 
-    const result = loadPrompt( 'test' );
+    expect( () => loadPrompt( 'writer@v1' ) ).toThrow(
+      /Error parsing frontmatter on prompt "writer@v1": bad delimiters/
+    );
+  } );
 
-    expect( result.config.provider ).toBe( canonical );
-    expect( validatePrompt ).toHaveBeenCalledWith( expect.objectContaining( {
-      config: expect.objectContaining( { provider: canonical } )
-    } ) );
-    expect( warn ).toHaveBeenCalledWith(
-      `Using deprecated provider alias "${alias}". Use "${canonical}" instead.`,
-      { namespace: 'LLM' }
+  it( 'wraps content render errors with the prompt name', () => {
+    liquidMocks.parseAndRenderSync
+      .mockReturnValueOnce( 'RAW_YAML' )
+      .mockImplementationOnce( () => {
+        throw new Error( 'unknown variable' );
+      } );
+
+    expect( () => loadPrompt( 'writer@v1' ) ).toThrow(
+      /Error rendering content on prompt "writer@v1": unknown variable/
     );
   } );
 
-  it( 'rewrites provider aliases on the decoded config', () => {
-    const warn = vi.spyOn( Logger, 'warn' ).mockImplementation( () => {} );
-    const parsedConfig = {
-      provider: 'bedrock',
-      model: 'test-model'
-    };
-    const decodedConfig = {
-      provider: 'bedrock',
-      model: 'test-model'
-    };
-    loadContent.mockReturnValue( {
-      content: '<user>Hello</user>',
-      dir: '/mock/dir'
+  it( 'wraps frontmatter render errors with the prompt name', () => {
+    liquidMocks.parseAndRenderSync.mockImplementationOnce( () => {
+      throw new Error( 'unknown filter' );
     } );
-    parsePrompt.mockReturnValue( {
-      config: parsedConfig,
-      messages: [ { role: 'user', content: 'Hello' } ],
-      instructions: null
-    } );
-    decode.mockImplementation( value => ( value === parsedConfig ? decodedConfig : value ) );
-
-    const result = loadPrompt( 'test' );
 
-    expect( decode ).toHaveBeenCalledWith( parsedConfig );
-    expect( result.config ).toBe( decodedConfig );
-    expect( result.config.provider ).toBe( 'amazon-bedrock' );
-    expect( validatePrompt ).toHaveBeenCalledWith( expect.objectContaining( {
-      config: decodedConfig
-    } ) );
-    expect( warn ).toHaveBeenCalledWith(
-      'Using deprecated provider alias "bedrock". Use "amazon-bedrock" instead.',
-      { namespace: 'LLM' }
+    expect( () => loadPrompt( 'writer@v1' ) ).toThrow(
+      /Error rendering frontmatter on prompt "writer@v1": unknown filter/
     );
   } );
 
-  it( 'leaves canonical provider names unchanged', () => {
-    const warn = vi.spyOn( Logger, 'warn' ).mockImplementation( () => {} );
-    loadContent.mockReturnValue( {
-      content: '<user>Hello</user>',
-      dir: '/mock/dir'
-    } );
-    parsePrompt.mockReturnValue( {
-      config: {
-        provider: 'google-vertex',
-        model: 'gemini-2.5-flash-lite'
-      },
-      messages: [ { role: 'user', content: 'Hello' } ],
-      instructions: null
+  it( 'wraps frontmatter yaml parse errors with the prompt name', () => {
+    matter.mockImplementation( ( _input, options ) => {
+      if ( options?.engines ) {
+        return { matter: 'RAW_YAML', content: 'RAW_BODY' };
+      }
+      throw new Error( 'invalid yaml' );
     } );
 
-    const result = loadPrompt( 'test' );
-
-    expect( result.config.provider ).toBe( 'google-vertex' );
-    expect( warn ).not.toHaveBeenCalled();
+    expect( () => loadPrompt( 'writer@v1' ) ).toThrow(
+      /Error converting frontmatter yaml to js on prompt "writer@v1": invalid yaml/
+    );
   } );
 
-  it( 'throws error when prompt file not found', () => {
-    loadContent.mockReturnValue( null );
+  it( 'wraps content parse errors with the prompt name', () => {
+    parseContent.mockImplementation( () => {
+      throw new Error( 'unknown option' );
+    } );
 
-    expect( () => {
-      loadPrompt( 'nonexistent' );
-    } ).toThrow( /Prompt "nonexistent" not found/ );
+    expect( () => loadPrompt( 'writer@v1' ) ).toThrow(
+      /Error parsing content on prompt "writer@v1": unknown option/
+    );
   } );
-
 } );

package/src/prompt/markup/attributes.js

@@ -0,0 +1,52 @@
+import { ValidationError } from '@outputai/core';
+
+const attributeSeparator = /(?<![=\s])\s+(?!\s*=)(?=(?:[^"']|"[^"]*"|'[^']*')*$)/;
+
+export const extractAttributes = rawAttributes => {
+  if ( !rawAttributes?.trim() ) {
+    return {};
+  }
+  const pairs = rawAttributes.trim().split( attributeSeparator );
+  const attributeKeyRule = /^[A-Za-z][\w-]*$/;
+
+  return Object.fromEntries(
+    pairs.map( p => {
+      const splitIndex = p.indexOf( '=' );
+      if ( splitIndex === -1 ) {
+        const key = p.toLowerCase();
+        if ( !attributeKeyRule.test( key ) ) {
+          throw new ValidationError( `Invalid attribute name "${key}".` );
+        }
+        return [ key, true ];
+      }
+
+      const key = p.slice( 0, splitIndex ).trim().toLowerCase();
+      if ( !key ) {
+        throw new ValidationError( `Invalid attribute "${p}": name is missing.` );
+      }
+      if ( !attributeKeyRule.test( key ) ) {
+        throw new ValidationError( `Invalid attribute name "${key}".` );
+      }
+      const value = p.slice( splitIndex + 1 ).trim();
+      const openingQuote = value[0];
+      const isQuoted = openingQuote === '\'' || openingQuote === '"';
+
+      if ( !isQuoted ) {
+        const invalidCharacter = value.match( /['"<>=]/ )?.[0];
+        if ( invalidCharacter ) {
+          throw new ValidationError( `Invalid attribute "${key}": unquoted value contains invalid character \`${invalidCharacter}\`.` );
+        }
+        return [ key, value ];
+      } else {
+        if ( value.at( -1 ) !== openingQuote ) {
+          throw new ValidationError( `Invalid attribute "${key}": quoted value is missing its closing quote (${openingQuote}).` );
+        }
+        const unquoted = value.slice( 1, -1 );
+        if ( unquoted.includes( openingQuote ) ) {
+          throw new ValidationError( `Invalid attribute "${key}": quoted value contains an unexpected quote (${openingQuote}).` );
+        }
+        return [ key, unquoted ];
+      }
+    } )
+  );
+};