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

package/src/utils/models.spec.js

@@ -1,119 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-const getProvider = vi.hoisted( () => vi.fn() );
-
-vi.mock( '../ai_provider.js', () => ( {
-  getProvider
-} ) );
-
-import { loadImageModel, loadTextModel } from './models.js';
-
-afterEach( () => {
-  vi.clearAllMocks();
-} );
-
-describe( 'loadTextModel', () => {
-  it( 'loads a text model using the prompt provider and model', () => {
-    const provider = vi.fn( model => ( { type: 'text-model', model } ) );
-    getProvider.mockReturnValue( provider );
-
-    const result = loadTextModel( {
-      config: {
-        provider: 'openai',
-        model: 'gpt-4o-mini'
-      }
-    } );
-
-    expect( getProvider ).toHaveBeenCalledWith( 'openai' );
-    expect( provider ).toHaveBeenCalledWith( 'gpt-4o-mini' );
-    expect( result ).toEqual( {
-      type: 'text-model',
-      model: 'gpt-4o-mini'
-    } );
-  } );
-
-  it( 'propagates provider lookup errors', () => {
-    getProvider.mockImplementation( () => {
-      throw new Error( 'Unsupported provider "missing"' );
-    } );
-
-    expect( () => loadTextModel( {
-      config: {
-        provider: 'missing',
-        model: 'model'
-      }
-    } ) ).toThrow( 'Unsupported provider "missing"' );
-  } );
-} );
-
-describe( 'loadImageModel', () => {
-  it( 'loads an image model using provider.image', () => {
-    const textProvider = vi.fn();
-    textProvider.image = vi.fn( model => ( { type: 'image-model', model } ) );
-    getProvider.mockReturnValue( textProvider );
-
-    const result = loadImageModel( {
-      config: {
-        provider: 'openai',
-        model: 'gpt-image-1'
-      }
-    } );
-
-    expect( getProvider ).toHaveBeenCalledWith( 'openai' );
-    expect( textProvider.image ).toHaveBeenCalledWith( 'gpt-image-1' );
-    expect( textProvider ).not.toHaveBeenCalled();
-    expect( result ).toEqual( {
-      type: 'image-model',
-      model: 'gpt-image-1'
-    } );
-  } );
-
-  it( 'falls back to provider.imageModel', () => {
-    const provider = vi.fn();
-    provider.imageModel = vi.fn( model => ( { type: 'legacy-image-model', model } ) );
-    getProvider.mockReturnValue( provider );
-
-    const result = loadImageModel( {
-      config: {
-        provider: 'custom',
-        model: 'image-v1'
-      }
-    } );
-
-    expect( provider.imageModel ).toHaveBeenCalledWith( 'image-v1' );
-    expect( result ).toEqual( {
-      type: 'legacy-image-model',
-      model: 'image-v1'
-    } );
-  } );
-
-  it( 'prefers provider.image when both image factories exist', () => {
-    const provider = vi.fn();
-    provider.image = vi.fn( model => ( { type: 'image', model } ) );
-    provider.imageModel = vi.fn( model => ( { type: 'imageModel', model } ) );
-    getProvider.mockReturnValue( provider );
-
-    const result = loadImageModel( {
-      config: {
-        provider: 'custom',
-        model: 'image-v1'
-      }
-    } );
-
-    expect( provider.image ).toHaveBeenCalledWith( 'image-v1' );
-    expect( provider.imageModel ).not.toHaveBeenCalled();
-    expect( result.type ).toBe( 'image' );
-  } );
-
-  it( 'throws a clear error when the provider does not support image models', () => {
-    getProvider.mockReturnValue( vi.fn() );
-
-    expect( () => loadImageModel( {
-      name: 'foo',
-      config: {
-        provider: 'azure',
-        model: 'gpt-image-1'
-      }
-    } ) ).toThrow( 'Provider "azure" used by prompt "foo" does not support image models.' );
-  } );
-} );

package/src/utils/models_pricing.spec.js

