@outputai/llm 0.6.1-dev.aab2335.0 → 0.6.1-next.0d08ff5.0

package/src/utils/__fixtures__/text_response.json

@@ -0,0 +1,201 @@
+{
+  "steps": [
+    {
+      "stepNumber": 0,
+      "model": {
+        "provider": "anthropic.messages",
+        "modelId": "claude-haiku-4-5"
+      },
+      "content": [
+        {
+          "type": "text",
+          "text": "{\"result\": \"yes\"}"
+        }
+      ],
+      "finishReason": "stop",
+      "rawFinishReason": "end_turn",
+      "usage": {
+        "inputTokens": 217,
+        "inputTokenDetails": {
+          "noCacheTokens": 217,
+          "cacheReadTokens": 0,
+          "cacheWriteTokens": 0
+        },
+        "outputTokens": 9,
+        "outputTokenDetails": {},
+        "totalTokens": 226,
+        "raw": {
+          "input_tokens": 217,
+          "output_tokens": 9,
+          "cache_creation_input_tokens": 0,
+          "cache_read_input_tokens": 0,
+          "cache_creation": {
+            "ephemeral_5m_input_tokens": 0,
+            "ephemeral_1h_input_tokens": 0
+          },
+          "service_tier": "standard",
+          "inference_geo": "not_available"
+        },
+        "cachedInputTokens": 0
+      },
+      "warnings": [],
+      "request": {
+        "body": {
+          "model": "claude-haiku-4-5",
+          "max_tokens": 64000,
+          "temperature": 0.7,
+          "output_config": {
+            "format": {
+              "type": "json_schema",
+              "schema": {
+                "$schema": "http://json-schema.org/draft-07/schema#",
+                "type": "object",
+                "properties": {
+                  "result": {
+                    "type": "string",
+                    "enum": [
+                      "yes",
+                      "no"
+                    ]
+                  }
+                },
+                "required": [
+                  "result"
+                ],
+                "additionalProperties": false
+              }
+            }
+          },
+          "messages": [
+            {
+              "role": "assistant",
+              "content": [
+                {
+                  "type": "text",
+                  "text": "You are a concise assistant."
+                }
+              ]
+            },
+            {
+              "role": "user",
+              "content": [
+                {
+                  "type": "text",
+                  "text": "Do humans like carburetors?"
+                }
+              ]
+            }
+          ]
+        }
+      },
+      "response": {
+        "id": "msg_01VQv2YKP97yEn4kin5Xvn6v",
+        "timestamp": "2026-06-04T15:30:32.333Z",
+        "modelId": "claude-haiku-4-5-20251001",
+        "headers": {
+          "__redacted__": "<<headers were removed>>"
+        },
+        "body": {
+          "model": "claude-haiku-4-5-20251001",
+          "id": "msg_01VQv2YKP97yEn4kin5Xvn6v",
+          "type": "message",
+          "role": "assistant",
+          "content": [
+            {
+              "type": "text",
+              "text": "{\"result\": \"yes\"}"
+            }
+          ],
+          "stop_reason": "end_turn",
+          "stop_sequence": null,
+          "stop_details": null,
+          "usage": {
+            "input_tokens": 217,
+            "cache_creation_input_tokens": 0,
+            "cache_read_input_tokens": 0,
+            "cache_creation": {
+              "ephemeral_5m_input_tokens": 0,
+              "ephemeral_1h_input_tokens": 0
+            },
+            "output_tokens": 9,
+            "service_tier": "standard",
+            "inference_geo": "not_available"
+          }
+        },
+        "messages": [
+          {
+            "role": "assistant",
+            "content": [
+              {
+                "type": "text",
+                "text": "{\"result\": \"yes\"}"
+              }
+            ]
+          }
+        ]
+      },
+      "providerMetadata": {
+        "anthropic": {
+          "usage": {
+            "input_tokens": 217,
+            "output_tokens": 9,
+            "cache_creation_input_tokens": 0,
+            "cache_read_input_tokens": 0,
+            "cache_creation": {
+              "ephemeral_5m_input_tokens": 0,
+              "ephemeral_1h_input_tokens": 0
+            },
+            "service_tier": "standard",
+            "inference_geo": "not_available"
+          },
+          "cacheCreationInputTokens": 0,
+          "stopSequence": null,
+          "iterations": null,
+          "container": null,
+          "contextManagement": null
+        }
+      },
+      "toolCalls": [
+        {
+          "type": "tool-call",
+          "toolCallId": "call_fixture_web_search",
+          "toolName": "webSearch",
+          "input": {
+            "query": "carburetor reference article"
+          }
+        }
+      ],
+      "toolResults": [
+        {
+          "type": "tool-result",
+          "toolCallId": "call_fixture_web_search",
+          "toolName": "webSearch",
+          "input": {
+            "query": "carburetor reference article"
+          },
+          "output": {
+            "results": [
+              {
+                "title": "Carburetor reference article",
+                "url": "https://example.com/carburetor-reference"
+              }
+            ]
+          }
+        }
+      ]
+    }
+  ],
+  "_output": "yes",
+  "totalUsage": {
+    "inputTokens": 217,
+    "inputTokenDetails": {
+      "noCacheTokens": 217,
+      "cacheReadTokens": 0,
+      "cacheWriteTokens": 0
+    },
+    "outputTokens": 9,
+    "outputTokenDetails": {},
+    "totalTokens": 226,
+    "cachedInputTokens": 0
+  }
+}

