@outputai/llm 0.11.1-next.b3beef1.0 → 0.11.1-next.b4488bf.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/llm",
-  "version": "0.11.1-next.b3beef1.0",
+  "version": "0.11.1-next.b4488bf.0",
   "description": "Framework abstraction to interact with LLM models",
   "type": "module",
   "main": "src/index.js",
@@ -12,29 +12,30 @@
     "./src"
   ],
   "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.b3beef1.0"
+    "@outputai/core": "0.11.1-next.b4488bf.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

@@ -8,24 +8,23 @@ import { loadSkills } from './utils/skills.js';
 import * as Validator from './validations.js';
 import { Logger } from '@outputai/core';
 
-export class Agent extends AIToolLoopAgent {
+export class Agent {
+  #agent;
   #prompt;
   #initialMessages;
   #store;
 
   constructor( args ) {
-    const { promptFile, promptDir, variables, tools, output, stopWhen, messageStore } = Validator.parseAgentArgs( args );
+    const { promptFile, promptObject, promptDir, variables, tools, output, stopWhen, messageStore } = Validator.parseAgentArgs( args );
 
-    const prompt = loadPrompt( promptFile, variables, promptDir );
+    const prompt = promptObject ?? loadPrompt( promptFile, variables, promptDir );
     const skills = loadSkills( prompt );
 
-    const { system, messages, ...aiOptions } = loadAiSdkTextOptions( { prompt, skills, tools, output, stopWhen } );
+    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( {
+    this.#agent = new AIToolLoopAgent( {
       ...aiOptions,
-      ...( system.length > 0 ? { instructions: system } : {} )
+      ...( instructions.length > 0 ? { instructions } : {} )
     } );
 
     this.#prompt = prompt;
@@ -53,13 +52,13 @@ export class Agent extends AIToolLoopAgent {
       name: 'Agent.generate',
       prompt: this.#prompt,
       fn: async () => {
-        const response = await super.generate( {
+        const response = await this.#agent.generate( {
           messages: combinedMessages,
           allowSystemInMessages: true,
           ...( abortSignal && { abortSignal } ),
           ...( toolChoice && { toolChoice } )
         } );
-        await this.#storeMessages( messages.concat( response.response?.messages ?? [] ) );
+        await this.#storeMessages( messages.concat( response.responseMessages ?? [] ) );
         return response;
       }
     } );
@@ -77,13 +76,13 @@ export class Agent extends AIToolLoopAgent {
       prompt: this.#prompt,
       fn: async () => {
         const state = { response: null };
-        const stream = await super.stream( {
+        const stream = await this.#agent.stream( {
           messages: combinedMessages,
           allowSystemInMessages: true,
           ...( onChunk && { onChunk } ),
           ...( abortSignal && { abortSignal } ),
           ...( toolChoice && { toolChoice } ),
-          onFinish: res => {
+          onEnd: res => {
             state.response = res;
           },
           onError: _ => {} // Suppress AI-SDK console printing
@@ -96,7 +95,7 @@ export class Agent extends AIToolLoopAgent {
         }
 
         state.response.output = await stream.output;
-        await this.#storeMessages( messages.concat( state.response.response?.messages ?? [] ) );
+        await this.#storeMessages( messages.concat( state.response.responseMessages ?? [] ) );
 
         return state.response;
       }
@@ -104,28 +103,28 @@ export class Agent extends AIToolLoopAgent {
   }
 
   async stream( args ) {
-    const { messages, abortSignal, toolChoice, onChunk, onFinish, onError } = Validator.parseAgentStreamArgs( 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,
-      fn: ( { onFinishHook, onErrorHook } ) => super.stream( {
+      fn: ( { onEndHook, onErrorHook } ) => this.#agent.stream( {
         messages: combinedMessages,
         allowSystemInMessages: true,
         ...( onChunk && { onChunk } ),
         ...( abortSignal && { abortSignal } ),
         ...( toolChoice && { toolChoice } ),
-        onFinish: response =>
-          onFinishHook( response, async parsedResponse => {
+        onEnd: response =>
+          onEndHook( response, async parsedResponse => {
             if ( response.finishReason !== 'error' ) {
-              await this.#storeMessages( messages.concat( response.response?.messages ?? [] ) )
+              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 onFinish?.( parsedResponse );
+            await onEnd?.( parsedResponse );
           } ),
         onError: event => onErrorHook( event, error => onError?.( { ...event, error } ) )
       } )

package/src/agent.spec.js

@@ -38,7 +38,7 @@ const optionMocks = vi.hoisted( () => ( {
 const wrapMocks = vi.hoisted( () => ( {
   wrapGeneration: vi.fn(),
   wrapStream: vi.fn(),
-  streamHooks: { onFinishHook: vi.fn(), onErrorHook: vi.fn() }
+  streamHooks: { onEndHook: vi.fn(), onErrorHook: vi.fn() }
 } ) );
 
 const streamMocks = vi.hoisted( () => ( {
@@ -113,7 +113,7 @@ const model = { id: 'MODEL' };
 
 const textOptions = {
   model,
-  system: [ { role: 'system', content: 'You are concise.' } ],
+  instructions: [ { role: 'system', content: 'You are concise.' } ],
   messages: [ { role: 'user', content: 'Initial user message' } ],
   providerOptions: { test: true },
   temperature: 0.3
@@ -124,7 +124,7 @@ const assistantMessage = { role: 'assistant', content: 'response' };
 const aiResponse = {
   text: 'response',
   finishReason: 'stop',
-  response: { messages: [ assistantMessage ] }
+  responseMessages: [ assistantMessage ]
 };
 
 describe( 'Agent', () => {
@@ -145,7 +145,7 @@ describe( 'Agent', () => {
 
     wrapMocks.wrapGeneration.mockReset().mockImplementation( async ( { fn } ) => fn() );
     wrapMocks.streamHooks = {
-      onFinishHook: vi.fn( async ( response, callback ) => callback?.( response ) ),
+      onEndHook: vi.fn( async ( response, callback ) => callback?.( response ) ),
       onErrorHook: vi.fn( ( event, callback ) => callback?.( event.error ) )
     };
     wrapMocks.wrapStream.mockReset().mockImplementation( ( { fn } ) => fn( wrapMocks.streamHooks ) );
@@ -213,6 +213,23 @@ describe( 'Agent', () => {
     } );
   } );
 
+  it( 'uses a prompt object without loading a prompt file', async () => {
+    validations.parseAgentArgs.mockReturnValueOnce( { promptObject: loadedPrompt } );
+    const { Agent } = await importSut();
+
+    new Agent( { prompt: loadedPrompt } );
+
+    expect( promptMocks.loadPrompt ).not.toHaveBeenCalled();
+    expect( skillMocks.loadSkills ).toHaveBeenCalledWith( loadedPrompt );
+    expect( optionMocks.loadAiSdkTextOptions ).toHaveBeenCalledWith( {
+      prompt: loadedPrompt,
+      skills: loadedSkills,
+      tools: undefined,
+      output: undefined,
+      stopWhen: undefined
+    } );
+  } );
+
   it( 'passes option tools through to ToolLoopAgent', async () => {
     const { Agent } = await importSut();
     optionMocks.loadAiSdkTextOptions.mockReturnValueOnce( {
@@ -238,7 +255,7 @@ describe( 'Agent', () => {
     };
     optionMocks.loadAiSdkTextOptions.mockReturnValueOnce( {
       model,
-      system: [ systemMessage ],
+      instructions: [ systemMessage ],
       messages: [ { role: 'user', content: 'Hello' } ]
     } );
 
@@ -255,7 +272,7 @@ describe( 'Agent', () => {
     const { Agent } = await importSut();
     optionMocks.loadAiSdkTextOptions.mockReturnValueOnce( {
       model,
-      system: [],
+      instructions: [],
       messages: [ { role: 'user', content: 'Hello' } ]
     } );
 
@@ -288,7 +305,7 @@ describe( 'Agent', () => {
     const { Agent } = await importSut();
     optionMocks.loadAiSdkTextOptions.mockReturnValueOnce( {
       model,
-      system: [ { role: 'system', content: 'You are concise.' } ],
+      instructions: [ { role: 'system', content: 'You are concise.' } ],
       messages: [
         { role: 'user', content: 'Initial user message' },
         { role: 'assistant', content: 'Authored assistant block' }
@@ -376,7 +393,7 @@ describe( 'Agent', () => {
     const response = { ...aiResponse };
     aiMocks.superStream.mockImplementationOnce( options => {
       options.onChunk( { chunk } );
-      options.onFinish( response );
+      options.onEnd( response );
       return stream;
     } );
     const { Agent } = await importSut();
@@ -409,7 +426,7 @@ describe( 'Agent', () => {
       onChunk,
       abortSignal,
       toolChoice: 'required',
-      onFinish: expect.any( Function ),
+      onEnd: expect.any( Function ),
       onError: expect.any( Function )
     } );
     expect( streamMocks.drainStream ).toHaveBeenCalledWith( stream, abortSignal );
@@ -424,7 +441,7 @@ describe( 'Agent', () => {
   it( 'omits onChunk when generateWithStreaming does not receive it', async () => {
     const stream = { output: Promise.resolve( undefined ) };
     aiMocks.superStream.mockImplementationOnce( options => {
-      options.onFinish( { ...aiResponse } );
+      options.onEnd( { ...aiResponse } );
       return stream;
     } );
     const { Agent } = await importSut();
@@ -453,14 +470,14 @@ describe( 'Agent', () => {
     expect( streamMocks.drainStream ).toHaveBeenCalledWith( stream, abortController.signal );
   } );
 
-  it( 'streams with initial, stored, and caller messages and stores on finish', async () => {
+  it( 'streams with initial, stored, and caller messages and stores on end', async () => {
     const store = {
       getMessages: vi.fn( () => [
         { role: 'assistant', content: 'Stored reply' }
       ] ),
       addMessages: vi.fn()
     };
-    const onFinish = vi.fn();
+    const onEnd = vi.fn();
     const onError = vi.fn();
     const onChunk = vi.fn();
     const callerMessage = { role: 'user', content: 'New question' };
@@ -469,14 +486,14 @@ describe( 'Agent', () => {
 
     const result = await agent.stream( {
       messages: [ callerMessage ],
-      onFinish,
+      onEnd,
       onError,
       onChunk
     } );
 
     expect( validations.parseAgentStreamArgs ).toHaveBeenCalledWith( {
       messages: [ callerMessage ],
-      onFinish,
+      onEnd,
       onError,
       onChunk
     } );
@@ -493,40 +510,40 @@ describe( 'Agent', () => {
       ],
       allowSystemInMessages: true,
       onChunk,
-      onFinish: expect.any( Function ),
+      onEnd: expect.any( Function ),
       onError: expect.any( Function )
     } );
     const streamOptions = aiMocks.superStream.mock.calls[0][0];
-    await streamOptions.onFinish( aiResponse );
-    expect( wrapMocks.streamHooks.onFinishHook ).toHaveBeenCalledWith( aiResponse, expect.any( Function ) );
+    await streamOptions.onEnd( aiResponse );
+    expect( wrapMocks.streamHooks.onEndHook ).toHaveBeenCalledWith( aiResponse, expect.any( Function ) );
     expect( store.addMessages ).toHaveBeenCalledWith( [
       callerMessage,
       assistantMessage
     ] );
-    expect( onFinish ).toHaveBeenCalledWith( aiResponse );
+    expect( onEnd ).toHaveBeenCalledWith( aiResponse );
     expect( result ).toEqual( { textStream: 'stream' } );
   } );
 
-  it( 'logs stream persistence failures and still completes onFinish', async () => {
+  it( 'logs stream persistence failures and still completes onEnd', async () => {
     const persistenceError = new Error( 'Store unavailable' );
     const store = {
       getMessages: vi.fn( () => [] ),
       addMessages: vi.fn().mockRejectedValue( persistenceError )
     };
-    const onFinish = vi.fn();
+    const onEnd = vi.fn();
     const { Agent } = await importSut();
     const agent = new Agent( { prompt: 'test@v1', messageStore: store } );
 
-    const result = await agent.stream( { onFinish } );
+    const result = await agent.stream( { onEnd } );
     const streamOptions = aiMocks.superStream.mock.calls[0][0];
 
-    await expect( streamOptions.onFinish( aiResponse ) ).resolves.toBeUndefined();
+    await expect( streamOptions.onEnd( aiResponse ) ).resolves.toBeUndefined();
 
     expect( loggerMocks.error ).toHaveBeenCalledWith(
       'Agent.stream message store persistence failed',
       { namespace: 'LLM', error: persistenceError.message }
     );
-    expect( onFinish ).toHaveBeenCalledWith( aiResponse );
+    expect( onEnd ).toHaveBeenCalledWith( aiResponse );
     expect( result ).toEqual( { textStream: 'stream' } );
   } );
 
@@ -535,16 +552,16 @@ describe( 'Agent', () => {
       getMessages: vi.fn( () => [] ),
       addMessages: vi.fn()
     };
-    const onFinish = vi.fn();
+    const onEnd = vi.fn();
     const { Agent } = await importSut();
     const agent = new Agent( { prompt: 'test@v1', messageStore: store } );
 
-    await agent.stream( { onFinish } );
+    await agent.stream( { onEnd } );
     const streamOptions = aiMocks.superStream.mock.calls[0][0];
-    await streamOptions.onFinish( { ...aiResponse, finishReason: 'error' } );
+    await streamOptions.onEnd( { ...aiResponse, finishReason: 'error' } );
 
     expect( store.addMessages ).not.toHaveBeenCalled();
-    expect( onFinish ).toHaveBeenCalledWith( { ...aiResponse, finishReason: 'error' } );
+    expect( onEnd ).toHaveBeenCalledWith( { ...aiResponse, finishReason: 'error' } );
   } );
 
   it( 'omits onChunk when stream does not receive it', async () => {

package/src/ai_sdk_options.js

@@ -2,12 +2,36 @@ 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 { stepCountIs } from 'ai';
+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.
  *
@@ -29,15 +53,15 @@ export const loadAiSdkTextOptions = ( { prompt, tools, skills, stopWhen, output,
     throw new FatalError( `Prompt "${prompt.name}" has no chat-style messages. Add role-tagged blocks like <system> or <user>.` );
   }
 
-  const systemMessages = prompt.messages.filter( m => m.role === Role.SYSTEM );
-  const allMessages = prompt.messages.filter( m => m.role !== Role.SYSTEM );
+  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 ( systemMessages.length > 0 ) {
-      systemMessages[0] = { ...systemMessages[0], content: `${systemMessages[0].content}\n\n${skillsMessageContent}` };
+    if ( instructions.length > 0 ) {
+      instructions[0] = { ...instructions[0], content: `${instructions[0].content}\n\n${skillsMessageContent}` };
     } else {
-      systemMessages.push( { role: Role.SYSTEM, content: skillsMessageContent } );
+      instructions.push( { role: Role.SYSTEM, content: skillsMessageContent } );
     }
   }
 
@@ -45,14 +69,12 @@ export const loadAiSdkTextOptions = ( { prompt, tools, skills, stopWhen, output,
     allowSystemInMessages: true,
     maxRetries: 0,
     model: loadTextModel( prompt ),
-    system: systemMessages,
-    messages: allMessages,
-    providerOptions: prompt.config.providerOptions,
+    instructions,
+    messages,
     ...( output && { output } ),
     ...( abortSignal && { abortSignal } ),
     ...( stopWhen && { stopWhen } ),
-    ...( Number.isFinite( prompt.config.temperature ) && { temperature: prompt.config.temperature } ),
-    ...( Number.isFinite( prompt.config.maxTokens ) && { maxOutputTokens: prompt.config.maxTokens } )
+    ...select( textPromptConfigKeys, prompt.config )
   };
 
   // Tools parsing
@@ -65,7 +87,7 @@ export const loadAiSdkTextOptions = ( { prompt, tools, skills, stopWhen, output,
       options.toolChoice = toolChoice;
     }
     if ( !options.stopWhen ) {
-      options.stopWhen = stepCountIs( prompt.config.maxSteps );
+      options.stopWhen = isStepCount( prompt.config.maxSteps );
     }
   }
 
@@ -90,7 +112,7 @@ 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 ) ? {
@@ -98,13 +120,7 @@ export const loadAiSdkImageOptions = ( { prompt, images, mask, abortSignal } ) =
       ...( images && { images } ),
       ...( mask && { mask } )
     } : prompt.instructions,
-    providerOptions: prompt.config.providerOptions,
-    ...( abortSignal && { abortSignal } )
+    ...( 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/ai_sdk_options.spec.js

@@ -16,7 +16,7 @@ vi.mock( './utils/tools.js', () => ( {
 } ) );
 
 vi.mock( 'ai', () => ( {
-  stepCountIs: count => ( { type: 'step-count', count } )
+  isStepCount: count => ( { type: 'step-count', count } )
 } ) );
 
 const importSut = async () => import( './ai_sdk_options.js' );
@@ -72,10 +72,10 @@ describe( 'ai_sdk_options', () => {
       return loadAiSdkTextOptions( { skills: [], ...args } );
     };
 
-    it( 'maps a loaded prompt to model, system, messages, and generation config', async () => {
+    it( 'maps a loaded prompt to model, instructions, messages, and generation config', async () => {
       const prompt = makeTextPrompt( {
         temperature: 0.3,
-        maxTokens: 1000,
+        maxOutputTokens: 1000,
         providerOptions: { anthropic: { effort: 'medium' } }
       } );
 
@@ -87,7 +87,7 @@ describe( 'ai_sdk_options', () => {
         allowSystemInMessages: true,
         maxRetries: 0,
         model: 'MODEL',
-        system: [ { role: 'system', content: 'You are concise.' } ],
+        instructions: [ { role: 'system', content: 'You are concise.' } ],
         messages: [ { role: 'user', content: 'Hello' } ],
         providerOptions: prompt.config.providerOptions,
         temperature: 0.3,
@@ -95,6 +95,24 @@ describe( 'ai_sdk_options', () => {
       } );
     } );
 
+    it( 'forwards all supported text generation options', async () => {
+      const generationOptions = {
+        frequencyPenalty: 0.2,
+        maxOutputTokens: 2000,
+        presencePenalty: 0.3,
+        providerOptions: { openai: { reasoningEffort: 'low' } },
+        seed: 42,
+        stopSequences: [ 'END' ],
+        temperature: 0.4,
+        topK: 40,
+        topP: 0.9
+      };
+
+      const result = await loadText( { prompt: makeTextPrompt( generationOptions ) } );
+
+      expect( result ).toMatchObject( generationOptions );
+    } );
+
     it( 'preserves temperature 0', async () => {
       const result = await loadText( { prompt: makeTextPrompt( { temperature: 0 } ) } );
 
@@ -128,7 +146,7 @@ describe( 'ai_sdk_options', () => {
 
       const result = await loadText( { prompt } );
 
-      expect( result.system ).toEqual( [ {
+      expect( result.instructions ).toEqual( [ {
         role: 'system',
         content: 'Static',
         providerOptions
@@ -136,7 +154,7 @@ describe( 'ai_sdk_options', () => {
       expect( result.messages ).toEqual( [ { role: 'user', content: 'Hello' } ] );
     } );
 
-    it( 'returns an empty system array when the prompt has no system block', async () => {
+    it( 'returns an empty instructions array when the prompt has no system block', async () => {
       const prompt = {
         name: 'no-system@v1',
         config: { provider: 'anthropic', model: 'claude-haiku-4-5' },
@@ -146,11 +164,11 @@ describe( 'ai_sdk_options', () => {
 
       const result = await loadText( { prompt } );
 
-      expect( result.system ).toEqual( [] );
+      expect( result.instructions ).toEqual( [] );
       expect( result.messages ).toEqual( [ { role: 'user', content: 'Hello' } ] );
     } );
 
-    it( 'groups multiple system blocks into system and keeps them out of messages', async () => {
+    it( 'groups multiple system blocks into instructions and keeps them out of messages', async () => {
       const prompt = {
         name: 'multi-system@v1',
         config: { provider: 'anthropic', model: 'claude-haiku-4-5' },
@@ -164,7 +182,7 @@ describe( 'ai_sdk_options', () => {
 
       const result = await loadText( { prompt } );
 
-      expect( result.system ).toEqual( [
+      expect( result.instructions ).toEqual( [
         { role: 'system', content: 'First' },
         { role: 'system', content: 'Second' }
       ] );
@@ -217,7 +235,7 @@ describe( 'ai_sdk_options', () => {
       } );
 
       expect( buildLoadSkillToolImpl ).toHaveBeenCalledWith( [ writerSkill ] );
-      expect( result.system ).toEqual( [
+      expect( result.instructions ).toEqual( [
         { role: 'system', content: `You are concise.\n\n${skillsCatalog}`, providerOptions }
       ] );
       expect( result.messages ).toEqual( [ { role: 'user', content: 'Hello' } ] );
@@ -237,7 +255,7 @@ describe( 'ai_sdk_options', () => {
 
       const result = await loadText( { prompt, skills: [ writerSkill ] } );
 
-      expect( result.system ).toEqual( [ { role: 'system', content: skillsCatalog } ] );
+      expect( result.instructions ).toEqual( [ { role: 'system', content: skillsCatalog } ] );
       expect( result.messages ).toEqual( [ { role: 'user', content: 'Hello' } ] );
     } );
 
@@ -310,7 +328,7 @@ describe( 'ai_sdk_options', () => {
         aspectRatio: '1:1',
         seed: 42,
         temperature: 0.7,
-        maxTokens: 1000,
+        maxOutputTokens: 1000,
         providerOptions: { openai: { quality: 'high' } }
       } );