@outputai/llm 0.10.1-next.fc0a41f.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/llm",
-  "version": "0.10.1-next.fc0a41f.0",
+  "version": "0.11.0",
   "description": "Framework abstraction to interact with LLM models",
   "type": "module",
   "main": "src/index.js",
@@ -14,12 +14,12 @@
   "dependencies": {
     "entities": "8.0.0",
     "gray-matter": "4.0.3",
-    "liquidjs": "10.25.7",
-    "undici": "8.5.0",
-    "@outputai/core": "0.10.1-next.fc0a41f.0"
+    "liquidjs": "10.27.2",
+    "undici": "8.9.0",
+    "@outputai/core": "0.11.0"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "4.0.111",
+    "@ai-sdk/amazon-bedrock": "4.0.138",
     "@ai-sdk/anthropic": "3.0.81",
     "@ai-sdk/azure": "3.0.68",
     "@ai-sdk/google-vertex": "4.0.140",

package/src/agent.js

@@ -19,6 +19,7 @@ export const createMemoryConversationStore = () => {
 export class Agent extends AIToolLoopAgent {
   #prompt;
   #modelId;
+  #providerId;
   #initialMessages;
   #store;
 
@@ -57,6 +58,7 @@ export class Agent extends AIToolLoopAgent {
 
     this.#prompt = prompt;
     this.#modelId = loadedPrompt.config.model;
+    this.#providerId = loadedPrompt.config.provider;
     // `messages` is system-free but may still hold authored <assistant>/<tool>
     // blocks; seed only <user> turns into each generate()/stream() call.
     this.#initialMessages = messages.filter( isRole( ROLE.USER ) );
@@ -79,7 +81,7 @@ export class Agent extends AIToolLoopAgent {
     try {
       const messages = await this.#fetchMessages( userMessages );
       const response = await super.generate( { messages, allowSystemInMessages: true, ...callOptions } );
-      const wrapped = await wrapTextResponse( { traceId, response, modelId: this.#modelId } );
+      const wrapped = await wrapTextResponse( { traceId, response, providerId: this.#providerId, modelId: this.#modelId } );
       await this.#storeMessages( userMessages, wrapped );
       return wrapped;
     } catch ( error ) {
@@ -96,7 +98,7 @@ export class Agent extends AIToolLoopAgent {
         messages,
         allowSystemInMessages: true,
         ...callOptions,
-        ...wrapStreamOnFinishResponse( { traceId, modelId: this.#modelId, onFinish } ),
+        ...wrapStreamOnFinishResponse( { traceId, modelId: this.#modelId, providerId: this.#providerId, onFinish } ),
         onError( event ) {
           endTraceWithError( { traceId, error: event.error } );
           onError?.( event );

package/src/agent.spec.js

@@ -100,7 +100,7 @@ const importSut = async () => import( './agent.js' );
 
 const loadedPrompt = {
   name: 'test@v1',
-  config: { model: 'test-model' },
+  config: { provider: 'openai', model: 'test-model' },
   messages: [
     { role: 'system', content: 'You are concise.' },
     { role: 'user', content: 'Initial user message' }
@@ -373,6 +373,7 @@ describe( 'Agent', () => {
     } );
     expect( wrapMocks.wrapTextResponse ).toHaveBeenCalledWith( {
       traceId: 'trace-id',
+      providerId: 'openai',
       modelId: 'test-model',
       response: aiResponse
     } );
@@ -422,6 +423,7 @@ describe( 'Agent', () => {
     } );
     expect( wrapMocks.wrapStreamOnFinishResponse ).toHaveBeenCalledWith( {
       traceId: 'trace-id',
+      providerId: 'openai',
       modelId: 'test-model',
       onFinish
     } );

package/src/ai_provider.js

@@ -7,6 +7,7 @@ import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
 import { createOpenAI } from '@ai-sdk/openai';
 import { createPerplexity } from '@ai-sdk/perplexity';
 import { createVertex } from '@ai-sdk/google-vertex';
+import { deprecatedProviderAliases } from './deprecated_provider_aliases.js';
 
 /** This custom dispatcher has longer timeouts. */
 const customDispatcher = new EnvHttpProxyAgent( {
@@ -20,12 +21,12 @@ const customFetch = ( input, init ) => fetch( input, { dispatcher: customDispatc
 
 /** Available provider to initialize. */
 const providerInitializers = {
+  'amazon-bedrock': createAmazonBedrock,
   anthropic: createAnthropic,
   azure: createAzure,
-  bedrock: createAmazonBedrock,
+  'google-vertex': createVertex,
   openai: createOpenAI,
-  perplexity: createPerplexity,
-  vertex: createVertex
+  perplexity: createPerplexity
 };
 
 /** Providers already initialized due usage */
@@ -57,6 +58,12 @@ export function registerProvider( name, providerFn ) {
   if ( !result.success ) {
     throw new ValidationError( `Invalid provider registration: ${z.prettifyError( result.error )}` );
   }
+  if ( Object.hasOwn( deprecatedProviderAliases, name ) ) {
+    const canonical = deprecatedProviderAliases[name];
+    throw new ValidationError(
+      `Cannot register provider "${name}": that name is a deprecated alias for "${canonical}". Register "${canonical}" instead.`
+    );
+  }
   registeredProviders[name] = providerFn;
 }
 

package/src/ai_provider.spec.js

@@ -1,12 +1,12 @@
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
 const SHIPPED_PROVIDERS = [
+  { name: 'amazon-bedrock', pkg: '@ai-sdk/amazon-bedrock', exportName: 'createAmazonBedrock' },
   { name: 'anthropic', pkg: '@ai-sdk/anthropic', exportName: 'createAnthropic' },
   { name: 'azure', pkg: '@ai-sdk/azure', exportName: 'createAzure' },
-  { name: 'bedrock', pkg: '@ai-sdk/amazon-bedrock', exportName: 'createAmazonBedrock' },
+  { name: 'google-vertex', pkg: '@ai-sdk/google-vertex', exportName: 'createVertex' },
   { name: 'openai', pkg: '@ai-sdk/openai', exportName: 'createOpenAI' },
-  { name: 'perplexity', pkg: '@ai-sdk/perplexity', exportName: 'createPerplexity' },
-  { name: 'vertex', pkg: '@ai-sdk/google-vertex', exportName: 'createVertex' }
+  { name: 'perplexity', pkg: '@ai-sdk/perplexity', exportName: 'createPerplexity' }
 ];
 
 const makeProviderModules = () => Object.fromEntries(
@@ -184,6 +184,17 @@ describe( 'registerProvider', () => {
     expect( () => registerProvider( '', vi.fn() ) ).toThrow( 'Provider name must be a non-empty string' );
     expect( () => registerProvider( 'custom', 'not-a-function' ) ).toThrow( 'expected function, received string' );
   } );
+
+  it.each( [
+    [ 'vertex', 'google-vertex' ],
+    [ 'bedrock', 'amazon-bedrock' ]
+  ] )( 'rejects registering deprecated provider alias %s', async ( alias, canonical ) => {
+    const { registerProvider } = await importWithMockedProviders();
+
+    expect( () => registerProvider( alias, vi.fn() ) ).toThrow(
+      `Cannot register provider "${alias}": that name is a deprecated alias for "${canonical}". Register "${canonical}" instead.`
+    );
+  } );
 } );
 
 describe( 'getProviderNames', () => {
@@ -194,12 +205,12 @@ describe( 'getProviderNames', () => {
     registerProvider( 'openai', vi.fn() );
 
     expect( getProviderNames() ).toEqual( [
+      'amazon-bedrock',
       'anthropic',
       'azure',
-      'bedrock',
+      'google-vertex',
       'openai',
       'perplexity',
-      'vertex',
       'custom'
     ] );
   } );

package/src/ai_sdk.js

@@ -17,7 +17,7 @@ export async function generateText( { prompt, variables, promptDir, skills = [],
   const { loadedPrompt, tools } = prepareTextPrompt( { prompt, variables, promptDir, skills: parsedSkills, tools: aiSdkArgs.tools } );
 
   const traceId = startTrace( { name: 'generateText', prompt, variables, loadedPrompt } );
-  const { model: modelId } = loadedPrompt.config;
+  const { model: modelId, provider: providerId } = loadedPrompt.config;
 
   try {
     const response = await AI.generateText( {
@@ -28,7 +28,7 @@ export async function generateText( { prompt, variables, promptDir, skills = [],
       ...( tools && { tools } ),
       ...( tools && !aiSdkArgs.stopWhen ? { stopWhen: stepCountIs( maxSteps ) } : {} )
     } );
-    return wrapTextResponse( { traceId, modelId, response } );
+    return wrapTextResponse( { traceId, providerId, modelId, response } );
   } catch ( originalError ) {
     const error = mapAiError( originalError );
     endTraceWithError( { traceId, error } );
@@ -46,7 +46,7 @@ export function streamText( { prompt, variables, promptDir, skills = [], maxStep
   const { loadedPrompt, tools } = prepareTextPrompt( { prompt, variables, promptDir, skills: parsedSkills, tools: aiSdkArgs.tools } );
 
   const traceId = startTrace( { name: 'streamText', prompt, variables, loadedPrompt } );
-  const { model: modelId } = loadedPrompt.config;
+  const { model: modelId, provider: providerId } = loadedPrompt.config;
 
   try {
     return AI.streamText( {
@@ -56,7 +56,7 @@ export function streamText( { prompt, variables, promptDir, skills = [], maxStep
       ...aiSdkArgs,
       ...( tools && { tools } ),
       ...( tools && !aiSdkArgs.stopWhen ? { stopWhen: stepCountIs( maxSteps ) } : {} ),
-      ...wrapStreamOnFinishResponse( { traceId, modelId, onFinish } ),
+      ...wrapStreamOnFinishResponse( { traceId, modelId, providerId, onFinish } ),
       onError( event ) {
         const error = mapAiError( event.error );
         endTraceWithError( { traceId, error } );
@@ -75,7 +75,7 @@ export async function generateImage( { prompt, variables, promptDir, images, mas
 
   const loadedPrompt = loadPrompt( prompt, variables, promptDir );
   const traceId = startTrace( { name: 'generateImage', prompt, variables, loadedPrompt } );
-  const { model: modelId } = loadedPrompt.config;
+  const { model: modelId, provider: providerId } = loadedPrompt.config;
 
   try {
     const response = await AI.generateImage( {
@@ -83,7 +83,7 @@ export async function generateImage( { prompt, variables, promptDir, images, mas
       maxRetries: 0,
       ...aiSdkArgs
     } );
-    return wrapImageResponse( { traceId, modelId, response } );
+    return wrapImageResponse( { traceId, providerId, modelId, response } );
   } catch ( originalError ) {
     const error = mapAiError( originalError );
     endTraceWithError( { traceId, error } );

package/src/ai_sdk.spec.js

@@ -74,7 +74,7 @@ const importSut = async () => import( './ai_sdk.js' );
 
 const loadedPrompt = {
   name: 'test@v1',
-  config: { model: 'test-model' },
+  config: { provider: 'openai', model: 'test-model' },
   messages: [ { role: 'user', content: 'Hello' } ]
 };
 
@@ -198,6 +198,7 @@ describe( 'ai_sdk', () => {
       } );
       expect( wrapMocks.wrapTextResponse ).toHaveBeenCalledWith( {
         traceId: 'trace-id',
+        providerId: 'openai',
         modelId: 'test-model',
         response: textResponse
       } );
@@ -322,6 +323,7 @@ describe( 'ai_sdk', () => {
       expect( optionMocks.loadAiSdkTextOptions ).toHaveBeenCalledWith( loadedPrompt );
       expect( wrapMocks.wrapStreamOnFinishResponse ).toHaveBeenCalledWith( {
         traceId: 'trace-id',
+        providerId: 'openai',
         modelId: 'test-model',
         onFinish
       } );
@@ -505,6 +507,7 @@ describe( 'ai_sdk', () => {
       } );
       expect( wrapMocks.wrapImageResponse ).toHaveBeenCalledWith( {
         traceId: 'trace-id',
+        providerId: 'openai',
         modelId: 'test-model',
         response: imageResponse
       } );

package/src/cost/fetch_models_pricing.js

@@ -18,7 +18,6 @@ const buildModelMap = data => {
   for ( const provider of Object.values( data ) ) {
     for ( const [ modelName, { cost } ] of Object.entries( provider.models ?? {} ) ) {
       if ( cost ) { // some models don't have cost
-        map.set( modelName, cost );
         map.set( `${provider.id}/${modelName}`, cost );
       }
     }

package/src/cost/fetch_models_pricing.spec.js

@@ -47,7 +47,7 @@ describe( 'fetchModelsPricing', () => {
     const firstModel = Object.values( fixture )[0];
     const firstModelId = Object.keys( firstModel.models )[0];
     const cost = firstModel.models[firstModelId].cost;
-    expect( result.get( firstModelId ) ).toEqual( cost );
+    expect( result.get( firstModelId ) ).toBeUndefined();
     expect( result.get( `${firstModel.id}/${firstModelId}` ) ).toEqual( cost );
   } );
 
@@ -58,11 +58,23 @@ describe( 'fetchModelsPricing', () => {
 
     const openaiProvider = fixture.openai;
     const openaiModelId = Object.keys( openaiProvider.models )[0];
-    expect( result.get( openaiModelId ) ).toBeDefined();
+    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( anthropicModelId ) ).toBeDefined();
+    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 () => {
@@ -149,7 +161,8 @@ describe( 'fetchModelsPricing', () => {
 
     const result = await fetchModelsPricing();
 
-    expect( result.get( 'withCost' ) ).toEqual( { input: 1, output: 2 } );
-    expect( result.get( 'noCost' ) ).toBeUndefined();
+    expect( result.get( 'p1/withCost' ) ).toEqual( { input: 1, output: 2 } );
+    expect( result.get( 'withCost' ) ).toBeUndefined();
+    expect( result.get( 'p1/noCost' ) ).toBeUndefined();
   } );
 } );

package/src/cost/fixtures/models_api_light.json

@@ -135,6 +135,20 @@
       }
     }
   },
+  "azure": {
+    "id": "azure",
+    "models": {
+      "gpt-4o-2024-11-20": {
+        "id": "gpt-4o-2024-11-20",
+        "name": "GPT-4o (2024-11-20)",
+        "cost": {
+          "input": 3,
+          "output": 12,
+          "cache_read": 1.5
+        }
+      }
+    }
+  },
   "anthropic": {
     "id": "anthropic",
     "models": {

package/src/cost/index.js

@@ -5,11 +5,12 @@ import { Logger } from '@outputai/core';
 /**
  * Calculates the cost of an llm call based on the model and usage.
  * @param {object} args
- * @param {string} args.modelId - Name of the model, provider prefix is optional
+ * @param {string} args.providerId - Id of the provider
+ * @param {string} args.modelId - Id of the model
  * @param {object} args.usage - Usage, as returned from AI SDK
  * @returns {object} The cost with total value and components
  */
-export const calculateLLMCallCost = async ( { modelId, usage } ) => {
+export const calculateLLMCallCost = async ( { providerId, modelId, usage } ) => {
   try {
     const models = await fetchModelsPricing();
 
@@ -18,9 +19,9 @@ export const calculateLLMCallCost = async ( { modelId, usage } ) => {
       return null;
     }
 
-    const pricing = models.get( modelId );
+    const pricing = models.get( `${providerId}/${modelId}` );
     if ( !pricing ) {
-      Logger.warn( 'Missing cost reference for model', { namespace: 'LLM' } );
+      Logger.warn( 'Missing cost reference for model', { namespace: 'LLM', modelId, providerId } );
       return null;
     }
 

package/src/cost/index.spec.js

@@ -47,6 +47,11 @@ vi.mock( '@outputai/core/sdk/runtime', () => {
 import { Tracing } from '@outputai/core/sdk/runtime';
 import { calculateLLMCallCost } from './index.js';
 
+const pricingMap = entries => new Map( entries.map( ( [ providerId, modelId, cost ] ) => [
+  `${providerId}/${modelId}`,
+  cost
+] ) );
+
 const expectLLMUsage = ( result, { modelId, usage, total, tokensUsed } ) => {
   expect( result ).toBeInstanceOf( Tracing.Attribute.LLMUsage );
   expect( result ).toEqual( expect.objectContaining( {
@@ -71,6 +76,7 @@ describe( 'calculateLLMCallCost', () => {
     mockFetchModelsPricing.mockResolvedValue( null );
 
     const result = await calculateLLMCallCost( {
+      providerId: 'openai',
       modelId: 'gpt-4o',
       usage: { inputTokens: 100, outputTokens: 50 }
     } );
@@ -82,6 +88,7 @@ describe( 'calculateLLMCallCost', () => {
     mockFetchModelsPricing.mockResolvedValue( new Map() );
 
     const result = await calculateLLMCallCost( {
+      providerId: 'openai',
       modelId: 'unknown-model',
       usage: { inputTokens: 100, outputTokens: 50 }
     } );
@@ -90,9 +97,12 @@ describe( 'calculateLLMCallCost', () => {
   } );
 
   it( 'calculates input and output usage from model pricing', async () => {
-    mockFetchModelsPricing.mockResolvedValue( new Map( [ [ 'gpt-4o', { input: 2, output: 10, cache_read: 1 } ] ] ) );
+    mockFetchModelsPricing.mockResolvedValue( pricingMap( [
+      [ 'openai', 'gpt-4o', { input: 2, output: 10, cache_read: 1 } ]
+    ] ) );
 
     const result = await calculateLLMCallCost( {
+      providerId: 'openai',
       modelId: 'gpt-4o',
       usage: { inputTokens: 1_000_000, outputTokens: 500_000 }
     } );
@@ -108,10 +118,51 @@ describe( 'calculateLLMCallCost', () => {
     } );
   } );
 
+  it( 'uses each provider pricing when the same model id exists under two providers', async () => {
+    mockFetchModelsPricing.mockResolvedValue( pricingMap( [
+      [ 'openai', 'gpt-4o', { input: 2, output: 10 } ],
+      [ 'azure', 'gpt-4o', { input: 3, output: 12 } ]
+    ] ) );
+    const usage = { inputTokens: 1_000_000, outputTokens: 0 };
+
+    const openai = await calculateLLMCallCost( {
+      providerId: 'openai',
+      modelId: 'gpt-4o',
+      usage
+    } );
+    const azure = await calculateLLMCallCost( {
+      providerId: 'azure',
+      modelId: 'gpt-4o',
+      usage
+    } );
+
+    expectLLMUsage( openai, {
+      modelId: 'gpt-4o',
+      usage: [
+        { type: 'input', ppm: 2, amount: 1_000_000, total: 2 },
+        { type: 'output', ppm: 10, amount: 0, total: 0 }
+      ],
+      total: 2,
+      tokensUsed: 1_000_000
+    } );
+    expectLLMUsage( azure, {
+      modelId: 'gpt-4o',
+      usage: [
+        { type: 'input', ppm: 3, amount: 1_000_000, total: 3 },
+        { type: 'output', ppm: 12, amount: 0, total: 0 }
+      ],
+      total: 3,
+      tokensUsed: 1_000_000
+    } );
+  } );
+
   it( 'splits input into non-cached and cached usage at respective rates', async () => {
-    mockFetchModelsPricing.mockResolvedValue( new Map( [ [ 'cached-model', { input: 4, cache_read: 1, output: 10 } ] ] ) );
+    mockFetchModelsPricing.mockResolvedValue( pricingMap( [
+      [ 'openai', 'cached-model', { input: 4, cache_read: 1, output: 10 } ]
+    ] ) );
 
     const result = await calculateLLMCallCost( {
+      providerId: 'openai',
       modelId: 'cached-model',
       usage: { inputTokens: 1_000_000, cachedInputTokens: 500_000, outputTokens: 100_000 }
     } );
@@ -129,9 +180,12 @@ describe( 'calculateLLMCallCost', () => {
   } );
 
   it( 'still counts cached tokens when the model has no cache_read rate', async () => {
-    mockFetchModelsPricing.mockResolvedValue( new Map( [ [ 'no-cache', { input: 2, output: 10 } ] ] ) );
+    mockFetchModelsPricing.mockResolvedValue( pricingMap( [
+      [ 'openai', 'no-cache', { input: 2, output: 10 } ]
+    ] ) );
 
     const result = await calculateLLMCallCost( {
+      providerId: 'openai',
       modelId: 'no-cache',
       usage: { inputTokens: 1_000_000, cachedInputTokens: 200_000, outputTokens: 0 }
     } );
@@ -151,9 +205,12 @@ describe( 'calculateLLMCallCost', () => {
   } );
 
   it( 'omits input usage when pricing has no input rate', async () => {
-    mockFetchModelsPricing.mockResolvedValue( new Map( [ [ 'out-only', { output: 10 } ] ] ) );
+    mockFetchModelsPricing.mockResolvedValue( pricingMap( [
+      [ 'openai', 'out-only', { output: 10 } ]
+    ] ) );
 
     const result = await calculateLLMCallCost( {
+      providerId: 'openai',
       modelId: 'out-only',
       usage: { inputTokens: 100, outputTokens: 50 }
     } );
@@ -169,9 +226,12 @@ describe( 'calculateLLMCallCost', () => {
   } );
 
   it( 'omits output usage when pricing has no output rate', async () => {
-    mockFetchModelsPricing.mockResolvedValue( new Map( [ [ 'in-only', { input: 1 } ] ] ) );
+    mockFetchModelsPricing.mockResolvedValue( pricingMap( [
+      [ 'openai', 'in-only', { input: 1 } ]
+    ] ) );
 
     const result = await calculateLLMCallCost( {
+      providerId: 'openai',
       modelId: 'in-only',
       usage: { inputTokens: 100, outputTokens: 50 }
     } );
@@ -187,12 +247,12 @@ describe( 'calculateLLMCallCost', () => {
   } );
 
   it( 'includes reasoning usage when present', async () => {
-    mockFetchModelsPricing.mockResolvedValue( new Map( [ [
-      'with-reasoning',
-      { input: 1, output: 10, reasoning: 60 }
-    ] ] ) );
+    mockFetchModelsPricing.mockResolvedValue( pricingMap( [
+      [ 'openai', 'with-reasoning', { input: 1, output: 10, reasoning: 60 } ]
+    ] ) );
 
     const result = await calculateLLMCallCost( {
+      providerId: 'openai',
       modelId: 'with-reasoning',
       usage: { inputTokens: 100, outputTokens: 20, reasoningTokens: 50 }
     } );
@@ -210,9 +270,12 @@ describe( 'calculateLLMCallCost', () => {
   } );
 
   it( 'omits reasoning usage when reasoning cost is missing', async () => {
-    mockFetchModelsPricing.mockResolvedValue( new Map( [ [ 'no-reasoning', { input: 1, output: 10 } ] ] ) );
+    mockFetchModelsPricing.mockResolvedValue( pricingMap( [
+      [ 'openai', 'no-reasoning', { input: 1, output: 10 } ]
+    ] ) );
 
     const result = await calculateLLMCallCost( {
+      providerId: 'openai',
       modelId: 'no-reasoning',
       usage: { inputTokens: 100, outputTokens: 20, reasoningTokens: 50 }
     } );
@@ -229,12 +292,12 @@ describe( 'calculateLLMCallCost', () => {
   } );
 
   it( 'includes reasoning usage with zero amount when reasoningTokens is zero', async () => {
-    mockFetchModelsPricing.mockResolvedValue( new Map( [ [
-      'full',
-      { input: 2, output: 8, reasoning: 60 }
-    ] ] ) );
+    mockFetchModelsPricing.mockResolvedValue( pricingMap( [
+      [ 'openai', 'full', { input: 2, output: 8, reasoning: 60 } ]
+    ] ) );
 
     const result = await calculateLLMCallCost( {
+      providerId: 'openai',
       modelId: 'full',
       usage: { inputTokens: 100, outputTokens: 50, reasoningTokens: 0 }
     } );
@@ -252,9 +315,12 @@ describe( 'calculateLLMCallCost', () => {
   } );
 
   it( 'omits usage entries for non-finite token counts', async () => {
-    mockFetchModelsPricing.mockResolvedValue( new Map( [ [ 'm', { input: 1, output: 2 } ] ] ) );
+    mockFetchModelsPricing.mockResolvedValue( pricingMap( [
+      [ 'openai', 'm', { input: 1, output: 2 } ]
+    ] ) );
 
     const result = await calculateLLMCallCost( {
+      providerId: 'openai',
       modelId: 'm',
       usage: { inputTokens: null, outputTokens: undefined }
     } );
@@ -274,6 +340,7 @@ describe( 'calculateLLMCallCost', () => {
     mockFetchModelsPricing.mockRejectedValue( error );
 
     const result = await calculateLLMCallCost( {
+      providerId: 'openai',
       modelId: 'gpt-4o',
       usage: { inputTokens: 100, outputTokens: 50 }
     } );

package/src/deprecated_provider_aliases.js

@@ -0,0 +1,8 @@
+/**
+ * Deprecated prompt `provider` spellings → canonical shipped names.
+ * Remove this module when the aliases are dropped.
+ */
+export const deprecatedProviderAliases = {
+  vertex: 'google-vertex',
+  bedrock: 'amazon-bedrock'
+};

package/src/index.d.ts

@@ -91,7 +91,13 @@ export type Prompt = {
 
   /** General configuration for the LLM */
   config: {
-    /** LLM provider (built-in: 'anthropic', 'openai', 'azure', 'vertex', 'bedrock', 'perplexity'; or any registered custom provider) */
+    /**
+     * LLM provider.
+     *
+     * Built-in: `'anthropic'`, `'openai'`, `'azure'`, `'amazon-bedrock'`, `'google-vertex'`,
+     * `'perplexity'`. Legacy aliases `'bedrock'` and `'vertex'` are deprecated but still accepted.
+     * Custom providers registered via {@link registerProvider} are also accepted.
+     */
     provider: string;
 
     /** Model name/identifier */

package/src/prompt/loader.js

@@ -2,8 +2,9 @@ import { parsePrompt } from './parser.js';
 import { Liquid } from 'liquidjs';
 import { loadContent } from './load_content.js';
 import { validatePrompt } from './validations.js';
-import { FatalError } from '@outputai/core';
+import { FatalError, Logger } from '@outputai/core';
 import { escape, decode, setupLiquidEncodeFilter } from './escape.js';
+import { deprecatedProviderAliases } from '../deprecated_provider_aliases.js';
 
 const liquid = new Liquid( {
   strictFilters: true,
@@ -47,6 +48,13 @@ export const loadPrompt = ( name, values = {}, dir ) => {
     instructions: instructions === null ? null : decode( instructions )
   };
 
+  const provider = prompt.config.provider;
+  if ( Object.hasOwn( deprecatedProviderAliases, provider ) ) {
+    const canonical = deprecatedProviderAliases[provider];
+    Logger.warn( `Using deprecated provider alias "${provider}". Use "${canonical}" instead.`, { namespace: 'LLM' } );
+    prompt.config.provider = canonical;
+  }
+
   validatePrompt( prompt );
 
   return { ...prompt, promptFileDir: file.dir };

package/src/prompt/loader.spec.js

@@ -1,4 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Logger } from '@outputai/core';
 import { loadPrompt } from './loader.js';
 
 vi.mock( './parser.js', () => ( {
@@ -263,6 +264,92 @@ model: gpt-4
     } );
   } );
 
+  it.each( [
+    [ 'vertex', 'google-vertex' ],
+    [ 'bedrock', 'amazon-bedrock' ]
+  ] )( 'rewrites deprecated provider alias %s to %s and warns', ( alias, canonical ) => {
+    const warn = vi.spyOn( Logger, 'warn' ).mockImplementation( () => {} );
+    loadContent.mockReturnValue( {
+      content: '<user>Hello</user>',
+      dir: '/mock/dir'
+    } );
+    parsePrompt.mockReturnValue( {
+      config: {
+        provider: alias,
+        model: 'test-model'
+      },
+      messages: [ { role: 'user', content: 'Hello' } ],
+      instructions: null
+    } );
+
+    const result = loadPrompt( 'test' );
+
+    expect( result.config.provider ).toBe( canonical );
+    expect( validatePrompt ).toHaveBeenCalledWith( expect.objectContaining( {
+      config: expect.objectContaining( { provider: canonical } )
+    } ) );
+    expect( warn ).toHaveBeenCalledWith(
+      `Using deprecated provider alias "${alias}". Use "${canonical}" instead.`,
+      { namespace: 'LLM' }
+    );
+  } );
+
+  it( 'rewrites provider aliases on the decoded config', () => {
+    const warn = vi.spyOn( Logger, 'warn' ).mockImplementation( () => {} );
+    const parsedConfig = {
+      provider: 'bedrock',
+      model: 'test-model'
+    };
+    const decodedConfig = {
+      provider: 'bedrock',
+      model: 'test-model'
+    };
+    loadContent.mockReturnValue( {
+      content: '<user>Hello</user>',
+      dir: '/mock/dir'
+    } );
+    parsePrompt.mockReturnValue( {
+      config: parsedConfig,
+      messages: [ { role: 'user', content: 'Hello' } ],
+      instructions: null
+    } );
+    decode.mockImplementation( value => ( value === parsedConfig ? decodedConfig : value ) );
+
+    const result = loadPrompt( 'test' );
+
+    expect( decode ).toHaveBeenCalledWith( parsedConfig );
+    expect( result.config ).toBe( decodedConfig );
+    expect( result.config.provider ).toBe( 'amazon-bedrock' );
+    expect( validatePrompt ).toHaveBeenCalledWith( expect.objectContaining( {
+      config: decodedConfig
+    } ) );
+    expect( warn ).toHaveBeenCalledWith(
+      'Using deprecated provider alias "bedrock". Use "amazon-bedrock" instead.',
+      { namespace: 'LLM' }
+    );
+  } );
+
+  it( 'leaves canonical provider names unchanged', () => {
+    const warn = vi.spyOn( Logger, 'warn' ).mockImplementation( () => {} );
+    loadContent.mockReturnValue( {
+      content: '<user>Hello</user>',
+      dir: '/mock/dir'
+    } );
+    parsePrompt.mockReturnValue( {
+      config: {
+        provider: 'google-vertex',
+        model: 'gemini-2.5-flash-lite'
+      },
+      messages: [ { role: 'user', content: 'Hello' } ],
+      instructions: null
+    } );
+
+    const result = loadPrompt( 'test' );
+
+    expect( result.config.provider ).toBe( 'google-vertex' );
+    expect( warn ).not.toHaveBeenCalled();
+  } );
+
   it( 'throws error when prompt file not found', () => {
     loadContent.mockReturnValue( null );
 

package/src/utils/error_handler.js

@@ -1,56 +1,26 @@
-import {
-  APICallError,
-  InvalidArgumentError,
-  InvalidDataContentError,
-  InvalidPromptError,
-  LoadAPIKeyError,
-  LoadSettingError,
-  NoImageGeneratedError,
-  NoObjectGeneratedError,
-  NoSuchModelError,
-  NoSuchProviderError,
-  UnsupportedFunctionalityError
-} from 'ai';
-import { FatalError } from '@outputai/core';
-
-// AI SDK does not expose a dedicated schema-mismatch discriminator for NoObjectGeneratedError.
-const NO_OBJECT_SCHEMA_MISMATCH_MESSAGE = 'No object generated: response did not match schema.';
-
-/**
- * Recursively search an error cause chain until finds an error which is instance of given prototype.
- *
- * @param {object} error - Error instance.
- * @param {Function|string} _class - Target constructor or constructor name.
- * @param {number} depth - Current depth, search up to 10 causes deep.
- * @returns {object|null} - Error or null if not found.
- */
-export const findInstanceInCauseChain = ( error, _class, depth = 0 ) => {
-  if ( !error || typeof error !== 'object' ) {
-    return null;
-  }
-  if ( typeof _class === 'string' && error.constructor?.name === _class ) {
-    return error;
-  }
-  if ( typeof _class === 'function' && error instanceof _class ) {
-    return error;
-  }
-  if ( depth >= 10 ) {
-    return null;
-  }
-  return error.cause ? findInstanceInCauseChain( error.cause, _class, depth + 1 ) : null;
-};
-
-const toFatalError = ( error, extraMessage = '' ) => new FatalError(
-  `AI-SDK fatal error${extraMessage ? ` (${extraMessage})` : ''}: ${error.message}`,
-  { cause: error }
-);
+import * as ai from 'ai';
+import { FatalError, TransparentFatalError } from '@outputai/core';
+
+const nonRetryableAiSdkErrorTypes = [
+  ai.InvalidArgumentError, // Invalid call settings are deterministic caller bugs, so retrying the same activity cannot fix them.
+  ai.InvalidDataContentError, // Invalid media content has the wrong local shape/encoding and will fail again with the same input.
+  ai.InvalidPromptError, // Invalid prompt structure is a deterministic request-construction error.
+  ai.LoadAPIKeyError, // Missing or invalid API key configuration will not change during an activity retry.
+  ai.LoadSettingError, // Missing or invalid provider settings are deployment/configuration problems.
+  ai.NoImageGeneratedError, // Image generation completed provider calls but collected zero images; repeating identical input is not useful.
+  ai.NoSuchProviderError, // A missing provider id is a deterministic provider registry/configuration error.
+  ai.NoSuchModelError, // A missing model id is a deterministic provider/model configuration error.
+  ai.UnsupportedFunctionalityError // The selected model/output mode does not support the requested feature.
+];
 
 /**
- * Map an AI SDK error to a framework specific error:
+ * Maps an AI SDK error to a framework error:
+ * - AI SDK Unrecoverable error types become TransparentFatalErrors;
+ * - AI SDK API error with isRetryable=false become TransparentFatalErrors;
+ * Some errors are not mapped:
+ * - Grammar which technically are isRetryable=false, will be rethrown, because they are actually transient;
+ * - Other errors are rethrown as well;
  *
- * - AI SDK Unrecoverable errors become FatalErrors, check code to see options.
- * - NoObjectGeneratedError from invalid schema are reinitialized with a better message.
- * - Other errors are preserved.
  * @param {object} error - Original Error
  * @returns {object} A new Error
  */
@@ -59,25 +29,7 @@ export const mapAiError = error => {
     return error;
   }
 
-  // NoObjectGeneratedError can be thrown when the response doesn't match the schema.
-  // This re-creates the error with a better message, making it easier to debug.
-  if ( NoObjectGeneratedError.isInstance( error ) && error.message.includes( NO_OBJECT_SCHEMA_MISMATCH_MESSAGE ) ) {
-    const zodError = findInstanceInCauseChain( error, 'ZodError' );
-    if ( zodError && zodError.issues?.length > 0 ) {
-      const [ { path, message } ] = zodError.issues;
-      return new NoObjectGeneratedError( {
-        message: `${error.message} First issue is "${message}" at path [${path.join( ', ' )}].`,
-        cause: error.cause,
-        text: error.text,
-        response: error.response,
-        usage: error.usage,
-        finishReason: error.finishReason
-      } );
-    }
-    return error;
-  }
-
-  const isApiError = APICallError.isInstance( error );
+  const isApiError = ai.APICallError.isInstance( error );
   const isGrammarCompilationError = error.message === 'Grammar compilation timed out.';
 
   // This error is actually transient, so instead of FatalError, return it
@@ -85,45 +37,13 @@ export const mapAiError = error => {
     return error;
   }
 
+  // Non-retryable API failures are already classified by AI SDK as permanent provider failures.
   if ( isApiError && !error.isRetryable ) {
-    // Non-retryable API failures are already classified by AI SDK as permanent provider failures.
-    return toFatalError( error, error.statusCode ? `HTTP ${error.statusCode}` : '' );
-  }
-  if ( InvalidArgumentError.isInstance( error ) ) {
-    // Invalid call settings are deterministic caller bugs, so retrying the same activity cannot fix them.
-    return toFatalError( error );
-  }
-  if ( InvalidDataContentError.isInstance( error ) ) {
-    // Invalid media content has the wrong local shape/encoding and will fail again with the same input.
-    return toFatalError( error );
-  }
-  if ( InvalidPromptError.isInstance( error ) ) {
-    // Invalid prompt structure is a deterministic request-construction error.
-    return toFatalError( error );
+    return new TransparentFatalError( error );
   }
-  if ( LoadAPIKeyError.isInstance( error ) ) {
-    // Missing or invalid API key configuration will not change during an activity retry.
-    return toFatalError( error );
-  }
-  if ( LoadSettingError.isInstance( error ) ) {
-    // Missing or invalid provider settings are deployment/configuration problems.
-    return toFatalError( error );
-  }
-  if ( NoImageGeneratedError.isInstance( error ) ) {
-    // Image generation completed provider calls but collected zero images; repeating identical input is not useful.
-    return toFatalError( error );
-  }
-  if ( NoSuchProviderError.isInstance( error ) ) {
-    // A missing provider id is a deterministic provider registry/configuration error.
-    return toFatalError( error );
-  }
-  if ( NoSuchModelError.isInstance( error ) ) {
-    // A missing model id is a deterministic provider/model configuration error.
-    return toFatalError( error );
-  }
-  if ( UnsupportedFunctionalityError.isInstance( error ) ) {
-    // The selected model/output mode does not support the requested feature.
-    return toFatalError( error );
+
+  if ( nonRetryableAiSdkErrorTypes.some( E => E.isInstance( error ) ) ) {
+    return new TransparentFatalError( error );
   }
   return error;
 };

package/src/utils/error_handler.spec.js

@@ -19,8 +19,8 @@ import {
   ToolCallRepairError,
   UnsupportedFunctionalityError
 } from 'ai';
-import { FatalError } from '@outputai/core';
-import { findInstanceInCauseChain, mapAiError } from './error_handler.js';
+import { FatalError, TransparentFatalError } from '@outputai/core';
+import { mapAiError } from './error_handler.js';
 
 const makeApiCallError = ( input = {} ) => new APICallError( {
   message: 'Provider rejected the request',
@@ -130,63 +130,6 @@ const preservedAiSdkErrors = [
   ]
 ];
 
-describe( 'findInstanceInCauseChain', () => {
-  class FirstCustomError extends Error {}
-  class SecondCustomError extends Error {}
-
-  it( 'returns the input error when it matches the target constructor', () => {
-    const error = new FirstCustomError( 'first' );
-
-    expect( findInstanceInCauseChain( error, FirstCustomError ) ).toBe( error );
-  } );
-
-  it( 'returns the input error when it matches the target constructor name', () => {
-    const error = new FirstCustomError( 'first' );
-
-    expect( findInstanceInCauseChain( error, 'FirstCustomError' ) ).toBe( error );
-  } );
-
-  it( 'walks the cause chain to find an error by constructor', () => {
-    const target = new SecondCustomError( 'second' );
-    const wrapper = new FirstCustomError( 'first', { cause: target } );
-
-    expect( findInstanceInCauseChain( wrapper, SecondCustomError ) ).toBe( target );
-  } );
-
-  it( 'walks the cause chain to find an error by constructor name', () => {
-    const target = new SecondCustomError( 'second' );
-    const wrapper = new FirstCustomError( 'first', { cause: target } );
-
-    expect( findInstanceInCauseChain( wrapper, 'SecondCustomError' ) ).toBe( target );
-  } );
-
-  it( 'returns null when the target is not found', () => {
-    const error = new FirstCustomError( 'first', { cause: new Error( 'root' ) } );
-
-    expect( findInstanceInCauseChain( error, SecondCustomError ) ).toBeNull();
-  } );
-
-  it( 'returns null for empty or non-object inputs', () => {
-    expect( findInstanceInCauseChain( null, Error ) ).toBeNull();
-    expect( findInstanceInCauseChain( 'not an error', Error ) ).toBeNull();
-  } );
-
-  it( 'returns null for object causes without constructors', () => {
-    const cause = Object.create( null );
-    const error = new FirstCustomError( 'first', { cause } );
-
-    expect( findInstanceInCauseChain( error, 'SecondCustomError' ) ).toBeNull();
-  } );
-
-  it( 'stops searching after the depth limit', () => {
-    const makeErrorChain = depth => depth === 0 ?
-      new SecondCustomError( 'target' ) :
-      new FirstCustomError( `level ${depth}`, { cause: makeErrorChain( depth - 1 ) } );
-
-    expect( findInstanceInCauseChain( makeErrorChain( 11 ), SecondCustomError ) ).toBeNull();
-  } );
-} );
-
 describe( 'mapAiError', () => {
   it( 'preserves existing FatalError instances', () => {
     const error = new FatalError( 'Already fatal' );
@@ -194,7 +137,7 @@ describe( 'mapAiError', () => {
     expect( mapAiError( error ) ).toBe( error );
   } );
 
-  it( 'adds first schema issue details to NoObjectGeneratedError schema mismatches', () => {
+  it( 'preserves NoObjectGeneratedError with its complete schema issue details', () => {
     class ZodError extends Error {
       constructor( issues ) {
         super( 'schema failed' );
@@ -217,32 +160,12 @@ describe( 'mapAiError', () => {
       cause: validationError
     } );
 
-    const result = mapAiError( error );
-
-    expect( result ).not.toBe( error );
-    expect( NoObjectGeneratedError.isInstance( result ) ).toBe( true );
-    expect( result.name ).toBe( 'AI_NoObjectGeneratedError' );
-    expect( result.message ).toBe(
-      'No object generated: response did not match schema. First issue is "Expected string" at path [items, 0, title].'
-    );
-    expect( result.cause ).toBe( validationError );
-    expect( result.text ).toBe( error.text );
-    expect( result.response ).toBe( error.response );
-    expect( result.usage ).toBe( error.usage );
-    expect( result.finishReason ).toBe( error.finishReason );
-  } );
-
-  it( 'preserves NoObjectGeneratedError schema mismatches when no schema issue is available', () => {
-    const error = new NoObjectGeneratedError( {
-      message: 'No object generated: response did not match schema.',
-      text: '{"items":[{}]}',
-      cause: new Error( 'validation failed' )
-    } );
-
     expect( mapAiError( error ) ).toBe( error );
+    expect( error.cause.cause ).toBe( zodError );
+    expect( error.cause.cause.issues ).toEqual( zodError.issues );
   } );
 
-  it( 'maps non-retryable APICallError instances to FatalError', () => {
+  it( 'maps non-retryable APICallError instances to TransparentFatalError', () => {
     const error = makeApiCallError( {
       statusCode: 400,
       isRetryable: false
@@ -250,20 +173,18 @@ describe( 'mapAiError', () => {
 
     const result = mapAiError( error );
 
-    expect( result ).toBeInstanceOf( FatalError );
-    expect( result.message ).toBe( 'AI-SDK fatal error (HTTP 400): Provider rejected the request' );
+    expect( result ).toBeInstanceOf( TransparentFatalError );
     expect( result.cause ).toBe( error );
   } );
 
-  it( 'maps non-retryable APICallError instances without status codes to FatalError', () => {
+  it( 'maps non-retryable APICallError instances without status codes to TransparentFatalError', () => {
     const error = makeApiCallError( {
       isRetryable: false
     } );
 
     const result = mapAiError( error );
 
-    expect( result ).toBeInstanceOf( FatalError );
-    expect( result.message ).toBe( 'AI-SDK fatal error: Provider rejected the request' );
+    expect( result ).toBeInstanceOf( TransparentFatalError );
     expect( result.cause ).toBe( error );
   } );
 
@@ -286,13 +207,12 @@ describe( 'mapAiError', () => {
     expect( mapAiError( error ) ).toBe( error );
   } );
 
-  it.each( fatalAiSdkErrors )( 'maps %s to FatalError', ( _name, makeError ) => {
+  it.each( fatalAiSdkErrors )( 'maps %s to TransparentFatalError', ( _name, makeError ) => {
     const error = makeError();
 
     const result = mapAiError( error );
 
-    expect( result ).toBeInstanceOf( FatalError );
-    expect( result.message ).toBe( `AI-SDK fatal error: ${error.message}` );
+    expect( result ).toBeInstanceOf( TransparentFatalError );
     expect( result.cause ).toBe( error );
   } );
 

package/src/utils/response_wrappers.js

@@ -12,14 +12,15 @@ import { calculateBase64FileSize } from './image.js';
  *
  * @param {object} args
  * @param {string} args.traceId - id created by the startTrace
+ * @param {string} args.providerId - id of the provider used
  * @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 } ) => {
+export const wrapTextResponse = async ( { traceId, providerId, modelId, response } ) => {
   const { totalUsage: usage, providerMetadata, text: result, steps, sources } = response;
 
-  const cost = await calculateLLMCallCost( { usage, modelId } );
+  const cost = await calculateLLMCallCost( { usage, modelId, providerId } );
   const sourcesFromTools = extractSourcesFromSteps( steps );
 
   endTraceWithSuccess( { traceId, usage, cost, result, providerMetadata, sourcesFromTools } );
@@ -48,13 +49,14 @@ export const wrapTextResponse = async ( { traceId, modelId, response } ) => {
  *
  * @param {object} args
  * @param {string} args.traceId - id created by the startTrace
+ * @param {string} args.providerId - id of the provider used
  * @param {string} args.modelId - id of the model used
  * @param {Function} args.onFinish - Original callback to call with the proxied response
  * @returns {object} Proxied response
  */
-export const wrapStreamOnFinishResponse = ( { traceId, modelId, onFinish: _onFinish } ) => ( {
+export const wrapStreamOnFinishResponse = ( { traceId, providerId, modelId, onFinish: _onFinish } ) => ( {
   async onFinish( response ) {
-    const proxiedResponse = await wrapTextResponse( { traceId, modelId, response } );
+    const proxiedResponse = await wrapTextResponse( { traceId, providerId, modelId, response } );
     _onFinish?.( proxiedResponse );
   }
 } );
@@ -68,13 +70,14 @@ export const wrapStreamOnFinishResponse = ( { traceId, modelId, onFinish: _onFin
  *
  * @param {object} args
  * @param {string} args.traceId - id created by the startTrace
+ * @param {string} args.providerId - id of the provider used
  * @param {string} args.modelId - id of the model used
  * @param {object} args.response - AI SDK's image response
  * @returns {object} Proxied response
  */
-export const wrapImageResponse = async ( { traceId, modelId, response } ) => {
+export const wrapImageResponse = async ( { traceId, providerId, modelId, response } ) => {
   const { usage, providerMetadata } = response;
-  const cost = await calculateLLMCallCost( { usage, modelId } );
+  const cost = await calculateLLMCallCost( { usage, providerId, modelId } );
 
   const result = response.images.map( ( { mediaType, base64 } ) => ( {
     size: calculateBase64FileSize( base64 ),

package/src/utils/response_wrappers.spec.js

@@ -52,6 +52,7 @@ const makeAiSdkImageResponse = () => generateImage( {
 
 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 } ] };
 
@@ -65,13 +66,14 @@ describe( 'wrapTextResponse', () => {
   it( 'uses a text response fixture to calculate cost, end trace, and attach cost', async () => {
     const response = clone( textResponseFixture );
 
-    const wrapped = await wrapTextResponse( { traceId, modelId, response } );
+    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
+      modelId,
+      providerId
     } );
     expect( mocks.extractSourcesFromSteps ).toHaveBeenCalledWith( response.steps );
     expect( mocks.endTraceWithSuccess ).toHaveBeenCalledWith( {
@@ -92,7 +94,7 @@ describe( 'wrapTextResponse', () => {
     response.sources = nativeSources;
     mocks.extractSourcesFromSteps.mockReturnValue( [] );
 
-    const wrapped = await wrapTextResponse( { traceId, modelId, response } );
+    const wrapped = await wrapTextResponse( { traceId, providerId, modelId, response } );
 
     expect( wrapped.sources ).toBe( nativeSources );
     expect( mocks.combineSources ).not.toHaveBeenCalled();
@@ -119,7 +121,7 @@ describe( 'wrapTextResponse', () => {
     mocks.extractSourcesFromSteps.mockReturnValue( [ toolSource ] );
     mocks.combineSources.mockReturnValue( mergedSources );
 
-    const wrapped = await wrapTextResponse( { traceId, modelId, response } );
+    const wrapped = await wrapTextResponse( { traceId, providerId, modelId, response } );
 
     expect( wrapped.sources ).toBe( mergedSources );
     expect( mocks.combineSources ).toHaveBeenCalledWith( {
@@ -131,6 +133,7 @@ describe( 'wrapTextResponse', () => {
 
 describe( 'wrapStreamOnFinishResponse', () => {
   const traceId = 'stream-trace';
+  const providerId = 'openai';
   const modelId = 'stream-model';
   const mockCost = { total: 0.002, components: [] };
 
@@ -146,6 +149,7 @@ describe( 'wrapStreamOnFinishResponse', () => {
 
     const callbacks = wrapStreamOnFinishResponse( {
       traceId,
+      providerId,
       modelId,
       onFinish: userOnFinish
     } );
@@ -173,6 +177,7 @@ describe( 'wrapStreamOnFinishResponse', () => {
 
     const callbacks = wrapStreamOnFinishResponse( {
       traceId,
+      providerId,
       modelId
     } );
 
@@ -188,13 +193,15 @@ describe( 'wrapStreamOnFinishResponse', () => {
     } );
     expect( mocks.calculateLLMCallCost ).toHaveBeenCalledWith( {
       usage: response.totalUsage,
-      modelId
+      modelId,
+      providerId
     } );
   } );
 } );
 
 describe( 'wrapImageResponse', () => {
   const traceId = 'image-trace';
+  const providerId = 'openai';
   const modelId = 'image-model';
   const mockCost = { total: 0.003, components: [] };
 
@@ -207,13 +214,14 @@ describe( 'wrapImageResponse', () => {
   it( 'uses an image response fixture to trace image metadata and attach cost', async () => {
     const response = await makeAiSdkImageResponse();
 
-    const wrapped = await wrapImageResponse( { traceId, modelId, response } );
+    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
+      modelId,
+      providerId
     } );
     expect( mocks.calculateBase64FileSize ).toHaveBeenCalledWith( response.images[0].base64 );
     expect( mocks.endTraceWithSuccess ).toHaveBeenCalledWith( {