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

package/src/prompt/blocks.js

@@ -1,47 +0,0 @@
-/**
- * Roles that introduce a message block. Add a role here to support a new
- * `<role>...</role>` block — the tokenizer pattern is derived from this set,
- * so no other parser change is required.
- */
-export const BLOCK_ROLES = new Set( [ 'system', 'user', 'assistant', 'tool' ] );
-
-const BLOCK_PATTERN = new RegExp(
-  `<(${[ ...BLOCK_ROLES ].join( '|' )})((?:\\s[^>]*)?)>([\\s\\S]*?)<\\/\\1>`,
-  'gm'
-);
-
-const ATTRIBUTE_PATTERN = /([a-zA-Z][\w-]*)(?:=(?:"([^"]*)"|'([^']*)'|(\S+)))?/g;
-
-/**
- * Parse a raw opening-tag attribute string into a plain object. Supports bare booleans
- * (`cache`), double/single-quoted values, and unquoted values:
- * `cache options="a b" ttl='1h'` → `{ cache: true, options: 'a b', ttl: '1h' }`.
- *
- * @param {string} [raw] - Raw attribute text between the role and the closing `>`
- * @returns {Record<string, string | true>} Parsed attributes
- */
-export const parseAttributes = ( raw = '' ) =>
-  Object.fromEntries(
-    [ ...raw.matchAll( ATTRIBUTE_PATTERN ) ].map(
-      ( [ _, key, doubleQuoted, singleQuoted, bare ] ) =>
-        [ key, doubleQuoted ?? singleQuoted ?? bare ?? true ]
-    )
-  );
-
-/**
- * Tokenize a rendered prompt body into message blocks. Each block is `{ role, content }`,
- * plus `attributes` when the opening tag carried any. Content between role tags is treated
- * as opaque text, so prompt bodies may freely contain other angle-bracket markup.
- *
- * @param {string} content - Rendered prompt body (after frontmatter is stripped)
- * @returns {Array<{ role: string, content: string, attributes?: Record<string, string | true> }>}
- */
-export const tokenizeBlocks = content =>
-  [ ...content.matchAll( BLOCK_PATTERN ) ].map( ( [ _, role, rawAttributes, text ] ) => {
-    const attributes = parseAttributes( rawAttributes.trim() );
-    return {
-      role,
-      content: text.trim(),
-      ...( Object.keys( attributes ).length > 0 && { attributes } )
-    };
-  } );

package/src/prompt/blocks.spec.js

@@ -1,63 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseAttributes, tokenizeBlocks, BLOCK_ROLES } from './blocks.js';
-
-describe( 'parseAttributes', () => {
-  it( 'parses a bare attribute as boolean true', () => {
-    expect( parseAttributes( 'pinned' ) ).toEqual( { pinned: true } );
-  } );
-
-  it( 'parses double- and single-quoted values', () => {
-    expect( parseAttributes( 'ttl="1h" mode=\'fast\'' ) ).toEqual( { ttl: '1h', mode: 'fast' } );
-  } );
-
-  it( 'parses unquoted values', () => {
-    expect( parseAttributes( 'ttl=1h' ) ).toEqual( { ttl: '1h' } );
-  } );
-
-  it( 'parses multiple attributes and preserves spaces inside quotes', () => {
-    expect( parseAttributes( 'pinned options="cached fast"' ) ).toEqual( {
-      pinned: true,
-      options: 'cached fast'
-    } );
-  } );
-
-  it( 'returns an empty object for blank input', () => {
-    expect( parseAttributes( '' ) ).toEqual( {} );
-    expect( parseAttributes() ).toEqual( {} );
-  } );
-} );
-
-describe( 'tokenizeBlocks', () => {
-  it( 'tokenizes plain blocks without an attributes key', () => {
-    const blocks = tokenizeBlocks( '<system>Hi</system>\n<user>Yo</user>' );
-    expect( blocks ).toEqual( [
-      { role: 'system', content: 'Hi' },
-      { role: 'user', content: 'Yo' }
-    ] );
-  } );
-
-  it( 'attaches parsed attributes to the block', () => {
-    const blocks = tokenizeBlocks( '<system options="a b" pinned>Hi</system>' );
-    expect( blocks[0] ).toEqual( {
-      role: 'system',
-      content: 'Hi',
-      attributes: { options: 'a b', pinned: true }
-    } );
-  } );
-
-  it( 'captures unknown attributes generically (validation rejects them later)', () => {
-    const blocks = tokenizeBlocks( '<user data="x">Hi</user>' );
-    expect( blocks[0].attributes ).toEqual( { data: 'x' } );
-  } );
-
-  it( 'treats angle-bracket markup inside a block as opaque content', () => {
-    const blocks = tokenizeBlocks( '<user>Compare <div> and <span> tags</user>' );
-    expect( blocks[0] ).toEqual( { role: 'user', content: 'Compare <div> and <span> tags' } );
-  } );
-
-  it( 'tokenizes every registered role', () => {
-    const body = [ ...BLOCK_ROLES ].map( role => `<${role}>${role} body</${role}>` ).join( '\n' );
-    const blocks = tokenizeBlocks( body );
-    expect( blocks.map( block => block.role ) ).toEqual( [ ...BLOCK_ROLES ] );
-  } );
-} );

