@outputai/core 0.15.1-next.15a30ef.0 → 0.15.1-next.2156c4b.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.15.1-next.15a30ef.0",
+  "version": "0.15.1-next.2156c4b.0",
   "description": "The core module of the output framework",
   "type": "module",
   "engines": {
@@ -34,6 +34,10 @@
     "./http": {
       "types": "./src/http/index.d.ts",
       "import": "./src/http/index.js"
+    },
+    "./llm": {
+      "types": "./src/llm/index.d.ts",
+      "import": "./src/llm/index.js"
     }
   },
   "files": [
@@ -41,7 +45,8 @@
     "./dist",
     "./bin",
     "!**/*.spec.*",
-    "!src/credentials"
+    "!src/credentials",
+    "!src/llm/fixtures"
   ],
   "bin": {
     "output-worker": "./bin/worker.sh",
@@ -62,9 +67,13 @@
     "@temporalio/common": "1.24.0",
     "@temporalio/worker": "1.24.0",
     "@temporalio/workflow": "1.24.0",
+    "decimal.js": "10.6.0",
+    "entities": "8.1.0",
     "folder-hash": "4.1.3",
+    "gray-matter": "4.0.3",
     "js-yaml": "5.4.2",
     "json-stream-stringify": "3.1.7",
+    "liquidjs": "10.29.0",
     "redis": "5.12.1",
     "stacktrace-parser": "0.1.11",
     "winston": "3.19.0"
@@ -72,13 +81,47 @@
   "peerDependencies": {
     "zod": ">=4.3 <5",
     "ky": ">=2 <3",
-    "undici": ">=8 <9"
+    "undici": ">=8 <9",
+    "ai": ">=7 <8",
+    "@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"
+  },
+  "peerDependenciesMeta": {
+    "@ai-sdk/amazon-bedrock": {
+      "optional": true
+    },
+    "@ai-sdk/anthropic": {
+      "optional": true
+    },
+    "@ai-sdk/azure": {
+      "optional": true
+    },
+    "@ai-sdk/google-vertex": {
+      "optional": true
+    },
+    "@ai-sdk/openai": {
+      "optional": true
+    },
+    "@ai-sdk/perplexity": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@types/js-yaml": "4.0.9",
     "zod": "4.6.5",
     "ky": "2.0.2",
-    "undici": "8.11.0"
+    "undici": "8.10.2",
+    "ai": "7.0.112",
+    "@ai-sdk/amazon-bedrock": "5.0.92",
+    "@ai-sdk/anthropic": "4.0.61",
+    "@ai-sdk/azure": "4.0.77",
+    "@ai-sdk/google-vertex": "5.0.91",
+    "@ai-sdk/openai": "4.0.73",
+    "@ai-sdk/perplexity": "4.0.49"
   },
   "license": "Apache-2.0",
   "publishConfig": {
@@ -101,6 +144,7 @@
   },
   "scripts": {
     "worker": "node ./src/worker/index.js",
-    "build": "rm -rf ./dist && tsc && pnpm exec tsc -p ./tsconfig.typecheck.json"
+    "build": "rm -rf ./dist && tsc && pnpm exec tsc -p ./tsconfig.typecheck.json",
+    "take-models-pricing-snapshot": "node ./scripts/take_models_pricing_snapshot.js"
   }
 }

package/src/helpers/path.js

@@ -0,0 +1,36 @@
+import * as stackTraceParser from 'stacktrace-parser';
+
+// OS separator, but in a deterministic way, allowing this to work in Temporal's sandbox
+// This avoids importing from node:path
+const SEP = new Error().stack.includes( '/' ) ? '/' : '\\';
+const transformSeparators = path => path.replaceAll( '/', SEP );
+
+const defaultIgnorePaths = [
+  '/@outputai/core/',
+  '/@outputai/evals/',
+  '/sdk/core/',
+  '/sdk/evals/',
+  'node:internal/',
+  'evalmachine.',
+  'webpack/bootstrap'
+];
+
+/**
+ * Return the first immediate directory of the file invoking the code that called this function.
+ *
+ * Excludes `@outputai/core`, node, other internal paths, and any additional ignore paths.
+ *
+ * @param {string[]} [additionalIgnorePaths]
+ * @returns {string}
+ */
+export const resolveInvocationDir = ( additionalIgnorePaths = [] ) => {
+  const stack = new Error().stack;
+  const lines = stackTraceParser.parse( stack );
+  const ignorePaths = [ ...additionalIgnorePaths, ...defaultIgnorePaths ].map( transformSeparators );
+
+  const frame = lines.find( l => !ignorePaths.some( p => l.file.includes( p ) ) );
+  if ( !frame ) {
+    throw new Error( `Invocation dir resolution via stack trace failed. Stack: ${stack}` );
+  }
+  return frame.file.replace( 'file://', '' ).split( SEP ).slice( 0, -1 ).join( SEP );
+};