@@ -1,162 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { fetchModelsPricing, cache } from './models_pricing.js';
-import fixture from '../fixtures/models_api_light.json' with { type: 'json' };
-
-const fetchMock = vi.hoisted( () => vi.fn() );
-const EnvHttpProxyAgentMock = vi.hoisted( () => vi.fn( function EnvHttpProxyAgent( options ) {
-  this.options = options;
-} ) );
-
-vi.mock( 'undici', () => ( {
-  EnvHttpProxyAgent: EnvHttpProxyAgentMock,
-  fetch: fetchMock
-} ) );
-
-const costTableUrl = 'https://models.dev/api.json';
-const okResponse = data => ( {
-  ok: true,
-  json: () => Promise.resolve( data )
-} );
-const stubFetch = response => {
-  fetchMock.mockResolvedValueOnce( response );
-  return fetchMock;
-};
-
-describe( 'modelsPricing', () => {
-  beforeEach( () => {
-    cache.content = null;
-    cache.expiresAt = 0;
-    fetchMock.mockReset();
-  } );
-
-  it( 'returns a Map of model costs when fetch succeeds', async () => {
-    const fetchMock = stubFetch( okResponse( fixture ) );
-
-    const result = await fetchModelsPricing();
-
-    expect( EnvHttpProxyAgentMock ).toHaveBeenCalledWith( { allowH2: false } );
-    expect( fetchMock ).toHaveBeenCalledWith( costTableUrl, { dispatcher: EnvHttpProxyAgentMock.mock.results[0].value } );
-    expect( result ).toBeInstanceOf( Map );
-    expect( result.size ).toBeGreaterThan( 0 );
-    const firstModel = Object.values( fixture )[0];
-    const firstModelId = Object.keys( firstModel.models )[0];
-    const cost = firstModel.models[firstModelId].cost;
-    expect( result.get( firstModelId ) ).toBeUndefined();
-    expect( result.get( `${firstModel.id}/${firstModelId}` ) ).toEqual( cost );
-  } );
-
-  it( 'includes main providers from fixture (openai, anthropic, google, nvidia, perplexity)', async () => {
-    stubFetch( okResponse( fixture ) );
-
-    const result = await fetchModelsPricing();
-
-    const openaiProvider = fixture.openai;
-    const openaiModelId = Object.keys( openaiProvider.models )[0];
-    expect( result.get( openaiModelId ) ).toBeUndefined();
-    expect( result.get( `openai/${openaiModelId}` ) ).toEqual( openaiProvider.models[openaiModelId].cost );
-
-    const anthropicModelId = Object.keys( fixture.anthropic.models )[0];
-    expect( result.get( `anthropic/${anthropicModelId}` ) ).toEqual( fixture.anthropic.models[anthropicModelId].cost );
-  } );
-
-  it( 'keeps separate costs when the same model id exists under two providers', async () => {
-    stubFetch( okResponse( fixture ) );
-
-    const result = await fetchModelsPricing();
-    const sharedModelId = 'gpt-4o-2024-11-20';
-
-    expect( result.get( sharedModelId ) ).toBeUndefined();
-    expect( result.get( `openai/${sharedModelId}` ) ).toEqual( fixture.openai.models[sharedModelId].cost );
-    expect( result.get( `azure/${sharedModelId}` ) ).toEqual( fixture.azure.models[sharedModelId].cost );
-    expect( result.get( `openai/${sharedModelId}` ) ).not.toEqual( result.get( `azure/${sharedModelId}` ) );
-  } );
-
-  it( 'returns null when response is not ok and no cache', async () => {
-    const status = 500;
-    stubFetch( { ok: false, status } );
-
-    const result = await fetchModelsPricing();
-
-    expect( result ).toBeNull();
-  } );
-
-  it( 'returns stale cache when response is not ok but cache exists', async () => {
-    stubFetch( okResponse( fixture ) );
-    await fetchModelsPricing();
-    cache.expiresAt = 0; // force refetch so we hit the !res.ok path
-
-    const status = 404;
-    stubFetch( { ok: false, status } );
-
-    const result = await fetchModelsPricing();
-
-    expect( result ).toBeInstanceOf( Map );
-    expect( result.size ).toBeGreaterThan( 0 );
-  } );
-
-  it( 'returns null when fetch rejects and no cache', async () => {
-    const error = new Error( 'network failure' );
-    fetchMock.mockRejectedValueOnce( error );
-
-    const result = await fetchModelsPricing();
-
-    expect( result ).toBeNull();
-  } );
-
-  it( 'returns stale cache when fetch rejects but cache exists', async () => {
-    stubFetch( okResponse( fixture ) );
-    const staleCache = await fetchModelsPricing();
-    cache.expiresAt = 0; // force refetch so we hit the catch path
-
-    const error = Object.assign( new Error( 'socket closed' ), { code: 'UND_ERR_SOCKET' } );
-    fetchMock.mockRejectedValueOnce( error );
-
-    const result = await fetchModelsPricing();
-
-    expect( result ).toBe( staleCache );
-  } );
-
-  it( 'returns stale cache when response JSON parsing fails but cache exists', async () => {
-    stubFetch( okResponse( fixture ) );
-    const staleCache = await fetchModelsPricing();
-    cache.expiresAt = 0; // force refetch so parsing errors can fall back to cache
-
-    stubFetch( {
-      ok: true,
-      json: () => Promise.reject( new SyntaxError( 'Unexpected token' ) )
-    } );
-
-    const result = await fetchModelsPricing();
-
-    expect( result ).toBe( staleCache );
-  } );
-
-  it( 'returns cached Map when cache is still valid', async () => {
-    const fetchMock = stubFetch( okResponse( fixture ) );
-
-    const first = await fetchModelsPricing();
-    const second = await fetchModelsPricing();
-
-    expect( first ).toBe( second );
-    expect( fetchMock ).toHaveBeenCalledTimes( 1 );
-  } );
-
-  it( 'only stores models that have a cost object', async () => {
-    const dataWithMissingCost = {
-      p1: {
-        id: 'p1',
-        models: {
-          withCost: { cost: { input: 1, output: 2 } },
-          noCost: { name: 'x' }
-        }
-      }
-    };
-    stubFetch( okResponse( dataWithMissingCost ) );
-
-    const result = await fetchModelsPricing();
-
-    expect( result.get( 'p1/withCost' ) ).toEqual( { input: 1, output: 2 } );
-    expect( result.get( 'withCost' ) ).toBeUndefined();
-    expect( result.get( 'p1/noCost' ) ).toBeUndefined();
-  } );
-} );