package/src/prompt/escape.spec.js

@@ -1,159 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Liquid } from 'liquidjs';
-import { decode, encodeFilter, escape, setupLiquidEncodeFilter } from './escape.js';
-
-describe( 'encodeFilter', () => {
-  it( 'encodes < to &lt;', () => {
-    expect( encodeFilter( '<' ) ).toBe( '&lt;' );
-  } );
-
-  it( 'encodes > to &gt;', () => {
-    expect( encodeFilter( '>' ) ).toBe( '&gt;' );
-  } );
-
-  it( 'encodes & to &amp;', () => {
-    expect( encodeFilter( '&' ) ).toBe( '&amp;' );
-  } );
-
-  it( 'encodes a string with multiple special characters in one pass', () => {
-    expect( encodeFilter( '<a & b>' ) ).toBe( '&lt;a &amp; b&gt;' );
-  } );
-
-  it( 'encodes a tag-shaped substring so the parser cannot tokenize it', () => {
-    expect( encodeFilter( '<system>x</system>' ) ).toBe( '&lt;system&gt;x&lt;/system&gt;' );
-  } );
-
-  it( 'returns an empty string for null', () => {
-    expect( encodeFilter( null ) ).toBe( '' );
-  } );
-
-  it( 'returns an empty string for undefined', () => {
-    expect( encodeFilter( undefined ) ).toBe( '' );
-  } );
-
-  it( 'coerces numbers to string before encoding', () => {
-    expect( encodeFilter( 42 ) ).toBe( '42' );
-  } );
-
-  it( 'coerces booleans to string before encoding', () => {
-    expect( encodeFilter( true ) ).toBe( 'true' );
-    expect( encodeFilter( false ) ).toBe( 'false' );
-  } );
-
-  it( 'passes empty strings through unchanged', () => {
-    expect( encodeFilter( '' ) ).toBe( '' );
-  } );
-
-  it( 'passes plain text through unchanged', () => {
-    expect( encodeFilter( 'hello world' ) ).toBe( 'hello world' );
-  } );
-} );
-
-describe( 'setupLiquidEncodeFilter', () => {
-  it( 'registers the safety filter on a Liquid instance', async () => {
-    const liquid = new Liquid();
-
-    setupLiquidEncodeFilter( liquid );
-
-    await expect( liquid.parseAndRender( '{{ value | __var_safe }}', {
-      value: '<system>x</system>'
-    } ) ).resolves.toBe( '&lt;system&gt;x&lt;/system&gt;' );
-  } );
-} );
-
-describe( 'escape', () => {
-  it( 'rewrites a single {{ var }} to append the safety filter', () => {
-    expect( escape( '{{ name }}' ) ).toBe( '{{ name | __var_safe }}' );
-  } );
-
-  it( 'rewrites multiple expressions in the same string', () => {
-    expect( escape( '{{ a }} and {{ b }}' ) ).toBe(
-      '{{ a | __var_safe }} and {{ b | __var_safe }}'
-    );
-  } );
-
-  it( 'appends the safety filter last in an existing filter chain', () => {
-    expect( escape( '{{ x | upcase }}' ) ).toBe(
-      '{{ x | upcase | __var_safe }}'
-    );
-  } );
-
-  it( 'handles longer filter chains', () => {
-    expect( escape( '{{ x | a | b }}' ) ).toBe(
-      '{{ x | a | b | __var_safe }}'
-    );
-  } );
-
-  it( 'handles dotted property paths', () => {
-    expect( escape( '{{ obj.field }}' ) ).toBe(
-      '{{ obj.field | __var_safe }}'
-    );
-  } );
-
-  it( 'preserves a {% raw %} block untouched even when it contains {{ ... }}', () => {
-    const input = '{% raw %}{{ literal }}{% endraw %}';
-    expect( escape( input ) ).toBe( input );
-  } );
-
-  it( 'rewrites {{ ... }} outside a raw block while preserving the raw block', () => {
-    expect( escape( '{{ a }}{% raw %}{{ b }}{% endraw %}{{ c }}' ) ).toBe(
-      '{{ a | __var_safe }}{% raw %}{{ b }}{% endraw %}{{ c | __var_safe }}'
-    );
-  } );
-
-  it( 'leaves {% if %} control tags untouched but still arms {{ ... }} inside them', () => {
-    expect( escape( '{% if cond %}{{ x }}{% endif %}' ) ).toBe(
-      '{% if cond %}{{ x | __var_safe }}{% endif %}'
-    );
-  } );
-
-  it( 'leaves {% for %} control tags untouched but still arms {{ ... }} inside them', () => {
-    expect( escape( '{% for x in xs %}{{ x }}{% endfor %}' ) ).toBe(
-      '{% for x in xs %}{{ x | __var_safe }}{% endfor %}'
-    );
-  } );
-
-  it( 'normalizes interior whitespace via expressionContent.trim()', () => {
-    expect( escape( '{{x}}' ) ).toBe( '{{ x | __var_safe }}' );
-    expect( escape( '{{   x   }}' ) ).toBe( '{{ x | __var_safe }}' );
-  } );
-
-  it( 'returns the input unchanged when there are no {{ ... }} expressions', () => {
-    expect( escape( '<user>plain text</user>' ) ).toBe(
-      '<user>plain text</user>'
-    );
-  } );
-
-  it( 'handles an empty string', () => {
-    expect( escape( '' ) ).toBe( '' );
-  } );
-} );
-
-describe( 'decode', () => {
-  it( 'decodes XML entities in a string', () => {
-    expect( decode( 'R&amp;D &lt; Speed &gt; &quot;Limits&quot;' ) ).toBe( 'R&D < Speed > "Limits"' );
-  } );
-
-  it( 'decodes XML entities recursively in arrays and plain objects', () => {
-    expect( decode( {
-      label: 'R&amp;D',
-      values: [ 'A &lt; B' ],
-      nested: {
-        title: '&quot;Race&quot;'
-      }
-    } ) ).toEqual( {
-      label: 'R&D',
-      values: [ 'A < B' ],
-      nested: {
-        title: '"Race"'
-      }
-    } );
-  } );
-
-  it( 'returns non-string scalar values unchanged', () => {
-    expect( decode( null ) ).toBeNull();
-    expect( decode( undefined ) ).toBeUndefined();
-    expect( decode( 42 ) ).toBe( 42 );
-    expect( decode( true ) ).toBe( true );
-  } );
-} );

