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

package/src/utils/response_wrappers.spec.js

@@ -1,240 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { generateImage } from 'ai';
-import { MockImageModelV3 } from 'ai/test';
-import textResponseFixture from './__fixtures__/text_response.json' with { type: 'json' };
-import streamResponseFixture from './__fixtures__/stream_response.json' with { type: 'json' };
-import imageResponseFixture from './__fixtures__/image_response.json' with { type: 'json' };
-
-const mocks = vi.hoisted( () => ( {
-  combineSources: vi.fn(),
-  extractSourcesFromSteps: vi.fn(),
-  calculateLLMCallCost: vi.fn(),
-  endTraceWithSuccess: vi.fn(),
-  calculateBase64FileSize: vi.fn()
-} ) );
-
-vi.mock( './source_extraction.js', () => ( {
-  combineSources: mocks.combineSources,
-  extractSourcesFromSteps: mocks.extractSourcesFromSteps
-} ) );
-
-vi.mock( '../cost/index.js', () => ( {
-  calculateLLMCallCost: mocks.calculateLLMCallCost
-} ) );
-
-vi.mock( './trace.js', () => ( {
-  endTraceWithSuccess: mocks.endTraceWithSuccess
-} ) );
-
-vi.mock( './image.js', () => ( {
-  calculateBase64FileSize: mocks.calculateBase64FileSize
-} ) );
-
-import { wrapTextResponse, wrapStreamOnFinishResponse, wrapImageResponse } from './response_wrappers.js';
-
-const clone = value => structuredClone( value );
-
-const makeAiSdkImageResponse = () => generateImage( {
-  model: new MockImageModelV3( {
-    doGenerate: async () => ( {
-      images: imageResponseFixture.images.map( image => Buffer.from( image.base64Data, 'base64' ) ),
-      warnings: imageResponseFixture.warnings,
-      response: {
-        ...imageResponseFixture.responses[0],
-        timestamp: new Date( imageResponseFixture.responses[0].timestamp )
-      },
-      providerMetadata: imageResponseFixture.providerMetadata,
-      usage: imageResponseFixture.usage
-    } )
-  } ),
-  prompt: 'fixture prompt'
-} );
-
-describe( 'wrapTextResponse', () => {
-  const traceId = 'trace-1';
-  const providerId = 'openai';
-  const modelId = 'test-model';
-  const mockCost = { total: 0.001, components: [ { name: 'input_tokens', value: 0.001 } ] };
-
-  beforeEach( () => {
-    vi.clearAllMocks();
-    mocks.extractSourcesFromSteps.mockReturnValue( [] );
-    mocks.calculateLLMCallCost.mockResolvedValue( mockCost );
-    mocks.combineSources.mockReturnValue( [] );
-  } );
-
-  it( 'uses a text response fixture to calculate cost, end trace, and attach cost', async () => {
-    const response = clone( textResponseFixture );
-
-    const wrapped = await wrapTextResponse( { traceId, providerId, modelId, response } );
-
-    expect( wrapped.result ).toBe( response.text );
-    expect( wrapped.cost ).toEqual( mockCost );
-    expect( mocks.calculateLLMCallCost ).toHaveBeenCalledWith( {
-      usage: response.totalUsage,
-      modelId,
-      providerId
-    } );
-    expect( mocks.extractSourcesFromSteps ).toHaveBeenCalledWith( response.steps );
-    expect( mocks.endTraceWithSuccess ).toHaveBeenCalledWith( {
-      traceId,
-      usage: response.totalUsage,
-      cost: mockCost,
-      result: response.text,
-      providerMetadata: response.providerMetadata,
-      sourcesFromTools: []
-    } );
-  } );
-
-  it( 'leaves sources unchanged when no tool-extracted sources are found', async () => {
-    const response = clone( streamResponseFixture );
-    const nativeSources = [
-      { type: 'source', sourceType: 'url', id: 'n1', url: 'https://native.test', title: 'Native' }
-    ];
-    response.sources = nativeSources;
-    mocks.extractSourcesFromSteps.mockReturnValue( [] );
-
-    const wrapped = await wrapTextResponse( { traceId, providerId, modelId, response } );
-
-    expect( wrapped.sources ).toBe( nativeSources );
-    expect( mocks.combineSources ).not.toHaveBeenCalled();
-  } );
-
-  it( 'delegates source merging when tool-extracted sources exist', async () => {
-    const response = clone( streamResponseFixture );
-    const toolSource = {
-      type: 'source',
-      sourceType: 'url',
-      id: 'id-a',
-      url: 'https://example.com/a',
-      title: 'A'
-    };
-    const responseSource = {
-      type: 'source',
-      sourceType: 'url',
-      id: 'id-b',
-      url: 'https://example.com/b',
-      title: 'B'
-    };
-    const mergedSources = [ toolSource, responseSource ];
-    response.sources = [ responseSource ];
-    mocks.extractSourcesFromSteps.mockReturnValue( [ toolSource ] );
-    mocks.combineSources.mockReturnValue( mergedSources );
-
-    const wrapped = await wrapTextResponse( { traceId, providerId, modelId, response } );
-
-    expect( wrapped.sources ).toBe( mergedSources );
-    expect( mocks.combineSources ).toHaveBeenCalledWith( {
-      sourcesFromTools: [ toolSource ],
-      sourcesFromResponse: [ responseSource ]
-    } );
-  } );
-} );
-
-describe( 'wrapStreamOnFinishResponse', () => {
-  const traceId = 'stream-trace';
-  const providerId = 'openai';
-  const modelId = 'stream-model';
-  const mockCost = { total: 0.002, components: [] };
-
-  beforeEach( () => {
-    vi.clearAllMocks();
-    mocks.calculateLLMCallCost.mockResolvedValue( mockCost );
-    mocks.extractSourcesFromSteps.mockReturnValue( [] );
-  } );
-
-  it( 'uses the stream response fixture to finish trace and call the user callback with a proxied response', async () => {
-    const userOnFinish = vi.fn();
-    const response = clone( streamResponseFixture );
-
-    const callbacks = wrapStreamOnFinishResponse( {
-      traceId,
-      providerId,
-      modelId,
-      onFinish: userOnFinish
-    } );
-
-    await callbacks.onFinish( response );
-
-    expect( mocks.endTraceWithSuccess ).toHaveBeenCalledWith( {
-      traceId,
-      usage: response.totalUsage,
-      cost: mockCost,
-      result: response.text,
-      providerMetadata: response.providerMetadata,
-      sourcesFromTools: []
-    } );
-    expect( userOnFinish ).toHaveBeenCalledTimes( 1 );
-    const proxied = userOnFinish.mock.calls[0][0];
-    expect( proxied.result ).toBe( response.text );
-    expect( proxied.cost ).toEqual( mockCost );
-    expect( proxied.finishReason ).toBe( response.finishReason );
-    expect( mocks.extractSourcesFromSteps ).toHaveBeenCalledWith( response.steps );
-  } );
-
-  it( 'finishes trace even when no user onFinish callback is provided', async () => {
-    const response = clone( streamResponseFixture );
-
-    const callbacks = wrapStreamOnFinishResponse( {
-      traceId,
-      providerId,
-      modelId
-    } );
-
-    await callbacks.onFinish( response );
-
-    expect( mocks.endTraceWithSuccess ).toHaveBeenCalledWith( {
-      traceId,
-      usage: response.totalUsage,
-      cost: mockCost,
-      result: response.text,
-      providerMetadata: response.providerMetadata,
-      sourcesFromTools: []
-    } );
-    expect( mocks.calculateLLMCallCost ).toHaveBeenCalledWith( {
-      usage: response.totalUsage,
-      modelId,
-      providerId
-    } );
-  } );
-} );
-
-describe( 'wrapImageResponse', () => {
-  const traceId = 'image-trace';
-  const providerId = 'openai';
-  const modelId = 'image-model';
-  const mockCost = { total: 0.003, components: [] };
-
-  beforeEach( () => {
-    vi.clearAllMocks();
-    mocks.calculateLLMCallCost.mockResolvedValue( mockCost );
-    mocks.calculateBase64FileSize.mockReturnValue( 1234 );
-  } );
-
-  it( 'uses an image response fixture to trace image metadata and attach cost', async () => {
-    const response = await makeAiSdkImageResponse();
-
-    const wrapped = await wrapImageResponse( { traceId, providerId, modelId, response } );
-
-    expect( wrapped.result ).toBe( response.images[0] );
-    expect( wrapped.cost ).toEqual( mockCost );
-    expect( mocks.calculateLLMCallCost ).toHaveBeenCalledWith( {
-      usage: response.usage,
-      modelId,
-      providerId
-    } );
-    expect( mocks.calculateBase64FileSize ).toHaveBeenCalledWith( response.images[0].base64 );
-    expect( mocks.endTraceWithSuccess ).toHaveBeenCalledWith( {
-      traceId,
-      usage: response.usage,
-      cost: mockCost,
-      result: [
-        {
-          size: 1234,
-          mediaType: response.images[0].mediaType
-        }
-      ],
-      providerMetadata: response.providerMetadata
-    } );
-  } );
-} );

