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

package/src/validations.spec.js

@@ -1,101 +1,310 @@
 import { describe, it, expect } from 'vitest';
 import { ValidationError } from '@outputai/core';
-import { validateGenerateTextArgs, validateStreamTextArgs, validateGenerateImageArgs } from './validations.js';
+import {
+  parseGenerateTextArgs,
+  parseGenerateTextWithStreamingArgs,
+  parseStreamTextArgs,
+  parseGenerateImageArgs,
+  parseAgentArgs,
+  parseAgentGenerateArgs,
+  parseAgentGenerateWithStreamingArgs,
+  parseAgentStreamArgs
+} from './validations.js';
 
-describe( 'validateGenerateTextArgs', () => {
-  it( 'accepts a prompt with optional variables', () => {
-    expect( () => validateGenerateTextArgs( {
+const makeOutput = () => ( { name: 'object' } );
+
+const searchTool = { description: 'Search' };
+const stopWhen = () => false;
+
+describe( 'parseGenerateTextArgs', () => {
+  it( 'renames prompt to promptFile and keeps allowlisted leftovers', () => {
+    const abortSignal = AbortSignal.abort();
+    const tools = { search: searchTool };
+    const output = makeOutput();
+
+    expect( parseGenerateTextArgs( {
       prompt: 'summary@v1',
-      variables: { topic: 'testing' },
+      variables: { topic: 'testing', count: 2, draft: false },
       promptDir: '/prompts',
-      skills: [ { name: 'style', description: 'Style', instructions: '# Style' } ],
-      maxSteps: 4
-    } ) ).not.toThrow();
+      tools,
+      output,
+      toolChoice: { type: 'tool', toolName: 'search' },
+      stopWhen,
+      abortSignal
+    } ) ).toEqual( {
+      promptFile: 'summary@v1',
+      variables: { topic: 'testing', count: 2, draft: false },
+      promptDir: '/prompts',
+      tools,
+      output,
+      toolChoice: { type: 'tool', toolName: 'search' },
+      stopWhen,
+      abortSignal
+    } );
   } );
 
-  it( 'accepts a dynamic skills function', () => {
-    expect( () => validateGenerateTextArgs( {
+  it( 'accepts an array of stopWhen functions', () => {
+    const parsed = parseGenerateTextArgs( {
       prompt: 'summary@v1',
-      skills: () => [ { name: 'style', description: 'Style', instructions: '# Style' } ]
-    } ) ).not.toThrow();
+      stopWhen: [ stopWhen ]
+    } );
+
+    expect( parsed.stopWhen ).toEqual( [ stopWhen ] );
   } );
 
   it( 'throws ValidationError with generateText prefix for invalid args', () => {
-    expect( () => validateGenerateTextArgs( {
+    expect( () => parseGenerateTextArgs( {
       variables: { topic: 'testing' }
     } ) ).toThrow( ValidationError );
 
-    expect( () => validateGenerateTextArgs( {
+    expect( () => parseGenerateTextArgs( {
       prompt: 123
     } ) ).toThrow( /Invalid generateText\(\) arguments/ );
-  } );
 
-  it( 'throws ValidationError for invalid promptDir, skills, or maxSteps', () => {
-    expect( () => validateGenerateTextArgs( {
+    expect( () => parseGenerateTextArgs( {
       prompt: 'summary@v1',
       promptDir: ''
     } ) ).toThrow( ValidationError );
 
-    expect( () => validateGenerateTextArgs( {
+    expect( () => parseGenerateTextArgs( {
       prompt: 'summary@v1',
-      skills: [ { name: '', description: 'Style', instructions: '# Style' } ]
+      abortSignal: {}
     } ) ).toThrow( ValidationError );
+  } );
 
-    expect( () => validateGenerateTextArgs( {
+  it( 'does not keep prompt-owned call arguments on the parsed result', () => {
+    expect( () => parseGenerateTextArgs( {
       prompt: 'summary@v1',
-      maxSteps: 0
+      skills: [ { name: 'style', description: 'Style', instructions: '# Style' } ]
+    } ) ).toThrow( /skills must be set in the prompt file/ );
+
+    expect( () => parseGenerateTextArgs( {
+      prompt: 'summary@v1',
+      maxSteps: 4,
+      skills: [ './writer.md' ]
+    } ) ).toThrow( /must be set in the prompt file/ );
+  } );
+
+  it( 'throws ValidationError for unrecognized call arguments', () => {
+    expect( () => parseGenerateTextArgs( {
+      prompt: 'summary@v1',
+      temperature: 0.2
+    } ) ).toThrow( /unrecognized key/i );
+
+    expect( () => parseGenerateTextArgs( {
+      prompt: 'summary@v1',
+      maxRetries: 2
+    } ) ).toThrow( /unrecognized key/i );
+
+    expect( () => parseGenerateTextArgs( {
+      prompt: 'summary@v1',
+      onChunk: () => {}
+    } ) ).toThrow( /unrecognized key/i );
+  } );
+
+  it( 'accepts nested objects and arrays as variables', () => {
+    const variables = {
+      company: { name: 'Acme', industries: [ 'SaaS', 'AI' ] },
+      criteria: [ { name: 'Accuracy', required: true } ]
+    };
+
+    expect( parseGenerateTextArgs( {
+      prompt: 'summary@v1',
+      variables
+    } ).variables ).toEqual( variables );
+  } );
+
+  it( 'throws ValidationError for invalid allowlisted field shapes', () => {
+    expect( () => parseGenerateTextArgs( {
+      prompt: 'summary@v1',
+      variables: [ 'not a record' ]
+    } ) ).toThrow( ValidationError );
+
+    expect( () => parseGenerateTextArgs( {
+      prompt: 'summary@v1',
+      tools: { search: true }
+    } ) ).toThrow( ValidationError );
+
+    expect( () => parseGenerateTextArgs( {
+      prompt: 'summary@v1',
+      output: true
+    } ) ).toThrow( ValidationError );
+
+    expect( () => parseGenerateTextArgs( {
+      prompt: 'summary@v1',
+      stopWhen: { type: 'custom-stop' }
+    } ) ).toThrow( ValidationError );
+
+    expect( () => parseGenerateTextArgs( {
+      prompt: 'summary@v1',
+      toolChoice: 'maybe'
     } ) ).toThrow( ValidationError );
   } );
-} );
 
-describe( 'validateStreamTextArgs', () => {
-  it( 'accepts a prompt with optional variables', () => {
-    expect( () => validateStreamTextArgs( {
+  it( 'accepts opaque tools and output objects', () => {
+    expect( parseGenerateTextArgs( {
       prompt: 'summary@v1',
-      variables: [ 'arrays are accepted by the current schema' ],
-      promptDir: '/prompts',
-      skills: [ { name: 'style', description: 'Style', instructions: '# Style' } ],
-      maxSteps: 4
-    } ) ).not.toThrow();
+      tools: { search: { description: 'Search' } },
+      output: { type: 'object' }
+    } ) ).toMatchObject( {
+      tools: { search: { description: 'Search' } },
+      output: { type: 'object' }
+    } );
   } );
 
-  it( 'accepts a dynamic skills function', () => {
-    expect( () => validateStreamTextArgs( {
+  it( 'preserves class-based tool and output identities', () => {
+    class TestTool {
+      #result = 'searched';
+
+      execute() {
+        return this.#result;
+      }
+    }
+
+    class TestOutput {
+      #result = 'parsed';
+
+      parseCompleteOutput() {
+        return this.#result;
+      }
+    }
+
+    const tool = new TestTool();
+    const output = new TestOutput();
+    const parsed = parseGenerateTextArgs( {
       prompt: 'summary@v1',
-      skills: () => [ { name: 'style', description: 'Style', instructions: '# Style' } ]
-    } ) ).not.toThrow();
+      tools: { search: tool },
+      output
+    } );
+
+    expect( parsed.tools.search ).toBe( tool );
+    expect( parsed.tools.search.execute() ).toBe( 'searched' );
+    expect( parsed.output ).toBe( output );
+    expect( parsed.output.parseCompleteOutput() ).toBe( 'parsed' );
   } );
+} );
 
-  it( 'throws ValidationError with streamText prefix for invalid args', () => {
-    expect( () => validateStreamTextArgs( {} ) ).toThrow( ValidationError );
-    expect( () => validateStreamTextArgs( { prompt: null } ) ).toThrow( /Invalid streamText\(\) arguments/ );
+describe( 'parseStreamTextArgs', () => {
+  it( 'keeps stream callbacks on the parsed result', () => {
+    const parsed = parseStreamTextArgs( {
+      prompt: 'summary@v1',
+      variables: { topic: 'testing' },
+      promptDir: '/prompts',
+      onFinish: () => {},
+      onError: () => {},
+      onChunk: () => {}
+    } );
+
+    expect( parsed.promptFile ).toBe( 'summary@v1' );
+    expect( parsed.variables ).toEqual( { topic: 'testing' } );
+    expect( parsed.promptDir ).toBe( '/prompts' );
+    expect( parsed.onFinish ).toBeTypeOf( 'function' );
+    expect( parsed.onError ).toBeTypeOf( 'function' );
+    expect( parsed.onChunk ).toBeTypeOf( 'function' );
   } );
 
-  it( 'throws ValidationError for invalid promptDir, skills, or maxSteps', () => {
-    expect( () => validateStreamTextArgs( {
+  it( 'throws ValidationError with streamText prefix for invalid args', () => {
+    expect( () => parseStreamTextArgs( {} ) ).toThrow( ValidationError );
+    expect( () => parseStreamTextArgs( { prompt: null } ) ).toThrow( /Invalid streamText\(\) arguments/ );
+
+    expect( () => parseStreamTextArgs( {
       prompt: 'summary@v1',
       promptDir: ''
     } ) ).toThrow( ValidationError );
+  } );
 
-    expect( () => validateStreamTextArgs( {
+  it( 'throws ValidationError for invalid callbacks', () => {
+    expect( () => parseStreamTextArgs( {
       prompt: 'summary@v1',
-      skills: [ { name: 'style', description: 'Style', instructions: '' } ]
+      onFinish: 'not a function'
     } ) ).toThrow( ValidationError );
 
-    expect( () => validateStreamTextArgs( {
+    expect( () => parseStreamTextArgs( {
       prompt: 'summary@v1',
-      maxSteps: 1.5
+      onError: {}
     } ) ).toThrow( ValidationError );
+
+    expect( () => parseStreamTextArgs( {
+      prompt: 'summary@v1',
+      onChunk: 'not a function'
+    } ) ).toThrow( ValidationError );
+  } );
+
+  it( 'throws ValidationError for unrecognized call arguments', () => {
+    expect( () => parseStreamTextArgs( {
+      prompt: 'summary@v1',
+      temperature: 0.2
+    } ) ).toThrow( /unrecognized key/i );
+
+    expect( () => parseStreamTextArgs( {
+      prompt: 'summary@v1',
+      skills: [ { name: 'style', description: 'Style', instructions: '# Style' } ]
+    } ) ).toThrow( /skills must be set in the prompt file/ );
+
+    expect( () => parseStreamTextArgs( {
+      prompt: 'summary@v1',
+      maxSteps: 1.5
+    } ) ).toThrow( /maxSteps must be set in the prompt file/ );
+  } );
+} );
+
+describe( 'parseGenerateTextWithStreamingArgs', () => {
+  it( 'keeps onChunk and omits streamText-only callbacks', () => {
+    const parsed = parseGenerateTextWithStreamingArgs( {
+      prompt: 'summary@v1',
+      onChunk: () => {}
+    } );
+
+    expect( parsed.promptFile ).toBe( 'summary@v1' );
+    expect( parsed.onChunk ).toBeTypeOf( 'function' );
+
+    expect( () => parseGenerateTextWithStreamingArgs( {
+      prompt: 'summary@v1',
+      onFinish: () => {}
+    } ) ).toThrow( /unrecognized key/i );
+  } );
+
+  it( 'uses the generateTextWithStreaming error prefix', () => {
+    expect( () => parseGenerateTextWithStreamingArgs( {
+      prompt: 'summary@v1',
+      maxSteps: 0
+    } ) ).toThrow( /Invalid generateTextWithStreaming\(\) arguments[\s\S]*maxSteps must be set in the prompt file/ );
   } );
 } );
 
-describe( 'validateGenerateImageArgs', () => {
+describe( 'parseGenerateImageArgs', () => {
+  it( 'renames prompt to promptFile and keeps allowlisted leftovers', () => {
+    const images = [ Buffer.from( 'image-bytes' ) ];
+    const mask = Buffer.from( 'mask-bytes' );
+    const abortSignal = AbortSignal.abort();
+
+    expect( parseGenerateImageArgs( {
+      prompt: 'image@v1',
+      variables: { scene: 'race cars' },
+      promptDir: '/prompts',
+      images,
+      mask,
+      abortSignal
+    } ) ).toEqual( {
+      promptFile: 'image@v1',
+      variables: { scene: 'race cars' },
+      promptDir: '/prompts',
+      images,
+      mask,
+      abortSignal
+    } );
+  } );
+
   it( 'accepts text-to-image args without images or mask', () => {
-    expect( () => validateGenerateImageArgs( {
+    expect( parseGenerateImageArgs( {
       prompt: 'image@v1',
       variables: { topic: 'race cars' },
       promptDir: '/prompts'
-    } ) ).not.toThrow();
+    } ) ).toEqual( {
+      promptFile: 'image@v1',
+      variables: { topic: 'race cars' },
+      promptDir: '/prompts'
+    } );
   } );
 
   it( 'accepts all supported image input shapes', () => {
@@ -105,7 +314,7 @@ describe( 'validateGenerateImageArgs', () => {
     const paddedBase64 = 'aW1hZ2UtYnl0ZXM=';
     const unpaddedBase64 = 'aW1hZ2U';
 
-    expect( () => validateGenerateImageArgs( {
+    expect( () => parseGenerateImageArgs( {
       prompt: 'image@v1',
       images: [
         buffer,
@@ -123,21 +332,21 @@ describe( 'validateGenerateImageArgs', () => {
   } );
 
   it( 'throws ValidationError for invalid image args', () => {
-    expect( () => validateGenerateImageArgs( {
+    expect( () => parseGenerateImageArgs( {
       prompt: ''
     } ) ).toThrow( /Invalid generateImage\(\) arguments/ );
 
-    expect( () => validateGenerateImageArgs( {
+    expect( () => parseGenerateImageArgs( {
       prompt: 'image@v1',
       images: []
     } ) ).toThrow( ValidationError );
 
-    expect( () => validateGenerateImageArgs( {
+    expect( () => parseGenerateImageArgs( {
       prompt: 'image@v1',
       images: [ { data: null } ]
     } ) ).toThrow( ValidationError );
 
-    expect( () => validateGenerateImageArgs( {
+    expect( () => parseGenerateImageArgs( {
       prompt: 'image@v1',
       images: [ { data: 'aW1hZ2U=', mediaType: '' } ]
     } ) ).toThrow( ValidationError );
@@ -150,7 +359,7 @@ describe( 'validateGenerateImageArgs', () => {
       'not base64',
       'abcde'
     ] ) {
-      expect( () => validateGenerateImageArgs( {
+      expect( () => parseGenerateImageArgs( {
         prompt: 'image@v1',
         images: [ image ]
       } ) ).toThrow( /Image strings must be raw base64 data/ );
@@ -158,9 +367,198 @@ describe( 'validateGenerateImageArgs', () => {
   } );
 
   it( 'requires images when mask is provided', () => {
-    expect( () => validateGenerateImageArgs( {
+    expect( () => parseGenerateImageArgs( {
       prompt: 'image@v1',
       mask: Buffer.from( 'mask-bytes' )
     } ) ).toThrow( /mask requires images/ );
   } );
+
+  it( 'throws ValidationError for unrecognized or prompt-owned call arguments', () => {
+    expect( () => parseGenerateImageArgs( {
+      prompt: 'image@v1',
+      size: '1024x1024',
+      n: 2
+    } ) ).toThrow( /unrecognized key/i );
+
+    expect( () => parseGenerateImageArgs( {
+      prompt: 'image@v1',
+      aspectRatio: '1:1'
+    } ) ).toThrow( /unrecognized key/i );
+
+    expect( () => parseGenerateImageArgs( {
+      prompt: 'image@v1',
+      providerOptions: { openai: { quality: 'high' } }
+    } ) ).toThrow( /unrecognized key/i );
+
+    expect( () => parseGenerateImageArgs( {
+      prompt: 'image@v1',
+      maxSteps: 4
+    } ) ).toThrow( /unrecognized key/i );
+  } );
+} );
+
+describe( 'parseAgentArgs', () => {
+  it( 'renames prompt to promptFile and keeps allowlisted leftovers', () => {
+    const tools = { search: searchTool };
+    const output = makeOutput();
+    const messageStore = { getMessages() {}, addMessages() {} };
+
+    const parsed = parseAgentArgs( {
+      prompt: 'summary@v1',
+      variables: { topic: 'testing' },
+      promptDir: '/prompts',
+      tools,
+      output,
+      stopWhen,
+      messageStore
+    } );
+
+    expect( parsed ).toEqual( {
+      promptFile: 'summary@v1',
+      variables: { topic: 'testing' },
+      promptDir: '/prompts',
+      tools,
+      output,
+      stopWhen,
+      messageStore
+    } );
+    expect( parsed.messageStore ).toBe( messageStore );
+  } );
+
+  it( 'preserves class-based message store identity', () => {
+    class TestMessageStore {
+      #messages = [];
+
+      getMessages() {
+        return this.#messages;
+      }
+
+      addMessages( messages ) {
+        this.#messages.push( ...messages );
+      }
+    }
+
+    const messageStore = new TestMessageStore();
+    const parsed = parseAgentArgs( {
+      prompt: 'summary@v1',
+      messageStore
+    } );
+    const message = { role: 'user', content: 'Hello' };
+
+    parsed.messageStore.addMessages( [ message ] );
+
+    expect( parsed.messageStore ).toBe( messageStore );
+    expect( parsed.messageStore.getMessages() ).toEqual( [ message ] );
+  } );
+
+  it( 'throws ValidationError with Agent prefix for invalid args', () => {
+    expect( () => parseAgentArgs( {} ) ).toThrow( ValidationError );
+    expect( () => parseAgentArgs( { prompt: '' } ) ).toThrow( /Invalid Agent\(\) arguments/ );
+
+    expect( () => parseAgentArgs( {
+      prompt: 'summary@v1',
+      promptDir: ''
+    } ) ).toThrow( ValidationError );
+  } );
+
+  it( 'does not keep prompt-owned call arguments on the parsed result', () => {
+    expect( () => parseAgentArgs( {
+      prompt: 'summary@v1',
+      skills: [ { name: 'style', description: 'Style', instructions: '# Style' } ]
+    } ) ).toThrow( /skills must be set in the prompt file/ );
+
+    expect( () => parseAgentArgs( {
+      prompt: 'summary@v1',
+      maxSteps: 4,
+      skills: [ './writer.md' ]
+    } ) ).toThrow( /must be set in the prompt file/ );
+  } );
+
+  it( 'throws ValidationError for unrecognized constructor arguments', () => {
+    expect( () => parseAgentArgs( {
+      prompt: 'summary@v1',
+      temperature: 0.2
+    } ) ).toThrow( /unrecognized key/i );
+  } );
+
+  it( 'throws ValidationError for an invalid message store', () => {
+    expect( () => parseAgentArgs( {
+      prompt: 'summary@v1',
+      messageStore: { getMessages() {} }
+    } ) ).toThrow( ValidationError );
+  } );
+} );
+
+describe( 'parseAgentGenerateArgs', () => {
+  it( 'defaults omitted args and messages to an empty list', () => {
+    expect( parseAgentGenerateArgs() ).toEqual( { messages: [] } );
+    expect( parseAgentGenerateArgs( undefined ) ).toEqual( { messages: [] } );
+    expect( parseAgentGenerateArgs( {} ) ).toEqual( { messages: [] } );
+  } );
+
+  it( 'keeps allowlisted generate options', () => {
+    const messages = [ { role: 'user', content: 'Hello' } ];
+    const abortSignal = AbortSignal.abort();
+
+    expect( parseAgentGenerateArgs( {
+      messages,
+      abortSignal,
+      toolChoice: 'required'
+    } ) ).toEqual( {
+      messages,
+      abortSignal,
+      toolChoice: 'required'
+    } );
+  } );
+
+  it( 'throws ValidationError for unrecognized or prompt-owned call arguments', () => {
+    expect( () => parseAgentGenerateArgs( { temperature: 0.2 } ) ).toThrow( /unrecognized key/i );
+    expect( () => parseAgentGenerateArgs( { onChunk: () => {} } ) ).toThrow( /unrecognized key/i );
+    expect( () => parseAgentGenerateArgs( { maxSteps: 4 } ) ).toThrow( /maxSteps must be set in the prompt file/ );
+  } );
+
+  it( 'throws ValidationError for invalid messages or toolChoice', () => {
+    expect( () => parseAgentGenerateArgs( {
+      messages: [ { content: 'Hello' } ]
+    } ) ).toThrow( ValidationError );
+
+    expect( () => parseAgentGenerateArgs( {
+      messages: [ { role: 'moderator', content: 'Hello' } ]
+    } ) ).toThrow( ValidationError );
+
+    expect( () => parseAgentGenerateArgs( {
+      toolChoice: { type: 'tool' }
+    } ) ).toThrow( ValidationError );
+  } );
+} );
+
+describe( 'parseAgentGenerateWithStreamingArgs', () => {
+  it( 'defaults omitted args and accepts onChunk', () => {
+    expect( parseAgentGenerateWithStreamingArgs() ).toEqual( { messages: [] } );
+
+    const parsed = parseAgentGenerateWithStreamingArgs( { onChunk: () => {} } );
+    expect( parsed.messages ).toEqual( [] );
+    expect( parsed.onChunk ).toBeTypeOf( 'function' );
+  } );
+
+  it( 'rejects stream-only callbacks', () => {
+    expect( () => parseAgentGenerateWithStreamingArgs( { onFinish: () => {} } ) ).toThrow( /unrecognized key/i );
+  } );
+} );
+
+describe( 'parseAgentStreamArgs', () => {
+  it( 'defaults omitted args and keeps stream callbacks', () => {
+    expect( parseAgentStreamArgs() ).toEqual( { messages: [] } );
+
+    const parsed = parseAgentStreamArgs( {
+      onFinish: () => {},
+      onError: () => {},
+      onChunk: () => {}
+    } );
+
+    expect( parsed.messages ).toEqual( [] );
+    expect( parsed.onFinish ).toBeTypeOf( 'function' );
+    expect( parsed.onError ).toBeTypeOf( 'function' );
+    expect( parsed.onChunk ).toBeTypeOf( 'function' );
+  } );
 } );

package/src/ai_model.js

@@ -1,60 +0,0 @@
-import { ValidationError } from '@outputai/core';
-import { getProvider } from './ai_provider.js';
-
-/**
- * Load a text model from a loaded prompt config.
- *
- * @param {object} prompt - Loaded prompt object with `config.provider` and `config.model`
- * @returns {unknown} AI SDK language model
- */
-export const loadTextModel = prompt => getProvider( prompt.config.provider )( prompt.config.model );
-
-/**
- * Load an image model from a loaded prompt config.
- *
- * @param {object} prompt - Loaded prompt object with `config.provider` and `config.model`
- * @returns {unknown} AI SDK image model
- */
-export const loadImageModel = prompt => {
-  const { provider: providerName, model } = prompt.config;
-  const provider = getProvider( prompt.config.provider );
-
-  const imageModelFactory = provider.image ?? provider.imageModel;
-  if ( typeof imageModelFactory !== 'function' ) {
-    throw new ValidationError( `Provider "${providerName}" does not support image models.` );
-  }
-  return imageModelFactory( model );
-};
-
-/**
- * Load provider-specific tools configured in a prompt.
- *
- * @param {object} prompt - Loaded prompt object with `config.provider` and optional `config.tools`
- * @returns {Record<string, unknown> | null} AI SDK tools, or null when none are configured
- */
-export const loadTools = prompt => {
-  const { tools: promptTools, provider: providerName } = prompt.config;
-
-  if ( Object.keys( promptTools ?? {} ).length === 0 ) {
-    return null;
-  }
-
-  const provider = getProvider( providerName );
-
-  if ( !provider.tools ) {
-    throw new ValidationError( `Provider "${providerName}" does not support provider-specific tools.` );
-  }
-
-  const supportedTools = Object.keys( provider.tools );
-  const invalidTools = Object.keys( promptTools ).filter( name => !supportedTools.includes( name ) );
-
-  if ( invalidTools.length > 0 ) {
-    throw new ValidationError( `Invalid tool(s) ${invalidTools.join( ', ' )} for provider "${providerName}". \
-Available: ${supportedTools.join( ', ' )}.` );
-  }
-
-  // load all tools and return in an object
-  return Object.fromEntries(
-    Object.entries( promptTools ).map( ( [ name, args ] ) => [ name, provider.tools[name]( args ) ] )
-  );
-};