@output.ai/llm 0.2.10 → 0.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/llm",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Framework abstraction to interact with LLM models",
   "type": "module",
   "main": "src/index.js",

package/src/ai_model.js

@@ -33,3 +33,79 @@ export function loadModel( prompt ) {
 
   return provider( modelName );
 }
+
+export function loadTools( prompt ) {
+  const config = prompt?.config;
+  const toolsConfig = config?.tools;
+
+  if ( !toolsConfig ) {
+    return null;
+  }
+
+  if ( Array.isArray( toolsConfig ) ) {
+    throw new Error(
+      'tools must be an object with tool configurations, got array. ' +
+      'Use "tools: { googleSearch: {} }" not "tools: [googleSearch]"'
+    );
+  }
+
+  if ( typeof toolsConfig !== 'object' || toolsConfig === null ) {
+    throw new Error(
+      `tools must be an object, got ${typeof toolsConfig}. ` +
+      'Use "tools: { googleSearch: {} }"'
+    );
+  }
+
+  // Return null if empty object
+  if ( Object.keys( toolsConfig ).length === 0 ) {
+    return null;
+  }
+
+  const providerName = config.provider;
+  const provider = providers[providerName];
+
+  if ( !provider ) {
+    const validProviders = Object.keys( providers ).join( ', ' );
+    throw new Error(
+      `Invalid provider "${providerName}". Valid providers: ${validProviders}`
+    );
+  }
+
+  // Check if provider has tools object
+  if ( !provider.tools || typeof provider.tools !== 'object' ) {
+    throw new Error(
+      `Provider "${providerName}" does not support provider-specific tools.`
+    );
+  }
+
+  const tools = {};
+
+  for ( const [ toolName, toolConfig ] of Object.entries( toolsConfig ) ) {
+    // Access tool factory directly from provider.tools (dynamic!)
+    const toolFactory = provider.tools[toolName];
+
+    if ( !toolFactory || typeof toolFactory !== 'function' ) {
+      // Dynamically list available tools for this provider
+      const availableTools = Object.keys( provider.tools )
+        .filter( key => typeof provider.tools[key] === 'function' )
+        .join( ', ' );
+
+      throw new Error(
+        `Unknown tool "${toolName}" for provider "${providerName}".` +
+        ( availableTools ? ` Available tools: ${availableTools}` : '' )
+      );
+    }
+
+    if ( typeof toolConfig !== 'object' || toolConfig === null ) {
+      throw new Error(
+        `Configuration for tool "${toolName}" must be an object. ` +
+        `Use "${toolName}: {}" for tools without configuration.`
+      );
+    }
+
+    // Call factory with config - this passes configuration to AI SDK
+    tools[toolName] = toolFactory( toolConfig );
+  }
+
+  return tools;
+}

package/src/ai_model.spec.js

@@ -1,33 +1,602 @@
-import { it, expect, vi, afterEach } from 'vitest';
+import { it, expect, vi, afterEach, describe } from 'vitest';
 
 const openaiImpl = vi.fn( model => `openai:${model}` );
 const azureImpl = vi.fn( model => `azure:${model}` );
 const anthropicImpl = vi.fn( model => `anthropic:${model}` );
 
-vi.mock( '@ai-sdk/openai', () => ( {
-  openai: ( ...values ) => openaiImpl( ...values )
-} ) );
+// OpenAI mock with tools support
+vi.mock( '@ai-sdk/openai', () => {
+  const openaiMock = ( ...values ) => openaiImpl( ...values );
+  openaiMock.tools = {
+    webSearch: ( config = {} ) => ( { type: 'webSearch', config } )
+  };
+  return { openai: openaiMock };
+} );
 
+// Azure mock without tools support
 vi.mock( '@ai-sdk/azure', () => ( {
   azure: ( ...values ) => azureImpl( ...values )
 } ) );
 
