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

package/src/utils/tools.spec.js

@@ -0,0 +1,167 @@
+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/wrap.js

@@ -0,0 +1,148 @@
+import { extractSources } from './sources.js';
+import { calculateLLMCallCost } from '../cost/index.js';
+import { calculateBase64FileSize } from './image.js';
+import { Tracing, Event } from '@outputai/core/sdk/runtime';
+import { mapAiError } from './error_handler.js';
+import { isPromise } from 'node:util/types';
+import { Logger } from '@outputai/core';
+
+/** Creates a proxy of the AI SDK response and attach virtual getters to it based on an object map */
+const createResponseProxy = ( { response, properties } ) => new Proxy( response, {
+  get( target, prop, receiver ) {
+    return Object.hasOwn( properties, prop ) ? properties[prop] : Reflect.get( target, prop, receiver );
+  }
+} );
+
+/** Generate a trace id, starts the tracing and return the id */
+const startTrace = ( { name, prompt } ) => {
+  const traceId = `${name}-${Date.now()}`;
+  Tracing.addEventStart( { kind: 'llm', id: traceId, name, details: { prompt } } );
+  return traceId;
+};
+
+/** Map AI Error, add an error trace entry and return the new error */
+const handleError = ( { traceId, error: originalError } ) => {
+  const error = mapAiError( originalError );
+  Tracing.addEventError( { id: traceId, details: error } );
+  return error;
+};
+
+/** Extract usage, calculate the cost, emit an event and return cost/usage */
+const handleCost = async ( { traceId, response, prompt } ) => {
+  const { model: modelId, provider: providerId } = prompt.config;
+  const usage = response.totalUsage ?? response.usage; // eg: image has .usage only
+  const cost = await calculateLLMCallCost( { usage, modelId, providerId } );
+  if ( cost ) {
+    Tracing.addEventAttribute( { eventId: traceId, attribute: cost } );
+    Event.emit( 'cost:llm:request', cost );
+  }
+  return { cost, usage };
+};
+
+/**
+ * Runs a completing AI SDK call (`generateText`, `generateImage`, `generateTextWithStreaming`,
+ * `Agent.generate`, `Agent.generateWithStreaming`): start the LLM trace, run `fn`, attach cost
+ * (and sources on text), end the trace, and return a proxied response.
+ *
+ * Text responses get `result` (`text`), `cost`, and merged `sources`. Image responses get
+ * `result` (`image`) and `cost`. Trace usage is `response.totalUsage` if set, otherwise `response.usage`.
+ *
+ * @param {object} args
+ * @param {string} args.name - Trace event name
+ * @param {object} args.prompt - Loaded prompt (`config.provider` / `config.model` used for cost)
+ * @param {() => Promise<object>} args.fn - AI SDK call; must return the SDK response
+ * @returns {Promise<object>} Proxied SDK response
+ */
+export const wrapGeneration = async ( { name, prompt, fn } ) => {
+  const traceId = startTrace( { name, prompt } );
+
+  try {
+    const response = await fn();
+    const { cost, usage } = await handleCost( { traceId, response, prompt } );
+
+    if ( Array.isArray( response.images ) ) {
+      const { image, images, providerMetadata } = response;
+      const mappedImages = images.map( ( { mediaType, base64 } ) => ( { size: calculateBase64FileSize( base64 ), mediaType } ) );
+
+      Tracing.addEventEnd( { id: traceId, details: { result: mappedImages, usage, cost, providerMetadata } } );
+      return createResponseProxy( { response, properties: { cost, result: image } } );
+    } else {
+      const { text: result, providerMetadata } = response;
+      const sources = extractSources( response );
+
+      Tracing.addEventEnd( { id: traceId, details: { result, usage, cost, providerMetadata, sources } } );
+      return createResponseProxy( { response, properties: { cost, sources, result } } );
+    }
+
+  } catch ( error ) {
+    throw handleError( { traceId, error } );
+  }
+};
+
+/**
+ * Starts an LLM trace around a live AI SDK stream (`streamText`, `Agent.stream`).
+ *
+ * `fn` receives `onFinishHook(response, callback)` and `onErrorHook(event, callback)`. Call
+ * `onFinishHook` from the SDK `onFinish`: it wraps the response, ends the trace, then invokes
+ * `callback` without rethrowing. Call `onErrorHook` from SDK `onError`: it maps the error,
+ * records it, and invokes `callback` without rethrowing. Callback failures are logged.
+ *
+ * A throw or rejected Promise from `fn` (stream creation / Agent setup) is mapped and recorded
+ * on the LLM trace. A non-Promise return (the `streamText` stream) is returned immediately.
+ *
+ * @param {object} args
+ * @param {string} args.name - Trace event name
+ * @param {object} args.prompt - Loaded prompt (`config.provider` / `config.model` used for cost)
+ * @param {(hooks: { onFinishHook: Function, onErrorHook: Function }) => object | Promise<object>} args.fn -
+ *   Return the SDK stream, or a Promise of that stream (`Agent.stream`); wire the hooks into SDK
+ *   `onFinish` / `onError`
+ * @returns {object | Promise<object>} Value returned by `fn`; a rejected Promise is remapped
+ */
+export const wrapStream = ( { name, prompt, fn } ) => {
+  const traceId = startTrace( { name, prompt } );
+
+  const onFinishHook = async ( response, callback ) => {
+    const state = { proxyResponse: null };
+    try {
+      const { text: result, providerMetadata } = response;
+      const { cost, usage } = await handleCost( { traceId, response, prompt } );
+      const sources = extractSources( response );
+      Tracing.addEventEnd( { id: traceId, details: { result, usage, cost, providerMetadata, sources } } );
+      state.proxyResponse = createResponseProxy( { response, properties: { cost, sources, result } } );
+    } catch ( error ) {
+      throw handleError( { traceId, error } );
+    }
+
+    try {
+      await callback?.( state.proxyResponse );
+    } catch ( callbackError ) {
+      // ignore these as this callback is fire and forget
+      Logger.error( 'Stream onFinish() callback failed', {
+        namespace: 'LLM',
+        error: callbackError instanceof Error ? callbackError.message : String( callbackError )
+      } );
+    }
+  };
+
+  const onErrorHook = async ( event, callback ) => {
+    const error = handleError( { traceId, error: event.error } );
+    try {
+      await callback?.( error );
+    } catch ( callbackError ) {
+      // ignore these as this callback is fire and forget
+      Logger.error( 'Stream onError() callback failed', {
+        namespace: 'LLM',
+        error: callbackError instanceof Error ? callbackError.message : String( callbackError )
+      } );
+    }
+  };
+
+  try {
+    const stream = fn( { onFinishHook, onErrorHook } );
+    return isPromise( stream ) ? stream.catch( error => {
+      throw handleError( { traceId, error } );
+    } ) : stream;
+  } catch ( error ) {
+    throw handleError( { traceId, error } );
+  }
+};