package/src/llm/agent.js

@@ -0,0 +1,141 @@
+import { ToolLoopAgent as AIToolLoopAgent } from 'ai';
+import { loadAiSdkTextOptions } from './ai_sdk_options.js';
+import { wrapTextGeneration, 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 '#runtime_logger';
+
+export class Agent {
+  #agent;
+  #prompt;
+  #initialMessages;
+  #store;
+
+  constructor( args ) {
+    const { promptFile, promptObject, promptDir, variables, tools, output, stopWhen, messageStore } = Validator.parseAgentArgs( args );
+
+    const prompt = promptObject ?? loadPrompt( promptFile, variables, promptDir );
+    const skills = loadSkills( prompt );
+
+    const { instructions, messages, ...aiOptions } = loadAiSdkTextOptions( { prompt, skills, tools, output, stopWhen } );
+
+    this.#agent = new AIToolLoopAgent( {
+      ...aiOptions,
+      ...( instructions.length > 0 ? { instructions } : {} )
+    } );
+
+    this.#prompt = prompt;
+    // `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 #combineWithPreviousMessages( messages ) {
+    return [ ...this.#initialMessages, ...( await this.#store?.getMessages() ?? [] ), ...messages ];
+  }
+
+  async #storeMessages( messages ) {
+    if ( this.#store ) {
+      await this.#store.addMessages( messages );
+    }
+  }
+
+  async generate( args ) {
+    const { messages, abortSignal, toolChoice } = Validator.parseAgentGenerateArgs( args );
+    const combinedMessages = await this.#combineWithPreviousMessages( messages );
+
+    return wrapTextGeneration( {
+      name: 'Agent.generate',
+      prompt: this.#prompt,
+      fn: async ( { onStepEndHook } ) => {
+        const response = await this.#agent.generate( {
+          messages: combinedMessages,
+          allowSystemInMessages: true,
+          ...( abortSignal && { abortSignal } ),
+          ...( toolChoice && { toolChoice } ),
+          onStepEnd: onStepEndHook
+        } );
+        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( args ) {
+    const { messages, abortSignal, toolChoice, onChunk } = Validator.parseAgentGenerateWithStreamingArgs( args );
+    const combinedMessages = await this.#combineWithPreviousMessages( messages );
+
+    return wrapTextGeneration( {
+      name: 'Agent.generateWithStreaming',
+      prompt: this.#prompt,
+      fn: async ( { onStepEndHook } ) => {
+        const state = { response: null };
+        const stream = await this.#agent.stream( {
+          messages: combinedMessages,
+          allowSystemInMessages: true,
+          ...( onChunk && { onChunk } ),
+          ...( abortSignal && { abortSignal } ),
+          ...( toolChoice && { toolChoice } ),
+          onStepEnd: onStepEndHook,
+          onEnd: res => {
+            state.response = res;
+          },
+          onError: _ => {} // Suppress AI-SDK console printing
+        } );
+
+        await drainStream( stream, abortSignal );
+
+        if ( !state.response ) {
+          throw new Error( 'Streaming completed without a response.' );
+        }
+
+        state.response.output = await stream.output;
+        if ( state.response.finishReason !== 'error' ) {
+          await this.#storeMessages( messages.concat( state.response.responseMessages ?? [] ) );
+        }
+
+        return state.response;
+      }
+    } );
+  }
+
+  async stream( args ) {
+    const { messages, abortSignal, toolChoice, onChunk, onEnd, onError } = Validator.parseAgentStreamArgs( args );
+    const combinedMessages = await this.#combineWithPreviousMessages( messages );
+
+    return wrapStream( {
+      name: 'Agent.stream',
+      prompt: this.#prompt,
+      abortSignal,
+      fn: ( { onEndHook, onErrorHook, onStepEndHook, onAbortHook } ) => this.#agent.stream( {
+        messages: combinedMessages,
+        allowSystemInMessages: true,
+        ...( onChunk && { onChunk } ),
+        ...( abortSignal && { abortSignal } ),
+        ...( toolChoice && { toolChoice } ),
+        onStepEnd: onStepEndHook,
+        onAbort: onAbortHook,
+        onEnd: response =>
+          onEndHook( response, async parsedResponse => {
+            if ( response.finishReason !== 'error' ) {
+              await this.#storeMessages( messages.concat( response.responseMessages ?? [] ) )
+                .catch( error =>
+                  Logger.error( 'Message store persistence failed', { namespace: 'LLM', error: error?.message || String( error ) } )
+                );
+            }
+            await onEnd?.( parsedResponse );
+          } ),
+        onError: event => onErrorHook( event, error => onError?.( { ...event, error } ) )
+      } )
+    } );
+  }
+}