package/src/utils/source_extraction.js

@@ -1,53 +0,0 @@
-import { createHash } from 'node:crypto';
-
-/**
- * Checks whether a tool result looks like a search response (has a `results` array with `url` strings).
- */
-const isSearchResult = v => Array.isArray( v?.results ) && v.results.some( r => typeof r?.url === 'string' );
-
-/**
- * Builds the final source shape
- * @param {object} args
- * @param {string} args.url
- * @param {string} args.title
- * @returns {object} final object
- */
-const buildSource = ( { url, title } ) => ( {
-  type: 'source',
-  sourceType: 'url',
-  id: createHash( 'sha256' ).update( url ).digest( 'hex' ).slice( 0, 16 ),
-  url,
-  title: title ?? ''
-} );
-
-/**
- * Extracts source URLs from search tool results embedded in AI SDK step data.
- *
- * Detects any tool result containing a `results[]` array whose items have a `url` string field.
- * This covers perplexitySearch, tavilySearch, exaSearch, and any future tool with the same shape.
- *
- * @param {Array} steps - AI SDK response steps (response.steps)
- * @returns {Array<{ type: string, sourceType: string, id: string, url: string, title: string }>}
- */
-export const extractSourcesFromSteps = steps =>
-  ( Array.isArray( steps ) ? steps : [] )
-    .flatMap( step => Array.isArray( step?.toolResults ) ? step.toolResults : [] )
-    .flatMap( toolResult => isSearchResult( toolResult?.output ) ? toolResult.output.results : [] )
-    .filter( item => typeof item?.url === 'string' && item.url.length > 0 ) // Ignore non string or empty string urls
-    .reduce( ( map, v ) => map.has( v.url ) ? map : map.set( v.url, v ), new Map() ) // deduplicate, by keeping first entry
-    .values().toArray()
-    .map( v => buildSource( v ) );
-
-/**
- * Merge sources used tools and sources from AI SDK response into a single list
- *
- * Deduplicate by url (prefer to keep items from sources from response).
- *
- * @param {object} args
- * @param {object[]} args.sourcesFromTools
- * @param {object[]} args.sourcesFromResponse
- * @returns {object[]} Merged sources
- */
-export const combineSources = ( { sourcesFromTools, sourcesFromResponse } ) =>
-  new Map( sourcesFromTools.concat( Array.isArray( sourcesFromResponse ) ? sourcesFromResponse : [] )
-    .map( s => [ s.url, s ] ) ).values().toArray();

