@outputai/llm 0.1.13-next.f537949.0 → 0.2.1-dev.82acd68.0

package/src/index.d.ts

@@ -1,4 +1,5 @@
 import type {
+  AgentStreamParameters,
   GenerateTextResult as AIGenerateTextResult,
   StreamTextResult as AIStreamTextResult,
   CallSettings,
@@ -122,8 +123,8 @@ export type {
   TextStreamPart
 } from 'ai';
 
-// Re-export the tool helper function, Output, smoothStream, and stop condition helpers
-export { tool, Output, smoothStream, stepCountIs, hasToolCall } from 'ai';
+// Re-export the tool helper function, Output, smoothStream, stop condition helpers, and jsonSchema
+export { tool, Output, smoothStream, stepCountIs, hasToolCall, jsonSchema } from 'ai';
 
 // Web search tool factories
 export { tavilySearch, tavilyExtract, tavilyCrawl, tavilyMap } from '@tavily/ai-sdk';
@@ -196,6 +197,21 @@ type StreamTextAiSdkOptions<
   experimental_transform?: StreamTextTransform<Tools> | Array<StreamTextTransform<Tools>>;
 };
 
+/**
+ * Like {@link StreamTextAiSdkOptions} but `onFinish` receives {@link WrappedStreamTextOnFinishEvent} (adds `cost`).
+ */
+type OutputStreamTextAiSdkOptions<
+  Tools extends ToolSet = ToolSet,
+  Output extends AIOutput<unknown, unknown> = AIOutput<unknown, unknown>
+> = Omit<StreamTextAiSdkOptions<Tools, Output>, 'onFinish'> & {
+  onFinish?: WrappedStreamTextOnFinishCallback<Tools>;
+};
+
+/** Agent {@link Agent.stream} options: same as AI SDK plus wrapped `onFinish` (adds `cost`). */
+export type OutputAgentStreamParameters = Omit<AgentStreamParameters<never, ToolSet>, 'onFinish'> & {
+  onFinish?: WrappedStreamTextOnFinishCallback<ToolSet>;
+};
+
 /** A source extracted from search tool results during multi-step LLM execution. */
 export type ExtractedSource = {
   type: 'source';
@@ -205,6 +221,29 @@ export type ExtractedSource = {
   title: string;
 };
 
+/**
+ * Cost breakdown from the cost module (`calculateLLMCallCost`). `total` is null when pricing data is missing or calculation fails.
+ */
+export type LLMCallCost = {
+  total: number | null;
+  components?: Array<{
+    name: string,
+    value: number
+  }>;
+  message?: string;
+};
+
+/**
+ * `streamText` and agent `stream` `onFinish` event after the stream response wrapper: same as the AI SDK
+ * finish payload plus optional `cost` from pricing.
+ */
+export type WrappedStreamTextOnFinishEvent<Tools extends ToolSet = ToolSet> =
+  Parameters<StreamTextOnFinishCallback<Tools>>[0] & { cost?: LLMCallCost };
+
+export type WrappedStreamTextOnFinishCallback<Tools extends ToolSet = ToolSet> = (
+  event: WrappedStreamTextOnFinishEvent<Tools>
+) => void | PromiseLike<void>;
+
 /**
  * Result from generateText including full AI SDK response metadata.
  * Extends AI SDK's GenerateTextResult with a unified `result` field.
@@ -216,6 +255,8 @@ export type GenerateTextResult<
 > = AIGenerateTextResult<Tools, Output> & {
   /** Unified field name alias for 'text' - provides consistency across all generate* functions */
   result: string;
+  /** Calculated cost in USD for the LLM call (present after wrapping; `total` may be null if pricing is unavailable) */
+  cost?: LLMCallCost;
   /** Sources extracted from search tool results, merged with any native provider sources */
   sources: ExtractedSource[];
 };
@@ -300,7 +341,7 @@ export function generateText<
  * @param args.prompt - Prompt file name.
  * @param args.variables - Variables to interpolate.
  * @param args.onChunk - Callback for each stream chunk (optional).
- * @param args.onFinish - Callback when stream finishes (optional).
+ * @param args.onFinish - Callback when stream finishes; receives {@link WrappedStreamTextOnFinishEvent} (`cost` optional).
  * @param args.onError - Callback when stream errors (optional).
  * @returns AI SDK stream result with textStream, fullStream, and metadata promises.
  */