package/src/llm/ai_provider.js

@@ -0,0 +1,131 @@
+import { z } from 'zod';
+import { FatalError, ValidationError } from '#errors';
+import { EnvHttpProxyAgent, fetch } from 'undici';
+import { deprecatedProviderAliases } from './deprecated_provider_aliases.js';
+import { resolveGoogleVertexAuthOptions } from './utils/google_vertex_auth.js';
+
+/** This custom dispatcher has longer timeouts. */
+const customDispatcher = new EnvHttpProxyAgent( {
+  headersTimeout: 15 * 60 * 1000, // 15 min
+  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 */
+const customFetch = ( input, init ) => fetch( input, { dispatcher: customDispatcher, ...init } );
+
+/** Shipped providers. Their packages are optional peer dependencies, so any of them may be missing. */
+const shippedProviders = {
+  'amazon-bedrock': {
+    pkg: '@ai-sdk/amazon-bedrock',
+    load: async () => ( await import( '@ai-sdk/amazon-bedrock' ) ).createAmazonBedrock
+  },
+  anthropic: {
+    pkg: '@ai-sdk/anthropic',
+    load: async () => ( await import( '@ai-sdk/anthropic' ) ).createAnthropic
+  },
+  azure: {
+    pkg: '@ai-sdk/azure',
+    load: async () => ( await import( '@ai-sdk/azure' ) ).createAzure
+  },
+  'google-vertex': {
+    pkg: '@ai-sdk/google-vertex',
+    load: async () => {
+      const { createVertex } = await import( '@ai-sdk/google-vertex' );
+      return options => createVertex( { ...options, ...resolveGoogleVertexAuthOptions() } );
+    }
+  },
+  openai: {
+    pkg: '@ai-sdk/openai',
+    load: async () => ( await import( '@ai-sdk/openai' ) ).createOpenAI
+  },
+  perplexity: {
+    pkg: '@ai-sdk/perplexity',
+    load: async () => ( await import( '@ai-sdk/perplexity' ) ).createPerplexity
+  }
+};
+
+/** Load a shipped provider initializer, or null when its package is not installed. */
+const loadInitializer = async ( { pkg, load } ) => {
+  try {
+    return await load();
+  } catch ( error ) {
+    if ( error?.code === 'ERR_MODULE_NOT_FOUND' && String( error.message ).includes( `'${pkg}'` ) ) {
+      return null;
+    }
+    throw error;
+  }
+};
+
+/** Available provider to initialize: the shipped providers whose package is installed. */
+const providerInitializers = Object.fromEntries(
+  ( await Promise.all( Object.entries( shippedProviders ).map( async ( [ name, provider ] ) => [ name, await loadInitializer( provider ) ] ) ) )
+    .filter( ( [ , initializer ] ) => initializer )
+);
+
+/** Providers already initialized due usage */
+const initializedProviders = {};
+
+/** Providers registered by the user */
+const registeredProviders = {};
+
+/**
+ * Get all available provider names: shipped providers whose package is installed, plus registered ones.
+ * @returns {string[]} Provider names
+ */
+export const getProviderNames = () =>
+  new Set( Object.keys( providerInitializers ).concat( Object.keys( registeredProviders ) ) ).values().toArray();
+
+const registerProviderSchema = z.object( {
+  name: z.string().min( 1, 'Provider name must be a non-empty string' ),
+  providerFn: z.function()
+} );
+
+/**
+ * Register or override an AI SDK provider factory by name.
+ * @param {string} name - Provider name used in prompt frontmatter
+ * @param {Function} providerFn - Factory function that receives a model id
+ * @returns {void}
+ */
+export const registerProvider = ( name, providerFn ) => {
+  const result = registerProviderSchema.safeParse( { name, providerFn } );
+  if ( !result.success ) {
+    throw new ValidationError( `Invalid provider registration: ${z.prettifyError( result.error )}` );
+  }
+  if ( Object.hasOwn( deprecatedProviderAliases, name ) ) {
+    const canonical = deprecatedProviderAliases[name];
+    throw new ValidationError(
+      `Cannot register provider "${name}": that name is a deprecated alias for "${canonical}". Register "${canonical}" instead.`
+    );
+  }
+  registeredProviders[name] = providerFn;
+};
+
+/**
+ * Return a provider by its name.
+ * Look for registered providers first.
+ * If none, looks for initialized providers.
+ * Finally, looks for available provider initializers, and if found, init it.
+ *
+ * @param {string} name
+ * @returns {object} provider
+ */
+export const getProvider = name => {
+  const provider = registeredProviders[name] ?? initializedProviders[name];
+
+  if ( provider ) {
+    return provider;
+  }
+  if ( providerInitializers[name] ) {
+    try {
+      return initializedProviders[name] = providerInitializers[name]( { fetch: customFetch } );
+    } catch ( error ) {
+      throw new FatalError( `Failed to initialize provider "${name}": ${error.message}`, { cause: error } );
+    }
+  }
+  if ( shippedProviders[name] ) {
+    throw new FatalError( `Provider "${name}" requires the "${shippedProviders[name].pkg}" package, which is not installed` );
+  }
+
+  throw new FatalError( `Unsupported provider "${name}"` );
+};

package/src/llm/ai_sdk_options.js

@@ -0,0 +1,126 @@
+import { loadImageModel, loadTextModel } from './utils/models.js';
+import { buildLoadSkillTool, loadPromptTools } from './utils/tools.js';
+import { Role } from './consts.js';
+import { FatalError } from '#errors';
+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 ) );
+
+/**
+ * Build options for AI SDK text generation.
+ *
+ * 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} 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, 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 instructions = prompt.messages.filter( m => m.role === Role.SYSTEM );
+  const messages = prompt.messages.filter( m => m.role !== Role.SYSTEM );
+
+  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 } );
+    }
+  }
+
+  const options = {
+    allowSystemInMessages: true,
+    maxRetries: 0,
+    model: loadTextModel( prompt ),
+    instructions,
+    messages,
+    ...( output && { output } ),
+    ...( abortSignal && { abortSignal } ),
+    ...( stopWhen && { stopWhen } ),
+    ...select( textPromptConfigKeys, prompt.config )
+  };
+
+  // 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;
+};
+
+/**
+ * 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} 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, abortSignal } ) => {
+  if ( !prompt.instructions ) {
+    throw new FatalError( `Prompt "${prompt.name}" has no instructions. Image prompts must use plain instructions.` );
+  }
+  return {
+    maxRetries: 0,
+    model: loadImageModel( prompt ),
+    prompt: ( images || mask ) ? {
+      text: prompt.instructions,
+      ...( images && { images } ),
+      ...( mask && { mask } )
+    } : prompt.instructions,
+    ...( abortSignal && { abortSignal } ),
+    ...select( imagePromptConfigKeys, prompt.config )
+  };
+};

package/src/llm/consts.js

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

package/src/llm/deprecated_provider_aliases.js

@@ -0,0 +1,8 @@
+/**
+ * Deprecated prompt `provider` spellings → canonical shipped names.
+ * Remove this module when the aliases are dropped.
+ */
+export const deprecatedProviderAliases = {
+  vertex: 'google-vertex',
+  bedrock: 'amazon-bedrock'
+};