package/src/utils/source_extraction.spec.js

@@ -1,194 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { combineSources, extractSourcesFromSteps } from './source_extraction.js';
-
-describe( 'extractSourcesFromSteps', () => {
-  it( 'returns empty array for undefined/null/empty steps', () => {
-    expect( extractSourcesFromSteps( undefined ) ).toEqual( [] );
-    expect( extractSourcesFromSteps( null ) ).toEqual( [] );
-    expect( extractSourcesFromSteps( [] ) ).toEqual( [] );
-  } );
-
-  it( 'skips steps with no toolResults', () => {
-    const steps = [ { text: 'hello' } ];
-    expect( extractSourcesFromSteps( steps ) ).toEqual( [] );
-  } );
-
-  it( 'skips non-search tool results', () => {
-    const steps = [ {
-      toolResults: [ {
-        output: { answer: 'some text', confidence: 0.9 }
-      } ]
-    } ];
-    expect( extractSourcesFromSteps( steps ) ).toEqual( [] );
-  } );
-
-  it( 'skips tool results with empty results array', () => {
-    const steps = [ {
-      toolResults: [ { output: { results: [] } } ]
-    } ];
-    expect( extractSourcesFromSteps( steps ) ).toEqual( [] );
-  } );
-
-  it( 'skips tool results where results items lack url', () => {
-    const steps = [ {
-      toolResults: [ {
-        output: { results: [ { title: 'no url', content: 'text' } ] }
-      } ]
-    } ];
-    expect( extractSourcesFromSteps( steps ) ).toEqual( [] );
-  } );
-
-  it( 'extracts from perplexity-shaped results', () => {
-    const steps = [ {
-      toolResults: [ {
-        output: {
-          id: 'pplx-123',
-          results: [
-            { url: 'https://example.com/1', title: 'Example 1', snippet: 'text' },
-            { url: 'https://example.com/2', title: 'Example 2', snippet: 'text' }
-          ]
-        }
-      } ]
-    } ];
-
-    const sources = extractSourcesFromSteps( steps );
-    expect( sources ).toHaveLength( 2 );
-    expect( sources[0] ).toEqual( {
-      type: 'source',
-      sourceType: 'url',
-      id: expect.any( String ),
-      url: 'https://example.com/1',
-      title: 'Example 1'
-    } );
-    expect( sources[1].url ).toBe( 'https://example.com/2' );
-  } );
-
-  it( 'extracts from tavily-shaped results', () => {
-    const steps = [ {
-      toolResults: [ {
-        output: {
-          query: 'test query',
-          results: [
-            { url: 'https://tavily.com/a', title: 'Tavily A', content: 'stuff', score: 0.95 }
-          ]
-        }
-      } ]
-    } ];
-
-    const sources = extractSourcesFromSteps( steps );
-    expect( sources ).toHaveLength( 1 );
-    expect( sources[0].url ).toBe( 'https://tavily.com/a' );
-    expect( sources[0].title ).toBe( 'Tavily A' );
-  } );
-
-  it( 'extracts from exa-shaped results', () => {
-    const steps = [ {
-      toolResults: [ {
-        output: {
-          results: [
-            { url: 'https://exa.ai/r', title: 'Exa Result', text: 'content', summary: 'summary' }
-          ]
-        }
-      } ]
-    } ];
-
-    const sources = extractSourcesFromSteps( steps );
-    expect( sources ).toHaveLength( 1 );
-    expect( sources[0].url ).toBe( 'https://exa.ai/r' );
-    expect( sources[0].title ).toBe( 'Exa Result' );
-  } );
-
-  it( 'deduplicates by URL across multiple steps', () => {
-    const steps = [
-      {
-        toolResults: [ {
-          output: { results: [ { url: 'https://dup.com', title: 'First' } ] }
-        } ]
-      },
-      {
-        toolResults: [ {
-          output: { results: [ { url: 'https://dup.com', title: 'Second' } ] }
-        } ]
-      }
-    ];
-
-    const sources = extractSourcesFromSteps( steps );
-    expect( sources ).toHaveLength( 1 );
-    expect( sources[0].title ).toBe( 'First' );
-  } );
-
-  it( 'deduplicates by URL within the same step', () => {
-    const steps = [ {
-      toolResults: [
-        { output: { results: [ { url: 'https://same.com', title: 'A' } ] } },
-        { output: { results: [ { url: 'https://same.com', title: 'B' } ] } }
-      ]
-    } ];
-
-    const sources = extractSourcesFromSteps( steps );
-    expect( sources ).toHaveLength( 1 );
-  } );
-
-  it( 'handles mixed search and non-search tool results', () => {
-    const steps = [ {
-      toolResults: [
-        { output: { calculation: 42 } },
-        { output: { results: [ { url: 'https://real.com', title: 'Real' } ] } },
-        { output: 'plain string' }
-      ]
-    } ];
-
-    const sources = extractSourcesFromSteps( steps );
-    expect( sources ).toHaveLength( 1 );
-    expect( sources[0].url ).toBe( 'https://real.com' );
-  } );
-
-  it( 'defaults title to empty string when missing', () => {
-    const steps = [ {
-      toolResults: [ {
-        output: { results: [ { url: 'https://notitle.com' } ] }
-      } ]
-    } ];
-
-    const sources = extractSourcesFromSteps( steps );
-    expect( sources[0].title ).toBe( '' );
-  } );
-
-  it( 'generates deterministic id from URL', () => {
-    const steps = [ {
-      toolResults: [ {
-        output: { results: [ { url: 'https://stable.com/path', title: 'S' } ] }
-      } ]
-    } ];
-
-    const s1 = extractSourcesFromSteps( steps );
-    const s2 = extractSourcesFromSteps( steps );
-    expect( s1[0].id ).toBe( s2[0].id );
-    expect( s1[0].id ).toHaveLength( 16 );
-  } );
-} );
-
-describe( 'combineSources', () => {
-  it( 'treats non-array sourcesFromResponse like empty array', () => {
-    const tool = [ { url: 'https://u.test', title: 'T', type: 'source', sourceType: 'url', id: '1' } ];
-
-    expect(
-      combineSources( { sourcesFromTools: tool, sourcesFromResponse: undefined } )
-    ).toHaveLength( 1 );
-
-    expect(
-      combineSources( { sourcesFromTools: tool, sourcesFromResponse: {} } )
-    ).toHaveLength( 1 );
-  } );
-
-  it( 'dedupes by url with response sources winning after tools', () => {
-    const url = 'https://shared.test';
-    const tools = [ { url, title: 'from-tool', type: 'source', sourceType: 'url', id: 'a' } ];
-    const response = [ { url, title: 'from-response', type: 'source', sourceType: 'url', id: 'b' } ];
-
-    const merged = combineSources( { sourcesFromTools: tools, sourcesFromResponse: response } );
-
-    expect( merged ).toHaveLength( 1 );
-    expect( merged[0].title ).toBe( 'from-response' );
-  } );
-} );

