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

package/src/utils/models.spec.js

@@ -0,0 +1,119 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const getProvider = vi.hoisted( () => vi.fn() );
+
+vi.mock( '../ai_provider.js', () => ( {
+  getProvider
+} ) );
+
+import { loadImageModel, loadTextModel } from './models.js';
+
+afterEach( () => {
+  vi.clearAllMocks();
+} );
+
+describe( 'loadTextModel', () => {
+  it( 'loads a text model using the prompt provider and model', () => {
+    const provider = vi.fn( model => ( { type: 'text-model', model } ) );
+    getProvider.mockReturnValue( provider );
+
+    const result = loadTextModel( {
+      config: {
+        provider: 'openai',
+        model: 'gpt-4o-mini'
+      }
+    } );
+
+    expect( getProvider ).toHaveBeenCalledWith( 'openai' );
+    expect( provider ).toHaveBeenCalledWith( 'gpt-4o-mini' );
+    expect( result ).toEqual( {
+      type: 'text-model',
+      model: 'gpt-4o-mini'
+    } );
+  } );
+
+  it( 'propagates provider lookup errors', () => {
+    getProvider.mockImplementation( () => {
+      throw new Error( 'Unsupported provider "missing"' );
+    } );
+
+    expect( () => loadTextModel( {
+      config: {
+        provider: 'missing',
+        model: 'model'
+      }
+    } ) ).toThrow( 'Unsupported provider "missing"' );
+  } );
+} );
+
+describe( 'loadImageModel', () => {
+  it( 'loads an image model using provider.image', () => {
+    const textProvider = vi.fn();
+    textProvider.image = vi.fn( model => ( { type: 'image-model', model } ) );
+    getProvider.mockReturnValue( textProvider );
+
+    const result = loadImageModel( {
+      config: {
+        provider: 'openai',
+        model: 'gpt-image-1'
+      }
+    } );
+
+    expect( getProvider ).toHaveBeenCalledWith( 'openai' );
+    expect( textProvider.image ).toHaveBeenCalledWith( 'gpt-image-1' );
+    expect( textProvider ).not.toHaveBeenCalled();
+    expect( result ).toEqual( {
+      type: 'image-model',
+      model: 'gpt-image-1'
+    } );
+  } );
+
+  it( 'falls back to provider.imageModel', () => {
+    const provider = vi.fn();
+    provider.imageModel = vi.fn( model => ( { type: 'legacy-image-model', model } ) );
+    getProvider.mockReturnValue( provider );
+
+    const result = loadImageModel( {
+      config: {
+        provider: 'custom',
+        model: 'image-v1'
+      }
+    } );
+
+    expect( provider.imageModel ).toHaveBeenCalledWith( 'image-v1' );
+    expect( result ).toEqual( {
+      type: 'legacy-image-model',
+      model: 'image-v1'
+    } );
+  } );
+
+  it( 'prefers provider.image when both image factories exist', () => {
+    const provider = vi.fn();
+    provider.image = vi.fn( model => ( { type: 'image', model } ) );
+    provider.imageModel = vi.fn( model => ( { type: 'imageModel', model } ) );
+    getProvider.mockReturnValue( provider );
+
+    const result = loadImageModel( {
+      config: {
+        provider: 'custom',
+        model: 'image-v1'
+      }
+    } );
+
+    expect( provider.image ).toHaveBeenCalledWith( 'image-v1' );
+    expect( provider.imageModel ).not.toHaveBeenCalled();
+    expect( result.type ).toBe( 'image' );
+  } );
+
+  it( 'throws a clear error when the provider does not support image models', () => {
+    getProvider.mockReturnValue( vi.fn() );
+
+    expect( () => loadImageModel( {
+      name: 'foo',
+      config: {
+        provider: 'azure',
+        model: 'gpt-image-1'
+      }
+    } ) ).toThrow( 'Provider "azure" used by prompt "foo" does not support image models.' );
+  } );
+} );

package/src/utils/skills.js