package/src/utils/error_handler.js

@@ -0,0 +1,65 @@
+import {
+  APICallError,
+  InvalidArgumentError,
+  InvalidDataContentError,
+  InvalidPromptError,
+  LoadAPIKeyError,
+  LoadSettingError,
+  NoImageGeneratedError,
+  NoSuchModelError,
+  NoSuchProviderError,
+  UnsupportedFunctionalityError
+} from 'ai';
+import { FatalError } from '@outputai/core';
+
+const toFatalError = ( error, extraMessage = '' ) => new FatalError(
+  `AI-SDK fatal error${extraMessage ? ` (${extraMessage})` : ''}: ${error.message}`,
+  { cause: error }
+);
+
+export const mapAiError = error => {
+  if ( error instanceof FatalError ) {
+    return error;
+  }
+  if ( APICallError.isInstance( error ) && !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 );
+  }
+  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 );
+  }
+  return error;
+};

package/src/utils/error_handler.spec.js

@@ -0,0 +1,195 @@
+import { describe, expect, it } from 'vitest';
+import {
+  APICallError,
+  InvalidArgumentError,
+  InvalidDataContentError,
+  InvalidMessageRoleError,
+  InvalidPromptError,
+  InvalidToolApprovalError,
+  InvalidToolInputError,
+  LoadAPIKeyError,
+  LoadSettingError,
+  MessageConversionError,
+  NoImageGeneratedError,
+  NoOutputGeneratedError,
+  NoObjectGeneratedError,
+  NoSuchModelError,
+  NoSuchProviderError,
+  ToolCallNotFoundForApprovalError,
+  ToolCallRepairError,
+  UnsupportedFunctionalityError
+} from 'ai';
+import { FatalError } from '@outputai/core';
+import { mapAiError } from './error_handler.js';
+
+const makeApiCallError = ( input = {} ) => new APICallError( {
+  message: 'Provider rejected the request',
+  url: 'https://provider.test/v1/generate',
+  requestBodyValues: {},
+  responseHeaders: {},
+  responseBody: '{"error":"bad request"}',
+  ...input
+} );
+
+const fatalAiSdkErrors = [
+  [
+    'InvalidArgumentError',
+    () => new InvalidArgumentError( {
+      parameter: 'temperature',
+      value: 'hot',
+      message: 'temperature must be a number'
+    } )
+  ],
+  [
+    'InvalidDataContentError',
+    () => new InvalidDataContentError( { content: { bad: true } } )
+  ],
+  [
+    'InvalidPromptError',
+    () => new InvalidPromptError( { prompt: {}, message: 'prompt or messages must be defined' } )
+  ],
+  [
+    'LoadAPIKeyError',
+    () => new LoadAPIKeyError( { message: 'Missing API key' } )
+  ],
+  [
+    'LoadSettingError',
+    () => new LoadSettingError( { message: 'Missing setting' } )
+  ],
+  [
+    'NoImageGeneratedError',
+    () => new NoImageGeneratedError( { responses: [] } )
+  ],
+  [
+    'NoSuchModelError',
+    () => new NoSuchModelError( { modelId: 'missing-model', modelType: 'languageModel' } )
+  ],
+  [
+    'NoSuchProviderError',
+    () => new NoSuchProviderError( {
+      modelId: 'missing-provider:model',
+      modelType: 'languageModel',
+      providerId: 'missing-provider',
+      availableProviders: [ 'openai' ]
+    } )
+  ],
+  [
+    'UnsupportedFunctionalityError',
+    () => new UnsupportedFunctionalityError( { functionality: 'image masks' } )
+  ]
+];
+
+const preservedAiSdkErrors = [
+  [
+    'InvalidMessageRoleError',
+    () => new InvalidMessageRoleError( { role: 'critic' } )
+  ],
+  [
+    'InvalidToolApprovalError',
+    () => new InvalidToolApprovalError( { approvalId: 'approval-1' } )
+  ],
+  [
+    'InvalidToolInputError',
+    () => new InvalidToolInputError( {
+      toolName: 'search',
+      toolInput: '{bad json',
+      cause: new Error( 'parse failed' )
+    } )
+  ],
+  [
+    'MessageConversionError',
+    () => new MessageConversionError( {
+      originalMessage: { role: 'critic', content: 'bad role' },
+      message: 'Unsupported role'
+    } )
+  ],
+  [
+    'NoObjectGeneratedError',
+    () => new NoObjectGeneratedError( {
+      text: 'not json',
+      cause: new Error( 'parse failed' )
+    } )
+  ],
+  [
+    'NoOutputGeneratedError',
+    () => new NoOutputGeneratedError()
+  ],
+  [
+    'ToolCallNotFoundForApprovalError',
+    () => new ToolCallNotFoundForApprovalError( {
+      toolCallId: 'tool-call-1',
+      approvalId: 'approval-1'
+    } )
+  ],
+  [
+    'ToolCallRepairError',
+    () => new ToolCallRepairError( {
+      cause: new Error( 'repair failed' ),
+      originalError: new Error( 'invalid tool input' )
+    } )
+  ]
+];
+
+describe( 'mapAiError', () => {
+  it( 'preserves existing FatalError instances', () => {
+    const error = new FatalError( 'Already fatal' );
+
+    expect( mapAiError( error ) ).toBe( error );
+  } );
+
+  it( 'maps non-retryable APICallError instances to FatalError', () => {
+    const error = makeApiCallError( {
+      statusCode: 400,
+      isRetryable: false
+    } );
+
+    const result = mapAiError( error );
+
+    expect( result ).toBeInstanceOf( FatalError );
+    expect( result.message ).toBe( 'AI-SDK fatal error (HTTP 400): Provider rejected the request' );
+    expect( result.cause ).toBe( error );
+  } );
+
+  it( 'maps non-retryable APICallError instances without status codes to FatalError', () => {
+    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.cause ).toBe( error );
+  } );
+
+  it( 'preserves retryable APICallError instances', () => {
+    const error = makeApiCallError( {
+      statusCode: 429,
+      isRetryable: true
+    } );
+
+    expect( mapAiError( error ) ).toBe( error );
+  } );
+
+  it.each( fatalAiSdkErrors )( 'maps %s to FatalError', ( _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.cause ).toBe( error );
+  } );
+
+  it.each( preservedAiSdkErrors )( 'preserves %s for now', ( _name, makeError ) => {
+    const error = makeError();
+
+    expect( mapAiError( error ) ).toBe( error );
+  } );
+
+  it( 'preserves ordinary errors', () => {
+    const error = new Error( 'Network exploded' );
+
+    expect( mapAiError( error ) ).toBe( error );
+  } );
+} );

