@outputai/llm 0.11.1-next.da26845.0 → 0.12.0

package/src/utils/tools.spec.js

@@ -1,167 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-
-const getProvider = vi.hoisted( () => vi.fn() );
-
-vi.mock( '../ai_provider.js', () => ( {
-  getProvider
-} ) );
-
-vi.mock( 'ai', () => ( {
-  tool: def => def
-} ) );
-
-import { buildLoadSkillTool, loadPromptTools } from './tools.js';
-
-const skills = [
-  { name: 'writer', description: 'Writes copy', instructions: '# Writer\nDo it.' },
-  { name: 'reviewer', description: 'Reviews drafts', instructions: 'Review carefully.' }
-];
-
-describe( 'buildLoadSkillTool', () => {
-  it( 'returns a tool that loads instructions by skill name', () => {
-    const tool = buildLoadSkillTool( skills );
-
-    expect( tool.description ).toBe( 'Get detailed instructions for a named skill' );
-    expect( tool.execute( { name: 'writer' } ) ).toBe( '# Writer\nDo it.' );
-    expect( tool.execute( { name: 'reviewer' } ) ).toBe( 'Review carefully.' );
-  } );
-
-  it( 'returns available skill names when the name is unknown', () => {
-    const tool = buildLoadSkillTool( skills );
-
-    expect( tool.execute( { name: 'missing' } ) ).toBe(
-      'Skill "missing" not found. Available: writer, reviewer'
-    );
-  } );
-
-  it( 'lists no names when the catalog is empty', () => {
-    const tool = buildLoadSkillTool( [] );
-
-    expect( tool.execute( { name: 'writer' } ) ).toBe( 'Skill "writer" not found. Available: ' );
-  } );
-} );
-
-describe( 'loadPromptTools', () => {
-  it( 'returns null and does not load the provider when no tools are configured', () => {
-    const result = loadPromptTools( {
-      config: {
-        provider: 'vertex',
-        model: 'gemini-2.0-flash'
-      }
-    } );
-
-    expect( result ).toBeNull();
-    expect( getProvider ).not.toHaveBeenCalled();
-  } );
-
-  it( 'returns null and does not load the provider when tools config is empty', () => {
-    const result = loadPromptTools( {
-      config: {
-        provider: 'vertex',
-        tools: {}
-      }
-    } );
-
-    expect( result ).toBeNull();
-    expect( getProvider ).not.toHaveBeenCalled();
-  } );
-
-  it( 'throws when the provider has no tools object', () => {
-    getProvider.mockReturnValue( vi.fn() );
-
-    expect( () => loadPromptTools( {
-      name: 'foo',
-      config: {
-        provider: 'azure',
-        tools: {
-          webSearch: {}
-        }
-      }
-    } ) ).toThrow( 'Provider "azure" used by prompt "foo" does not support provider-specific tools.' );
-  } );
-
-  it( 'loads a single provider tool with config', () => {
-    const googleSearch = vi.fn( config => ( { type: 'googleSearch', config } ) );
-    const provider = {
-      tools: {
-        googleSearch
-      }
-    };
-    getProvider.mockReturnValue( provider );
-
-    const result = loadPromptTools( {
-      config: {
-        provider: 'vertex',
-        tools: {
-          googleSearch: {
-            mode: 'MODE_DYNAMIC',
-            dynamicThreshold: 0.8
-          }
-        }
-      }
-    } );
-
-    expect( getProvider ).toHaveBeenCalledWith( 'vertex' );
-    expect( googleSearch ).toHaveBeenCalledWith( {
-      mode: 'MODE_DYNAMIC',
-      dynamicThreshold: 0.8
-    } );
-    expect( result ).toEqual( {
-      googleSearch: {
-        type: 'googleSearch',
-        config: {
-          mode: 'MODE_DYNAMIC',
-          dynamicThreshold: 0.8
-        }
-      }
-    } );
-  } );
-
-  it( 'loads multiple provider tools', () => {
-    const googleSearch = vi.fn( config => ( { type: 'googleSearch', config } ) );
-    const urlContext = vi.fn( config => ( { type: 'urlContext', config } ) );
-    getProvider.mockReturnValue( {
-      tools: {
-        googleSearch,
-        urlContext
-      }
-    } );
-
-    const result = loadPromptTools( {
-      config: {
-        provider: 'vertex',
-        tools: {
-          googleSearch: {
-            mode: 'MODE_DYNAMIC'
-          },
-          urlContext: {}
-        }
-      }
-    } );
-
-    expect( Object.keys( result ) ).toEqual( [ 'googleSearch', 'urlContext' ] );
-    expect( googleSearch ).toHaveBeenCalledWith( { mode: 'MODE_DYNAMIC' } );
-    expect( urlContext ).toHaveBeenCalledWith( {} );
-    expect( result.googleSearch.type ).toBe( 'googleSearch' );
-    expect( result.urlContext.type ).toBe( 'urlContext' );
-  } );
-
-  it( 'throws when a configured tool is not supported by the provider', () => {
-    getProvider.mockReturnValue( {
-      tools: {
-        googleSearch: vi.fn(),
-        urlContext: vi.fn()
-      }
-    } );
-
-    expect( () => loadPromptTools( {
-      name: 'foo',
-      config: {
-        provider: 'vertex',
-        tools: {
-          unknownTool: {}
-        }
-      }
-    } ) ).toThrow( 'Provider "vertex" used by prompt "foo" does not support these tools: unknownTool.' );
-  } );
-} );