@@ -311,7 +352,7 @@ export function streamText<
   args: {
     prompt: string,
     variables?: Record<string, string | number | boolean>
-  } & StreamTextAiSdkOptions<Tools, Output>
+  } & OutputStreamTextAiSdkOptions<Tools, Output>
 ): AIStreamTextResult<Tools, Output>;
 
 export { skill } from './skill.js';
@@ -385,18 +426,21 @@ export declare class Agent extends import( 'ai' ).ToolLoopAgent {
     maxRetries?: number;
   } );
 
-  /** Run the agent and return when complete. */
+  /**
+   * Run the agent and return when complete.
+   * Same augmented shape as {@link generateText}: `result`, optional `cost`, merged `sources`.
+   */
   generate( options?: {
     messages?: import( 'ai' ).ModelMessage[];
     abortSignal?: AbortSignal;
     onStepFinish?: import( 'ai' ).GenerateTextOnStepFinishCallback<ToolSet>;
-  } ): Promise<import( 'ai' ).GenerateTextResult<ToolSet, import( 'ai' ).Output<unknown, unknown>>>;
+  } ): Promise<GenerateTextResult<ToolSet, import( 'ai' ).Output<unknown, unknown>>>;
 
-  /** Stream the agent's response. */
-  stream( options?: {
-    messages?: import( 'ai' ).ModelMessage[];
-    abortSignal?: AbortSignal;
-    onStepFinish?: import( 'ai' ).StreamTextOnStepFinishCallback<ToolSet>;
-    experimental_transform?: import( 'ai' ).StreamTextTransform<ToolSet> | import( 'ai' ).StreamTextTransform<ToolSet>[];
-  } ): Promise<import( 'ai' ).StreamTextResult<ToolSet, import( 'ai' ).Output<unknown, unknown>>>;
+  /**
+   * Stream the agent's response.
+   * `onFinish` receives {@link WrappedStreamTextOnFinishEvent} (`cost` optional), matching {@link streamText}.
+   */
+  stream( options?: OutputAgentStreamParameters ): Promise<
+    AIStreamTextResult<ToolSet, import( 'ai' ).Output<unknown, unknown>>
+  >;
 };

package/src/index.js

@@ -5,5 +5,5 @@ export { registerProvider, getRegisteredProviders } from './ai_model.js';
 export { tavilySearch, tavilyExtract, tavilyCrawl, tavilyMap } from '@tavily/ai-sdk';
 export { webSearch as exaSearch } from '@exalabs/ai-sdk';
 export { perplexitySearch } from '@perplexity-ai/ai-sdk';
-export { tool, Output, smoothStream, stepCountIs, hasToolCall } from 'ai';
+export { tool, Output, smoothStream, stepCountIs, hasToolCall, jsonSchema } from 'ai';
 export * as ai from 'ai';

package/src/utils/message.spec.js

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { ROLE, getContent, isRole } from './message.js';
+
+describe( 'message utils', () => {
+  describe( 'ROLE', () => {
+    it( 'exposes expected role string constants', () => {
+      expect( ROLE ).toEqual( {
+        SYSTEM: 'system',
+        USER: 'user',
+        ASSISTANT: 'assistant',
+        TOOL: 'tool'
+      } );
+    } );
+  } );
+
+  describe( 'isRole', () => {
+    it( 'returns a predicate that matches messages by role', () => {
+      const isUser = isRole( ROLE.USER );
+      expect( isUser( { role: 'user', content: 'hi' } ) ).toBe( true );
+      expect( isUser( { role: 'assistant', content: 'bye' } ) ).toBe( false );
+    } );
+  } );
+
+  describe( 'getContent', () => {
+    it( 'returns message content', () => {
+      expect( getContent( { role: 'user', content: 'hello' } ) ).toBe( 'hello' );
+    } );
+  } );
+} );

package/src/utils/response_wrappers.js