package/src/utils/skills.spec.js

@@ -1,168 +0,0 @@
-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 { ValidationError } from '@outputai/core';
-import { loadSkills, recursiveLoadSkillFile } from './skills.js';
-
-const dirs = [];
-
-const tempDir = () => {
-  const dir = mkdtempSync( join( tmpdir(), 'skills-' ) );
-  dirs.push( dir );
-  return dir;
-};
-
-const writeSkill = ( dir, filename, body ) => {
-  writeFileSync( join( dir, filename ), body );
-};
-
-afterEach( () => {
-  for ( const dir of dirs.splice( 0 ) ) {
-    rmSync( dir, { recursive: true, force: true } );
-  }
-} );
-
-describe( 'recursiveLoadSkillFile', () => {
-  it( 'returns an empty array for no paths', () => {
-    expect( recursiveLoadSkillFile( [] ) ).toEqual( [] );
-  } );
-
-  it( 'throws ValidationError when a path is missing', () => {
-    const missing = join( tempDir(), 'gone.md' );
-
-    expect( () => recursiveLoadSkillFile( [ missing ] ) ).toThrow( ValidationError );
-    expect( () => recursiveLoadSkillFile( [ missing ] ) ).toThrow( `Skill path "${missing}" not found` );
-  } );
-
-  it( 'loads an explicitly listed non-md file', () => {
-    const dir = tempDir();
-    writeSkill( dir, 'notes.txt', 'not a skill' );
-
-    expect( recursiveLoadSkillFile( [ join( dir, 'notes.txt' ) ] ) ).toEqual( [
-      { name: 'notes.txt', description: 'notes.txt', instructions: 'not a skill' }
-    ] );
-  } );
-
-  it( 'loads a markdown file and defaults name/description to the basename', () => {
-    const dir = tempDir();
-    writeSkill( dir, 'writer.md', '# Writer\n\nDo the thing.\n' );
-
-    expect( recursiveLoadSkillFile( [ join( dir, 'writer.md' ) ] ) ).toEqual( [ {
-      name: 'writer',
-      description: 'writer',
-      instructions: '# Writer\n\nDo the thing.'
-    } ] );
-  } );
-
-  it( 'uses frontmatter name and description when present', () => {
-    const dir = tempDir();
-    writeSkill( dir, 'file.md', [
-      '---',
-      'name: copywriter',
-      'description: Writes marketing copy',
-      '---',
-      '',
-      'Use a confident tone.'
-    ].join( '\n' ) );
-
-    expect( recursiveLoadSkillFile( [ join( dir, 'file.md' ) ] ) ).toEqual( [ {
-      name: 'copywriter',
-      description: 'Writes marketing copy',
-      instructions: 'Use a confident tone.'
-    } ] );
-  } );
-
-  it( 'returns an empty array for an empty directory', () => {
-    expect( recursiveLoadSkillFile( [ tempDir() ] ) ).toEqual( [] );
-  } );
-
-  it( 'loads markdown files from a directory in sorted order and skips other files', () => {
-    const dir = tempDir();
-    writeSkill( dir, 'z.md', 'zeta' );
-    writeSkill( dir, 'a.md', 'alpha' );
-    writeSkill( dir, 'readme.txt', 'ignore' );
-
-    expect( recursiveLoadSkillFile( [ dir ] ) ).toEqual( [
-      { name: 'a', description: 'a', instructions: 'alpha' },
-      { name: 'z', description: 'z', instructions: 'zeta' }
-    ] );
-  } );
-
-  it( 'recurses into nested directories', () => {
-    const dir = tempDir();
-    const nested = join( dir, 'nested' );
-    mkdirSync( nested );
-    writeSkill( dir, 'root.md', 'root' );
-    writeSkill( nested, 'child.md', 'child' );
-
-    expect( recursiveLoadSkillFile( [ dir ] ) ).toEqual( [
-      { name: 'child', description: 'child', instructions: 'child' },
-      { name: 'root', description: 'root', instructions: 'root' }
-    ] );
-  } );
-
-  it( 'loads files from a directory whose name ends in .md', () => {
-    const dir = tempDir();
-    const nested = join( dir, 'nested.md' );
-    mkdirSync( nested );
-    writeSkill( nested, 'child.md', 'child' );
-
-    expect( recursiveLoadSkillFile( [ nested ] ) ).toEqual( [
-      { name: 'child', description: 'child', instructions: 'child' }
-    ] );
-  } );
-
-  it( 'does not follow directory symlinks', () => {
-    const dir = tempDir();
-    const target = tempDir();
-    writeSkill( target, 'external.md', 'external' );
-    symlinkSync( target, join( dir, 'linked' ), 'dir' );
-
-    expect( recursiveLoadSkillFile( [ dir ] ) ).toEqual( [] );
-  } );
-} );
-
-describe( 'loadSkills', () => {
-  it( 'returns an empty array when the prompt lists no skills', () => {
-    expect( loadSkills( { fileDir: tempDir(), config: { skills: [] } } ) ).toEqual( [] );
-  } );
-
-  it( 'resolves skill paths relative to the prompt fileDir', () => {
-    const fileDir = tempDir();
-    const skillsDir = join( fileDir, 'skills' );
-    mkdirSync( skillsDir );
-    writeSkill( skillsDir, 'reviewer.md', [
-      '---',
-      'name: reviewer',
-      'description: Reviews drafts',
-      '---',
-      'Check the brief.'
-    ].join( '\n' ) );
-
-    expect( loadSkills( {
-      fileDir,
-      config: { skills: [ 'skills/reviewer.md' ] }
-    } ) ).toEqual( [ {
-      name: 'reviewer',
-      description: 'Reviews drafts',
-      instructions: 'Check the brief.'
-    } ] );
-  } );
-
-  it( 'loads a directory listed in prompt config', () => {
-    const fileDir = tempDir();
-    const skillsDir = join( fileDir, 'skills' );
-    mkdirSync( skillsDir );
-    writeSkill( skillsDir, 'one.md', 'first' );
-
-    expect( loadSkills( {
-      fileDir,
-      config: { skills: [ 'skills' ] }
-    } ) ).toEqual( [ {
-      name: 'one',
-      description: 'one',
-      instructions: 'first'
-    } ] );
-  } );
-} );

