@outputai/llm 0.11.0 → 0.11.1-next.2223fa5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/llm",
-  "version": "0.11.0",
+  "version": "0.11.1-next.2223fa5.0",
   "description": "Framework abstraction to interact with LLM models",
   "type": "module",
   "main": "src/index.js",
@@ -16,7 +16,7 @@
     "gray-matter": "4.0.3",
     "liquidjs": "10.27.2",
     "undici": "8.9.0",
-    "@outputai/core": "0.11.0"
+    "@outputai/core": "0.11.1-next.2223fa5.0"
   },
   "devDependencies": {
     "@ai-sdk/amazon-bedrock": "4.0.138",

package/src/agent.js

@@ -1,112 +1,134 @@
-import { ValidationError } from '@outputai/core';
-import { Path } from '@outputai/core/sdk/helpers';
-import { ToolLoopAgent as AIToolLoopAgent, stepCountIs } from 'ai';
+import { ToolLoopAgent as AIToolLoopAgent } from 'ai';
 import { loadAiSdkTextOptions } from './ai_sdk_options.js';
-import { prepareTextPrompt } from './prompt/prepare_text.js';
-import { startTrace, endTraceWithError } from './utils/trace.js';
-import { wrapTextResponse, wrapStreamOnFinishResponse } from './utils/response_wrappers.js';
-import { ROLE, isRole } from './utils/message.js';
-export { skill } from './prompt/skill.js';
-
-export const createMemoryConversationStore = () => {
-  const messages = [];
-  return {
-    getMessages: () => messages,
-    addMessages: newMessages => messages.push( ...newMessages )
-  };
-};
+import { wrapGeneration, wrapStream } from './utils/wrap.js';
+import { Role } from './consts.js';
+import { drainStream } from './utils/stream.js';
+import { loadPrompt } from './prompt/loader.js';
+import { loadSkills } from './utils/skills.js';
+import * as Validator from './validations.js';
+import { Logger } from '@outputai/core';
 
 export class Agent extends AIToolLoopAgent {
   #prompt;
-  #modelId;
-  #providerId;
   #initialMessages;
   #store;
 
-  constructor( {
-    prompt,
-    promptDir,
-    variables = {},
-    skills = [],
-    tools: toolsArg,
-    stopWhen,
-    maxSteps = 10,
-    conversationStore,
-    ...rest
-  } ) {
-    if ( !prompt ) {
-      throw new ValidationError( 'Agent requires a prompt' );
-    }
-
-    // Must be captured synchronously — Temporal async activity execution
-    // breaks the call stack, so Path.resolveInvocationDir() fails if called lazily.
-    const resolvedPromptDir = promptDir ?? Path.resolveInvocationDir();
+  constructor( args ) {
+    const { promptFile, promptDir, variables, tools, output, stopWhen, messageStore } = Validator.parseAgentArgs( args );
 
-    const { loadedPrompt, tools } = prepareTextPrompt( { prompt, variables, promptDir: resolvedPromptDir, skills, tools: toolsArg } );
+    const prompt = loadPrompt( promptFile, variables, promptDir );
+    const skills = loadSkills( prompt );
 
-    const { system, messages, ...constructorOptions } = loadAiSdkTextOptions( loadedPrompt );
+    const { system, messages, ...aiOptions } = loadAiSdkTextOptions( { prompt, skills, tools, output, stopWhen } );
 
     // loadAiSdkTextOptions routes system blocks to the `system` slot (preserving
     // per-message providerOptions); pass them as the agent's `instructions`.
     super( {
-      ...constructorOptions,
-      ...( system.length > 0 ? { instructions: system } : {} ),
-      ...( tools ? { tools } : {} ),
-      stopWhen: stopWhen ?? stepCountIs( maxSteps ),
-      ...rest
+      ...aiOptions,
+      ...( system.length > 0 ? { instructions: system } : {} )
     } );
 
     this.#prompt = prompt;
-    this.#modelId = loadedPrompt.config.model;
-    this.#providerId = loadedPrompt.config.provider;
-    // `messages` is system-free but may still hold authored <assistant>/<tool>
-    // blocks; seed only <user> turns into each generate()/stream() call.
-    this.#initialMessages = messages.filter( isRole( ROLE.USER ) );
-    this.#store = conversationStore ?? null;
+    // `messages` is system-free but may still hold authored <assistant> blocks;
+    // seed only <user> turns into each generate()/stream() call.
+    this.#initialMessages = messages.filter( m => m.role === Role.USER );
+    this.#store = messageStore ?? null;
   }
 
-  async #fetchMessages( userMessages ) {
-    const priorMessages = this.#store ? await this.#store.getMessages() : [];
-    return [ ...this.#initialMessages, ...priorMessages, ...userMessages ];
+  async #combineWithPreviousMessages( messages ) {
+    return [ ...this.#initialMessages, ...( await this.#store?.getMessages() ?? [] ), ...messages ];
   }
 
-  async #storeMessages( userMessages, result ) {
+  async #storeMessages( messages ) {
     if ( this.#store ) {
-      await this.#store.addMessages( [ ...userMessages, ...( result.response?.messages ?? [] ) ] );
+      await this.#store.addMessages( messages );
     }
   }
 
-  async generate( { messages: userMessages = [], ...callOptions } = {} ) {
-    const traceId = startTrace( { name: 'Agent.generate', prompt: this.#prompt } );
-    try {
-      const messages = await this.#fetchMessages( userMessages );
-      const response = await super.generate( { messages, allowSystemInMessages: true, ...callOptions } );
-      const wrapped = await wrapTextResponse( { traceId, response, providerId: this.#providerId, modelId: this.#modelId } );
-      await this.#storeMessages( userMessages, wrapped );
-      return wrapped;
-    } catch ( error ) {
-      endTraceWithError( { traceId, error } );
-      throw error;
-    }
+  async generate( args ) {
+    const { messages, abortSignal, toolChoice } = Validator.parseAgentGenerateArgs( args );
+    const combinedMessages = await this.#combineWithPreviousMessages( messages );
+
+    return wrapGeneration( {
+      name: 'Agent.generate',
+      prompt: this.#prompt,
+      fn: async () => {
+        const response = await super.generate( {
+          messages: combinedMessages,
+          allowSystemInMessages: true,
+          ...( abortSignal && { abortSignal } ),
+          ...( toolChoice && { toolChoice } )
+        } );
+        await this.#storeMessages( messages.concat( response.response?.messages ?? [] ) );
+        return response;
+      }
+    } );
   }
 
-  async stream( { messages: userMessages = [], onFinish, onError, ...callOptions } = {} ) {
-    const traceId = startTrace( { name: 'Agent.stream', prompt: this.#prompt } );
-    try {
-      const messages = await this.#fetchMessages( userMessages );
-      return super.stream( {
-        messages,
-        allowSystemInMessages: true,
-        ...callOptions,
-        ...wrapStreamOnFinishResponse( { traceId, modelId: this.#modelId, providerId: this.#providerId, onFinish } ),
-        onError( event ) {
-          endTraceWithError( { traceId, error: event.error } );
-          onError?.( event );
+  /**
+   * Generates a completed agent response over streaming transport, invoking `onChunk` as parts arrive.
+   */
+  async generateWithStreaming( args ) {
+    const { messages, abortSignal, toolChoice, onChunk } = Validator.parseAgentGenerateWithStreamingArgs( args );
+    const combinedMessages = await this.#combineWithPreviousMessages( messages );
+
+    return wrapGeneration( {
+      name: 'Agent.generateWithStreaming',
+      prompt: this.#prompt,
+      fn: async () => {
+        const state = { response: null };
+        const stream = await super.stream( {
+          messages: combinedMessages,
+          allowSystemInMessages: true,
+          ...( onChunk && { onChunk } ),
+          ...( abortSignal && { abortSignal } ),
+          ...( toolChoice && { toolChoice } ),
+          onFinish: res => {
+            state.response = res;
+          },
+          onError: _ => {} // Suppress AI-SDK console printing
+        } );
+
+        await drainStream( stream, abortSignal );
+
+        if ( !state.response ) {
+          throw new Error( 'Agent streaming generation completed without a response.' );
         }
-      } );
-    } catch ( error ) {
-      endTraceWithError( { traceId, error } );
-      throw error;
-    }
+
+        state.response.output = await stream.output;
+        await this.#storeMessages( messages.concat( state.response.response?.messages ?? [] ) );
+
+        return state.response;
+      }
+    } );
+  }
+
+  async stream( args ) {
+    const { messages, abortSignal, toolChoice, onChunk, onFinish, onError } = Validator.parseAgentStreamArgs( args );
+    const combinedMessages = await this.#combineWithPreviousMessages( messages );
+
+    return wrapStream( {
+      name: 'Agent.stream',
+      prompt: this.#prompt,
+      fn: ( { onFinishHook, onErrorHook } ) => super.stream( {
+        messages: combinedMessages,
+        allowSystemInMessages: true,
+        ...( onChunk && { onChunk } ),
+        ...( abortSignal && { abortSignal } ),
+        ...( toolChoice && { toolChoice } ),
+        onFinish: response =>
+          onFinishHook( response, async parsedResponse => {
+            if ( response.finishReason !== 'error' ) {
+              await this.#storeMessages( messages.concat( response.response?.messages ?? [] ) )
+                .catch( error => Logger.error( 'Agent.stream message store persistence failed', {
+                  namespace: 'LLM',
+                  error: error instanceof Error ? error.message : String( error )
+                } ) );
+            }
+            await onFinish?.( parsedResponse );
+          } ),
+        onError: event => onErrorHook( event, error => onError?.( { ...event, error } ) )
+      } )
+    } );
   }
 }