@outputai/llm 0.2.1-next.fd72d95.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/llm",
-  "version": "0.2.1-next.fd72d95.0",
+  "version": "0.3.0",
   "description": "Framework abstraction to interact with LLM models",
   "type": "module",
   "main": "src/index.js",
@@ -9,20 +9,20 @@
     "./src"
   ],
   "dependencies": {
-    "@ai-sdk/amazon-bedrock": "4.0.95",
+    "@ai-sdk/amazon-bedrock": "4.0.96",
     "@ai-sdk/anthropic": "3.0.71",
     "@ai-sdk/azure": "3.0.54",
     "@ai-sdk/google-vertex": "4.0.112",
     "@ai-sdk/openai": "3.0.53",
     "@ai-sdk/perplexity": "3.0.29",
     "@exalabs/ai-sdk": "2.0.1",
-    "@perplexity-ai/ai-sdk": "0.1.2",
+    "@perplexity-ai/ai-sdk": "0.1.3",
     "@tavily/ai-sdk": "0.4.1",
     "ai": "6.0.168",
     "decimal.js": "10.6.0",
     "gray-matter": "4.0.3",
-    "liquidjs": "10.25.5",
-    "@outputai/core": "0.2.1-next.fd72d95.0"
+    "liquidjs": "10.25.7",
+    "@outputai/core": "0.3.0"
   },
   "license": "Apache-2.0",
   "publishConfig": {

package/src/agent.js

@@ -2,9 +2,9 @@ import { ValidationError } from '@outputai/core';
 import { resolveInvocationDir } from '@outputai/core/sdk_utils';
 import { ToolLoopAgent as AIToolLoopAgent, stepCountIs } from 'ai';
 import { hydratePromptTemplate, loadAiSdkOptionsFromPrompt } from './ai_sdk.js';
-import { startTrace, endTraceWithError, traceStreamCallbacks } from './trace_utils.js';
-import { wrapInOutputResponse } from './response_utils.js';
-import { ROLE, isRole, getContent } from './message_utils.js';
+import { startTrace, endTraceWithError } from './utils/trace.js';
+import { wrapTextResponse, wrapStreamOnFinishResponse } from './utils/response_wrappers.js';
+import { ROLE, isRole, getContent } from './utils/message.js';
 
 export { skill } from './skill.js';
 
@@ -17,10 +17,10 @@ export const createMemoryConversationStore = () => {
 };
 
 export class Agent extends AIToolLoopAgent {
-  _prompt;
-  _modelId;
-  _initialMessages;
-  _store;
+  #prompt;
+  #modelId;
+  #initialMessages;
+  #store;
 
   constructor( {
     prompt, promptDir, variables = {}, skills = [], tools = {},
@@ -52,48 +52,52 @@ export class Agent extends AIToolLoopAgent {
       ...rest
     } );
 
-    this._prompt = prompt;
-    this._modelId = loadedPrompt.config.model;
-    this._initialMessages = allMessages.filter( isRole( ROLE.USER ) );
-    this._store = conversationStore ?? null;
+    this.#prompt = prompt;
+    this.#modelId = loadedPrompt.config.model;
+    this.#initialMessages = allMessages.filter( isRole( ROLE.USER ) );
+    this.#store = conversationStore ?? null;
   }
 
-  async _preSendHook( userMessages ) {
-    const priorMessages = this._store ? await this._store.getMessages() : [];
-    return [ ...this._initialMessages, ...priorMessages, ...userMessages ];
+  async #fetchMessages( userMessages ) {
+    const priorMessages = this.#store ? await this.#store.getMessages() : [];
+    return [ ...this.#initialMessages, ...priorMessages, ...userMessages ];
   }
 
-  async _postSendHook( userMessages, result ) {
-    if ( this._store ) {
-      await this._store.addMessages( [ ...userMessages, ...( result.response?.messages ?? [] ) ] );
+  async #storeMessages( userMessages, result ) {
+    if ( this.#store ) {
+      await this.#store.addMessages( [ ...userMessages, ...( result.response?.messages ?? [] ) ] );
     }
   }
 
   async generate( { messages: userMessages = [], ...callOptions } = {} ) {
-    const traceId = startTrace( 'Agent.generate', { prompt: this._prompt } );
+    const traceId = startTrace( { name: 'Agent.generate', prompt: this.#prompt } );
     try {
-      const messages = await this._preSendHook( userMessages );
-      const result = await super.generate( { messages, ...callOptions } );
-      const wrapped = await wrapInOutputResponse( result, { traceId, modelId: this._modelId } );
-      await this._postSendHook( userMessages, wrapped );
+      const messages = await this.#fetchMessages( userMessages );
+      const response = await super.generate( { messages, ...callOptions } );
+      const wrapped = await wrapTextResponse( { traceId, response, modelId: this.#modelId } );
+      await this.#storeMessages( userMessages, wrapped );
       return wrapped;
     } catch ( error ) {
-      endTraceWithError( traceId, error );
+      endTraceWithError( { traceId, error } );
       throw error;
     }
   }
 
   async stream( { messages: userMessages = [], onFinish, onError, ...callOptions } = {} ) {
-    const traceId = startTrace( 'Agent.stream', { prompt: this._prompt } );
+    const traceId = startTrace( { name: 'Agent.stream', prompt: this.#prompt } );
     try {
-      const messages = await this._preSendHook( userMessages );
+      const messages = await this.#fetchMessages( userMessages );
       return super.stream( {
         messages,
         ...callOptions,
-        ...traceStreamCallbacks( traceId, this._modelId, { onFinish, onError } )
+        ...wrapStreamOnFinishResponse( { traceId, modelId: this.#modelId, onFinish } ),
+        onError( event ) {
+          endTraceWithError( { traceId, error: event.error } );
+          onError?.( event );
+        }
       } );
     } catch ( error ) {
-      endTraceWithError( traceId, error );
+      endTraceWithError( { traceId, error } );
       throw error;
     }
   }

package/src/agent.spec.js

@@ -45,16 +45,16 @@ vi.mock( './ai_sdk.js', () => ( {
 
 const startTraceImpl = vi.fn( () => 'trace-id' );
 const endTraceWithErrorImpl = vi.fn();
-const traceStreamCallbacksImpl = vi.fn( () => ( {} ) );
-vi.mock( './trace_utils.js', () => ( {
+vi.mock( './utils/trace.js', () => ( {
   startTrace: ( ...args ) => startTraceImpl( ...args ),
-  endTraceWithError: ( ...args ) => endTraceWithErrorImpl( ...args ),
-  traceStreamCallbacks: ( ...args ) => traceStreamCallbacksImpl( ...args )
+  endTraceWithError: ( ...args ) => endTraceWithErrorImpl( ...args )
 } ) );
 
-const wrapInOutputResponseImpl = vi.fn( response => response );
-vi.mock( './response_utils.js', () => ( {
-  wrapInOutputResponse: ( ...args ) => wrapInOutputResponseImpl( ...args )
+const wrapTextResponseImpl = vi.fn( async ( { response } ) => response );
+const wrapStreamOnFinishResponseImpl = vi.fn( () => ( {} ) );
+vi.mock( './utils/response_wrappers.js', () => ( {
+  wrapTextResponse: ( ...args ) => wrapTextResponseImpl( ...args ),
+  wrapStreamOnFinishResponse: ( ...args ) => wrapStreamOnFinishResponseImpl( ...args )
 } ) );
 
 vi.mock( './skill.js', () => ( {
@@ -88,6 +88,8 @@ beforeEach( () => {
   } );
   superGenerateImpl.mockResolvedValue( { text: 'response', response: { messages: [] } } );
   superStreamImpl.mockReturnValue( { textStream: 'stream' } );
+  wrapTextResponseImpl.mockImplementation( async ( { response } ) => response );
+  wrapStreamOnFinishResponseImpl.mockReturnValue( {} );
 } );
 
 // ─── Tests ────────────────────────────────────────────────────────────────────
@@ -263,14 +265,44 @@ describe( 'createMemoryConversationStore()', () => {
   } );
 } );
 
+describe( 'Agent — utils delegation', () => {
+  it( 'generate() calls trace and wrapTextResponse with model id and response', async () => {
+    const { Agent } = await importSut();
+    const agent = new Agent( { prompt: 'test@v1' } );
+    await agent.generate( { messages: [ { role: 'user', content: 'hi' } ] } );
+
+    expect( startTraceImpl ).toHaveBeenCalledWith( { name: 'Agent.generate', prompt: 'test@v1' } );
+    expect( wrapTextResponseImpl ).toHaveBeenCalledWith( {
+      traceId: 'trace-id',
+      modelId: 'claude-sonnet-4-6',
+      response: expect.objectContaining( { text: 'response' } )
+    } );
+  } );
+
+  it( 'stream() calls trace and wrapStreamOnFinishResponse', async () => {
+    const { Agent } = await importSut();
+    const agent = new Agent( { prompt: 'test@v1' } );
+    await agent.stream();
+
+    expect( startTraceImpl ).toHaveBeenCalledWith( { name: 'Agent.stream', prompt: 'test@v1' } );
+    expect( wrapStreamOnFinishResponseImpl ).toHaveBeenCalledWith( {
+      traceId: 'trace-id',
+      modelId: 'claude-sonnet-4-6',
+      onFinish: undefined
+    } );
+  } );
+} );
+
 describe( 'Agent.stream()', () => {
   it( 'uses pre-rendered messages when no variables provided', async () => {
     const { Agent } = await importSut();
     const agent = new Agent( { prompt: 'test@v1' } );
     await agent.stream();
-    expect( superStreamImpl ).toHaveBeenCalledWith( {
-      messages: defaultMessages
-    } );
+    expect( superStreamImpl ).toHaveBeenCalledWith(
+      expect.objectContaining( {
+        messages: defaultMessages
+      } )
+    );
   } );
 
   it( 'loads prior messages from store', async () => {
@@ -284,9 +316,11 @@ describe( 'Agent.stream()', () => {
     const agent = new Agent( { prompt: 'test@v1', conversationStore: store } );
     await agent.stream( { messages: [ { role: 'user', content: 'new' } ] } );
 
-    expect( superStreamImpl ).toHaveBeenCalledWith( {
-      messages: [ ...defaultMessages, ...priorMessages, { role: 'user', content: 'new' } ]
-    } );
+    expect( superStreamImpl ).toHaveBeenCalledWith(
+      expect.objectContaining( {
+        messages: [ ...defaultMessages, ...priorMessages, { role: 'user', content: 'new' } ]
+      } )
+    );
   } );
 
   it( 'does not auto-append to store', async () => {

package/src/ai_sdk.js

@@ -4,8 +4,8 @@ import { stepCountIs } from 'ai';
 import { validateGenerateTextArgs, validateStreamTextArgs } from './validations.js';
 import { loadPrompt } from './prompt_loader.js';
 import { buildSystemSkillsVar, buildLoadSkillTool, loadPromptSkills, loadColocatedSkills } from './skill.js';
-import { startTrace, endTraceWithError, traceStreamCallbacks } from './trace_utils.js';
-import { wrapInOutputResponse } from './response_utils.js';
+import { startTrace, endTraceWithError } from './utils/trace.js';
+import { wrapTextResponse, wrapStreamOnFinishResponse } from './utils/response_wrappers.js';
 
 export const loadAiSdkOptionsFromPrompt = prompt => {
   const options = {
@@ -72,7 +72,7 @@ export async function generateText( { prompt, variables, promptDir, skills = [],
 
   validateGenerateTextArgs( { prompt, variables: allVariables } );
 
-  const traceId = startTrace( 'generateText', { prompt, variables: allVariables, loadedPrompt } );
+  const traceId = startTrace( { name: 'generateText', prompt, variables: allVariables, loadedPrompt } );
   const { model: modelId } = loadedPrompt.config;
 
   try {
@@ -82,9 +82,9 @@ export async function generateText( { prompt, variables, promptDir, skills = [],
       ...( hasTools ? { tools } : {} ),
       ...( hasTools && !extraAiSdkOptions.stopWhen ? { stopWhen: stepCountIs( maxSteps ) } : {} )
     } );
-    return wrapInOutputResponse( response, { traceId, modelId } );
+    return wrapTextResponse( { traceId, modelId, response } );
   } catch ( error ) {
-    endTraceWithError( traceId, error );
+    endTraceWithError( { traceId, error } );
     throw error;
   }
 }
@@ -92,17 +92,21 @@ export async function generateText( { prompt, variables, promptDir, skills = [],
 export function streamText( { prompt, variables, onFinish, onError, ...restOptions } ) {
   validateStreamTextArgs( { prompt, variables } );
   const loadedPrompt = loadPrompt( prompt, variables );
-  const traceId = startTrace( 'streamText', { prompt, variables, loadedPrompt } );
+  const traceId = startTrace( { name: 'streamText', prompt, variables, loadedPrompt } );
   const { model: modelId } = loadedPrompt.config;
 
   try {
     return AI.streamText( {
       ...loadAiSdkOptionsFromPrompt( loadedPrompt ),
       ...restOptions,
-      ...traceStreamCallbacks( traceId, modelId, { onFinish, onError } )
+      ...wrapStreamOnFinishResponse( { traceId, modelId, onFinish } ),
+      onError( event ) {
+        endTraceWithError( { traceId, error: event.error } );
+        onError?.( event );
+      }
     } );
   } catch ( error ) {
-    endTraceWithError( traceId, error );
+    endTraceWithError( { traceId, error } );
     throw error;
   }
 }