-vi.mock( '@ai-sdk/anthropic', () => ( {
-  anthropic: ( ...values ) => anthropicImpl( ...values )
-} ) );
+// Anthropic mock with tools support
+vi.mock( '@ai-sdk/anthropic', () => {
+  const anthropicMock = ( ...values ) => anthropicImpl( ...values );
+  anthropicMock.tools = {
+    webSearch_20250305: ( config = {} ) => ( { type: 'webSearch_20250305', config } ),
+    bash_20241022: ( config = {} ) => ( { type: 'bash_20241022', config } ),
+    bash_20250124: ( config = {} ) => ( { type: 'bash_20250124', config } ),
+    codeExecution_20250522: ( config = {} ) => ( { type: 'codeExecution_20250522', config } ),
+    codeExecution_20250825: ( config = {} ) => ( { type: 'codeExecution_20250825', config } )
+  };
+  return { anthropic: anthropicMock };
+} );
 
-import { loadModel } from './ai_model.js';
+// Vertex mock with tools support
+vi.mock( '@ai-sdk/google-vertex', () => {
+  const vertexFn = model => `vertex:${model}`;
+  vertexFn.tools = {
+    googleSearch: ( config = {} ) => ( { type: 'googleSearch', config } ),
+    fileSearch: ( config = {} ) => ( { type: 'fileSearch', config } ),
+    urlContext: ( config = {} ) => ( { type: 'urlContext', config } ),
+    enterpriseWebSearch: ( config = {} ) => ( { type: 'enterpriseWebSearch', config } ),
+    googleMaps: ( config = {} ) => ( { type: 'googleMaps', config } ),
+    codeExecution: ( config = {} ) => ( { type: 'codeExecution', config } ),
+    vertexRagStore: ( config = {} ) => ( { type: 'vertexRagStore', config } )
+  };
+  return { vertex: vertexFn };
+} );
+
+import { loadModel, loadTools } from './ai_model.js';
 
 afterEach( async () => {
   await vi.resetModules();
   vi.clearAllMocks();
 } );
 
