@output.ai/llm 0.2.13 → 0.3.0-dev.pr341-d46aaf1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/llm",
-  "version": "0.2.13",
+  "version": "0.3.0-dev.pr341-d46aaf1",
   "description": "Framework abstraction to interact with LLM models",
   "type": "module",
   "main": "src/index.js",
@@ -9,12 +9,12 @@
     "./src"
   ],
   "dependencies": {
-    "@ai-sdk/anthropic": "2.0.28",
-    "@ai-sdk/azure": "2.0.53",
-    "@ai-sdk/google-vertex": "3.0.96",
-    "@ai-sdk/openai": "2.0.52",
-    "@output.ai/core": ">=0.0.1",
-    "ai": "5.0.52",
+    "@ai-sdk/anthropic": "3.0.43",
+    "@ai-sdk/azure": "3.0.29",
+    "@ai-sdk/google-vertex": "4.0.57",
+    "@ai-sdk/openai": "3.0.28",
+    "@output.ai/core": "^0.5.2",
+    "ai": "6.0.84",
     "gray-matter": "4.0.3",
     "liquidjs": "10.22.0"
   },

package/src/ai_model.js

@@ -3,7 +3,30 @@ import { azure } from '@ai-sdk/azure';
 import { vertex } from '@ai-sdk/google-vertex';
 import { openai } from '@ai-sdk/openai';
 
-const providers = { azure, anthropic, openai, vertex };
+const builtInProviders = { azure, anthropic, openai, vertex };
+const providers = { ...builtInProviders };
+
+/** @internal Resets providers to built-in state. For testing only. */
+export function _resetProviders() {
+  for ( const key of Object.keys( providers ) ) {
+    delete providers[key];
+  }
+  Object.assign( providers, builtInProviders );
+}
+
+export function registerProvider( name, providerFn ) {
+  if ( typeof name !== 'string' || name.length === 0 ) {
+    throw new Error( 'Provider name must be a non-empty string' );
+  }
+  if ( typeof providerFn !== 'function' ) {
+    throw new Error( `Provider "${name}" must be a function that creates a model` );
+  }
+  providers[name] = providerFn;
+}
+
+export function getRegisteredProviders() {
+  return Object.keys( providers );
+}
 
 export function loadModel( prompt ) {
   const config = prompt?.config;
@@ -56,7 +79,6 @@ export function loadTools( prompt ) {
     );
   }
 
-  // Return null if empty object
   if ( Object.keys( toolsConfig ).length === 0 ) {
     return null;
   }
@@ -71,7 +93,6 @@ export function loadTools( prompt ) {
     );
   }
 