@@ -0,0 +1,70 @@
+import { combineSources, extractSourcesFromSteps } from './source_extraction.js';
+import { calculateLLMCallCost } from '../cost/index.js';
+import { endTraceWithSuccess } from './trace.js';
+
+/**
+ * Calculates the cost and wraps an AI SDK text response in a Proxy with shortcut for 'result' and 'cost'
+ *
+ * Emits the `cost:llm:request` event.
+ *
+ * Also finishes the trace events.
+ *
+ * @param {object} args
+ * @param {string} args.traceId - id created by the startTrace
+ * @param {string} args.modelId - id of the model used
+ * @param {object} args.response - AI SDK's text response
+ * @returns {object} Proxied response
+ */
+export const wrapTextResponse = async ( { traceId, modelId, response } ) => {
+  const sourcesFromTools = extractSourcesFromSteps( response.steps );
+  const cost = await calculateLLMCallCost( { usage: response.totalUsage, modelId } );
+
+  endTraceWithSuccess( { traceId, modelId, response, cost, sourcesFromTools } );
+
+  return new Proxy( response, {
+    get( target, prop, receiver ) {
+      if ( prop === 'result' ) {
+        return target.text;
+      }
+      if ( prop === 'cost' ) {
+        return cost;
+      }
+      if ( prop === 'sources' && sourcesFromTools.length > 0 ) {
+        return combineSources( { sourcesFromTools, sourcesFromResponse: response.sources } );
+      }
+      return Reflect.get( target, prop, receiver );
+    }
+  } );
+};
+
+/**
+ * Wraps the response returned by the onFinish callback from the stream.
+ *
+ * When the onFinish is triggered, concludes the trace event, calculates cost and emits `cost:llm:request`.
+ * Returns a proxy around the response with `cost` property.
+ *
+ * @param {object} args
+ * @param {string} args.traceId - id created by the startTrace
+ * @param {string} args.modelId - id of the model used
+ * @param {Function} args.onFinish - Original callback to call with the Proxied reponse
+ * @returns {object} Proxied response
+ */
+export const wrapStreamOnFinishResponse = ( { traceId, modelId, onFinish: _onFinish } ) => ( {
+  async onFinish( response ) {
+    const cost = await calculateLLMCallCost( { modelId, usage: response.totalUsage } );
+
+    endTraceWithSuccess( { traceId, modelId, response, cost } );
+
+    _onFinish?.( new Proxy( response, {
+      get( target, prop, receiver ) {
+        if ( prop === 'result' ) {
+          return target.text;
+        }
+        if ( prop === 'cost' ) {
+          return cost;
+        }
+        return Reflect.get( target, prop, receiver );
+      }
+    } ) );
+  }
+} );

package/src/utils/response_wrappers.spec.js