-it( 'loads model using selected provider', () => {
-  const result = loadModel( { config: { provider: 'openai', model: 'gpt-4o-mini' } } );
+describe( 'loadModel', () => {
+  it( 'loads model using selected provider', () => {
+    const result = loadModel( { config: { provider: 'openai', model: 'gpt-4o-mini' } } );
+
+    expect( result ).toBe( 'openai:gpt-4o-mini' );
+    expect( openaiImpl ).toHaveBeenCalledWith( 'gpt-4o-mini' );
+    expect( azureImpl ).not.toHaveBeenCalled();
+    expect( anthropicImpl ).not.toHaveBeenCalled();
+  } );
+} );
+
+describe( 'loadTools', () => {
+  // Category 1: Basic Functionality (5 tests)
+  describe( 'Basic Functionality', () => {
+    it( 'returns null when no tools configured', () => {
+      const result = loadTools( { config: { provider: 'vertex', model: 'gemini-2.0-flash' } } );
+      expect( result ).toBeNull();
+    } );
+
+    it( 'returns null when tools is empty object', () => {
+      const result = loadTools( { config: { provider: 'vertex', model: 'gemini-2.0-flash', tools: {} } } );
+      expect( result ).toBeNull();
+    } );
+
+    it( 'loads single tool with empty config', () => {
+      const result = loadTools( {
+        config: { provider: 'vertex', tools: { googleSearch: {} } }
+      } );
+
+      expect( result ).toEqual( {
+        googleSearch: { type: 'googleSearch', config: {} }
+      } );
+    } );
+
+    it( 'loads single tool with config', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: { googleSearch: { mode: 'MODE_DYNAMIC' } }
+        }
+      } );
+
+      expect( result ).toEqual( {
+        googleSearch: { type: 'googleSearch', config: { mode: 'MODE_DYNAMIC' } }
+      } );
+    } );
+
+    it( 'loads multiple tools with different configs', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: {
+            googleSearch: { mode: 'MODE_DYNAMIC' },
+            urlContext: {},
+            fileSearch: { topK: 5 }
+          }
+        }
+      } );
+
+      expect( Object.keys( result ) ).toEqual( [ 'googleSearch', 'urlContext', 'fileSearch' ] );
+      expect( result.googleSearch.config ).toEqual( { mode: 'MODE_DYNAMIC' } );
+      expect( result.urlContext.config ).toEqual( {} );
+      expect( result.fileSearch.config ).toEqual( { topK: 5 } );
+    } );
+  } );
+
+  // Category 2: Vertex Provider (8 tests)
+  describe( 'Vertex Provider', () => {
+    it( 'loads googleSearch with mode and dynamicThreshold', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: {
+            googleSearch: {
+              mode: 'MODE_DYNAMIC',
+              dynamicThreshold: 0.8
+            }
+          }
+        }
+      } );
+
+      expect( result.googleSearch ).toEqual( {
+        type: 'googleSearch',
+        config: {
+          mode: 'MODE_DYNAMIC',
+          dynamicThreshold: 0.8
+        }
+      } );
+    } );
+
+    it( 'loads fileSearch with fileSearchStoreNames and topK', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: {
+            fileSearch: {
+              fileSearchStoreNames: [ 'store-1', 'store-2' ],
+              topK: 5,
+              metadataFilter: 'category = "docs"'
+            }
+          }
+        }
+      } );
+
+      expect( result.fileSearch.config ).toEqual( {
+        fileSearchStoreNames: [ 'store-1', 'store-2' ],
+        topK: 5,
+        metadataFilter: 'category = "docs"'
+      } );
+    } );
+
+    it( 'loads urlContext with empty config', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: { urlContext: {} }
+        }
+      } );
+
+      expect( result.urlContext ).toEqual( {
+        type: 'urlContext',
+        config: {}
+      } );
+    } );
+
+    it( 'loads enterpriseWebSearch with config', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: { enterpriseWebSearch: { threshold: 0.5 } }
+        }
+      } );
+
+      expect( result.enterpriseWebSearch.config ).toEqual( { threshold: 0.5 } );
+    } );
+
+    it( 'loads googleMaps with config', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: { googleMaps: { region: 'US' } }
+        }
+      } );
+
+      expect( result.googleMaps.config ).toEqual( { region: 'US' } );
+    } );
+
+    it( 'loads codeExecution with config', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: { codeExecution: { timeout: 30 } }
+        }
+      } );
+
+      expect( result.codeExecution.config ).toEqual( { timeout: 30 } );
+    } );
+
+    it( 'loads vertexRagStore with config', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: {
+            vertexRagStore: {
+              ragCorpus: 'my-corpus-id',
+              topK: 3
+            }
+          }
+        }
+      } );
+
+      expect( result.vertexRagStore.config ).toEqual( {
+        ragCorpus: 'my-corpus-id',
+        topK: 3
+      } );
+    } );
+
+    it( 'loads multiple Vertex tools simultaneously', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: {
+            googleSearch: { mode: 'MODE_DYNAMIC' },
+            fileSearch: { topK: 5 },
+            urlContext: {}
+          }
+        }
+      } );
+
+      expect( Object.keys( result ) ).toEqual( [ 'googleSearch', 'fileSearch', 'urlContext' ] );
+      expect( result.googleSearch.type ).toBe( 'googleSearch' );
+      expect( result.fileSearch.type ).toBe( 'fileSearch' );
+      expect( result.urlContext.type ).toBe( 'urlContext' );
+    } );
+  } );
+
+  // Category 3: OpenAI Provider (5 tests)
+  describe( 'OpenAI Provider', () => {
+    it( 'loads webSearch with empty config', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'openai',
+          tools: { webSearch: {} }
+        }
+      } );
+
+      expect( result.webSearch ).toEqual( {
+        type: 'webSearch',
+        config: {}
+      } );
+    } );
+
+    it( 'loads webSearch with searchContextSize', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'openai',
+          tools: {
+            webSearch: { searchContextSize: 'high' }
+          }
+        }
+      } );
+
+      expect( result.webSearch.config.searchContextSize ).toBe( 'high' );
+    } );
+
+    it( 'loads webSearch with filters.allowedDomains array', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'openai',
+          tools: {
+            webSearch: {
+              filters: {
+                allowedDomains: [ 'wikipedia.org', 'github.com' ]
+              }
+            }
+          }
+        }
+      } );
+
+      expect( result.webSearch.config.filters.allowedDomains ).toEqual( [
+        'wikipedia.org',
+        'github.com'
+      ] );
+    } );
+
+    it( 'loads webSearch with userLocation object', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'openai',
+          tools: {
+            webSearch: {
+              userLocation: {
+                type: 'approximate',
+                country: 'US',
+                city: 'San Francisco'
+              }
+            }
+          }
+        }
+      } );
+
+      expect( result.webSearch.config.userLocation ).toEqual( {
+        type: 'approximate',
+        country: 'US',
+        city: 'San Francisco'
+      } );
+    } );
+
+    it( 'loads webSearch with all config options combined', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'openai',
+          tools: {
+            webSearch: {
+              searchContextSize: 'high',
+              filters: {
+                allowedDomains: [ 'wikipedia.org' ]
+              },
+              userLocation: {
+                type: 'approximate',
+                country: 'US'
+              }
+            }
+          }
+        }
+      } );
+
+      expect( result.webSearch.config.searchContextSize ).toBe( 'high' );
+      expect( result.webSearch.config.filters.allowedDomains ).toHaveLength( 1 );
+      expect( result.webSearch.config.userLocation.country ).toBe( 'US' );
+    } );
+  } );
+
+  // Category 4: Anthropic Provider (6 tests)
+  describe( 'Anthropic Provider', () => {
+    it( 'loads webSearch_20250305 with empty config', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'anthropic',
+          tools: { webSearch_20250305: {} }
+        }
+      } );
+
+      expect( result.webSearch_20250305 ).toEqual( {
+        type: 'webSearch_20250305',
+        config: {}
+      } );
+    } );
+
+    it( 'loads webSearch_20250305 with maxUses number', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'anthropic',
+          tools: {
+            webSearch_20250305: { maxUses: 3 }
+          }
+        }
+      } );
+
+      expect( result.webSearch_20250305.config.maxUses ).toBe( 3 );
+    } );
+
+    it( 'loads webSearch_20250305 with allowedDomains and blockedDomains', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'anthropic',
+          tools: {
+            webSearch_20250305: {
+              allowedDomains: [ 'reuters.com', 'bbc.com' ],
+              blockedDomains: [ 'tabloid.com' ]
+            }
+          }
+        }
+      } );
+
+      expect( result.webSearch_20250305.config.allowedDomains ).toEqual( [
+        'reuters.com',
+        'bbc.com'
+      ] );
+      expect( result.webSearch_20250305.config.blockedDomains ).toEqual( [ 'tabloid.com' ] );
+    } );
+
+    it( 'loads webSearch_20250305 with userLocation object', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'anthropic',
+          tools: {
+            webSearch_20250305: {
+              userLocation: {
+                type: 'approximate',
+                country: 'GB',
+                city: 'London',
+                timezone: 'Europe/London'
+              }
+            }
+          }
+        }
+      } );
+
+      expect( result.webSearch_20250305.config.userLocation.city ).toBe( 'London' );
+      expect( result.webSearch_20250305.config.userLocation.timezone ).toBe( 'Europe/London' );
+    } );
+
+    it( 'loads bash_20241022 and bash_20250124 tools', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'anthropic',
+          tools: {
+            bash_20241022: {},
+            bash_20250124: {}
+          }
+        }
+      } );
+
+      expect( result.bash_20241022.type ).toBe( 'bash_20241022' );
+      expect( result.bash_20250124.type ).toBe( 'bash_20250124' );
+    } );
+
+    it( 'loads codeExecution_20250522 and codeExecution_20250825 tools', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'anthropic',
+          tools: {
+            codeExecution_20250522: {},
+            codeExecution_20250825: {}
+          }
+        }
+      } );
+
+      expect( result.codeExecution_20250522.type ).toBe( 'codeExecution_20250522' );
+      expect( result.codeExecution_20250825.type ).toBe( 'codeExecution_20250825' );
+    } );
+  } );
+
+  // Category 5: Error Handling (9 tests)
+  describe( 'Error Handling', () => {
+    it( 'throws clear error for array format (migration guide)', () => {
+      expect( () => loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: [ 'googleSearch', 'urlContext' ]
+        }
+      } ) ).toThrow( 'tools must be an object with tool configurations, got array' );
+    } );
+
+    it( 'throws error for string format', () => {
+      expect( () => loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: 'googleSearch'
+        }
+      } ) ).toThrow( 'tools must be an object' );
+    } );
+
+    it( 'throws error for number format', () => {
+      expect( () => loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: 123
+        }
+      } ) ).toThrow( 'tools must be an object' );
+    } );
+
+    it( 'throws error for provider without tools support', () => {
+      expect( () => loadTools( {
+        config: {
+          provider: 'azure',
+          tools: { someTool: {} }
+        }
+      } ) ).toThrow( 'does not support provider-specific tools' );
+    } );
+
+    it( 'throws error for unknown tool on Vertex with dynamic tool listing', () => {
+      expect( () => loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: { unknownTool: {} }
+        }
+      } ) ).toThrow( /Unknown tool "unknownTool" for provider "vertex".*Available tools:/ );
+    } );
+
+    it( 'throws error for unknown tool on OpenAI with dynamic tool listing', () => {
+      expect( () => loadTools( {
+        config: {
+          provider: 'openai',
+          tools: { googleSearch: {} }
+        }
+      } ) ).toThrow( /Unknown tool "googleSearch" for provider "openai".*Available tools:/ );
+    } );
+
+    it( 'throws error for unknown tool on Anthropic with dynamic tool listing', () => {
+      expect( () => loadTools( {
+        config: {
+          provider: 'anthropic',
+          tools: { googleSearch: {} }
+        }
+      } ) ).toThrow( /Unknown tool "googleSearch" for provider "anthropic".*Available tools:/ );
+    } );
+
+    it( 'throws error when tool config is null', () => {
+      expect( () => loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: { googleSearch: null }
+        }
+      } ) ).toThrow( 'Configuration for tool "googleSearch" must be an object' );
+    } );
+
+    it( 'throws error when tool config is a string', () => {
+      expect( () => loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: { googleSearch: 'MODE_DYNAMIC' }
+        }
+      } ) ).toThrow( 'Configuration for tool "googleSearch" must be an object' );
+    } );
+  } );
+
+  // Category 6: Integration (3 tests)
+  describe( 'Integration', () => {
+    it( 'simulates variable interpolation scenario', () => {
+      // Simulate what would come from renderPrompt + parsePrompt
+      const renderedConfig = {
+        provider: 'vertex',
+        model: 'gemini-2.0-flash',
+        tools: {
+          googleSearch: {
+            mode: 'MODE_DYNAMIC',
+            dynamicThreshold: 0.8
+          }
+        }
+      };
+
+      const result = loadTools( { config: renderedConfig } );
+
+      expect( result.googleSearch.config ).toEqual( {
+        mode: 'MODE_DYNAMIC',
+        dynamicThreshold: 0.8
+      } );
+    } );
+
+    it( 'validates that config objects are passed to factory functions', () => {
+      const customConfig = {
+        mode: 'MODE_DYNAMIC',
+        dynamicThreshold: 0.7,
+        customField: 'value'
+      };
+
+      const result = loadTools( {
+        config: {
+          provider: 'vertex',
+          tools: { googleSearch: customConfig }
+        }
+      } );
+
+      // The mock returns { type, config }, so we can verify config was passed through
+      expect( result.googleSearch.config ).toEqual( customConfig );
+    } );
+
+    it( 'handles nested configuration objects', () => {
+      const result = loadTools( {
+        config: {
+          provider: 'openai',
+          tools: {
+            webSearch: {
+              searchContextSize: 'high',
+              filters: {
+                allowedDomains: [ 'example.com' ],
+                blockedDomains: [ 'spam.com' ]
+              },
+              userLocation: {
+                type: 'approximate',
+                country: 'US',
+                city: 'Seattle',
+                region: 'WA'
+              }
+            }
+          }
+        }
+      } );
 
-  expect( result ).toBe( 'openai:gpt-4o-mini' );
-  expect( openaiImpl ).toHaveBeenCalledWith( 'gpt-4o-mini' );
-  expect( azureImpl ).not.toHaveBeenCalled();
-  expect( anthropicImpl ).not.toHaveBeenCalled();
+      expect( result.webSearch.config.filters ).toBeDefined();
+      expect( result.webSearch.config.userLocation ).toBeDefined();
+      expect( result.webSearch.config.filters.allowedDomains ).toEqual( [ 'example.com' ] );
+    } );
+  } );
 } );