package/src/utils/usage.full.spec.js

@@ -1,215 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { req1 as anthropicCacheSeed, req2 as anthropicCacheReadWrite } from '../fixtures/text_response_v7_anthropic_cache.js';
-import anthropicStream from '../fixtures/stream_response_v7_anthropic.js';
-import anthropicText from '../fixtures/text_response_v7_anthropic.js';
-import googleVertexImage from '../fixtures/image_response_v7_google_vertex.js';
-import googleVertexStream from '../fixtures/stream_response_v7_google_vertex.js';
-import googleVertexText from '../fixtures/text_response_v7_google_vertex.js';
-import openaiImage from '../fixtures/image_response_v7_openai.js';
-import openaiStream from '../fixtures/stream_response_v7_openai.js';
-import openaiText from '../fixtures/text_response_v7_openai.js';
-import perplexityStream from '../fixtures/stream_response_v7_perplexity.js';
-import perplexityText from '../fixtures/text_response_v7_perplexity.js';
-import { LLMGenerationUsage, LLMGenerationUsageItem, parseLLMUsage } from './usage.js';
-
-const INPUT = LLMGenerationUsageItem.Group.INPUT;
-const OUTPUT = LLMGenerationUsageItem.Group.OUTPUT;
-
-const cases = [
-  {
-    name: 'OpenAI text',
-    fixture: openaiText,
-    providerId: 'openai',
-    modelId: 'gpt-4.1-mini',
-    input: 1035,
-    output: 396,
-    items: [
-      { group: INPUT, label: 'no_cache', amount: 1035 },
-      { group: INPUT, label: 'cache_read', amount: 0 },
-      { group: INPUT, label: 'cache_write', amount: 0 },
-      { group: OUTPUT, label: 'text', amount: 396 },
-      { group: OUTPUT, label: 'reasoning', amount: 0 }
-    ]
-  },
-  {
-    name: 'OpenAI stream',
-    fixture: openaiStream,
-    providerId: 'openai',
-    modelId: 'gpt-4.1-mini',
-    input: 1035,
-    output: 386,
-    items: [
-      { group: INPUT, label: 'no_cache', amount: 1035 },
-      { group: INPUT, label: 'cache_read', amount: 0 },
-      { group: INPUT, label: 'cache_write', amount: 0 },
-      { group: OUTPUT, label: 'text', amount: 386 },
-      { group: OUTPUT, label: 'reasoning', amount: 0 }
-    ]
-  },
-  {
-    name: 'OpenAI image',
-    fixture: openaiImage,
-    providerId: 'openai',
-    modelId: 'gpt-image-1',
-    input: 151,
-    output: 4160,
-    items: [
-      { group: INPUT, label: null, amount: 151 },
-      { group: OUTPUT, label: null, amount: 4160 }
-    ]
-  },
-  {
-    name: 'Anthropic text',
-    fixture: anthropicText,
-    providerId: 'anthropic',
-    modelId: 'claude-haiku-4-5',
-    input: 1113,
-    output: 845,
-    items: [
-      { group: INPUT, label: 'no_cache', amount: 1113 },
-      { group: INPUT, label: 'cache_read', amount: 0 },
-      { group: INPUT, label: 'cache_write', amount: 0 },
-      { group: OUTPUT, label: null, amount: 845 }
-    ]
-  },
-  {
-    name: 'Anthropic stream',
-    fixture: anthropicStream,
-    providerId: 'anthropic',
-    modelId: 'claude-haiku-4-5',
-    input: 1113,
-    output: 1047,
-    items: [
-      { group: INPUT, label: 'no_cache', amount: 1113 },
-      { group: INPUT, label: 'cache_read', amount: 0 },
-      { group: INPUT, label: 'cache_write', amount: 0 },
-      { group: OUTPUT, label: null, amount: 1047 }
-    ]
-  },
-  {
-    name: 'Anthropic cache seed',
-    fixture: anthropicCacheSeed,
-    providerId: 'anthropic',
-    modelId: 'claude-haiku-4-5',
-    input: 15016,
-    output: 5,
-    items: [
-      { group: INPUT, label: 'no_cache', amount: 15 },
-      { group: INPUT, label: 'cache_read', amount: 0 },
-      { group: INPUT, label: 'cache_write', amount: 15001 },
-      { group: OUTPUT, label: null, amount: 5 }
-    ]
-  },
-  {
-    name: 'Anthropic cache read and write',
-    fixture: anthropicCacheReadWrite,
-    providerId: 'anthropic',
-    modelId: 'claude-haiku-4-5',
-    input: 19017,
-    output: 4,
-    items: [
-      { group: INPUT, label: 'no_cache', amount: 14 },
-      { group: INPUT, label: 'cache_read', amount: 15001 },
-      { group: INPUT, label: 'cache_write', amount: 4002 },
-      { group: OUTPUT, label: null, amount: 4 }
-    ]
-  },
-  {
-    name: 'Google Vertex text',
-    fixture: googleVertexText,
-    providerId: 'google-vertex',
-    modelId: 'gemini-2.5-flash',
-    input: 1032,
-    output: 1381,
-    items: [
-      { group: INPUT, label: 'no_cache', amount: 1032 },
-      { group: INPUT, label: 'cache_read', amount: 0 },
-      { group: OUTPUT, label: 'text', amount: 793 },
-      { group: OUTPUT, label: 'reasoning', amount: 588 }
-    ]
-  },
-  {
-    name: 'Google Vertex stream',
-    fixture: googleVertexStream,
-    providerId: 'google-vertex',
-    modelId: 'gemini-2.5-flash',
-    input: 1032,
-    output: 1347,
-    items: [
-      { group: INPUT, label: 'no_cache', amount: 1032 },
-      { group: INPUT, label: 'cache_read', amount: 0 },
-      { group: OUTPUT, label: 'text', amount: 858 },
-      { group: OUTPUT, label: 'reasoning', amount: 489 }
-    ]
-  },
-  {
-    name: 'Google Vertex image',
-    fixture: googleVertexImage,
-    providerId: 'google-vertex',
-    modelId: 'gemini-2.5-flash-image',
-    input: 157,
-    output: 1290,
-    items: [
-      { group: INPUT, label: null, amount: 157 },
-      { group: OUTPUT, label: null, amount: 1290 }
-    ]
-  },
-  {
-    name: 'Perplexity text',
-    fixture: perplexityText,
-    providerId: 'perplexity',
-    modelId: 'sonar',
-    input: 1025,
-    output: 437,
-    items: [
-      { group: INPUT, label: 'no_cache', amount: 1025 },
-      { group: OUTPUT, label: 'text', amount: 437 },
-      { group: OUTPUT, label: 'reasoning', amount: 0 }
-    ]
-  },
-  {
-    name: 'Perplexity stream',
-    fixture: perplexityStream,
-    providerId: 'perplexity',
-    modelId: 'sonar',
-    input: 1025,
-    output: 448,
-    items: [
-      { group: INPUT, label: 'no_cache', amount: 1025 },
-      { group: OUTPUT, label: 'text', amount: 448 },
-      { group: OUTPUT, label: 'reasoning', amount: 0 }
-    ]
-  }
-];
-
-describe( 'parseLLMUsage with AI SDK response fixtures', () => {
-  it.each( cases )( 'normalizes $name usage', ( {
-    fixture,
-    providerId,
-    modelId,
-    input,
-    output,
-    items
-  } ) => {
-    const result = parseLLMUsage( {
-      prompt: {
-        config: {
-          provider: providerId,
-          model: modelId
-        }
-      },
-      usage: fixture.usage
-    } );
-
-    expect( JSON.parse( JSON.stringify( result ) ) ).toEqual( {
-      type: LLMGenerationUsage.TYPE,
-      providerId,
-      modelId,
-      status: LLMGenerationUsage.Status.COMPLETE,
-      input,
-      output,
-      total: input + output,
-      items
-    } );
-  } );
-} );

