@outputai/llm 0.11.1-next.90d8cc0.0 → 0.11.1-next.a07f3e4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/llm",
-  "version": "0.11.1-next.90d8cc0.0",
+  "version": "0.11.1-next.a07f3e4.0",
   "description": "Framework abstraction to interact with LLM models",
   "type": "module",
   "main": "src/index.js",
@@ -9,32 +9,37 @@
     "node": ">=24.15.0"
   },
   "files": [
-    "./src"
+    "./src/!(*.spec).js",
+    "./src/index.d.ts",
+    "./src/prompt/!(*.spec).js",
+    "./src/prompt/markup/!(*.spec).js",
+    "./src/utils/!(*.spec).js"
   ],
   "dependencies": {
+    "decimal.js": "10.6.0",
     "entities": "8.0.0",
     "gray-matter": "4.0.3",
     "liquidjs": "10.27.2",
     "undici": "8.9.0",
-    "@outputai/core": "0.11.1-next.90d8cc0.0"
+    "@outputai/core": "0.11.1-next.a07f3e4.0"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "4.0.138",
-    "@ai-sdk/anthropic": "3.0.81",
-    "@ai-sdk/azure": "3.0.68",
-    "@ai-sdk/google-vertex": "4.0.140",
-    "@ai-sdk/openai": "3.0.67",
-    "@ai-sdk/perplexity": "3.0.33",
-    "ai": "6.0.168"
+    "@ai-sdk/amazon-bedrock": "5.0.57",
+    "@ai-sdk/anthropic": "4.0.39",
+    "@ai-sdk/azure": "4.0.43",
+    "@ai-sdk/google-vertex": "5.0.54",
+    "@ai-sdk/openai": "4.0.42",
+    "@ai-sdk/perplexity": "4.0.29",
+    "ai": "7.0.66"
   },
   "peerDependencies": {
-    "@ai-sdk/amazon-bedrock": ">=4 <5",
-    "@ai-sdk/anthropic": ">=3 <4",
-    "@ai-sdk/azure": ">=3 <4",
-    "@ai-sdk/google-vertex": ">=4 <5",
-    "@ai-sdk/openai": ">=3 <4",
-    "@ai-sdk/perplexity": ">=3 <4",
-    "ai": ">=6 <7"
+    "@ai-sdk/amazon-bedrock": ">=5 <6",
+    "@ai-sdk/anthropic": ">=4 <5",
+    "@ai-sdk/azure": ">=4 <5",
+    "@ai-sdk/google-vertex": ">=5 <6",
+    "@ai-sdk/openai": ">=4 <5",
+    "@ai-sdk/perplexity": ">=4 <5",
+    "ai": ">=7 <8"
   },
   "license": "Apache-2.0",
   "publishConfig": {

package/src/agent.js

@@ -1,165 +1,138 @@
-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 } from './utils/response_wrappers.js';
-import { mapAiError } from './utils/error_handler.js';
-import { ROLE, isRole } from './utils/message.js';
+import { wrapGeneration, wrapStream } from './utils/wrap.js';
+import { Role } from './consts.js';
 import { drainStream } from './utils/stream.js';
-export { skill } from './prompt/skill.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 const createMemoryConversationStore = () => {
-  const messages = [];
-  return {
-    getMessages: () => messages,
-    addMessages: newMessages => messages.push( ...newMessages )
-  };
-};
-
-export class Agent extends AIToolLoopAgent {
+export class Agent {
+  #agent;
   #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, promptObject, promptDir, variables, tools, output, stopWhen, messageStore } = Validator.parseAgentArgs( args );
 
-    const { loadedPrompt, tools } = prepareTextPrompt( { prompt, variables, promptDir: resolvedPromptDir, skills, tools: toolsArg } );
+    const prompt = promptObject ?? loadPrompt( promptFile, variables, promptDir );
+    const skills = loadSkills( prompt );
 
-    const { system, messages, ...constructorOptions } = loadAiSdkTextOptions( loadedPrompt );
+    const { instructions, 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
+    this.#agent = new AIToolLoopAgent( {
+      ...aiOptions,
+      ...( instructions.length > 0 ? { instructions } : {} )
     } );
 
     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 ( originalError ) {
-      const error = mapAiError( originalError );
-      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 this.#agent.generate( {
+          messages: combinedMessages,
+          allowSystemInMessages: true,
+          ...( abortSignal && { abortSignal } ),
+          ...( toolChoice && { toolChoice } )
+        } );
+        if ( response.finishReason !== 'error' ) {
+          await this.#storeMessages( messages.concat( response.responseMessages ?? [] ) );
+        }
+        return response;
+      }
+    } );
   }
 
   /**
    * Generates a completed agent response over streaming transport, invoking `onChunk` as parts arrive.
    */