package/src/utils/image.js

@@ -0,0 +1,10 @@
+/**
+ * Get the approximate file size from a base64 string.
+ * @param {string} b64data
+ * @returns {number} Size in bytes
+ */
+export const calculateBase64FileSize = b64data => {
+  const baseSize = b64data.length * ( 3 / 4 );
+  const paddingSize = [ b64data.at( -2 ), b64data.at( -1 ) ].filter( v => v === '=' ).length;
+  return baseSize - paddingSize;
+};

package/src/utils/image.spec.js

@@ -0,0 +1,20 @@
+import { describe, it, expect } from 'vitest';
+import { calculateBase64FileSize } from './image.js';
+
+describe( 'calculateBase64FileSize', () => {
+  it( 'calculates size for base64 without padding', () => {
+    expect( calculateBase64FileSize( 'TWFu' ) ).toBe( 3 );
+  } );
+
+  it( 'calculates size for base64 with one padding character', () => {
+    expect( calculateBase64FileSize( 'TWE=' ) ).toBe( 2 );
+  } );
+
+  it( 'calculates size for base64 with two padding characters', () => {
+    expect( calculateBase64FileSize( 'TQ==' ) ).toBe( 1 );
+  } );
+
+  it( 'returns zero for an empty string', () => {
+    expect( calculateBase64FileSize( '' ) ).toBe( 0 );
+  } );
+} );