package/src/utils/sources.spec.js

@@ -1,122 +0,0 @@
-import { createHash } from 'node:crypto';
-import { describe, it, expect } from 'vitest';
-import { extractSources } from './sources.js';
-
-const hashedId = url => createHash( 'sha256' ).update( url ).digest( 'hex' ).slice( 0, 16 );
-
-const fromSteps = ( steps, sources = [] ) => extractSources( { steps, sources } );
-
-const searchStep = results => ( {
-  toolResults: [ { output: { results } } ]
-} );
-
-describe( 'extractSources', () => {
-  it( 'returns empty when steps and sources are missing or empty', () => {
-    expect( extractSources( {} ) ).toEqual( [] );
-    expect( fromSteps( undefined ) ).toEqual( [] );
-    expect( fromSteps( null ) ).toEqual( [] );
-    expect( fromSteps( [] ) ).toEqual( [] );
-    expect( fromSteps( [ { text: 'hello' } ] ) ).toEqual( [] );
-  } );
-
-  it( 'treats non-array response sources as empty', () => {
-    const steps = [ searchStep( [ { url: 'https://u.test', title: 'T' } ] ) ];
-    expect( extractSources( { steps, sources: undefined } ) ).toHaveLength( 1 );
-    expect( extractSources( { steps, sources: {} } ) ).toHaveLength( 1 );
-  } );
-
-  it( 'skips tool results that are not a results array with urls', () => {
-    const steps = [ {
-      toolResults: [
-        { output: { answer: 'some text' } },
-        { output: { results: [] } },
-        { output: { results: [ { title: 'no url' } ] } },
-        { output: { results: [ { url: '   ' } ] } },
-        { output: 'plain string' }
-      ]
-    } ];
-    expect( fromSteps( steps ) ).toEqual( [] );
-  } );
-
-  it( 'extracts url and title from search-shaped results', () => {
-    const sources = fromSteps( [ searchStep( [
-      { url: 'https://example.com/1', title: 'Example 1', snippet: 'text' },
-      { url: 'https://example.com/2', title: 'Example 2' }
-    ] ) ] );
-
-    expect( sources ).toHaveLength( 2 );
-    expect( sources[0] ).toEqual( {
-      type: 'source',
-      sourceType: 'url',
-      id: hashedId( 'https://example.com/1' ),
-      url: 'https://example.com/1',
-      title: 'Example 1'
-    } );
-    expect( sources[1].url ).toBe( 'https://example.com/2' );
-  } );
-
-  it( 'keeps the last tool hit when urls repeat', () => {
-    const steps = [
-      searchStep( [ { url: 'https://dup.com', title: 'First' } ] ),
-      searchStep( [ { url: 'https://dup.com', title: 'Second' } ] )
-    ];
-    const sources = fromSteps( steps );
-    expect( sources ).toHaveLength( 1 );
-    expect( sources[0].title ).toBe( 'Second' );
-  } );
-
-  it( 'keeps a search hit among mixed tool results', () => {
-    const steps = [ {
-      toolResults: [
-        { output: { calculation: 42 } },
-        { output: { results: [ { url: 'https://real.com', title: 'Real' } ] } },
-        { output: 'plain string' }
-      ]
-    } ];
-    const sources = fromSteps( steps );
-    expect( sources ).toHaveLength( 1 );
-    expect( sources[0].url ).toBe( 'https://real.com' );
-  } );
-
-  it( 'defaults title to empty string when missing', () => {
-    expect( fromSteps( [ searchStep( [ { url: 'https://notitle.com' } ] ) ] )[0].title ).toBe( '' );
-  } );
-
-  it( 'trims urls for storage and id', () => {
-    const sources = fromSteps( [ searchStep( [ { url: '  https://stable.com/path  ', title: 'S' } ] ) ] );
-    expect( sources[0].url ).toBe( 'https://stable.com/path' );
-    expect( sources[0].id ).toBe( hashedId( 'https://stable.com/path' ) );
-    expect( sources[0].id ).toHaveLength( 16 );
-  } );
-
-  it( 'lets response sources win on the same url', () => {
-    const url = 'https://shared.test';
-    const sources = extractSources( {
-      steps: [ searchStep( [ { url, title: 'from-tool' } ] ) ],
-      sources: [ { url, title: 'from-response', type: 'source', sourceType: 'url', id: 'b' } ]
-    } );
-
-    expect( sources ).toHaveLength( 1 );
-    expect( sources[0].title ).toBe( 'from-response' );
-  } );
-
-  it( 'keeps document sources that have id and no url', () => {
-    const docA = { type: 'source', sourceType: 'document', id: 'doc-a', mediaType: 'application/pdf', title: 'A' };
-    const docB = { type: 'source', sourceType: 'document', id: 'doc-b', mediaType: 'application/pdf', title: 'B' };
-
-    expect( extractSources( { sources: [ docA, docB ] } ) ).toEqual( [ docA, docB ] );
-  } );
-
-  it( 'keeps url and document sources together', () => {
-    const url = 'https://page.test';
-    const doc = { type: 'source', sourceType: 'document', id: 'doc-1', title: 'Doc' };
-    const sources = extractSources( {
-      steps: [ searchStep( [ { url, title: 'from-tool' } ] ) ],
-      sources: [ doc ]
-    } );
-
-    expect( sources ).toHaveLength( 2 );
-    expect( sources[0].url ).toBe( url );
-    expect( sources[1] ).toBe( doc );
-  } );
-} );