@@ -0,0 +1,172 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mocks = vi.hoisted( () => ( {
+  extractSourcesFromSteps: vi.fn(),
+  calculateLLMCallCost: vi.fn(),
+  endTraceWithSuccess: vi.fn()
+} ) );
+
+vi.mock( './source_extraction.js', async importOriginal => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    extractSourcesFromSteps: mocks.extractSourcesFromSteps
+  };
+} );
+
+vi.mock( '../cost/index.js', () => ( {
+  calculateLLMCallCost: mocks.calculateLLMCallCost
+} ) );
+
+vi.mock( './trace.js', () => ( {
+  endTraceWithSuccess: mocks.endTraceWithSuccess
+} ) );
+
+import { wrapTextResponse, wrapStreamOnFinishResponse } from './response_wrappers.js';
+
+describe( 'wrapTextResponse', () => {
+  const traceId = 'trace-1';
+  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 );
+  } );
+
+  it( 'proxies result to text and attaches cost', async () => {
+    const response = {
+      text: 'hello',
+      totalUsage: { inputTokens: 10, outputTokens: 5 },
+      steps: [],
+      sources: []
+    };
+
+    const wrapped = await wrapTextResponse( { traceId, modelId, response } );
+
+    expect( wrapped.result ).toBe( 'hello' );
+    expect( wrapped.text ).toBe( 'hello' );
+    expect( wrapped.cost ).toEqual( mockCost );
+    expect( mocks.calculateLLMCallCost ).toHaveBeenCalledWith( {
+      usage: response.totalUsage,
+      modelId
+    } );
+    expect( mocks.endTraceWithSuccess ).toHaveBeenCalledWith( {
+      traceId,
+      modelId,
+      response,
+      cost: mockCost,
+      sourcesFromTools: []
+    } );
+  } );
+
+  it( 'leaves sources unchanged when no tool-extracted sources (same as raw response)', async () => {
+    const nativeSources = [
+      { type: 'source', sourceType: 'url', id: 'n1', url: 'https://native.test', title: 'Native' }
+    ];
+    mocks.extractSourcesFromSteps.mockReturnValue( [] );
+
+    const response = {
+      text: 'x',
+      totalUsage: {},
+      steps: [],
+      sources: nativeSources
+    };
+
+    const wrapped = await wrapTextResponse( { traceId, modelId, response } );
+
+    expect( wrapped.sources ).toBe( nativeSources );
+  } );
+
+  it( 'merges tool-extracted sources with response sources by url when tool sources exist', async () => {
+    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'
+    };
+    mocks.extractSourcesFromSteps.mockReturnValue( [ toolSource ] );
+
+    const response = {
+      text: 'x',
+      totalUsage: {},
+      steps: [ {} ],
+      sources: [ responseSource ]
+    };
+
+    const wrapped = await wrapTextResponse( { traceId, modelId, response } );
+
+    expect( wrapped.sources ).toEqual( expect.arrayContaining( [ toolSource, responseSource ] ) );
+    expect( wrapped.sources ).toHaveLength( 2 );
+  } );
+
+  it( 'when tool sources overlap urls, later entry in merge wins', async () => {
+    const url = 'https://example.com/same';
+    mocks.extractSourcesFromSteps.mockReturnValue( [
+      { type: 'source', sourceType: 'url', id: '1', url, title: 'from-tool' }
+    ] );
+
+    const response = {
+      text: 'x',
+      totalUsage: {},
+      steps: [],
+      sources: [
+        { type: 'source', sourceType: 'url', id: '2', url, title: 'from-response' }
+      ]
+    };
+
+    const wrapped = await wrapTextResponse( { traceId, modelId, response } );
+
+    expect( wrapped.sources ).toHaveLength( 1 );
+    expect( wrapped.sources[0].title ).toBe( 'from-response' );
+  } );
+} );
+
+describe( 'wrapStreamOnFinishResponse', () => {
+  const traceId = 'stream-trace';
+  const modelId = 'stream-model';
+  const mockCost = { total: 0.002, components: [] };
+
+  beforeEach( () => {
+    vi.clearAllMocks();
+    mocks.calculateLLMCallCost.mockResolvedValue( mockCost );
+  } );
+
+  it( 'onFinish finishes trace, proxies result and cost for user callback, and forwards other props', async () => {
+    const userOnFinish = vi.fn();
+    const response = {
+      text: 'done',
+      totalUsage: { inputTokens: 1 },
+      finishReason: 'stop'
+    };
+
+    const callbacks = wrapStreamOnFinishResponse( {
+      traceId,
+      modelId,
+      onFinish: userOnFinish
+    } );
+
+    await callbacks.onFinish( response );
+
+    expect( mocks.endTraceWithSuccess ).toHaveBeenCalledWith( {
+      traceId,
+      modelId,
+      response,
+      cost: mockCost
+    } );
+    expect( userOnFinish ).toHaveBeenCalledTimes( 1 );
+    const proxied = userOnFinish.mock.calls[0][0];
+    expect( proxied.result ).toBe( 'done' );
+    expect( proxied.cost ).toEqual( mockCost );
+    expect( proxied.finishReason ).toBe( 'stop' );
+  } );
+} );

package/src/{source_extraction.js → utils/source_extraction.js}

@@ -47,3 +47,17 @@ export function extractSourcesFromSteps( steps ) {
     return [];
   }
 }