package/src/prompt/load_content.spec.js

@@ -1,83 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { join } from 'path';
-import { mkdtempSync, writeFileSync, mkdirSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-
-// Hoisted state so mocks can read dynamic values set in tests
-const state = vi.hoisted( () => ( { dir: '', entries: {} } ) );
-
-// Mock SDK helpers to control resolveInvocationDir
-vi.mock( '@outputai/core/sdk/helpers', () => ( {
-  Path: {
-    resolveInvocationDir: () => state.dir
-  }
-} ) );
-
-// Mock node:fs.readFileSync for directory scans while delegating file reads
-vi.mock( 'node:fs', async importOriginal => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    readFileSync: vi.fn( ( path, options ) => {
-      if ( options && typeof options === 'object' && options.withFileTypes ) {
-        return state.entries[path] || [];
-      }
-      return actual.readFileSync( path, options );
-    } )
-  };
-} );
-
-const dirEntry = ( name, { isDir = false, isLink = false } = {} ) => ( {
-  name,
-  isDirectory: () => isDir,
-  isSymbolicLink: () => isLink
-} );
-
-beforeEach( () => {
-  state.dir = '';
-  state.entries = {};
-} );
-
-describe( 'loadContent', () => {
-  it( 'loads file from root directory using mocked resolveInvocationDir', async () => {
-    const tempDir = mkdtempSync( join( tmpdir(), 'load-content-test-' ) );
-    state.dir = tempDir;
-    const testContent = 'test file content';
-    writeFileSync( join( tempDir, 'test.txt' ), testContent );
-    state.entries[tempDir] = [ dirEntry( 'test.txt' ) ];
-
-    const { loadContent } = await import( './load_content.js' );
-    const result = loadContent( 'test.txt' );
-
-    expect( result ).toEqual( { content: testContent, dir: tempDir } );
-  } );
-
-  it( 'loads file from nested subdirectory via recursion', async () => {
-    const tempDir = mkdtempSync( join( tmpdir(), 'load-content-test-' ) );
-    const subDir = join( tempDir, 'subdir' );
-    mkdirSync( subDir );
-    state.dir = tempDir;
-
-    const testContent = 'nested file content';
-    writeFileSync( join( subDir, 'nested.txt' ), testContent );
-
-    state.entries[tempDir] = [ dirEntry( 'subdir', { isDir: true } ) ];
-    state.entries[subDir] = [ dirEntry( 'nested.txt' ) ];
-
-    const { loadContent } = await import( './load_content.js' );
-    const result = loadContent( 'nested.txt' );
-
-    expect( result ).toEqual( { content: testContent, dir: subDir } );
-  } );
-
-  it( 'returns null when file does not exist', async () => {
-    const tempDir = mkdtempSync( join( tmpdir(), 'load-content-test-' ) );
-    state.dir = tempDir;
-    state.entries[tempDir] = [ dirEntry( 'other.txt' ) ];
-
-    const { loadContent } = await import( './load_content.js' );
-    const result = loadContent( 'nonexistent.txt' );
-
-    expect( result ).toBeNull();
-  } );
-} );

