@outputai/llm 0.11.1-next.da26845.0 → 0.12.0

package/src/utils/error_handler.spec.js

@@ -1,230 +0,0 @@
-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, TransparentFatalError } 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( 'preserves NoObjectGeneratedError with its complete schema issue details', () => {
-    class ZodError extends Error {
-      constructor( issues ) {
-        super( 'schema failed' );
-        this.issues = issues;
-      }
-    }
-    const zodError = new ZodError( [
-      {
-        path: [ 'items', 0, 'title' ],
-        message: 'Expected string'
-      }
-    ] );
-    const validationError = new Error( 'validation failed', { cause: zodError } );
-    const error = new NoObjectGeneratedError( {
-      message: 'No object generated: response did not match schema.',
-      text: '{"items":[{}]}',
-      response: { id: 'response-1' },
-      usage: { totalTokens: 10 },
-      finishReason: 'stop',
-      cause: validationError
-    } );
-
-    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 TransparentFatalError', () => {
-    const error = makeApiCallError( {
-      statusCode: 400,
-      isRetryable: false
-    } );
-
-    const result = mapAiError( error );
-
-    expect( result ).toBeInstanceOf( TransparentFatalError );
-    expect( result.cause ).toBe( error );
-  } );
-
-  it( 'maps non-retryable APICallError instances without status codes to TransparentFatalError', () => {
-    const error = makeApiCallError( {
-      isRetryable: false
-    } );
-
-    const result = mapAiError( error );
-
-    expect( result ).toBeInstanceOf( TransparentFatalError );
-    expect( result.cause ).toBe( error );
-  } );
-
-  it( 'preserves retryable APICallError instances', () => {
-    const error = makeApiCallError( {
-      statusCode: 429,
-      isRetryable: true
-    } );
-
-    expect( mapAiError( error ) ).toBe( error );
-  } );
-
-  it( 'preserves Anthropic grammar compilation timeouts as retryable activity failures', () => {
-    const error = makeApiCallError( {
-      message: 'Grammar compilation timed out.',
-      statusCode: 400,
-      isRetryable: false
-    } );
-
-    expect( mapAiError( error ) ).toBe( error );
-  } );
-
-  it.each( fatalAiSdkErrors )( 'maps %s to TransparentFatalError', ( _name, makeError ) => {
-    const error = makeError();
-
-    const result = mapAiError( error );
-
-    expect( result ).toBeInstanceOf( TransparentFatalError );
-    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/file.spec.js

@@ -1,89 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { FatalError } from '@outputai/core';
-import { searchAndReadFile } from './file.js';
-
-const dirs = [];
-
-const tempDir = () => {
-  const dir = mkdtempSync( join( tmpdir(), 'search-and-read-' ) );
-  dirs.push( dir );
-  return dir;
-};
-
-afterEach( () => {
-  for ( const dir of dirs.splice( 0 ) ) {
-    rmSync( dir, { recursive: true, force: true } );
-  }
-} );
-
-describe( 'searchAndReadFile', () => {
-  it( 'reads a file in the search directory', () => {
-    const dir = tempDir();
-    writeFileSync( join( dir, 'notes.txt' ), 'hello' );
-
-    expect( searchAndReadFile( dir, 'notes.txt' ) ).toEqual( {
-      dir,
-      content: 'hello'
-    } );
-  } );
-
-  it( 'reads a file from a nested subdirectory and returns that directory', () => {
-    const dir = tempDir();
-    const nested = join( dir, 'prompts' );
-    mkdirSync( nested );
-    writeFileSync( join( nested, 'writer@v1.prompt' ), 'Write it.' );
-
-    expect( searchAndReadFile( dir, 'writer@v1.prompt' ) ).toEqual( {
-      dir: nested,
-      content: 'Write it.'
-    } );
-  } );
-
-  it( 'continues into later siblings after a subdirectory miss', () => {
-    const dir = tempDir();
-    mkdirSync( join( dir, 'empty' ) );
-    const found = join( dir, 'found' );
-    mkdirSync( found );
-    writeFileSync( join( found, 'target.txt' ), 'here' );
-
-    expect( searchAndReadFile( dir, 'target.txt' ) ).toEqual( {
-      dir: found,
-      content: 'here'
-    } );
-  } );
-
-  it( 'skips symbolic-link directories', () => {
-    const dir = tempDir();
-    const hidden = join( dir, 'hidden' );
-    const search = join( dir, 'search' );
-    mkdirSync( hidden );
-    mkdirSync( search );
-    writeFileSync( join( hidden, 'secret.txt' ), 'nope' );
-    symlinkSync( hidden, join( search, 'link' ) );
-
-    expect( searchAndReadFile( search, 'secret.txt' ) ).toBeNull();
-  } );
-
-  it( 'returns null when the file is not found', () => {
-    const dir = tempDir();
-    writeFileSync( join( dir, 'other.txt' ), 'x' );
-
-    expect( searchAndReadFile( dir, 'missing.txt' ) ).toBeNull();
-  } );
-
-  it( 'returns null for an empty directory', () => {
-    expect( searchAndReadFile( tempDir(), 'missing.txt' ) ).toBeNull();
-  } );
-
-  it( 'throws FatalError when the search directory cannot be scanned', () => {
-    const missing = join( tempDir(), 'gone' );
-
-    expect( () => searchAndReadFile( missing, 'notes.txt' ) ).toThrow( FatalError );
-    expect( () => searchAndReadFile( missing, 'notes.txt' ) ).toThrow(
-      `Error scanning directory "${missing}"`
-    );
-  } );
-} );

package/src/utils/image.spec.js

@@ -1,20 +0,0 @@
-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/legacy_cost_attribute.spec.js

@@ -1,278 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { LLMUsageLegacy, convertCostToLegacy } from './legacy_cost_attribute.js';
-
-const MODEL_ID = 'test-model';
-const INPUT = 'input';
-const OUTPUT = 'output';
-const OK = 'ok';
-const FALLBACK = 'fallback';
-const MISSING = 'missing';
-
-const item = ( group, label, amount, ppm, total, status = OK ) => ( {
-  group,
-  label,
-  amount,
-  ppm,
-  total,
-  status
-} );
-
-const cost = items => ( { modelId: MODEL_ID, items } );
-
-describe( 'convertCostToLegacy', () => {
-  it( 'returns a legacy usage attribute instance', () => {
-    const result = convertCostToLegacy( cost( [
-      item( INPUT, null, 100, 2, 0.0002 )
-    ] ) );
-
-    expect( result ).toBeInstanceOf( LLMUsageLegacy );
-  } );
-
-  it( 'returns null without a cost', () => {
-    expect( convertCostToLegacy( null ) ).toBeNull();
-  } );
-
-  it( 'returns null when there are no cost items', () => {
-    expect( convertCostToLegacy( cost( [] ) ) ).toBeNull();
-  } );
-
-  it( 'returns null when every cost item is missing', () => {
-    expect( convertCostToLegacy( cost( [
-      item( INPUT, null, 100, null, null, MISSING ),
-      item( INPUT, 'cache_read', 20, null, null, MISSING ),
-      item( OUTPUT, null, 50, null, null, MISSING )
-    ] ) ) ).toBeNull();
-  } );
-
-  it( 'converts aggregate input and output items', () => {
-    expect( convertCostToLegacy( cost( [
-      item( INPUT, null, 100, 2, 0.0002 ),
-      item( OUTPUT, null, 50, 10, 0.0005 )
-    ] ) ) ).toEqual( {
-      type: 'llm:usage',
-      modelId: MODEL_ID,
-      usage: [
-        { type: 'input', ppm: 2, amount: 100, total: 0.0002 },
-        { type: 'output', ppm: 10, amount: 50, total: 0.0005 }
-      ],
-      total: 0.0007,
-      tokensUsed: 150
-    } );
-  } );
-
-  it( 'converts every detailed input and output item', () => {
-    expect( convertCostToLegacy( cost( [
-      item( INPUT, 'no_cache', 500_000, 4, 2 ),
-      item( INPUT, 'cache_read', 400_000, 1, 0.4 ),
-      item( INPUT, 'cache_write', 100_000, 5, 0.5 ),
-      item( OUTPUT, 'text', 200_000, 10, 2 ),
-      item( OUTPUT, 'reasoning', 50_000, 20, 1 )
-    ] ) ) ).toEqual( {
-      type: 'llm:usage',
-      modelId: MODEL_ID,
-      usage: [
-        { type: 'input', ppm: 4, amount: 600_000, total: 2.4 },
-        { type: 'input_cached', ppm: 1, amount: 400_000, total: 0.4 },
-        { type: 'output', ppm: 10, amount: 200_000, total: 2 },
-        { type: 'reasoning', ppm: 20, amount: 50_000, total: 1 }
-      ],
-      total: 5.8,
-      tokensUsed: 1_250_000
-    } );
-  } );
-
-  it( 'converts no-cache input without other input details', () => {
-    expect( convertCostToLegacy( cost( [
-      item( INPUT, 'no_cache', 100, 2, 0.0002 )
-    ] ) ) ).toEqual( {
-      type: 'llm:usage',
-      modelId: MODEL_ID,
-      usage: [
-        { type: 'input', ppm: 2, amount: 100, total: 0.0002 }
-      ],
-      total: 0.0002,
-      tokensUsed: 100
-    } );
-  } );
-
-  it( 'converts cache-write input without a no-cache item', () => {
-    expect( convertCostToLegacy( cost( [
-      item( INPUT, 'cache_write', 100, 5, 0.0005 )
-    ] ) ) ).toEqual( {
-      type: 'llm:usage',
-      modelId: MODEL_ID,
-      usage: [
-        { type: 'input', ppm: 5, amount: 100, total: 0.0005 }
-      ],
-      total: 0.0005,
-      tokensUsed: 100
-    } );
-  } );
-
-  it( 'uses no-cache ppm when folding cache-write input', () => {
-    expect( convertCostToLegacy( cost( [
-      item( INPUT, 'no_cache', 0, 2, 0 ),
-      item( INPUT, 'cache_write', 100, 5, 0.0005 )
-    ] ) ) ).toEqual( {
-      type: 'llm:usage',
-      modelId: MODEL_ID,
-      usage: [
-        { type: 'input', ppm: 2, amount: 100, total: 0.0002 }
-      ],
-      total: 0.0002,
-      tokensUsed: 100
-    } );
-  } );
-
-  it( 'converts exactly priced cache reads', () => {
-    expect( convertCostToLegacy( cost( [
-      item( INPUT, 'cache_read', 200, 1, 0.0002 )
-    ] ) ) ).toEqual( {
-      type: 'llm:usage',
-      modelId: MODEL_ID,
-      usage: [
-        { type: 'input_cached', ppm: 1, amount: 200, total: 0.0002 }
-      ],
-      total: 0.0002,
-      tokensUsed: 200
-    } );
-  } );
-
-  it.each( [ FALLBACK, MISSING ] )(
-    'converts %s cache reads using the legacy zero price',
-    status => {
-      expect( convertCostToLegacy( cost( [
-        item( INPUT, 'cache_read', 200, status === FALLBACK ? 2 : null, status === FALLBACK ? 0.0004 : null, status ),
-        item( OUTPUT, null, 50, 10, 0.0005 )
-      ] ) ) ).toEqual( {
-        type: 'llm:usage',
-        modelId: MODEL_ID,
-        usage: [
-          { type: 'input_cached', ppm: 0, amount: 200, total: 0 },
-          { type: 'output', ppm: 10, amount: 50, total: 0.0005 }
-        ],
-        total: 0.0005,
-        tokensUsed: 250
-      } );
-    }
-  );
-
-  it( 'gives aggregate input precedence over detailed input items', () => {
-    expect( convertCostToLegacy( cost( [
-      item( INPUT, null, 100, 2, 0.0002 ),
-      item( INPUT, 'no_cache', 60, 2, 0.00012 ),
-      item( INPUT, 'cache_read', 20, 1, 0.00002 ),
-      item( INPUT, 'cache_write', 20, 3, 0.00006 )
-    ] ) ) ).toEqual( {
-      type: 'llm:usage',
-      modelId: MODEL_ID,
-      usage: [
-        { type: 'input', ppm: 2, amount: 100, total: 0.0002 }
-      ],
-      total: 0.0002,
-      tokensUsed: 100
-    } );
-  } );
-
-  it( 'converts text output without reasoning', () => {
-    expect( convertCostToLegacy( cost( [
-      item( OUTPUT, 'text', 50, 10, 0.0005 )
-    ] ) ) ).toEqual( {
-      type: 'llm:usage',
-      modelId: MODEL_ID,
-      usage: [
-        { type: 'output', ppm: 10, amount: 50, total: 0.0005 }
-      ],
-      total: 0.0005,
-      tokensUsed: 50
-    } );
-  } );
-
-  it( 'converts reasoning output without text', () => {
-    expect( convertCostToLegacy( cost( [
-      item( OUTPUT, 'reasoning', 50, 20, 0.001 )
-    ] ) ) ).toEqual( {
-      type: 'llm:usage',
-      modelId: MODEL_ID,
-      usage: [
-        { type: 'reasoning', ppm: 20, amount: 50, total: 0.001 }
-      ],
-      total: 0.001,
-      tokensUsed: 50
-    } );
-  } );
-
-  it( 'gives aggregate output precedence over detailed output items', () => {
-    expect( convertCostToLegacy( cost( [
-      item( OUTPUT, null, 70, 10, 0.0007 ),
-      item( OUTPUT, 'text', 20, 10, 0.0002 ),
-      item( OUTPUT, 'reasoning', 50, 20, 0.001 )
-    ] ) ) ).toEqual( {
-      type: 'llm:usage',
-      modelId: MODEL_ID,
-      usage: [
-        { type: 'output', ppm: 10, amount: 70, total: 0.0007 }
-      ],
-      total: 0.0007,
-      tokensUsed: 70
-    } );
-  } );
-
-  it( 'omits unpriced aggregate and detailed items from a partially priced cost', () => {
-    expect( convertCostToLegacy( cost( [
-      item( INPUT, null, 100, null, null, MISSING ),
-      item( INPUT, 'no_cache', 100, null, null, MISSING ),
-      item( INPUT, 'cache_write', 20, null, null, MISSING ),
-      item( OUTPUT, null, 50, null, null, MISSING ),
-      item( OUTPUT, 'text', 40, null, null, MISSING ),
-      item( OUTPUT, 'reasoning', 10, null, null, MISSING ),
-      item( INPUT, 'cache_read', 25, null, null, MISSING ),
-      item( OUTPUT, 'text', 5, 10, 0.00005, OK )
-    ] ) ) ).toEqual( {
-      type: 'llm:usage',
-      modelId: MODEL_ID,
-      usage: [
-        { type: 'input_cached', ppm: 0, amount: 25, total: 0 },
-        { type: 'output', ppm: 10, amount: 5, total: 0.00005 }
-      ],
-      total: 0.00005,
-      tokensUsed: 30
-    } );
-  } );
-
-  it( 'preserves zero amounts and prices', () => {
-    expect( convertCostToLegacy( cost( [
-      item( INPUT, 'no_cache', 0, 0, 0 ),
-      item( INPUT, 'cache_read', 0, 0, 0 ),
-      item( OUTPUT, 'text', 0, 0, 0 ),
-      item( OUTPUT, 'reasoning', 0, 0, 0 )
-    ] ) ) ).toEqual( {
-      type: 'llm:usage',
-      modelId: MODEL_ID,
-      usage: [
-        { type: 'input', ppm: 0, amount: 0, total: 0 },
-        { type: 'input_cached', ppm: 0, amount: 0, total: 0 },
-        { type: 'output', ppm: 0, amount: 0, total: 0 },
-        { type: 'reasoning', ppm: 0, amount: 0, total: 0 }
-      ],
-      total: 0,
-      tokensUsed: 0
-    } );
-  } );
-
-  it( 'recalculates line and aggregate totals from amount and ppm', () => {
-    expect( convertCostToLegacy( cost( [
-      item( INPUT, null, 333_333, 3, 999 ),
-      item( OUTPUT, null, 100_000, 7, 999 )
-    ] ) ) ).toEqual( {
-      type: 'llm:usage',
-      modelId: MODEL_ID,
-      usage: [
-        { type: 'input', ppm: 3, amount: 333_333, total: 0.999999 },
-        { type: 'output', ppm: 7, amount: 100_000, total: 0.7 }
-      ],
-      total: 1.699999,
-      tokensUsed: 433_333
-    } );
-  } );
-} );