-  async generateWithStreaming( { messages: userMessages = [], ...options } = {} ) {
-    const traceId = startTrace( { name: 'Agent.generateWithStreaming', prompt: this.#prompt } );
-    const state = { response: null };
-
-    try {
-      const messages = await this.#fetchMessages( userMessages );
-      const stream = await super.stream( {
-        messages,
-        allowSystemInMessages: true,
-        ...options,
-        onFinish( response ) {
-          state.response = response;
-        },
-        onError: _ => {} // Suppress AI-SDK console printing
-      } );
+  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 this.#agent.stream( {
+          messages: combinedMessages,
+          allowSystemInMessages: true,
+          ...( onChunk && { onChunk } ),
+          ...( abortSignal && { abortSignal } ),
+          ...( toolChoice && { toolChoice } ),
+          onEnd: 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.' );
+        }
 
-      await drainStream( stream, options?.abortSignal );
+        state.response.output = await stream.output;
+        if ( state.response.finishReason !== 'error' ) {
+          await this.#storeMessages( messages.concat( state.response.responseMessages ?? [] ) );
+        }
 
-      if ( !state.response ) {
-        throw new Error( 'Agent streaming generation completed without a response.' );
+        return state.response;
       }
-
-      state.response.output = await stream.output;
-      const wrappedResponse = await wrapTextResponse( {
-        traceId,
-        providerId: this.#providerId,
-        modelId: this.#modelId,
-        response: state.response
-      } );
-      await this.#storeMessages( userMessages, wrappedResponse );
-
-      return wrappedResponse;
-
-    } catch ( originalError ) {
-      const error = mapAiError( originalError );
-      endTraceWithError( { traceId, error } );
-      throw error;
-    }
-
+    } );
   }
 