@@ -0,0 +1,74 @@
+import { existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
+import { resolve, basename } from 'node:path';
+import matter from 'gray-matter';
+import { ValidationError } from '@outputai/core';
+
+/**
+ * @typedef Skill
+ * @property {string} name
+ * @property {string} description
+ * @property {string} instructions
+ */
+
+/**
+ * Recursively load skill paths. Explicit files may use any extension; directories load `.md` files only.
+ * Frontmatter may provide `name` and `description`; body becomes the instructions.
+ *
+ * @param {string[]} paths
+ * @param {boolean} markdownFilesOnly
+ * @returns {Skills[]}
+ */
+const recursiveLoadSkillPaths = ( paths, markdownFilesOnly ) => {
+  const loaded = [];
+  for ( const path of paths ) {
+    if ( !existsSync( path ) ) {
+      throw new ValidationError( `Skill path "${path}" not found` );
+    }
+    const stats = lstatSync( path );
+    if ( stats.isSymbolicLink() ) {
+      continue;
+    }
+    if ( stats.isDirectory() ) {
+      loaded.push( ...recursiveLoadSkillPaths(
+        readdirSync( path ).sort().map( f => resolve( path, f ) ),
+        true
+      ) );
+      continue;
+    }
+    if ( markdownFilesOnly && !path.endsWith( '.md' ) ) {
+      continue;
+    }
+
+    const raw = readFileSync( path, 'utf-8' );
+    const { data, content } = matter( raw );
+    loaded.push( {
+      name: data.name ?? basename( path, '.md' ),
+      description: data.description ?? basename( path, '.md' ),
+      instructions: content.trim()
+    } );
+  }
+  return loaded;
+};
+
+/**
+ * Recursively load skill files without following symbolic links.
+ *
+ * @param {string[]} paths
+ * @returns {Skills[]}
+ */
+export const recursiveLoadSkillFile = paths => recursiveLoadSkillPaths( paths, false );
+
+/**
+ * Resolve all skills available to a prompt.
+ *
+ * @param {object} prompt - Loaded prompt object
+ * @returns {{ name: string, description: string, instructions: string }[]}
+ */
+export const loadSkills = prompt => {
+  const baseDir = prompt.fileDir;
+
+  // skills referenced in the prompt config
+  const promptSkillPaths = prompt.config.skills.map( f => resolve( baseDir, f ) );
+
+  return recursiveLoadSkillFile( promptSkillPaths );
+};

package/src/utils/skills.spec.js

@@ -0,0 +1,168 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { ValidationError } from '@outputai/core';
+import { loadSkills, recursiveLoadSkillFile } from './skills.js';
+
+const dirs = [];
+
+const tempDir = () => {
+  const dir = mkdtempSync( join( tmpdir(), 'skills-' ) );
+  dirs.push( dir );
+  return dir;
+};
+
+const writeSkill = ( dir, filename, body ) => {
+  writeFileSync( join( dir, filename ), body );
+};
+
+afterEach( () => {
+  for ( const dir of dirs.splice( 0 ) ) {
+    rmSync( dir, { recursive: true, force: true } );
+  }
+} );
+
+describe( 'recursiveLoadSkillFile', () => {
+  it( 'returns an empty array for no paths', () => {
+    expect( recursiveLoadSkillFile( [] ) ).toEqual( [] );
+  } );
+
+  it( 'throws ValidationError when a path is missing', () => {
+    const missing = join( tempDir(), 'gone.md' );
+
+    expect( () => recursiveLoadSkillFile( [ missing ] ) ).toThrow( ValidationError );
+    expect( () => recursiveLoadSkillFile( [ missing ] ) ).toThrow( `Skill path "${missing}" not found` );
+  } );
+
+  it( 'loads an explicitly listed non-md file', () => {
+    const dir = tempDir();
+    writeSkill( dir, 'notes.txt', 'not a skill' );
+
+    expect( recursiveLoadSkillFile( [ join( dir, 'notes.txt' ) ] ) ).toEqual( [
+      { name: 'notes.txt', description: 'notes.txt', instructions: 'not a skill' }
+    ] );
+  } );
+
+  it( 'loads a markdown file and defaults name/description to the basename', () => {
+    const dir = tempDir();
+    writeSkill( dir, 'writer.md', '# Writer\n\nDo the thing.\n' );
+
+    expect( recursiveLoadSkillFile( [ join( dir, 'writer.md' ) ] ) ).toEqual( [ {
+      name: 'writer',
+      description: 'writer',
+      instructions: '# Writer\n\nDo the thing.'
+    } ] );
+  } );
+
+  it( 'uses frontmatter name and description when present', () => {
+    const dir = tempDir();
+    writeSkill( dir, 'file.md', [
+      '---',
+      'name: copywriter',
+      'description: Writes marketing copy',
+      '---',
+      '',
+      'Use a confident tone.'
+    ].join( '\n' ) );
+
+    expect( recursiveLoadSkillFile( [ join( dir, 'file.md' ) ] ) ).toEqual( [ {
+      name: 'copywriter',
+      description: 'Writes marketing copy',
+      instructions: 'Use a confident tone.'
+    } ] );
+  } );
+
+  it( 'returns an empty array for an empty directory', () => {
+    expect( recursiveLoadSkillFile( [ tempDir() ] ) ).toEqual( [] );
+  } );
+
+  it( 'loads markdown files from a directory in sorted order and skips other files', () => {
+    const dir = tempDir();
+    writeSkill( dir, 'z.md', 'zeta' );
+    writeSkill( dir, 'a.md', 'alpha' );
+    writeSkill( dir, 'readme.txt', 'ignore' );
+
+    expect( recursiveLoadSkillFile( [ dir ] ) ).toEqual( [
+      { name: 'a', description: 'a', instructions: 'alpha' },
+      { name: 'z', description: 'z', instructions: 'zeta' }
+    ] );
+  } );
+
+  it( 'recurses into nested directories', () => {
+    const dir = tempDir();
+    const nested = join( dir, 'nested' );
+    mkdirSync( nested );
+    writeSkill( dir, 'root.md', 'root' );
+    writeSkill( nested, 'child.md', 'child' );
+
+    expect( recursiveLoadSkillFile( [ dir ] ) ).toEqual( [
+      { name: 'child', description: 'child', instructions: 'child' },
+      { name: 'root', description: 'root', instructions: 'root' }
+    ] );
+  } );
+
+  it( 'loads files from a directory whose name ends in .md', () => {
+    const dir = tempDir();
+    const nested = join( dir, 'nested.md' );
+    mkdirSync( nested );
+    writeSkill( nested, 'child.md', 'child' );
+
+    expect( recursiveLoadSkillFile( [ nested ] ) ).toEqual( [
+      { name: 'child', description: 'child', instructions: 'child' }
+    ] );
+  } );
+
+  it( 'does not follow directory symlinks', () => {
+    const dir = tempDir();
+    const target = tempDir();
+    writeSkill( target, 'external.md', 'external' );
+    symlinkSync( target, join( dir, 'linked' ), 'dir' );
+
+    expect( recursiveLoadSkillFile( [ dir ] ) ).toEqual( [] );
+  } );
+} );
+
+describe( 'loadSkills', () => {
+  it( 'returns an empty array when the prompt lists no skills', () => {
+    expect( loadSkills( { fileDir: tempDir(), config: { skills: [] } } ) ).toEqual( [] );
+  } );
+
+  it( 'resolves skill paths relative to the prompt fileDir', () => {
+    const fileDir = tempDir();
+    const skillsDir = join( fileDir, 'skills' );
+    mkdirSync( skillsDir );
+    writeSkill( skillsDir, 'reviewer.md', [
+      '---',
+      'name: reviewer',
+      'description: Reviews drafts',
+      '---',
+      'Check the brief.'
+    ].join( '\n' ) );
+
+    expect( loadSkills( {
+      fileDir,
+      config: { skills: [ 'skills/reviewer.md' ] }
+    } ) ).toEqual( [ {
+      name: 'reviewer',
+      description: 'Reviews drafts',
+      instructions: 'Check the brief.'
+    } ] );
+  } );
+
+  it( 'loads a directory listed in prompt config', () => {
+    const fileDir = tempDir();
+    const skillsDir = join( fileDir, 'skills' );
+    mkdirSync( skillsDir );
+    writeSkill( skillsDir, 'one.md', 'first' );
+
+    expect( loadSkills( {
+      fileDir,
+      config: { skills: [ 'skills' ] }
+    } ) ).toEqual( [ {
+      name: 'one',
+      description: 'one',
+      instructions: 'first'
+    } ] );
+  } );
+} );

package/src/utils/sources.js

@@ -0,0 +1,48 @@
+import { createHash } from 'node:crypto';
+
+/** Builds the final source shape */
+const buildSource = ( { url, title } ) => {
+  const trimmedUrl = url.trim();
+  return {
+    type: 'source',
+    sourceType: 'url',
+    id: createHash( 'sha256' ).update( trimmedUrl ).digest( 'hex' ).slice( 0, 16 ),
+    url: trimmedUrl,
+    title: title ?? ''
+  };
+};
+
+/** Return value it is array, otherwise return [] */
+const asArray = v => Array.isArray( v ) ? v : [];
+
+/**
+ * Extracts source URLs from search tool results embedded in AI SDK step data.
+ *
+ * Detects any tool result containing a `results[]` array whose items have a `url` string field.
+ * This covers perplexitySearch, tavilySearch, exaSearch, and any future tool with the same shape.
+ *
+ * @param {Array} steps - AI SDK response steps (response.steps)
+ * @returns {Array<{ type: string, sourceType: string, id: string, url: string, title: string }>}
+ */
+const extractSourcesFromSteps = steps =>
+  asArray( steps )
+    .flatMap( step => asArray( step?.toolResults ) )
+    .flatMap( toolResult => asArray( toolResult?.output?.results ) )
+    .filter( item => typeof item?.url === 'string' && !!item.url.trim() )
+    .map( v => buildSource( v ) );
+
+/**
+ * Extract sources from tools usage and final response, deduplicate, and return.
+ *
+ * Dedup key is `url` when set, otherwise `id` (document sources have `id` and no `url`).
+ * Response sources are preferred over tools when the key matches.
+ *
+ * @param {object} response AI SDK response
+ * @returns {object[]} Merged sources
+ */
+export const extractSources = response => {
+  const { steps, sources: sourcesFromResponse } = response;
+  const sourcesFromTools = extractSourcesFromSteps( steps );
+  const allSources = sourcesFromTools.concat( asArray( sourcesFromResponse ) );
+  return new Map( allSources.map( s => [ s.url ?? s.id, s ] ) ).values().toArray();
+};

package/src/utils/sources.spec.js

@@ -0,0 +1,122 @@
+import { createHash } from 'node:crypto';
+import { describe, it, expect } from 'vitest';
+import { extractSources } from './sources.js';
+
+const hashedId = url => createHash( 'sha256' ).update( url ).digest( 'hex' ).slice( 0, 16 );
+
+const fromSteps = ( steps, sources = [] ) => extractSources( { steps, sources } );
+
+const searchStep = results => ( {
+  toolResults: [ { output: { results } } ]
+} );
+
+describe( 'extractSources', () => {
+  it( 'returns empty when steps and sources are missing or empty', () => {
+    expect( extractSources( {} ) ).toEqual( [] );
+    expect( fromSteps( undefined ) ).toEqual( [] );
+    expect( fromSteps( null ) ).toEqual( [] );
+    expect( fromSteps( [] ) ).toEqual( [] );
+    expect( fromSteps( [ { text: 'hello' } ] ) ).toEqual( [] );
+  } );
+
+  it( 'treats non-array response sources as empty', () => {
+    const steps = [ searchStep( [ { url: 'https://u.test', title: 'T' } ] ) ];
+    expect( extractSources( { steps, sources: undefined } ) ).toHaveLength( 1 );
+    expect( extractSources( { steps, sources: {} } ) ).toHaveLength( 1 );
+  } );
+
+  it( 'skips tool results that are not a results array with urls', () => {
+    const steps = [ {
+      toolResults: [
+        { output: { answer: 'some text' } },
+        { output: { results: [] } },
+        { output: { results: [ { title: 'no url' } ] } },
+        { output: { results: [ { url: '   ' } ] } },
+        { output: 'plain string' }
+      ]
+    } ];
+    expect( fromSteps( steps ) ).toEqual( [] );
+  } );
+
+  it( 'extracts url and title from search-shaped results', () => {
+    const sources = fromSteps( [ searchStep( [
+      { url: 'https://example.com/1', title: 'Example 1', snippet: 'text' },
+      { url: 'https://example.com/2', title: 'Example 2' }
+    ] ) ] );
+
+    expect( sources ).toHaveLength( 2 );
+    expect( sources[0] ).toEqual( {
+      type: 'source',
+      sourceType: 'url',
+      id: hashedId( 'https://example.com/1' ),
+      url: 'https://example.com/1',
+      title: 'Example 1'
+    } );
+    expect( sources[1].url ).toBe( 'https://example.com/2' );
+  } );
+
+  it( 'keeps the last tool hit when urls repeat', () => {
+    const steps = [
+      searchStep( [ { url: 'https://dup.com', title: 'First' } ] ),
+      searchStep( [ { url: 'https://dup.com', title: 'Second' } ] )
+    ];
+    const sources = fromSteps( steps );
+    expect( sources ).toHaveLength( 1 );
+    expect( sources[0].title ).toBe( 'Second' );
+  } );
+
+  it( 'keeps a search hit among mixed tool results', () => {
+    const steps = [ {
+      toolResults: [
+        { output: { calculation: 42 } },
+        { output: { results: [ { url: 'https://real.com', title: 'Real' } ] } },
+        { output: 'plain string' }
+      ]
+    } ];
+    const sources = fromSteps( steps );
+    expect( sources ).toHaveLength( 1 );
+    expect( sources[0].url ).toBe( 'https://real.com' );
+  } );
+
+  it( 'defaults title to empty string when missing', () => {
+    expect( fromSteps( [ searchStep( [ { url: 'https://notitle.com' } ] ) ] )[0].title ).toBe( '' );
+  } );
+
+  it( 'trims urls for storage and id', () => {
+    const sources = fromSteps( [ searchStep( [ { url: '  https://stable.com/path  ', title: 'S' } ] ) ] );
+    expect( sources[0].url ).toBe( 'https://stable.com/path' );
+    expect( sources[0].id ).toBe( hashedId( 'https://stable.com/path' ) );
+    expect( sources[0].id ).toHaveLength( 16 );
+  } );
+
+  it( 'lets response sources win on the same url', () => {
+    const url = 'https://shared.test';
+    const sources = extractSources( {
+      steps: [ searchStep( [ { url, title: 'from-tool' } ] ) ],
+      sources: [ { url, title: 'from-response', type: 'source', sourceType: 'url', id: 'b' } ]
+    } );
+
+    expect( sources ).toHaveLength( 1 );
+    expect( sources[0].title ).toBe( 'from-response' );
+  } );
+
+  it( 'keeps document sources that have id and no url', () => {
+    const docA = { type: 'source', sourceType: 'document', id: 'doc-a', mediaType: 'application/pdf', title: 'A' };
+    const docB = { type: 'source', sourceType: 'document', id: 'doc-b', mediaType: 'application/pdf', title: 'B' };
+
+    expect( extractSources( { sources: [ docA, docB ] } ) ).toEqual( [ docA, docB ] );
+  } );
+
+  it( 'keeps url and document sources together', () => {
+    const url = 'https://page.test';
+    const doc = { type: 'source', sourceType: 'document', id: 'doc-1', title: 'Doc' };
+    const sources = extractSources( {
+      steps: [ searchStep( [ { url, title: 'from-tool' } ] ) ],
+      sources: [ doc ]
+    } );
+
+    expect( sources ).toHaveLength( 2 );
+    expect( sources[0].url ).toBe( url );
+    expect( sources[1] ).toBe( doc );
+  } );
+} );

package/src/utils/stream.js

@@ -0,0 +1,22 @@
+/**
+ * Consumes a streaming result until it completes. Throws on abort or error parts.
+ * Callers must not throw from the AI SDK `onError` callback; that errors the stream before these parts are delivered.
+ *
+ * @param {object} stream - AI SDK stream result with `fullStream`
+ * @param {AbortSignal} [abortSignal] - Used to recover the original abort reason
+ */
+export const drainStream = async ( stream, abortSignal ) => {
+  for await ( const part of stream.fullStream ) {
+    if ( part.type === 'abort' ) {
+      const reason = abortSignal?.reason;
+      throw reason instanceof Error ?
+        reason :
+        new Error( part.reason ?? 'Streaming generation aborted.', { cause: reason } );
+    }
+    if ( part.type === 'error' ) {
+      throw part.error instanceof Error ?
+        part.error :
+        new Error( part.error ? String( part.error ) : 'Streaming generation failed.', { cause: part.error } );
+    }
+  }
+};

package/src/utils/stream.spec.js

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+import { drainStream } from './stream.js';
+
+const asyncParts = parts => ( {
+  async *[Symbol.asyncIterator]() {
+    yield* parts;
+  }
+} );
+
+const streamOf = parts => ( { fullStream: asyncParts( parts ) } );
+
+describe( 'drainStream', () => {
+  it( 'consumes fullStream parts without throwing', async () => {
+    await expect( drainStream( streamOf( [ { type: 'text-delta', text: 'hi' } ] ) ) ).resolves.toBeUndefined();
+  } );
+
+  it( 'throws the abort signal reason when it is an Error', async () => {
+    const abortController = new AbortController();
+    const abortReason = new Error( 'Cancelled by caller' );
+    abortController.abort( abortReason );
+
+    await expect( drainStream(
+      streamOf( [ { type: 'abort', reason: abortReason.message } ] ),
+      abortController.signal
+    ) ).rejects.toBe( abortReason );
+  } );
+
+  it( 'throws part.reason when the abort signal reason is not an Error', async () => {
+    const abortController = new AbortController();
+    abortController.abort( 'cancelled' );
+
+    await expect( drainStream(
+      streamOf( [ { type: 'abort', reason: 'from-part' } ] ),
+      abortController.signal
+    ) ).rejects.toMatchObject( { message: 'from-part', cause: 'cancelled' } );
+  } );
+
+  it( 'throws a generic abort error when no reason is available', async () => {
+    await expect( drainStream( streamOf( [ { type: 'abort' } ] ) ) ).rejects.toThrow( 'Streaming generation aborted.' );
+  } );
+
+  it( 'throws the provider error when the error part is an Error', async () => {
+    const error = new Error( 'Provider failed' );
+
+    await expect( drainStream( streamOf( [ { type: 'error', error } ] ) ) ).rejects.toBe( error );
+  } );
+
+  it( 'wraps a non-Error error part', async () => {
+    await expect( drainStream( streamOf( [ { type: 'error', error: 'no model' } ] ) ) ).rejects.toThrow( 'no model' );
+  } );
+
+  it( 'throws a generic stream error when the error part has no value', async () => {
+    await expect( drainStream( streamOf( [ { type: 'error', error: null } ] ) ) ).rejects.toThrow( 'Streaming generation failed.' );
+  } );
+} );

package/src/utils/tools.js

@@ -0,0 +1,47 @@
+import { tool as createTool } from 'ai';
+import { ValidationError, z } from '@outputai/core';
+import { getProvider } from '../ai_provider.js';
+
+/**
+ * Build the `load_skill` AI SDK tool that the LLM calls to retrieve full skill instructions.
+ *
+ * @param {Skill[]} skills
+ * @returns {import('ai').Tool}
+ */
+export const buildLoadSkillTool = skills => createTool( {
+  description: 'Get detailed instructions for a named skill',
+  inputSchema: z.object( { name: z.string().describe( 'Name of the skill to load' ) } ),
+  execute: ( { name } ) => {
+    const sk = skills.find( s => s.name === name );
+    if ( !sk ) {
+      return `Skill "${name}" not found. Available: ${skills.map( s => s.name ).join( ', ' )}`;
+    }
+    return sk.instructions;
+  }
+} );
+
+const buildProviderError = ( prompt, suffix ) => `Provider "${prompt.config.provider}" used by prompt "${prompt.name}" does not support ${suffix}.`;
+
+/** Load tools from a prompt provider. */
+export const loadPromptTools = prompt => {
+  const promptToolNames = Object.keys( prompt.config.tools ?? {} );
+  if ( promptToolNames.length === 0 ) {
+    return null;
+  }
+
+  const { tools } = getProvider( prompt.config.provider );
+  if ( !tools ) {
+    throw new ValidationError( buildProviderError( prompt, 'provider-specific tools' ) );
+  }
+
+  const missingTools = promptToolNames.filter( t => !Object.hasOwn( tools, t ) || typeof tools[t] !== 'function' );
+  if ( missingTools.length > 0 ) {
+    throw new ValidationError( buildProviderError( prompt, `these tools: ${missingTools.join( ', ' )}` ) );
+  }
+
+  const loadedTools = {};
+  for ( const name of promptToolNames ) {
+    loadedTools[name] = tools[name]( prompt.config.tools[name] );
+  }
+  return loadedTools;
+};