package/src/utils/usage.spec.js

@@ -1,246 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { Tracing } from '@outputai/core/sdk/runtime';
-import { LLMGenerationUsage, LLMGenerationUsageItem, parseLLMUsage } from './usage.js';
-
-const prompt = {
-  config: {
-    provider: 'test-provider',
-    model: 'test-model'
-  }
-};
-
-const parse = usage => parseLLMUsage( { prompt, usage } );
-const serialize = value => JSON.parse( JSON.stringify( value ) );
-
-describe( 'LLMGenerationUsage', () => {
-  it( 'aggregates usage items and produces serializable data', () => {
-    const usage = new LLMGenerationUsage( 'test-model', 'test-provider', [
-      new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.INPUT, 'no_cache', 70 ),
-      new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.INPUT, 'cache_read', 30 ),
-      new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.OUTPUT, 'text', 40 ),
-      new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.OUTPUT, 'reasoning', 10 )
-    ] );
-
-    expect( usage ).toBeInstanceOf( Tracing.Attribute.BaseAttribute );
-    expect( serialize( usage ) ).toEqual( {
-      type: LLMGenerationUsage.TYPE,
-      providerId: 'test-provider',
-      modelId: 'test-model',
-      status: LLMGenerationUsage.Status.COMPLETE,
-      input: 100,
-      output: 50,
-      total: 150,
-      items: [
-        { group: LLMGenerationUsageItem.Group.INPUT, label: 'no_cache', amount: 70 },
-        { group: LLMGenerationUsageItem.Group.INPUT, label: 'cache_read', amount: 30 },
-        { group: LLMGenerationUsageItem.Group.OUTPUT, label: 'text', amount: 40 },
-        { group: LLMGenerationUsageItem.Group.OUTPUT, label: 'reasoning', amount: 10 }
-      ]
-    } );
-  } );
-
-  it( 'keeps missing groups null and marks usage incomplete', () => {
-    const usage = new LLMGenerationUsage( 'test-model', 'test-provider', [
-      new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.INPUT, null, 25 )
-    ] );
-
-    expect( usage ).toMatchObject( {
-      status: LLMGenerationUsage.Status.INCOMPLETE,
-      input: 25,
-      output: null,
-      total: 25
-    } );
-  } );
-
-  it( 'represents empty items as incomplete usage without totals', () => {
-    const usage = new LLMGenerationUsage( 'test-model', 'test-provider', [] );
-
-    expect( usage ).toMatchObject( {
-      status: LLMGenerationUsage.Status.INCOMPLETE,
-      input: null,
-      output: null,
-      total: null,
-      items: []
-    } );
-  } );
-} );
-
-describe( 'parseLLMUsage', () => {
-  it( 'uses complete input and output breakdowns', () => {
-    const result = parse( {
-      inputTokens: 100,
-      inputTokenDetails: {
-        noCacheTokens: 70,
-        cacheReadTokens: 20,
-        cacheWriteTokens: 10
-      },
-      outputTokens: 50,
-      outputTokenDetails: {
-        textTokens: 40,
-        reasoningTokens: 10
-      }
-    } );
-
-    expect( serialize( result ) ).toEqual( {
-      type: LLMGenerationUsage.TYPE,
-      providerId: 'test-provider',
-      modelId: 'test-model',
-      status: LLMGenerationUsage.Status.COMPLETE,
-      input: 100,
-      output: 50,
-      total: 150,
-      items: [
-        { group: LLMGenerationUsageItem.Group.INPUT, label: 'no_cache', amount: 70 },
-        { group: LLMGenerationUsageItem.Group.INPUT, label: 'cache_read', amount: 20 },
-        { group: LLMGenerationUsageItem.Group.INPUT, label: 'cache_write', amount: 10 },
-        { group: LLMGenerationUsageItem.Group.OUTPUT, label: 'text', amount: 40 },
-        { group: LLMGenerationUsageItem.Group.OUTPUT, label: 'reasoning', amount: 10 }
-      ]
-    } );
-  } );
-
-  it( 'uses sparse breakdowns when their reported values match the aggregates', () => {
-    const result = parse( {
-      inputTokens: 100,
-      inputTokenDetails: {
-        noCacheTokens: 80,
-        cacheReadTokens: 20
-      },
-      outputTokens: 50,
-      outputTokenDetails: {
-        textTokens: 50
-      }
-    } );
-
-    expect( result.items ).toEqual( [
-      new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.INPUT, 'no_cache', 80 ),
-      new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.INPUT, 'cache_read', 20 ),
-      new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.OUTPUT, 'text', 50 )
-    ] );
-    expect( result.status ).toBe( LLMGenerationUsage.Status.COMPLETE );
-  } );
-
-  it( 'uses aggregate items when no breakdown is reported', () => {
-    const result = parse( {
-      inputTokens: 100,
-      outputTokens: 50
-    } );
-
-    expect( result.items ).toEqual( [
-      new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.INPUT, null, 100 ),
-      new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.OUTPUT, null, 50 )
-    ] );
-    expect( result ).toMatchObject( {
-      status: LLMGenerationUsage.Status.COMPLETE,
-      input: 100,
-      output: 50,
-      total: 150
-    } );
-  } );
-
-  it( 'uses aggregate items when reported breakdowns do not match', () => {
-    const result = parse( {
-      inputTokens: 100,
-      inputTokenDetails: {
-        noCacheTokens: 90,
-        cacheReadTokens: 5,
-        cacheWriteTokens: 0
-      },
-      outputTokens: 50,
-      outputTokenDetails: {
-        textTokens: 40,
-        reasoningTokens: 5
-      }
-    } );
-
-    expect( result.items ).toEqual( [
-      new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.INPUT, null, 100 ),
-      new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.OUTPUT, null, 50 )
-    ] );
-  } );
-
-  it( 'preserves known zero aggregates', () => {
-    const result = parse( {
-      inputTokens: 0,
-      inputTokenDetails: {
-        noCacheTokens: 0,
-        cacheReadTokens: 0,
-        cacheWriteTokens: 0
-      },
-      outputTokens: 0,
-      outputTokenDetails: {
-        textTokens: 0,
-        reasoningTokens: 0
-      }
-    } );
-
-    expect( result ).toMatchObject( {
-      status: LLMGenerationUsage.Status.COMPLETE,
-      input: 0,
-      output: 0,
-      total: 0
-    } );
-    expect( result.items ).toEqual( [
-      new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.INPUT, null, 0 ),
-      new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.OUTPUT, null, 0 )
-    ] );
-  } );
-
-  it.each( [
-    {
-      name: 'input',
-      usage: { inputTokens: 25 },
-      expected: { input: 25, output: null, total: 25 },
-      item: new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.INPUT, null, 25 )
-    },
-    {
-      name: 'output',
-      usage: { outputTokens: 15 },
-      expected: { input: null, output: 15, total: 15 },
-      item: new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.OUTPUT, null, 15 )
-    }
-  ] )( 'marks $name-only usage incomplete', ( { usage, expected, item } ) => {
-    const result = parse( usage );
-
-    expect( result ).toMatchObject( {
-      status: LLMGenerationUsage.Status.INCOMPLETE,
-      ...expected
-    } );
-    expect( result.items ).toEqual( [ item ] );
-  } );
-
-  it.each( [
-    Number.POSITIVE_INFINITY,
-    -1,
-    1.5
-  ] )( 'ignores invalid aggregate value %s', inputTokens => {
-    const result = parse( {
-      inputTokens,
-      outputTokens: 15
-    } );
-
-    expect( result ).toMatchObject( {
-      status: LLMGenerationUsage.Status.INCOMPLETE,
-      input: null,
-      output: 15,
-      total: 15
-    } );
-    expect( result.items ).toEqual( [
-      new LLMGenerationUsageItem( LLMGenerationUsageItem.Group.OUTPUT, null, 15 )
-    ] );
-  } );
-
-  it( 'returns null when neither aggregate is reported', () => {
-    const result = parse( {
-      inputTokenDetails: {
-        noCacheTokens: 10
-      },
-      outputTokenDetails: {
-        textTokens: 5
-      },
-      totalTokens: 15
-    } );
-
-    expect( result ).toBeNull();
-  } );
-} );