package/src/utils/response_wrappers.js

@@ -1,6 +1,7 @@
 import { combineSources, extractSourcesFromSteps } from './source_extraction.js';
 import { calculateLLMCallCost } from '../cost/index.js';
 import { endTraceWithSuccess } from './trace.js';
+import { calculateBase64FileSize } from './image.js';
 
 /**
  * Calculates the cost and wraps an AI SDK text response in a Proxy with shortcut for 'result' and 'cost'
@@ -16,10 +17,12 @@ import { endTraceWithSuccess } from './trace.js';
  * @returns {object} Proxied response
  */
 export const wrapTextResponse = async ( { traceId, modelId, response } ) => {
-  const sourcesFromTools = extractSourcesFromSteps( response.steps );
-  const cost = await calculateLLMCallCost( { usage: response.totalUsage, modelId } );
+  const { totalUsage: usage, providerMetadata, text: result, steps, sources } = response;
 
-  endTraceWithSuccess( { traceId, modelId, response, cost, sourcesFromTools } );
+  const cost = await calculateLLMCallCost( { usage, modelId } );
+  const sourcesFromTools = extractSourcesFromSteps( steps );
+
+  endTraceWithSuccess( { traceId, usage, cost, result, providerMetadata, sourcesFromTools } );
 
   return new Proxy( response, {
     get( target, prop, receiver ) {
@@ -30,7 +33,7 @@ export const wrapTextResponse = async ( { traceId, modelId, response } ) => {
         return cost;
       }
       if ( prop === 'sources' && sourcesFromTools.length > 0 ) {
-        return combineSources( { sourcesFromTools, sourcesFromResponse: response.sources } );
+        return combineSources( { sourcesFromTools, sourcesFromResponse: sources } );
       }
       return Reflect.get( target, prop, receiver );
     }
@@ -46,25 +49,49 @@ export const wrapTextResponse = async ( { traceId, modelId, response } ) => {
  * @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
+ * @param {Function} args.onFinish - Original callback to call with the proxied response
  * @returns {object} Proxied response
  */
 export const wrapStreamOnFinishResponse = ( { traceId, modelId, onFinish: _onFinish } ) => ( {
   async onFinish( response ) {
-    const cost = await calculateLLMCallCost( { modelId, usage: response.totalUsage } );
+    const proxiedResponse = await wrapTextResponse( { traceId, modelId, response } );
+    _onFinish?.( proxiedResponse );
+  }
+} );
+
+/**
+ * Calculates the cost and wraps an AI SDK image 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 image response
+ * @returns {object} Proxied response
+ */
+export const wrapImageResponse = async ( { traceId, modelId, response } ) => {
+  const { usage, providerMetadata } = response;
+  const cost = await calculateLLMCallCost( { usage, modelId } );
+
+  const result = response.images.map( ( { mediaType, base64 } ) => ( {
+    size: calculateBase64FileSize( base64 ),
+    mediaType
+  } ) );
 
-    endTraceWithSuccess( { traceId, modelId, response, cost } );
+  endTraceWithSuccess( { traceId, usage, cost, result, providerMetadata } );
 
-    _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 );
+  return new Proxy( response, {
+    get( target, prop, receiver ) {
+      if ( prop === 'result' ) {
+        return target.image;
       }
-    } ) );
-  }
-} );
+      if ( prop === 'cost' ) {
+        return cost;
+      }
+      return Reflect.get( target, prop, receiver );
+    }
+  } );
+};