package/src/utils/stream.spec.js

@@ -1,55 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { drainStream } from './stream.js';
-
-const asyncParts = parts => ( {
-  async *[Symbol.asyncIterator]() {
-    yield* parts;
-  }
-} );
-
-const streamOf = parts => ( { stream: asyncParts( parts ) } );
-
-describe( 'drainStream', () => {
-  it( 'consumes stream parts without throwing', async () => {
-    await expect( drainStream( streamOf( [ { type: 'text-delta', text: 'hi' } ] ) ) ).resolves.toBeUndefined();
-  } );
-
-  it( 'throws the abort signal reason when it is an Error', async () => {
-    const abortController = new AbortController();
-    const abortReason = new Error( 'Cancelled by caller' );
-    abortController.abort( abortReason );
-
-    await expect( drainStream(
-      streamOf( [ { type: 'abort', reason: abortReason.message } ] ),
-      abortController.signal
-    ) ).rejects.toBe( abortReason );
-  } );
-
-  it( 'throws part.reason when the abort signal reason is not an Error', async () => {
-    const abortController = new AbortController();
-    abortController.abort( 'cancelled' );
-
-    await expect( drainStream(
-      streamOf( [ { type: 'abort', reason: 'from-part' } ] ),
-      abortController.signal
-    ) ).rejects.toMatchObject( { message: 'from-part', cause: 'cancelled' } );
-  } );
-
-  it( 'throws a generic abort error when no reason is available', async () => {
-    await expect( drainStream( streamOf( [ { type: 'abort' } ] ) ) ).rejects.toThrow( 'Streaming generation aborted.' );
-  } );
-
-  it( 'throws the provider error when the error part is an Error', async () => {
-    const error = new Error( 'Provider failed' );
-
-    await expect( drainStream( streamOf( [ { type: 'error', error } ] ) ) ).rejects.toBe( error );
-  } );
-
-  it( 'wraps a non-Error error part', async () => {
-    await expect( drainStream( streamOf( [ { type: 'error', error: 'no model' } ] ) ) ).rejects.toThrow( 'no model' );
-  } );
-
-  it( 'throws a generic stream error when the error part has no value', async () => {
-    await expect( drainStream( streamOf( [ { type: 'error', error: null } ] ) ) ).rejects.toThrow( 'Streaming generation failed.' );
-  } );
-} );