+
+/**
+ * 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/{source_extraction.spec.js → utils/source_extraction.spec.js}

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { extractSourcesFromSteps } from './source_extraction.js';
+import { combineSources, extractSourcesFromSteps } from './source_extraction.js';
 
 describe( 'extractSourcesFromSteps', () => {
   it( 'returns empty array for undefined/null/empty steps', () => {
@@ -167,3 +167,28 @@ describe( 'extractSourcesFromSteps', () => {
     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

@@ -0,0 +1,18 @@
+import { Tracing, emitEvent } from '@outputai/core/sdk_activity_integration';
+
+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, modelId, response, cost, ...extra } ) => {
+  const { totalUsage: usage, text: result, providerMetadata } = response;
+  Tracing.addEventAttribute( { eventId: traceId, name: Tracing.Attribute.COST, value: cost } );
+  Tracing.addEventEnd( { id: traceId, details: { result, usage, providerMetadata, ...extra } } );
+  emitEvent( 'cost:llm:request', { modelId, cost, usage } );
+};

package/src/utils/trace.spec.js

@@ -0,0 +1,95 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+vi.mock( '@outputai/core/sdk_activity_integration', () => ( {
+  Tracing: {
+    addEventStart: vi.fn(),
+    addEventError: vi.fn(),
+    addEventAttribute: vi.fn(),
+    addEventEnd: vi.fn(),
+    Attribute: {
+      COST: 'cost'
+    }
+  },
+  emitEvent: vi.fn()
+} ) );
+
+import { Tracing, emitEvent } from '@outputai/core/sdk_activity_integration';
+import { startTrace, endTraceWithError, endTraceWithSuccess } from './trace.js';
+
+const tracing = vi.mocked( Tracing, 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, ends the trace with response fields and extra details, and emits cost:llm:request', () => {
+      const cost = { total: 0.01, components: [] };
+      const usage = { inputTokens: 2, outputTokens: 3 };
+      const response = {
+        text: 'hello',
+        totalUsage: usage,
+        providerMetadata: { provider: 'x' }
+      };
+
+      endTraceWithSuccess( {
+        traceId: 'trace-a',
+        modelId: 'my-model',
+        response,
+        cost,
+        sourcesFromTools: [ { url: 'https://u.test', title: '' } ]
+      } );
+
+      expect( tracing.addEventAttribute ).toHaveBeenCalledWith( {
+        eventId: 'trace-a',
+        name: 'cost',
+        value: cost
+      } );
+      expect( tracing.addEventEnd ).toHaveBeenCalledWith( {
+        id: 'trace-a',
+        details: {
+          result: 'hello',
+          usage,
+          providerMetadata: { provider: 'x' },
+          sourcesFromTools: [ { url: 'https://u.test', title: '' } ]
+        }
+      } );
+      expect( emitEvent ).toHaveBeenCalledWith( 'cost:llm:request', {
+        modelId: 'my-model',
+        cost,
+        usage
+      } );
+    } );
+  } );
+} );

package/src/response_utils.js

@@ -1,21 +0,0 @@
-import { extractSourcesFromSteps } from './source_extraction.js';
-import { endTraceWithSuccess } from './trace_utils.js';
-
-export const wrapInOutputResponse = async ( response, { traceId, modelId } ) => {
-  const sourcesFromTools = extractSourcesFromSteps( response.steps );
-  await endTraceWithSuccess( traceId, modelId, response, { sourcesFromTools } );
-
-  return new Proxy( response, {
-    get( target, prop, receiver ) {
-      if ( prop === 'result' ) {
-        return target.text;
-      }
-      if ( prop === 'sources' && sourcesFromTools.length > 0 ) {
-        const responseSources = Array.isArray( target[prop] ) ? target[prop] : [];
-        const byUrl = new Map( [ ...sourcesFromTools, ...responseSources ].map( s => [ s.url, s ] ) );
-        return [ ...byUrl.values() ];
-      }
-      return Reflect.get( target, prop, receiver );
-    }
-  } );
-};

package/src/trace_utils.js

@@ -1,30 +0,0 @@
-import { Tracing, emitEvent } from '@outputai/core/sdk_activity_integration';
-import { calculateLLMCallCost } from './cost/index.js';
-
-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 = async ( traceId, modelId, response, extraDetails = {} ) => {
-  const { text: result, totalUsage: usage, providerMetadata } = response;
-  const cost = await calculateLLMCallCost( { usage, modelId } );
-  emitEvent( 'llm:call_cost', { modelId, cost, usage } );
-  Tracing.addEventEnd( { id: traceId, details: { result, usage, cost, providerMetadata, ...extraDetails } } );
-};
-
-export const traceStreamCallbacks = ( traceId, modelId, { onFinish: userOnFinish, onError: userOnError } = {} ) => ( {
-  async onFinish( response ) {
-    await endTraceWithSuccess( traceId, modelId, response );
-    userOnFinish?.( response );
-  },
-  onError( event ) {
-    Tracing.addEventError( { id: traceId, details: event.error } );
-    userOnError?.( event );
-  }
-} );