package/src/utils/wrap.spec.js

@@ -0,0 +1,359 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import streamResponseFixture from './__fixtures__/stream_response.json' with { type: 'json' };
+
+const mocks = vi.hoisted( () => ( {
+  extractSources: vi.fn(),
+  calculateLLMCallCost: vi.fn(),
+  calculateBase64FileSize: vi.fn(),
+  mapAiError: vi.fn()
+} ) );
+
+vi.mock( './sources.js', () => ( {
+  extractSources: mocks.extractSources
+} ) );
+
+vi.mock( '../cost/index.js', () => ( {
+  calculateLLMCallCost: mocks.calculateLLMCallCost
+} ) );
+
+vi.mock( './image.js', () => ( {
+  calculateBase64FileSize: mocks.calculateBase64FileSize
+} ) );
+
+vi.mock( './error_handler.js', () => ( {
+  mapAiError: mocks.mapAiError
+} ) );
+
+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 { wrapGeneration, wrapStream } from './wrap.js';
+
+const tracing = vi.mocked( Tracing, true );
+const event = vi.mocked( Event, true );
+
+const clone = value => structuredClone( value );
+
+const prompt = {
+  name: 'writer@v1',
+  config: { provider: 'openai', model: 'test-model' }
+};
+
+const mockCost = { total: 0.001, components: [] };
+const mappedError = new Error( 'mapped' );
+
+describe( 'wrapGeneration / wrapStream', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    vi.spyOn( Date, 'now' ).mockReturnValue( 9_000_000_000 );
+    mocks.extractSources.mockReturnValue( [] );
+    mocks.calculateLLMCallCost.mockResolvedValue( mockCost );
+    mocks.calculateBase64FileSize.mockReturnValue( 1234 );
+    mocks.mapAiError.mockReturnValue( mappedError );
+  } );
+
+  afterEach( () => {
+    vi.restoreAllMocks();
+  } );
+
+  describe( 'wrapGeneration', () => {
+    it( 'starts an llm trace, wraps a text response, and ends with cost and sources', async () => {
+      const response = clone( streamResponseFixture );
+      const mergedSources = [ { url: 'https://merged.test' } ];
+      mocks.extractSources.mockReturnValue( mergedSources );
+
+      const wrapped = await wrapGeneration( {
+        name: 'generateText',
+        prompt,
+        fn: async () => response
+      } );
+
+      expect( tracing.addEventStart ).toHaveBeenCalledWith( {
+        kind: 'llm',
+        id: 'generateText-9000000000',
+        name: 'generateText',
+        details: { prompt }
+      } );
+      expect( mocks.calculateLLMCallCost ).toHaveBeenCalledWith( {
+        usage: response.totalUsage,
+        modelId: 'test-model',
+        providerId: 'openai'
+      } );
+      expect( tracing.addEventAttribute ).toHaveBeenCalledWith( {
+        eventId: 'generateText-9000000000',
+        attribute: mockCost
+      } );
+      expect( event.emit ).toHaveBeenCalledWith( 'cost:llm:request', mockCost );
+      expect( mocks.extractSources ).toHaveBeenCalledWith( response );
+      expect( tracing.addEventEnd ).toHaveBeenCalledWith( {
+        id: 'generateText-9000000000',
+        details: {
+          result: response.text,
+          usage: response.totalUsage,
+          cost: mockCost,
+          providerMetadata: response.providerMetadata,
+          sources: mergedSources
+        }
+      } );
+      expect( wrapped.result ).toBe( response.text );
+      expect( wrapped.cost ).toEqual( mockCost );
+      expect( wrapped.sources ).toBe( mergedSources );
+      expect( wrapped.text ).toBe( response.text );
+    } );
+
+    it( 'prefers totalUsage over usage when both are present', async () => {
+      const response = {
+        text: 'hi',
+        totalUsage: { inputTokens: 2 },
+        usage: { inputTokens: 99 },
+        steps: [],
+        sources: []
+      };
+
+      await wrapGeneration( { name: 'generateText', prompt, fn: async () => response } );
+
+      expect( mocks.calculateLLMCallCost ).toHaveBeenCalledWith( {
+        usage: { inputTokens: 2 },
+        modelId: 'test-model',
+        providerId: 'openai'
+      } );
+    } );
+
+    it( 'wraps an image response using usage and mapped image metadata', async () => {
+      const image = { mediaType: 'image/png', base64: 'abc' };
+      const response = {
+        image,
+        images: [ image ],
+        usage: { inputTokens: 8, outputTokens: 16 },
+        providerMetadata: { openai: {} }
+      };
+
+      const wrapped = await wrapGeneration( {
+        name: 'generateImage',
+        prompt,
+        fn: async () => response
+      } );
+
+      expect( mocks.calculateLLMCallCost ).toHaveBeenCalledWith( {
+        usage: response.usage,
+        modelId: 'test-model',
+        providerId: 'openai'
+      } );
+      expect( mocks.calculateBase64FileSize ).toHaveBeenCalledWith( 'abc' );
+      expect( tracing.addEventEnd ).toHaveBeenCalledWith( {
+        id: 'generateImage-9000000000',
+        details: {
+          result: [ { size: 1234, mediaType: 'image/png' } ],
+          usage: response.usage,
+          cost: mockCost,
+          providerMetadata: response.providerMetadata
+        }
+      } );
+      expect( mocks.extractSources ).not.toHaveBeenCalled();
+      expect( wrapped.result ).toBe( image );
+      expect( wrapped.cost ).toEqual( mockCost );
+    } );
+
+    it( 'skips cost attribute and event when cost is missing', async () => {
+      mocks.calculateLLMCallCost.mockResolvedValue( null );
+      const response = clone( streamResponseFixture );
+
+      const wrapped = await wrapGeneration( {
+        name: 'generateText',
+        prompt,
+        fn: async () => response
+      } );
+
+      expect( tracing.addEventAttribute ).not.toHaveBeenCalled();
+      expect( event.emit ).not.toHaveBeenCalled();
+      expect( tracing.addEventEnd ).toHaveBeenCalledWith( {
+        id: 'generateText-9000000000',
+        details: expect.objectContaining( { cost: null, result: response.text } )
+      } );
+      expect( wrapped.cost ).toBeNull();
+    } );
+
+    it( 'maps fn errors onto the llm trace and rethrows', async () => {
+      const original = new Error( 'boom' );
+
+      await expect( wrapGeneration( {
+        name: 'Agent.generate',
+        prompt,
+        fn: async () => {
+          throw original;
+        }
+      } ) ).rejects.toBe( mappedError );
+
+      expect( mocks.mapAiError ).toHaveBeenCalledWith( original );
+      expect( tracing.addEventError ).toHaveBeenCalledWith( {
+        id: 'Agent.generate-9000000000',
+        details: mappedError
+      } );
+      expect( tracing.addEventEnd ).not.toHaveBeenCalled();
+    } );
+  } );
+
+  describe( 'wrapStream', () => {
+    const hooksFrom = name => {
+      const fn = vi.fn( () => ( {} ) );
+      wrapStream( { name, prompt, fn } );
+      return fn.mock.calls[0][0];
+    };
+
+    it( 'starts an llm trace, returns fn result, and passes hooks', () => {
+      const stream = { kind: 'stream' };
+      const fn = vi.fn( () => stream );
+
+      const result = wrapStream( { name: 'streamText', prompt, fn } );
+
+      expect( result ).toBe( stream );
+      expect( tracing.addEventStart ).toHaveBeenCalledWith( {
+        kind: 'llm',
+        id: 'streamText-9000000000',
+        name: 'streamText',
+        details: { prompt }
+      } );
+      expect( fn ).toHaveBeenCalledWith( {
+        onFinishHook: expect.any( Function ),
+        onErrorHook: expect.any( Function )
+      } );
+      expect( tracing.addEventEnd ).not.toHaveBeenCalled();
+    } );
+
+    it( 'wraps onFinish, ends the trace, then awaits the callback', async () => {
+      const response = clone( streamResponseFixture );
+      const mergedSources = [ { url: 'https://s.test' } ];
+      mocks.extractSources.mockReturnValue( mergedSources );
+      const callback = vi.fn();
+      const { onFinishHook } = hooksFrom( 'Agent.stream' );
+
+      await onFinishHook( response, callback );
+
+      expect( mocks.extractSources ).toHaveBeenCalledWith( response );
+      expect( callback ).toHaveBeenCalledOnce();
+      const proxied = callback.mock.calls[0][0];
+      expect( proxied.result ).toBe( response.text );
+      expect( proxied.cost ).toEqual( mockCost );
+      expect( proxied.sources ).toBe( mergedSources );
+      expect( tracing.addEventEnd ).toHaveBeenCalledWith( {
+        id: 'Agent.stream-9000000000',
+        details: {
+          result: response.text,
+          usage: response.totalUsage,
+          cost: mockCost,
+          providerMetadata: response.providerMetadata,
+          sources: mergedSources
+        }
+      } );
+      expect( tracing.addEventEnd.mock.invocationCallOrder[0] ).toBeLessThan( callback.mock.invocationCallOrder[0] );
+    } );
+
+    it( 'ends the trace and swallows throws from the onFinish callback', async () => {
+      const response = clone( streamResponseFixture );
+      const { onFinishHook } = hooksFrom( 'Agent.stream' );
+
+      await expect( onFinishHook( response, async () => {
+        throw new Error( 'user onFinish' );
+      } ) ).resolves.toBeUndefined();
+
+      expect( tracing.addEventEnd ).toHaveBeenCalledOnce();
+      expect( tracing.addEventError ).not.toHaveBeenCalled();
+      expect( mocks.mapAiError ).not.toHaveBeenCalled();
+    } );
+
+    it( 'maps onError events and forwards the mapped error to the callback', () => {
+      const original = new Error( 'stream failed' );
+      const callback = vi.fn();
+      const { onErrorHook } = hooksFrom( 'streamText' );
+
+      onErrorHook( { error: original }, callback );
+
+      expect( mocks.mapAiError ).toHaveBeenCalledWith( original );
+      expect( tracing.addEventError ).toHaveBeenCalledWith( {
+        id: 'streamText-9000000000',
+        details: mappedError
+      } );
+      expect( callback ).toHaveBeenCalledWith( mappedError );
+    } );
+
+    it( 'swallows throws from the onError callback', async () => {
+      const { onErrorHook } = hooksFrom( 'streamText' );
+
+      await expect( onErrorHook( { error: new Error( 'x' ) }, () => {
+        throw new Error( 'user onError' );
+      } ) ).resolves.toBeUndefined();
+    } );
+
+    it( 'awaits and swallows rejected promises from the onError callback', async () => {
+      const state = { rejection: null };
+      const callback = vi.fn( () => new Promise( ( _, reject ) => {
+        state.rejection = reject;
+      } ) );
+      const { onErrorHook } = hooksFrom( 'streamText' );
+
+      const hookPromise = onErrorHook( { error: new Error( 'x' ) }, callback );
+
+      expect( hookPromise ).toBeInstanceOf( Promise );
+      state.rejection( new Error( 'async user onError' ) );
+      await expect( hookPromise ).resolves.toBeUndefined();
+    } );
+
+    it( 'maps a throw from fn onto the llm trace and rethrows', () => {
+      const original = new Error( 'create stream' );
+
+      expect( () => wrapStream( {
+        name: 'streamText',
+        prompt,
+        fn: () => {
+          throw original;
+        }
+      } ) ).toThrow( mappedError );
+
+      expect( mocks.mapAiError ).toHaveBeenCalledWith( original );
+      expect( tracing.addEventError ).toHaveBeenCalledWith( {
+        id: 'streamText-9000000000',
+        details: mappedError
+      } );
+    } );
+
+    it( 'maps a rejected promise from fn onto the llm trace and rethrows', async () => {
+      const original = new Error( 'prepareCall failed' );
+
+      await expect( wrapStream( {
+        name: 'Agent.stream',
+        prompt,
+        fn: () => Promise.reject( original )
+      } ) ).rejects.toBe( mappedError );
+
+      expect( mocks.mapAiError ).toHaveBeenCalledWith( original );
+      expect( tracing.addEventError ).toHaveBeenCalledWith( {
+        id: 'Agent.stream-9000000000',
+        details: mappedError
+      } );
+      expect( tracing.addEventEnd ).not.toHaveBeenCalled();
+    } );
+
+    it( 'returns a fulfilled promise from fn without mapping', async () => {
+      const stream = { kind: 'stream' };
+
+      await expect( wrapStream( {
+        name: 'Agent.stream',
+        prompt,
+        fn: () => Promise.resolve( stream )
+      } ) ).resolves.toBe( stream );
+
+      expect( mocks.mapAiError ).not.toHaveBeenCalled();
+      expect( tracing.addEventError ).not.toHaveBeenCalled();
+    } );
+  } );
+} );