package/src/prompt/loader_validation.spec.js

@@ -1,128 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { loadPrompt } from './loader.js';
-
-vi.mock( './load_content.js', () => ( {
-  loadContent: vi.fn()
-} ) );
-
-import { loadContent } from './load_content.js';
-
-describe( 'loadPrompt - validation with real schema', () => {
-  beforeEach( () => {
-    vi.clearAllMocks();
-  } );
-
-  it( 'should accept valid camelCase format with providerOptions and 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( { content: promptContent, dir: '/mock/dir' } );
-
-    const result = loadPrompt( 'test', {} );
-
-    expect( result.config.providerOptions ).toBeDefined();
-    expect( result.config.providerOptions.thinking.type ).toBe( 'enabled' );
-    expect( result.config.providerOptions.thinking.budgetTokens ).toBe( 1500 );
-  } );
-
-  it( 'should accept a plain-instructions prompt without message blocks', () => {
-    const promptContent = `---
-provider: openai
-model: gpt-image-1
-size: 1024x1024
----
-
-Create a {{ style }} NASCAR image.
-
-Scene:
-{{ scene }}`;
-
-    loadContent.mockReturnValue( { content: promptContent, dir: '/mock/dir' } );
-
-    const result = loadPrompt( 'image_prompt', {
-      scene: 'Three cars racing side-by-side through a banked turn',
-      style: 'cinematic'
-    } );
-
-    expect( result.messages ).toEqual( [] );
-    expect( result.instructions ).toBe(
-      `Create a cinematic NASCAR image.
-
-Scene:
-Three cars racing side-by-side through a banked turn`
-    );
-    expect( result.config ).toEqual( {
-      provider: 'openai',
-      model: 'gpt-image-1',
-      size: '1024x1024'
-    } );
-  } );
-
-  it( 'should accept snake_case max_tokens via config passthrough (no longer strict)', () => {
-    const promptContent = `---
-provider: anthropic
-model: claude-sonnet-4-20250514
-max_tokens: 64000
----
-
-<user>Hello</user>`;
-
-    loadContent.mockReturnValue( { content: promptContent, dir: '/mock/dir' } );
-
-    // Config uses passthrough, so max_tokens is accepted (though ignored by SDK)
-    expect( () => {
-      loadPrompt( 'test', {} );
-    } ).not.toThrow();
-  } );
-
-  it( 'should accept "options" field via config passthrough (no longer strict)', () => {
-    const promptContent = `---
-provider: anthropic
-model: claude-sonnet-4-20250514
-options:
-  thinking:
-    type: enabled
-    budgetTokens: 1500
----
-
-<user>Hello</user>`;
-
-    loadContent.mockReturnValue( { content: promptContent, dir: '/mock/dir' } );
-
-    // Config uses passthrough, so 'options' passes through (though not used)
-    expect( () => {
-      loadPrompt( 'test', {} );
-    } ).not.toThrow();
-  } );
-
-  it( 'should accept snake_case budget_tokens in thinking via passthrough', () => {
-    const promptContent = `---
-provider: anthropic
-model: claude-sonnet-4-20250514
-providerOptions:
-  thinking:
-    type: enabled
-    budget_tokens: 1500
----
-
-<user>Hello</user>`;
-
-    loadContent.mockReturnValue( { content: promptContent, dir: '/mock/dir' } );
-
-    // budget_tokens is silently stripped from thinking (unknown field), not rejected
-    expect( () => {
-      loadPrompt( 'test', {} );
-    } ).not.toThrow();
-  } );
-
-} );