-  async stream( { messages: userMessages = [], onFinish, onError, ...callOptions } = {} ) {
-    const traceId = startTrace( { name: 'Agent.stream', prompt: this.#prompt } );
+  async stream( args ) {
+    const { messages, abortSignal, toolChoice, onChunk, onEnd, onError } = Validator.parseAgentStreamArgs( args );
+    const combinedMessages = await this.#combineWithPreviousMessages( messages );
 
-    try {
-      const messages = await this.#fetchMessages( userMessages );
-      return await super.stream( {
-        messages,
+    return wrapStream( {
+      name: 'Agent.stream',
+      prompt: this.#prompt,
+      abortSignal,
+      fn: ( { onEndHook, onErrorHook } ) => this.#agent.stream( {
+        messages: combinedMessages,
         allowSystemInMessages: true,
-        ...callOptions,
-        onFinish: async response => {
-          const proxiedResponse = await wrapTextResponse( { traceId, providerId: this.#providerId, modelId: this.#modelId, response } );
-          return onFinish?.( proxiedResponse );
-        },
-        onError( event ) {
-          const error = mapAiError( event.error );
-          endTraceWithError( { traceId, error } );
-          return onError?.( { ...event, error } );
-        }
-      } );
-    } catch ( originalError ) {
-      const error = mapAiError( originalError );
-      endTraceWithError( { traceId, error } );
-      throw error;
-    }
+        ...( onChunk && { onChunk } ),
+        ...( abortSignal && { abortSignal } ),
+        ...( toolChoice && { toolChoice } ),
+        onEnd: response =>
+          onEndHook( response, async parsedResponse => {
+            if ( response.finishReason !== 'error' ) {
+              await this.#storeMessages( messages.concat( response.responseMessages ?? [] ) )
+                .catch( error => Logger.error( 'Agent.stream message store persistence failed', {
+                  namespace: 'LLM',
+                  error: error instanceof Error ? error.message : String( error )
+                } ) );
+            }
+            await onEnd?.( parsedResponse );
+          } ),
+        onError: event => onErrorHook( event, error => onError?.( { ...event, error } ) )
+      } )
+    } );
   }
 }

package/src/ai_provider.js

@@ -53,7 +53,7 @@ const registerProviderSchema = z.object( {
  * @param {Function} providerFn - Factory function that receives a model id
  * @returns {void}
  */
-export function registerProvider( name, providerFn ) {
+export const registerProvider = ( name, providerFn ) => {
   const result = registerProviderSchema.safeParse( { name, providerFn } );
   if ( !result.success ) {
     throw new ValidationError( `Invalid provider registration: ${z.prettifyError( result.error )}` );
@@ -65,7 +65,7 @@ export function registerProvider( name, providerFn ) {
     );
   }
   registeredProviders[name] = providerFn;
-}
+};
 
 /**
  * Return a provider by its name.

package/src/ai_sdk_options.js

@@ -1,72 +1,126 @@
-import { loadImageModel, loadTextModel, loadTools } from './ai_model.js';
-import { resolveMessageProviderOptions } from './prompt/block_options.js';
-import { ROLE, isRole } from './utils/message.js';
+import { loadImageModel, loadTextModel } from './utils/models.js';
+import { buildLoadSkillTool, loadPromptTools } from './utils/tools.js';
+import { Role } from './consts.js';
 import { FatalError } from '@outputai/core';
+import { isStepCount } from 'ai';
+
+const buildSkillsMessageContent = skills =>
+  'Available skills (use load_skill to get full instructions):\n' +
+  skills.map( s => `- ${s.name}: ${s.description}` ).join( '\n' );
+
+const textPromptConfigKeys = [
+  'frequencyPenalty',
+  'maxOutputTokens',
+  'presencePenalty',
+  'providerOptions',
+  'seed',
+  'stopSequences',
+  'temperature',
+  'topK',
+  'topP'
+];
+
+const imagePromptConfigKeys = [
+  'aspectRatio',
+  'maxImagesPerCall',
+  'n',
+  'providerOptions',
+  'seed',
+  'size'
+];
+
+const select = ( keys, target ) =>
+  Object.fromEntries( Object.entries( target ).filter( ( [ k, v ] ) => keys.includes( k ) && v !== undefined ) );
 
 /**
- * Convert a loaded prompt into AI SDK text generation options.
+ * Build options for AI SDK text generation.
  *
- * System blocks are routed to the `system` option (as `SystemModelMessage[]`, so
- * per-message providerOptions like `cacheControl` are preserved) rather than left
- * in `messages` — the AI SDK flags system roles inside `messages` as a prompt
- * injection risk, and `system` is the provider-recommended slot.
+ * Splits system vs chat messages, applies prompt generation config, and merges tools
+ * with a step limit when any tools are present. Always sets `maxRetries` to 0.
  *
- * @param {object} prompt - Loaded prompt object
- * @returns {object} Options for AI SDK text calls
+ * @param {object} args
+ * @param {object} args.prompt - Loaded prompt object
+ * @param {object} [args.tools] - Caller tools
+ * @param {Skill[]} args.skills - Resolved skills
+ * @param {unknown} [args.stopWhen] - Caller stop condition; otherwise prompt `maxSteps` when tools exist
+ * @param {unknown} [args.output] - Structured output spec
+ * @param {unknown} [args.toolChoice] - Tool choice, set only when tools exist
+ * @param {AbortSignal} [args.abortSignal] - Abort signal for the request
+ * @returns {object} AI SDK text options
  */
-export const loadAiSdkTextOptions = prompt => {
+export const loadAiSdkTextOptions = ( { prompt, tools, skills, stopWhen, output, toolChoice, abortSignal } ) => {
   if ( prompt.messages.length === 0 ) {
     throw new FatalError( `Prompt "${prompt.name}" has no chat-style messages. Add role-tagged blocks like <system> or <user>.` );
   }
-  const isSystem = isRole( ROLE.SYSTEM );
-  const resolvedMessages = resolveMessageProviderOptions( prompt );
 
-  const options = {
-    model: loadTextModel( prompt ),
-    system: resolvedMessages.filter( isSystem ),
-    messages: resolvedMessages.filter( message => !isSystem( message ) ),
-    providerOptions: prompt.config.providerOptions
-  };
+  const instructions = prompt.messages.filter( m => m.role === Role.SYSTEM );
+  const messages = prompt.messages.filter( m => m.role !== Role.SYSTEM );
 
-  if ( Number.isFinite( prompt.config.temperature ) ) {
-    options.temperature = prompt.config.temperature;
+  if ( skills.length > 0 ) {
+    const skillsMessageContent = buildSkillsMessageContent( skills );
+    if ( instructions.length > 0 ) {
+      instructions[0] = { ...instructions[0], content: `${instructions[0].content}\n\n${skillsMessageContent}` };
+    } else {
+      instructions.push( { role: Role.SYSTEM, content: skillsMessageContent } );
+    }
   }
 
-  if ( prompt.config.maxTokens ) {
-    options.maxOutputTokens = prompt.config.maxTokens;
-  }
+  const options = {
+    allowSystemInMessages: true,
+    maxRetries: 0,
+    model: loadTextModel( prompt ),
+    instructions,
+    messages,
+    ...( output && { output } ),
+    ...( abortSignal && { abortSignal } ),
+    ...( stopWhen && { stopWhen } ),
+    ...select( textPromptConfigKeys, prompt.config )
+  };
 
-  const tools = loadTools( prompt );
-  if ( tools ) {
-    options.tools = tools;
+  // Tools parsing
+  const promptTools = loadPromptTools( prompt );
+  const skillsTools = skills.length > 0 ? { load_skill: buildLoadSkillTool( skills ) } : {};
+  const mergedTools = { ...promptTools, ...tools, ...skillsTools };
+  if ( Object.keys( mergedTools ).length > 0 ) {
+    options.tools = mergedTools;
+    if ( toolChoice ) {
+      options.toolChoice = toolChoice;
+    }
+    if ( !options.stopWhen ) {
+      options.stopWhen = isStepCount( prompt.config.maxSteps );
+    }
   }
 
   return options;
 };
 
 /**
- * Convert a loaded prompt into AI SDK image generation options.
+ * Build options for AI SDK image generation.
+ *
+ * Uses prompt instructions (with optional source images and mask) and prompt-owned
+ * image config (`n`, `size`, `aspectRatio`, `seed`, `maxImagesPerCall`, `providerOptions`).
+ * Always sets `maxRetries` to 0.
  *
- * @param {object} prompt - Loaded prompt object
- * @returns {object} Options for AI SDK image calls
+ * @param {object} args
+ * @param {object} args.prompt - Loaded prompt object
+ * @param {unknown} [args.images] - Source images for image-to-image
+ * @param {unknown} [args.mask] - Inpainting mask
+ * @param {AbortSignal} [args.abortSignal] - Abort signal for the request
+ * @returns {object} AI SDK image options
  */
-export const loadAiSdkImageOptions = ( { prompt, images, mask } ) => {
+export const loadAiSdkImageOptions = ( { prompt, images, mask, abortSignal } ) => {
   if ( !prompt.instructions ) {
     throw new FatalError( `Prompt "${prompt.name}" has no instructions. Image prompts must use plain instructions.` );
   }
-  const options = {
+  return {
+    maxRetries: 0,
     model: loadImageModel( prompt ),
     prompt: ( images || mask ) ? {
       text: prompt.instructions,
       ...( images && { images } ),
       ...( mask && { mask } )
     } : prompt.instructions,
-    providerOptions: prompt.config.providerOptions
+    ...( abortSignal && { abortSignal } ),
+    ...select( imagePromptConfigKeys, prompt.config )
   };
-  for ( const key of [ 'n', 'maxImagesPerCall', 'size', 'aspectRatio', 'seed' ] ) {
-    if ( prompt.config[key] !== undefined ) {
-      options[key] = prompt.config[key];
-    }
-  }
-  return options;
 };

package/src/consts.js

@@ -0,0 +1,6 @@
+/** Supported message roles */
+export const Role = {
+  SYSTEM: 'system',
+  USER: 'user',
+  ASSISTANT: 'assistant'
+};

package/src/generate.js

@@ -0,0 +1,82 @@
+import * as AI from 'ai';
+import { loadPrompt } from './prompt/loader.js';
+import { wrapGeneration, wrapStream } from './utils/wrap.js';
+import { loadAiSdkTextOptions, loadAiSdkImageOptions } from './ai_sdk_options.js';
+import { drainStream } from './utils/stream.js';
+import { loadSkills } from './utils/skills.js';
+import * as Validator from './validations.js';
+
+export const generateText = async args => {
+  const { promptFile, promptObject, variables, promptDir, ...aiOptions } = Validator.parseGenerateTextArgs( args );
+  const prompt = promptObject ?? loadPrompt( promptFile, variables, promptDir );
+  const skills = loadSkills( prompt );
+
+  return wrapGeneration( {
+    name: 'generateText',
+    prompt,
+    fn: () => AI.generateText( loadAiSdkTextOptions( { prompt, skills, ...aiOptions } ) )
+  } );
+};
+
+export const streamText = args => {
+  const { promptFile, promptObject, variables, promptDir, onEnd, onError, onChunk, ...aiOptions } = Validator.parseStreamTextArgs( args );
+  const prompt = promptObject ?? loadPrompt( promptFile, variables, promptDir );
+  const skills = loadSkills( prompt );
+
+  return wrapStream( {
+    name: 'streamText',
+    prompt,
+    abortSignal: aiOptions.abortSignal,
+    fn: ( { onEndHook, onErrorHook } ) => AI.streamText( {
+      ...loadAiSdkTextOptions( { prompt, skills, ...aiOptions } ),
+      ...( onChunk && { onChunk } ),
+      onEnd: response => onEndHook( response, onEnd ),
+      onError: event => onErrorHook( event, error => onError?.( { ...event, error } ) )
+    } )
+  } );
+};
+
+/**
+ * Generates a completed text response over streaming transport, invoking `onChunk` as parts arrive.
+ */
+export const generateTextWithStreaming = async args => {
+  const { promptFile, promptObject, variables, promptDir, onChunk, ...aiOptions } = Validator.parseGenerateTextWithStreamingArgs( args );
+  const prompt = promptObject ?? loadPrompt( promptFile, variables, promptDir );
+  const skills = loadSkills( prompt );
+
+  return wrapGeneration( {
+    name: 'generateTextWithStreaming',
+    prompt,
+    fn: async () => {
+      const state = { response: null };
+      const stream = AI.streamText( {
+        ...loadAiSdkTextOptions( { prompt, skills, ...aiOptions } ),
+        ...( onChunk && { onChunk } ),
+        onEnd: res => {
+          state.response = res;
+        },
+        onError: _ => {} // Suppress AI-SDK console printing
+      } );
+
+      await drainStream( stream, aiOptions.abortSignal );
+
+      if ( !state.response ) {
+        throw new Error( 'Streaming generation completed without a response.' );
+      }
+
+      state.response.output = await stream.output;
+      return state.response;
+    }
+  } );
+};
+
+export const generateImage = async args => {
+  const { promptFile, promptObject, promptDir, variables, ...aiOptions } = Validator.parseGenerateImageArgs( args );
+  const prompt = promptObject ?? loadPrompt( promptFile, variables, promptDir );
+
+  return wrapGeneration( {
+    name: 'generateImage',
+    prompt,
+    fn: () => AI.generateImage( loadAiSdkImageOptions( { prompt, ...aiOptions } ) )
+  } );
+};