package/src/ai_sdk.js

@@ -1,6 +1,6 @@
 import { Tracing } from '@output.ai/core/tracing';
 import { z } from '@output.ai/core';
-import { loadModel } from './ai_model.js';
+import { loadModel, loadTools } from './ai_model.js';
 import * as AI from 'ai';
 import { validateGenerateTextArgs, validateGenerateObjectArgs, validateGenerateArrayArgs, validateGenerateEnumArgs } from './validations.js';
 import { loadPrompt } from './prompt_loader.js';
@@ -51,6 +51,14 @@ const aiSdkOptionsFromPrompt = prompt => {
 
   if ( prompt.config.maxTokens ) {
     options.maxOutputTokens = prompt.config.maxTokens;
+  } else if ( prompt.config.provider === 'anthropic' ) {
+    // Override Anthropic SDK's low 4096 default - Claude models support up to 64k output tokens
+    options.maxOutputTokens = 64000;
+  }
+
+  const tools = loadTools( prompt );
+  if ( tools ) {
+    options.tools = tools;
   }
 
   return options;

package/src/ai_sdk.spec.js

@@ -9,8 +9,10 @@ const tracingSpies = {
 vi.mock( '@output.ai/core/tracing', () => ( { Tracing: tracingSpies } ), { virtual: true } );
 
 const loadModelImpl = vi.fn();
+const loadToolsImpl = vi.fn();
 vi.mock( './ai_model.js', () => ( {
-  loadModel: ( ...values ) => loadModelImpl( ...values )
+  loadModel: ( ...values ) => loadModelImpl( ...values ),
+  loadTools: ( ...values ) => loadToolsImpl( ...values )
 } ) );
 
 const aiFns = {
@@ -219,6 +221,7 @@ describe( 'ai_sdk', () => {
     expect( aiFns.generateText ).toHaveBeenCalledWith( {
       model: 'MODEL',
       messages: promptWithProviderOptions.messages,
+      maxOutputTokens: 64000,
       providerOptions: {
         thinking: {
           type: 'enabled',
@@ -337,6 +340,7 @@ describe( 'ai_sdk', () => {
       enum: [ 'A', 'B', 'C' ],
       model: 'MODEL',
       messages: promptWithMixedOptions.messages,
+      maxOutputTokens: 64000,
       providerOptions: {
         thinking: {
           type: 'enabled',

package/src/index.d.ts

@@ -60,6 +60,28 @@ export type Prompt = {
     /** Maximum number of tokens in the response */
     maxTokens?: number;
 
+    /**
+     * Provider-specific tools with configuration.
+     *
+     * @example Vertex googleSearch with config
+     * ```yaml
+     * tools:
+     *   googleSearch:
+     *     mode: MODE_DYNAMIC
+     *     dynamicThreshold: 0.8
+     * ```
+     *
+     * @example OpenAI webSearch with filters
+     * ```yaml
+     * tools:
+     *   webSearch:
+     *     searchContextSize: high
+     *     filters:
+     *       allowedDomains: [wikipedia.org]
+     * ```
+     */
+    tools?: Record<string, Record<string, unknown>>;
+
     /** Provider-specific options */
     providerOptions?: Record<string, unknown>;
   };

package/src/prompt_validations.js

@@ -7,6 +7,7 @@ export const promptSchema = z.object( {
     model: z.string(),
     temperature: z.number().optional(),
     maxTokens: z.number().optional(),
+    tools: z.record( z.string(), z.object( {} ).passthrough() ).optional(),
     providerOptions: z.object( {
       thinking: z.object( {
         type: z.literal( 'enabled' ),