package/src/prompt/parser.js

@@ -1,16 +0,0 @@
-import matter from 'gray-matter';
-import { FatalError } from '@outputai/core';
-import { tokenizeBlocks } from './blocks.js';
-
-export function parsePrompt( { name, raw } ) {
-  const { data: config, content } = matter( raw );
-
-  if ( !content || content.trim() === '' ) {
-    throw new FatalError( `Prompt "${name}" has no content after frontmatter` );
-  }
-
-  const messages = tokenizeBlocks( content );
-  const instructions = messages.length === 0 ? content.trim() : null;
-
-  return { config, messages, instructions };
-}

package/src/prompt/parser.spec.js

@@ -1,186 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parsePrompt } from './parser.js';
-
-describe( 'parsePrompt', () => {
-  it( 'parses frontmatter config and message blocks', () => {
-    const raw = `---
-provider: anthropic
-model: claude-3-5-sonnet-20241022
----
-
-<system>You are a helpful assistant.</system>
-<user>Hello!</user>`;
-
-    const result = parsePrompt( { name: 'test', raw } );
-
-    expect( result.config ).toEqual( {
-      provider: 'anthropic',
-      model: 'claude-3-5-sonnet-20241022'
-    } );
-    expect( result.messages ).toHaveLength( 2 );
-    expect( result.messages[0] ).toEqual( {
-      role: 'system',
-      content: 'You are a helpful assistant.'
-    } );
-    expect( result.messages[1] ).toEqual( {
-      role: 'user',
-      content: 'Hello!'
-    } );
-    expect( result.instructions ).toBeNull();
-  } );
-
-  it( 'parses raw instructions when no message blocks are present', () => {
-    const raw = `---
-provider: openai
-model: gpt-image-1
----
-
-Generate a cinematic image of a NASCAR race at sunset.`;
-
-    const result = parsePrompt( { name: 'image_prompt', raw } );
-
-    expect( result ).toEqual( {
-      config: {
-        provider: 'openai',
-        model: 'gpt-image-1'
-      },
-      messages: [],
-      instructions: 'Generate a cinematic image of a NASCAR race at sunset.'
-    } );
-  } );
-
-  it( 'trims raw instructions', () => {
-    const raw = `---
-provider: openai
-model: gpt-image-1
----
-
-  Generate a poster.
-
-`;
-
-    const result = parsePrompt( { name: 'image_prompt', raw } );
-
-    expect( result.instructions ).toBe( 'Generate a poster.' );
-  } );
-
-  it( 'throws error when content is empty', () => {
-    const raw = `---
-provider: anthropic
-model: claude-3-5-sonnet-20241022
----
-
-`;
-
-    expect( () => {
-      parsePrompt( { name: 'empty_prompt', raw } );
-    } ).toThrow( /Prompt "empty_prompt" has no content after frontmatter/ );
-  } );
-
-  it( 'parses providerOptions with budgetTokens in camelCase', () => {
-    const raw = `---
-provider: anthropic
-model: claude-sonnet-4-20250514
-temperature: 0.7
-maxTokens: 64000
-providerOptions:
-  thinking:
-    type: enabled
-    budgetTokens: 1500
----
-
-<user>Test</user>`;
-
-    const result = parsePrompt( { name: 'test', raw } );
-
-    expect( result.config.provider ).toBe( 'anthropic' );
-    expect( result.config.model ).toBe( 'claude-sonnet-4-20250514' );
-    expect( result.config.temperature ).toBe( 0.7 );
-    expect( result.config.maxTokens ).toBe( 64000 );
-    expect( result.config.providerOptions ).toBeDefined();
-    expect( result.config.providerOptions.thinking ).toBeDefined();
-    expect( result.config.providerOptions.thinking.type ).toBe( 'enabled' );
-    expect( result.config.providerOptions.thinking.budgetTokens ).toBe( 1500 );
-  } );
-
-  it( 'parses snake_case fields as-is so validation can catch them later', () => {
-    const raw = `---
-provider: anthropic
-model: claude-sonnet-4-20250514
-temperature: 0.7
-max_tokens: 64000
-providerOptions:
-  thinking:
-    type: enabled
-    budget_tokens: 1500
----
-
-<user>Test</user>`;
-
-    const result = parsePrompt( { name: 'test', raw } );
-
-    expect( result.config.provider ).toBe( 'anthropic' );
-    expect( result.config.model ).toBe( 'claude-sonnet-4-20250514' );
-    expect( result.config.temperature ).toBe( 0.7 );
-    expect( result.config.max_tokens ).toBe( 64000 );
-    expect( result.config.maxTokens ).toBeUndefined();
-    expect( result.config.providerOptions ).toBeDefined();
-    expect( result.config.providerOptions.thinking ).toBeDefined();
-    expect( result.config.providerOptions.thinking.type ).toBe( 'enabled' );
-    expect( result.config.providerOptions.thinking.budget_tokens ).toBe( 1500 );
-    expect( result.config.providerOptions.thinking.budgetTokens ).toBeUndefined();
-  } );
-
-  it( 'parses supported message roles', () => {
-    const raw = `---
-provider: anthropic
-model: claude-3-5-sonnet-20241022
----
-
-<system>System message</system>
-<assistant>Assistant message</assistant>
-<tool>Tool message</tool>
-<user>User message</user>`;
-
-    const result = parsePrompt( { name: 'test', raw } );
-
-    expect( result.messages ).toEqual( [
-      {
-        role: 'system',
-        content: 'System message'
-      },
-      {
-        role: 'assistant',
-        content: 'Assistant message'
-      },
-      {
-        role: 'tool',
-        content: 'Tool message'
-      },
-      {
-        role: 'user',
-        content: 'User message'
-      }
-    ] );
-    expect( result.instructions ).toBeNull();
-  } );
-
-  it( 'surfaces block opening-tag attributes as an attributes object', () => {
-    const raw = `---
-provider: anthropic
-model: claude-sonnet-4-5
----
-
-<system options="cached">Static.</system>
-<user>Question</user>`;
-
-    const result = parsePrompt( { name: 'test', raw } );
-
-    expect( result.messages[0] ).toEqual( {
-      role: 'system',
-      content: 'Static.',
-      attributes: { options: 'cached' }
-    } );
-    expect( result.messages[1] ).toEqual( { role: 'user', content: 'Question' } );
-  } );
-} );