@outputai/llm 0.9.1-next.ca5a2f9.0 → 0.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/llm",
-  "version": "0.9.1-next.ca5a2f9.0",
+  "version": "0.9.1",
   "description": "Framework abstraction to interact with LLM models",
   "type": "module",
   "main": "src/index.js",
@@ -13,7 +13,7 @@
     "gray-matter": "4.0.3",
     "liquidjs": "10.25.7",
     "undici": "8.5.0",
-    "@outputai/core": "0.9.1-next.ca5a2f9.0"
+    "@outputai/core": "0.9.1"
   },
   "devDependencies": {
     "@ai-sdk/amazon-bedrock": "4.0.111",

package/src/ai_provider.js

@@ -1,5 +1,5 @@
 import { FatalError, ValidationError, z } from '@outputai/core';
-import { Agent, fetch } from 'undici';
+import { EnvHttpProxyAgent, fetch } from 'undici';
 // providers
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { createAzure } from '@ai-sdk/azure';
@@ -8,10 +8,11 @@ import { createOpenAI } from '@ai-sdk/openai';
 import { createPerplexity } from '@ai-sdk/perplexity';
 import { createVertex } from '@ai-sdk/google-vertex';
 
-/** This custom dispatcher has longer timeouts */
-const customDispatcher = new Agent( {
+/** This custom dispatcher has longer timeouts. */
+const customDispatcher = new EnvHttpProxyAgent( {
   headersTimeout: 15 * 60 * 1000, // 15 min
-  bodyTimeout: 15 * 60 * 1000
+  bodyTimeout: 15 * 60 * 1000,
+  allowH2: false // Ignore HTTP/2. Check: https://github.com/growthxai/output/issues/299
 } );
 
 /** This custom fetch instance uses the custom dispatcher */

package/src/ai_provider.spec.js

@@ -18,7 +18,14 @@ const makeProviderModules = () => Object.fromEntries(
   ] )
 );
 
-const importWithMockedProviders = async ( modules = makeProviderModules() ) => {
+const undiciSpies = vi.hoisted( () => ( {
+  EnvHttpProxyAgent: vi.fn(),
+  fetch: vi.fn()
+} ) );
+
+const importWithMockedProviders = async ( {
+  modules = makeProviderModules()
+} = {} ) => {
   await vi.resetModules();
 
   for ( const { pkg, exportName } of SHIPPED_PROVIDERS ) {
@@ -27,6 +34,20 @@ const importWithMockedProviders = async ( modules = makeProviderModules() ) => {
     } ) );
   }
 
+  vi.doMock( 'undici', async importOriginal => {
+    const actual = await importOriginal();
+    undiciSpies.EnvHttpProxyAgent.mockImplementation( function EnvHttpProxyAgent( options ) {
+      return new actual.EnvHttpProxyAgent( options );
+    } );
+    undiciSpies.fetch.mockResolvedValue( new actual.Response( null, { status: 204 } ) );
+
+    return {
+      ...actual,
+      EnvHttpProxyAgent: undiciSpies.EnvHttpProxyAgent,
+      fetch: undiciSpies.fetch
+    };
+  } );
+
   return {
     modules,
     ...( await import( './ai_provider.js' ) )
@@ -37,6 +58,9 @@ afterEach( () => {
   for ( const { pkg } of SHIPPED_PROVIDERS ) {
     vi.doUnmock( pkg );
   }
+  vi.doUnmock( 'undici' );
+  undiciSpies.EnvHttpProxyAgent.mockReset();
+  undiciSpies.fetch.mockReset();
   vi.resetModules();
   vi.restoreAllMocks();
 } );
@@ -59,6 +83,41 @@ describe( 'getProvider', () => {
       expect( provider ).toMatchObject( { name, options: { fetch: expect.any( Function ) } } );
       expect( modules[pkg][exportName] ).toHaveBeenCalledWith( { fetch: expect.any( Function ) } );
     }
+
+    expect( undiciSpies.EnvHttpProxyAgent ).toHaveBeenCalledWith( {
+      headersTimeout: 15 * 60 * 1000,
+      bodyTimeout: 15 * 60 * 1000,
+      allowH2: false
+    } );
+  } );
+
+  it( 'passes the custom dispatcher through injected fetch', async () => {
+    const { getProvider } = await importWithMockedProviders();
+    const provider = getProvider( 'openai' );
+    const init = { method: 'POST', body: 'body' };
+
+    await provider.options.fetch( 'https://api.example.test', init );
+
+    expect( undiciSpies.fetch ).toHaveBeenCalledWith(
+      'https://api.example.test',
+      {
+        ...init,
+        dispatcher: undiciSpies.EnvHttpProxyAgent.mock.results[0].value
+      }
+    );
+  } );
+
+  it( 'allows injected fetch callers to override the dispatcher', async () => {
+    const { getProvider } = await importWithMockedProviders();
+    const provider = getProvider( 'openai' );
+    const dispatcher = { name: 'custom-dispatcher' };
+
+    await provider.options.fetch( 'https://api.example.test', { dispatcher } );
+
+    expect( undiciSpies.fetch ).toHaveBeenCalledWith(
+      'https://api.example.test',
+      { dispatcher }
+    );
   } );
 
   it( 'can import and initialize all installed shipped providers', async () => {
@@ -100,7 +159,7 @@ describe( 'getProvider', () => {
     modules['@ai-sdk/openai'].createOpenAI.mockImplementation( () => {
       throw new Error( 'Missing OpenAI API key' );
     } );
-    const { getProvider } = await importWithMockedProviders( modules );
+    const { getProvider } = await importWithMockedProviders( { modules } );
 
     expect( () => getProvider( 'openai' ) ).toThrow(
       'Failed to initialize provider "openai": Missing OpenAI API key'

package/src/cost/fetch_models_pricing.js

@@ -1,8 +1,13 @@
 import { Logger } from '@outputai/core';
+import { EnvHttpProxyAgent, fetch } from 'undici';
 
+const logger = Logger.createLogger( 'LLM' );
 const costTableUrl = 'https://models.dev/api.json';
 const cacheTTL = 1000 * 60 * 60 * 24; // 1 day
 
+/* Ignore HTTP/2. Check: https://github.com/growthxai/output/issues/299 */
+const dispatcher = new EnvHttpProxyAgent( { allowH2: false } );
+
 export const cache = {
   content: null,
   expiresAt: 0
@@ -21,20 +26,36 @@ const buildModelMap = data => {
   return map;
 };
 
+const buildErrorMessage = cause => `Error "${cause}" when fetching models pricing at ${costTableUrl}`;
+
 export const fetchModelsPricing = async () => {
   if ( cache.content && cache.expiresAt > Date.now() ) {
     return cache.content;
   }
-  const res = await fetch( costTableUrl );
-  if ( !res.ok ) {
+
+  const state = { errorMessage: null, table: null };
+
+  try {
+    const res = await fetch( costTableUrl, { dispatcher } );
+    if ( res.ok ) {
+      state.table = await res.json();
+    } else {
+      state.errorMessage = buildErrorMessage( res.status );
+    }
+  } catch ( error ) {
+    state.errorMessage = buildErrorMessage( error.code ?? error.name ?? error.constructor.name );
+  }
+
+  if ( state.errorMessage ) {
     if ( cache.content ) {
-      Logger.warn( `Error ${res.status} when fetching models pricing at ${costTableUrl}, falling back to stale cache`, { namespace: 'LLM' } );
+      logger.warn( state.errorMessage + ', falling back to stale cache' );
       return cache.content;
     }
-    Logger.error( `Error ${res.status} when fetching models pricing at ${costTableUrl}`, { namespace: 'LLM' } );
+    logger.error( state.errorMessage );
     return null;
   }
-  cache.content = buildModelMap( await res.json() );
+
+  cache.content = buildModelMap( state.table );
   cache.expiresAt = Date.now() + cacheTTL;
   return cache.content;
 };

package/src/cost/fetch_models_pricing.spec.js

@@ -4,6 +4,16 @@ import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { fetchModelsPricing, cache } from './fetch_models_pricing.js';
 
+const fetchMock = vi.hoisted( () => vi.fn() );
+const EnvHttpProxyAgentMock = vi.hoisted( () => vi.fn( function EnvHttpProxyAgent( options ) {
+  this.options = options;
+} ) );
+
+vi.mock( 'undici', () => ( {
+  EnvHttpProxyAgent: EnvHttpProxyAgentMock,
+  fetch: fetchMock
+} ) );
+
 const __dirname = dirname( fileURLToPath( import.meta.url ) );
 const fixturePath = join( __dirname, 'fixtures', 'models_api_light.json' );
 const fixture = JSON.parse( readFileSync( fixturePath, 'utf8' ) );
@@ -14,8 +24,7 @@ const okResponse = data => ( {
   json: () => Promise.resolve( data )
 } );
 const stubFetch = response => {
-  const fetchMock = vi.fn().mockResolvedValue( response );
-  vi.stubGlobal( 'fetch', fetchMock );
+  fetchMock.mockResolvedValueOnce( response );
   return fetchMock;
 };
 
@@ -23,7 +32,7 @@ describe( 'fetchModelsPricing', () => {
   beforeEach( () => {
     cache.content = null;
     cache.expiresAt = 0;
-    vi.unstubAllGlobals();
+    fetchMock.mockReset();
   } );
 
   it( 'returns a Map of model costs when fetch succeeds', async () => {
@@ -31,7 +40,8 @@ describe( 'fetchModelsPricing', () => {
 
     const result = await fetchModelsPricing();
 
-    expect( fetchMock ).toHaveBeenCalledWith( costTableUrl );
+    expect( EnvHttpProxyAgentMock ).toHaveBeenCalledWith( { allowH2: false } );
+    expect( fetchMock ).toHaveBeenCalledWith( costTableUrl, { dispatcher: EnvHttpProxyAgentMock.mock.results[0].value } );
     expect( result ).toBeInstanceOf( Map );
     expect( result.size ).toBeGreaterThan( 0 );
     const firstModel = Object.values( fixture )[0];
@@ -78,6 +88,43 @@ describe( 'fetchModelsPricing', () => {
     expect( result.size ).toBeGreaterThan( 0 );
   } );
 
+  it( 'returns null when fetch rejects and no cache', async () => {
+    const error = new Error( 'network failure' );
+    fetchMock.mockRejectedValueOnce( error );
+
+    const result = await fetchModelsPricing();
+
+    expect( result ).toBeNull();
+  } );
+
+  it( 'returns stale cache when fetch rejects but cache exists', async () => {
+    stubFetch( okResponse( fixture ) );
+    const staleCache = await fetchModelsPricing();
+    cache.expiresAt = 0; // force refetch so we hit the catch path
+
+    const error = Object.assign( new Error( 'socket closed' ), { code: 'UND_ERR_SOCKET' } );
+    fetchMock.mockRejectedValueOnce( error );
+
+    const result = await fetchModelsPricing();
+
+    expect( result ).toBe( staleCache );
+  } );
+
+  it( 'returns stale cache when response JSON parsing fails but cache exists', async () => {
+    stubFetch( okResponse( fixture ) );
+    const staleCache = await fetchModelsPricing();
+    cache.expiresAt = 0; // force refetch so parsing errors can fall back to cache
+
+    stubFetch( {
+      ok: true,
+      json: () => Promise.reject( new SyntaxError( 'Unexpected token' ) )
+    } );
+
+    const result = await fetchModelsPricing();
+
+    expect( result ).toBe( staleCache );
+  } );
+
   it( 'returns cached Map when cache is still valid', async () => {
     const fetchMock = stubFetch( okResponse( fixture ) );