package/src/llm/generate.js

@@ -0,0 +1,88 @@
+import * as AI from 'ai';
+import { loadPrompt } from './prompt/loader.js';
+import { wrapImageGeneration, wrapStream, wrapTextGeneration } 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 wrapTextGeneration( {
+    name: 'generateText',
+    prompt,
+    fn: ( { onStepEndHook } ) => AI.generateText( {
+      ...loadAiSdkTextOptions( { prompt, skills, ...aiOptions } ),
+      onStepEnd: onStepEndHook
+    } )
+  } );
+};
+
+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, onStepEndHook, onAbortHook } ) => AI.streamText( {
+      ...loadAiSdkTextOptions( { prompt, skills, ...aiOptions } ),
+      ...( onChunk && { onChunk } ),
+      onStepEnd: onStepEndHook,
+      onAbort: onAbortHook,
+      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 wrapTextGeneration( {
+    name: 'generateTextWithStreaming',
+    prompt,
+    fn: async ( { onStepEndHook } ) => {
+      const state = { response: null };
+      const stream = AI.streamText( {
+        ...loadAiSdkTextOptions( { prompt, skills, ...aiOptions } ),
+        ...( onChunk && { onChunk } ),
+        onStepEnd: onStepEndHook,
+        onEnd: res => {
+          state.response = res;
+        },
+        onError: _ => {} // Suppress AI-SDK console printing
+      } );
+
+      await drainStream( stream, aiOptions.abortSignal );
+
+      if ( !state.response ) {
+        throw new Error( 'Streaming 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 wrapImageGeneration( {
+    name: 'generateImage',
+    prompt,
+    fn: () => AI.generateImage( loadAiSdkImageOptions( { prompt, ...aiOptions } ) )
+  } );
+};