-  // Check if provider has tools object
   if ( !provider.tools || typeof provider.tools !== 'object' ) {
     throw new Error(
       `Provider "${providerName}" does not support provider-specific tools.`
@@ -81,11 +102,9 @@ export function loadTools( prompt ) {
   const tools = {};
 
   for ( const [ toolName, toolConfig ] of Object.entries( toolsConfig ) ) {
-    // Access tool factory directly from provider.tools (dynamic!)
     const toolFactory = provider.tools[toolName];
 
     if ( !toolFactory || typeof toolFactory !== 'function' ) {
-      // Dynamically list available tools for this provider
       const availableTools = Object.keys( provider.tools )
         .filter( key => typeof provider.tools[key] === 'function' )
         .join( ', ' );
@@ -103,7 +122,6 @@ export function loadTools( prompt ) {
       );
     }
 
-    // Call factory with config - this passes configuration to AI SDK
     tools[toolName] = toolFactory( toolConfig );
   }
 

package/src/ai_model.spec.js

@@ -46,7 +46,7 @@ vi.mock( '@ai-sdk/google-vertex', () => {
   return { vertex: vertexFn };
 } );
 
-import { loadModel, loadTools } from './ai_model.js';
+import { loadModel, loadTools, registerProvider, getRegisteredProviders, _resetProviders } from './ai_model.js';
 
 afterEach( async () => {
   await vi.resetModules();
@@ -600,3 +600,67 @@ describe( 'loadTools', () => {
     } );
   } );
 } );
+
+describe( 'registerProvider', () => {
+  afterEach( () => {
+    _resetProviders();
+  } );
+
+  it( 'registers a custom provider and uses it in loadModel', () => {
+    const customProvider = vi.fn( model => `custom:${model}` );
+    registerProvider( 'custom', customProvider );
+
+    const result = loadModel( { config: { provider: 'custom', model: 'my-model' } } );
+
+    expect( result ).toBe( 'custom:my-model' );
+    expect( customProvider ).toHaveBeenCalledWith( 'my-model' );
+  } );
+
+  it( 'overrides a built-in provider', () => {
+    const overrideOpenai = vi.fn( model => `override:${model}` );
+    registerProvider( 'openai', overrideOpenai );
+
+    const result = loadModel( { config: { provider: 'openai', model: 'gpt-custom' } } );
+
+    expect( result ).toBe( 'override:gpt-custom' );
+  } );
+
+  it( 'throws when name is empty string', () => {
+    expect( () => registerProvider( '', vi.fn() ) ).toThrow( 'non-empty string' );
+  } );
+
+  it( 'throws when name is not a string', () => {
+    expect( () => registerProvider( 123, vi.fn() ) ).toThrow( 'non-empty string' );
+  } );
+
+  it( 'throws when providerFn is not a function', () => {
+    expect( () => registerProvider( 'bad', 'not-a-function' ) ).toThrow( 'must be a function' );
+  } );
+
+  it( 'throws when providerFn is null', () => {
+    expect( () => registerProvider( 'bad', null ) ).toThrow( 'must be a function' );
+  } );
+} );
+
+describe( 'getRegisteredProviders', () => {
+  afterEach( () => {
+    _resetProviders();
+  } );
+
+  it( 'returns default providers', () => {
+    const providers = getRegisteredProviders();
+
+    expect( providers ).toContain( 'anthropic' );
+    expect( providers ).toContain( 'openai' );
+    expect( providers ).toContain( 'azure' );
+    expect( providers ).toContain( 'vertex' );
+  } );
+
+  it( 'includes dynamically registered providers', () => {
+    registerProvider( 'bedrock', vi.fn() );
+
+    const providers = getRegisteredProviders();
+
+    expect( providers ).toContain( 'bedrock' );
+  } );
+} );

package/src/ai_sdk.js

@@ -12,13 +12,11 @@ const traceWrapper = async ( { traceId, resultProperty, fn } ) => {
     const result = response[resultProperty];
     Tracing.addEventEnd( { id: traceId, details: { result, usage, providerMetadata } } );
 
-    // Use a Proxy to add 'result' as a unified field name without mutating the AI SDK response.
-    // This preserves the original response object (with its getters/prototype) while allowing
-    // developers to use 'result' consistently across all generate* functions.
-    // Note: Don't use spread/rest on response - AI SDK uses getters that won't copy correctly.
+    // Proxy adds unified 'result' alias and backward-compat 'object' alias without mutating the response.
+    // Don't use spread/rest on response - AI SDK uses getters that won't copy correctly.
     return new Proxy( response, {
       get( target, prop, receiver ) {
-        if ( prop === 'result' ) {
+        if ( prop === 'result' || ( prop === 'object' && resultProperty === 'output' ) ) {
           return target[resultProperty];
         }
         return Reflect.get( target, prop, receiver );
@@ -99,20 +97,15 @@ export async function generateText( { prompt, variables, ...extraAiSdkOptions }
 /**
  * Use an LLM model to generate an object with a fixed schema.
  *
- * Accepts additional AI SDK options (maxRetries, seed, etc.) that are passed through
- * to the underlying provider. Options from the prompt file can be overridden at call time.
+ * @deprecated Use generateText() with Output.object({ schema }) instead:
+ *   generateText({ prompt, output: Output.object({ schema }) })
  *
  * @param {object} args - Generation arguments
  * @param {string} args.prompt - Prompt file name
  * @param {Record<string, string | number>} [args.variables] - Variables to interpolate
- * @param {z.ZodObject} args.schema - Output schema
+ * @param {z.ZodType} args.schema - Output schema
  * @param {string} [args.schemaName] - Output schema name
  * @param {string} [args.schemaDescription] - Output schema description
- * @param {number} [args.maxRetries] - Max retry attempts (default: 2)
- * @param {number} [args.seed] - Seed for deterministic output
- * @param {AbortSignal} [args.abortSignal] - Signal to abort the request
- * @throws {ValidationError} If the prompt config is invalid (e.g., snake_case fields)
- * @throws {FatalError} If the prompt file is not found or template rendering fails
  * @returns {Promise<GenerateObjectResult>} AI SDK response with object and metadata
  */
 export async function generateObject( args ) {
@@ -122,12 +115,9 @@ export async function generateObject( args ) {
   const traceId = startTrace( 'generateObject', { prompt, variables, schema: z.toJSONSchema( schema ), loadedPrompt } );
 
   return traceWrapper( {
-    traceId, resultProperty: 'object', fn: async () =>
-      AI.generateObject( {
-        output: 'object',
-        schema,
-        schemaName,
-        schemaDescription,
+    traceId, resultProperty: 'output', fn: async () =>
+      AI.generateText( {
+        output: AI.Output.object( { schema, name: schemaName, description: schemaDescription } ),
         ...aiSdkOptionsFromPrompt( loadedPrompt ),
         ...extraAiSdkOptions
       } )
@@ -137,8 +127,8 @@ export async function generateObject( args ) {
 /**
  * Use an LLM model to generate an array of values with a fixed schema.
  *
- * Accepts additional AI SDK options (maxRetries, seed, etc.) that are passed through
- * to the underlying provider. Options from the prompt file can be overridden at call time.
+ * @deprecated Use generateText() with Output.array({ element }) instead:
+ *   generateText({ prompt, output: Output.array({ element: schema }) })
  *
  * @param {object} args - Generation arguments
  * @param {string} args.prompt - Prompt file name
@@ -146,11 +136,6 @@ export async function generateObject( args ) {
  * @param {z.ZodType} args.schema - Output schema (array item)
  * @param {string} [args.schemaName] - Output schema name
  * @param {string} [args.schemaDescription] - Output schema description
- * @param {number} [args.maxRetries] - Max retry attempts (default: 2)
- * @param {number} [args.seed] - Seed for deterministic output
- * @param {AbortSignal} [args.abortSignal] - Signal to abort the request
- * @throws {ValidationError} If the prompt config is invalid (e.g., snake_case fields)
- * @throws {FatalError} If the prompt file is not found or template rendering fails
  * @returns {Promise<GenerateObjectResult>} AI SDK response with array and metadata
  */
 export async function generateArray( args ) {
@@ -160,12 +145,9 @@ export async function generateArray( args ) {
   const traceId = startTrace( 'generateArray', { prompt, variables, schema: z.toJSONSchema( schema ), loadedPrompt } );
 
   return traceWrapper( {
-    traceId, resultProperty: 'object', fn: async () =>
-      AI.generateObject( {
-        output: 'array',
-        schema,
-        schemaName,
-        schemaDescription,
+    traceId, resultProperty: 'output', fn: async () =>
+      AI.generateText( {
+        output: AI.Output.array( { element: schema, name: schemaName, description: schemaDescription } ),
         ...aiSdkOptionsFromPrompt( loadedPrompt ),
         ...extraAiSdkOptions
       } )
@@ -175,18 +157,13 @@ export async function generateArray( args ) {
 /**
  * Use an LLM model to generate a result from an enum (array of string values).
  *
- * Accepts additional AI SDK options (maxRetries, seed, etc.) that are passed through
- * to the underlying provider. Options from the prompt file can be overridden at call time.
+ * @deprecated Use generateText() with Output.choice({ options }) instead:
+ *   generateText({ prompt, output: Output.choice({ options: enumValues }) })
  *
  * @param {object} args - Generation arguments
  * @param {string} args.prompt - Prompt file name
  * @param {Record<string, string | number>} [args.variables] - Variables to interpolate
  * @param {string[]} args.enum - Allowed values for the generation
- * @param {number} [args.maxRetries] - Max retry attempts (default: 2)
- * @param {number} [args.seed] - Seed for deterministic output
- * @param {AbortSignal} [args.abortSignal] - Signal to abort the request
- * @throws {ValidationError} If the prompt config is invalid (e.g., snake_case fields)
- * @throws {FatalError} If the prompt file is not found or template rendering fails
  * @returns {Promise<GenerateObjectResult>} AI SDK response with enum value and metadata
  */
 export async function generateEnum( args ) {
@@ -196,10 +173,9 @@ export async function generateEnum( args ) {
   const traceId = startTrace( 'generateEnum', { prompt, variables, loadedPrompt } );
 
   return traceWrapper( {
-    traceId, resultProperty: 'object', fn: async () =>
-      AI.generateObject( {
-        output: 'enum',
-        enum: _enum,
+    traceId, resultProperty: 'output', fn: async () =>
+      AI.generateText( {
+        output: AI.Output.choice( { options: _enum } ),
         ...aiSdkOptionsFromPrompt( loadedPrompt ),
         ...extraAiSdkOptions
       } )