package/src/utils/trace.js

@@ -1,19 +0,0 @@
-import { Tracing, Event } from '@outputai/core/sdk/runtime';
-
-export const startTrace = ( { name, ...details } ) => {
-  const traceId = `${name}-${Date.now()}`;
-  Tracing.addEventStart( { kind: 'llm', name, id: traceId, details } );
-  return traceId;
-};
-
-export const endTraceWithError = ( { traceId, error } ) => {
-  Tracing.addEventError( { id: traceId, details: error } );
-};
-
-export const endTraceWithSuccess = ( { traceId, result, cost, ...extra } ) => {
-  if ( cost ) {
-    Tracing.addEventAttribute( { eventId: traceId, attribute: cost } );
-    Event.emit( 'cost:llm:request', cost );
-  }
-  Tracing.addEventEnd( { id: traceId, details: { result, ...extra } } );
-};

package/src/utils/trace.spec.js

@@ -1,112 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-vi.mock( '@outputai/core/sdk/runtime', () => ( {
-  Tracing: {
-    addEventStart: vi.fn(),
-    addEventError: vi.fn(),
-    addEventAttribute: vi.fn(),
-    addEventEnd: vi.fn()
-  },
-  Event: {
-    emit: vi.fn()
-  }
-} ) );
-
-import { Tracing, Event } from '@outputai/core/sdk/runtime';
-import { startTrace, endTraceWithError, endTraceWithSuccess } from './trace.js';
-
-const tracing = vi.mocked( Tracing, true );
-const event = vi.mocked( Event, true );
-
-describe( 'trace utils', () => {
-  beforeEach( () => {
-    vi.clearAllMocks();
-  } );
-
-  afterEach( () => {
-    vi.restoreAllMocks();
-  } );
-
-  describe( 'startTrace', () => {
-    it( 'starts an llm trace with name-based id and passes remaining fields as details', () => {
-      vi.spyOn( Date, 'now' ).mockReturnValue( 9_000_000_000 );
-
-      const traceId = startTrace( { name: 'generateText', prompt: 'p', variables: { k: 1 } } );
-
-      expect( traceId ).toBe( 'generateText-9000000000' );
-      expect( tracing.addEventStart ).toHaveBeenCalledWith( {
-        kind: 'llm',
-        name: 'generateText',
-        id: 'generateText-9000000000',
-        details: { prompt: 'p', variables: { k: 1 } }
-      } );
-    } );
-  } );
-
-  describe( 'endTraceWithError', () => {
-    it( 'records an error on the trace event', () => {
-      const err = new Error( 'failed' );
-
-      endTraceWithError( { traceId: 't-1', error: err } );
-
-      expect( tracing.addEventError ).toHaveBeenCalledWith( { id: 't-1', details: err } );
-    } );
-  } );
-
-  describe( 'endTraceWithSuccess', () => {
-    it( 'adds cost attribute, emits cost event, and ends the trace with normalized details', () => {
-      const cost = { type: 'llm:usage', modelId: 'my-model', total: 0.01, usage: [] };
-      const usage = { inputTokens: 2, outputTokens: 3 };
-
-      endTraceWithSuccess( {
-        traceId: 'trace-a',
-        modelId: 'my-model',
-        result: 'hello',
-        usage,
-        providerMetadata: { provider: 'x' },
-        cost,
-        sourcesFromTools: [ { url: 'https://u.test', title: '' } ]
-      } );
-
-      expect( tracing.addEventAttribute ).toHaveBeenCalledWith( {
-        eventId: 'trace-a',
-        attribute: cost
-      } );
-      expect( event.emit ).toHaveBeenCalledWith( 'cost:llm:request', cost );
-      expect( tracing.addEventEnd ).toHaveBeenCalledWith( {
-        id: 'trace-a',
-        details: {
-          result: 'hello',
-          modelId: 'my-model',
-          usage,
-          providerMetadata: { provider: 'x' },
-          sourcesFromTools: [ { url: 'https://u.test', title: '' } ]
-        }
-      } );
-    } );
-
-    it( 'does not emit or add an attribute when cost is missing', () => {
-      const usage = { inputTokens: 2, outputTokens: 3 };
-
-      endTraceWithSuccess( {
-        traceId: 'trace-no-cost',
-        modelId: 'my-model',
-        result: 'hello',
-        usage,
-        providerMetadata: { provider: 'x' }
-      } );
-
-      expect( tracing.addEventAttribute ).not.toHaveBeenCalled();
-      expect( event.emit ).not.toHaveBeenCalled();
-      expect( tracing.addEventEnd ).toHaveBeenCalledWith( {
-        id: 'trace-no-cost',
-        details: {
-          result: 'hello',
-          modelId: 'my-model',
-          usage,
-          providerMetadata: { provider: 'x' }
-        }
-      } );
-    } );
-  } );
-} );