praisonai 1.3.6 → 1.5.0

package/dist/tools/builtins/custom.js

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * Custom Tool Registration API
+ *
+ * Clean API to register custom tools (local + npm) with minimal friction.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCustomTool = registerCustomTool;
+exports.createCustomTool = createCustomTool;
+exports.registerNpmTool = registerNpmTool;
+exports.registerLocalTool = registerLocalTool;
+exports.Tool = Tool;
+const registry_1 = require("../registry/registry");
+/**
+ * Register a custom tool with the global registry
+ */
+function registerCustomTool(config) {
+    const metadata = {
+        id: config.id,
+        displayName: config.name,
+        description: config.description,
+        tags: config.tags || ['custom'],
+        requiredEnv: [],
+        optionalEnv: [],
+        install: {
+            npm: '# Custom tool - no installation required',
+            pnpm: '# Custom tool - no installation required',
+            yarn: '# Custom tool - no installation required',
+            bun: '# Custom tool - no installation required',
+        },
+        docsSlug: config.docsSlug || `tools/custom/${config.id}`,
+        capabilities: {},
+        packageName: 'custom',
+    };
+    const tool = {
+        name: config.name,
+        description: config.description,
+        parameters: config.parameters || { type: 'object', properties: {} },
+        execute: async (input, context) => {
+            return config.execute(input, context);
+        },
+    };
+    // Register with the global registry
+    const registry = (0, registry_1.getToolsRegistry)();
+    registry.register(metadata, () => tool);
+    return tool;
+}
+/**
+ * Create a custom tool without registering it
+ */
+function createCustomTool(config) {
+    return {
+        name: config.name,
+        description: config.description,
+        parameters: config.parameters || { type: 'object', properties: {} },
+        execute: async (input, context) => {
+            return config.execute(input, context);
+        },
+    };
+}
+/**
+ * Register a tool from an npm package
+ */
+async function registerNpmTool(packageName, toolName) {
+    try {
+        const pkg = await Promise.resolve(`${packageName}`).then(s => __importStar(require(s)));
+        // Try to find the tool export
+        const toolExport = toolName
+            ? pkg[toolName]
+            : pkg.default || pkg.tool || pkg[Object.keys(pkg)[0]];
+        if (!toolExport) {
+            throw new Error(`Could not find tool export in package "${packageName}"`);
+        }
+        // If it's a function, call it to get the tool
+        const tool = typeof toolExport === 'function' ? toolExport() : toolExport;
+        // Validate it has the required properties
+        if (!tool.name || !tool.execute) {
+            throw new Error(`Invalid tool structure in package "${packageName}"`);
+        }
+        // Register with the registry
+        const metadata = {
+            id: `npm:${packageName}${toolName ? `:${toolName}` : ''}`,
+            displayName: tool.name,
+            description: tool.description || `Tool from ${packageName}`,
+            tags: ['npm', 'external'],
+            requiredEnv: [],
+            optionalEnv: [],
+            install: {
+                npm: `npm install ${packageName}`,
+                pnpm: `pnpm add ${packageName}`,
+                yarn: `yarn add ${packageName}`,
+                bun: `bun add ${packageName}`,
+            },
+            docsSlug: `tools/npm/${packageName.replace(/[@/]/g, '-')}`,
+            capabilities: {},
+            packageName,
+        };
+        const registry = (0, registry_1.getToolsRegistry)();
+        registry.register(metadata, () => tool);
+        return tool;
+    }
+    catch (error) {
+        throw new Error(`Failed to register tool from "${packageName}": ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Register a tool from a local file path
+ */
+async function registerLocalTool(filePath, toolName) {
+    try {
+        // Resolve the path
+        const resolvedPath = require.resolve(filePath, { paths: [process.cwd()] });
+        const pkg = await Promise.resolve(`${resolvedPath}`).then(s => __importStar(require(s)));
+        const toolExport = toolName
+            ? pkg[toolName]
+            : pkg.default || pkg.tool || pkg[Object.keys(pkg)[0]];
+        if (!toolExport) {
+            throw new Error(`Could not find tool export in file "${filePath}"`);
+        }
+        const tool = typeof toolExport === 'function' ? toolExport() : toolExport;
+        if (!tool.name || !tool.execute) {
+            throw new Error(`Invalid tool structure in file "${filePath}"`);
+        }
+        const metadata = {
+            id: `local:${filePath}${toolName ? `:${toolName}` : ''}`,
+            displayName: tool.name,
+            description: tool.description || `Tool from ${filePath}`,
+            tags: ['local', 'custom'],
+            requiredEnv: [],
+            optionalEnv: [],
+            install: {
+                npm: '# Local tool - no installation required',
+                pnpm: '# Local tool - no installation required',
+                yarn: '# Local tool - no installation required',
+                bun: '# Local tool - no installation required',
+            },
+            docsSlug: `tools/local`,
+            capabilities: {},
+            packageName: 'local',
+        };
+        const registry = (0, registry_1.getToolsRegistry)();
+        registry.register(metadata, () => tool);
+        return tool;
+    }
+    catch (error) {
+        throw new Error(`Failed to register tool from "${filePath}": ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Decorator for creating tools from class methods
+ */
+function Tool(config) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        // Create and register the tool
+        registerCustomTool({
+            ...config,
+            execute: originalMethod,
+        });
+        return descriptor;
+    };
+}

package/dist/tools/builtins/exa.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Exa Web Search Tool
+ *
+ * AI-powered web search with semantic understanding.
+ * Package: @exalabs/ai-sdk
+ */
+import type { ToolMetadata, PraisonTool } from '../registry/types';
+export declare const EXA_METADATA: ToolMetadata;
+export interface ExaSearchConfig {
+    type?: 'auto' | 'neural' | 'fast' | 'deep';
+    category?: 'company' | 'research paper' | 'news' | 'pdf' | 'github' | 'personal site' | 'linkedin profile' | 'financial report';
+    numResults?: number;
+    includeDomains?: string[];
+    excludeDomains?: string[];
+    startPublishedDate?: string;
+    endPublishedDate?: string;
+    includeText?: string[];
+    excludeText?: string[];
+    userLocation?: string;
+    contents?: {
+        text?: {
+            maxCharacters?: number;
+            includeHtmlTags?: boolean;
+        };
+        summary?: {
+            query?: string;
+        } | boolean;
+        livecrawl?: 'never' | 'fallback' | 'always' | 'preferred';
+        livecrawlTimeout?: number;
+    };
+}
+export interface ExaSearchInput {
+    query: string;
+}
+export interface ExaSearchResult {
+    results: Array<{
+        title: string;
+        url: string;
+        text?: string;
+        summary?: string;
+        publishedDate?: string;
+        author?: string;
+        score?: number;
+    }>;
+}
+/**
+ * Create an Exa Web Search tool
+ */
+export declare function exaSearch(config?: ExaSearchConfig): PraisonTool<ExaSearchInput, ExaSearchResult>;
+/**
+ * Factory function for registry
+ */
+export declare function createExaSearchTool(config?: ExaSearchConfig): PraisonTool<unknown, unknown>;

package/dist/tools/builtins/exa.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Exa Web Search Tool
+ *
+ * AI-powered web search with semantic understanding.
+ * Package: @exalabs/ai-sdk
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXA_METADATA = void 0;
+exports.exaSearch = exaSearch;
+exports.createExaSearchTool = createExaSearchTool;
+const types_1 = require("../registry/types");
+exports.EXA_METADATA = {
+    id: 'exa',
+    displayName: 'Exa Web Search',
+    description: 'AI-powered web search with semantic understanding and content extraction',
+    tags: ['search', 'web', 'semantic'],
+    requiredEnv: ['EXA_API_KEY'],
+    optionalEnv: [],
+    install: {
+        npm: 'npm install @exalabs/ai-sdk',
+        pnpm: 'pnpm add @exalabs/ai-sdk',
+        yarn: 'yarn add @exalabs/ai-sdk',
+        bun: 'bun add @exalabs/ai-sdk',
+    },
+    docsSlug: 'tools/exa',
+    capabilities: {
+        search: true,
+        extract: true,
+    },
+    packageName: '@exalabs/ai-sdk',
+};
+async function loadExaPackage() {
+    if (!process.env.EXA_API_KEY) {
+        throw new types_1.MissingEnvVarError(exports.EXA_METADATA.id, 'EXA_API_KEY', exports.EXA_METADATA.docsSlug);
+    }
+    try {
+        // @ts-ignore - optional dependency
+        return await Promise.resolve().then(() => __importStar(require('@exalabs/ai-sdk')));
+    }
+    catch {
+        throw new types_1.MissingDependencyError(exports.EXA_METADATA.id, exports.EXA_METADATA.packageName, exports.EXA_METADATA.install, exports.EXA_METADATA.requiredEnv, exports.EXA_METADATA.docsSlug);
+    }
+}
+/**
+ * Create an Exa Web Search tool
+ */
+function exaSearch(config) {
+    return {
+        name: 'webSearch',
+        description: 'Search the web using Exa AI-powered search. Returns semantically relevant results with content.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The search query',
+                },
+            },
+            required: ['query'],
+        },
+        execute: async (input, _context) => {
+            const pkg = await loadExaPackage();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const tool = pkg.webSearch(config);
+            if (tool && typeof tool.execute === 'function') {
+                const result = await tool.execute(input, { toolCallId: 'exa-search', messages: [] });
+                return result;
+            }
+            return { results: [] };
+        },
+    };
+}
+/**
+ * Factory function for registry
+ */
+function createExaSearchTool(config) {
+    return exaSearch(config);
+}

package/dist/tools/builtins/firecrawl.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Firecrawl Tool
+ *
+ * Web scraping, crawling, and content extraction.
+ * Package: @mendable/firecrawl-js
+ */
+import type { ToolMetadata, PraisonTool } from '../registry/types';
+export declare const FIRECRAWL_METADATA: ToolMetadata;
+export interface FirecrawlScrapeConfig {
+    formats?: ('markdown' | 'html' | 'rawHtml' | 'links' | 'screenshot')[];
+    onlyMainContent?: boolean;
+    includeTags?: string[];
+    excludeTags?: string[];
+    waitFor?: number;
+}
+export interface FirecrawlCrawlConfig {
+    limit?: number;
+    maxDepth?: number;
+    includePaths?: string[];
+    excludePaths?: string[];
+    allowBackwardLinks?: boolean;
+    allowExternalLinks?: boolean;
+}
+export interface FirecrawlScrapeInput {
+    url: string;
+}
+export interface FirecrawlCrawlInput {
+    url: string;
+}
+export interface FirecrawlScrapeResult {
+    content: string;
+    markdown?: string;
+    html?: string;
+    links?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface FirecrawlCrawlResult {
+    pages: Array<{
+        url: string;
+        content: string;
+        markdown?: string;
+    }>;
+}
+/**
+ * Create a Firecrawl Scrape tool
+ */
+export declare function firecrawlScrape(config?: FirecrawlScrapeConfig): PraisonTool<FirecrawlScrapeInput, FirecrawlScrapeResult>;
+/**
+ * Create a Firecrawl Crawl tool
+ */
+export declare function firecrawlCrawl(config?: FirecrawlCrawlConfig): PraisonTool<FirecrawlCrawlInput, FirecrawlCrawlResult>;
+/**
+ * Factory functions for registry
+ */
+export declare function createFirecrawlScrapeTool(config?: FirecrawlScrapeConfig): PraisonTool<unknown, unknown>;
+export declare function createFirecrawlCrawlTool(config?: FirecrawlCrawlConfig): PraisonTool<unknown, unknown>;

package/dist/tools/builtins/firecrawl.js

@@ -0,0 +1,158 @@
+"use strict";
+/**
+ * Firecrawl Tool
+ *
+ * Web scraping, crawling, and content extraction.
+ * Package: @mendable/firecrawl-js
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIRECRAWL_METADATA = void 0;
+exports.firecrawlScrape = firecrawlScrape;
+exports.firecrawlCrawl = firecrawlCrawl;
+exports.createFirecrawlScrapeTool = createFirecrawlScrapeTool;
+exports.createFirecrawlCrawlTool = createFirecrawlCrawlTool;
+const types_1 = require("../registry/types");
+exports.FIRECRAWL_METADATA = {
+    id: 'firecrawl',
+    displayName: 'Firecrawl',
+    description: 'Web scraping, crawling, and content extraction for LLM-ready data',
+    tags: ['scrape', 'crawl', 'extract', 'web'],
+    requiredEnv: ['FIRECRAWL_API_KEY'],
+    optionalEnv: [],
+    install: {
+        npm: 'npm install @mendable/firecrawl-js',
+        pnpm: 'pnpm add @mendable/firecrawl-js',
+        yarn: 'yarn add @mendable/firecrawl-js',
+        bun: 'bun add @mendable/firecrawl-js',
+    },
+    docsSlug: 'tools/firecrawl',
+    capabilities: {
+        crawl: true,
+        extract: true,
+    },
+    packageName: '@mendable/firecrawl-js',
+};
+async function loadFirecrawlPackage() {
+    if (!process.env.FIRECRAWL_API_KEY) {
+        throw new types_1.MissingEnvVarError(exports.FIRECRAWL_METADATA.id, 'FIRECRAWL_API_KEY', exports.FIRECRAWL_METADATA.docsSlug);
+    }
+    try {
+        return await Promise.resolve().then(() => __importStar(require('@mendable/firecrawl-js')));
+    }
+    catch {
+        throw new types_1.MissingDependencyError(exports.FIRECRAWL_METADATA.id, exports.FIRECRAWL_METADATA.packageName, exports.FIRECRAWL_METADATA.install, exports.FIRECRAWL_METADATA.requiredEnv, exports.FIRECRAWL_METADATA.docsSlug);
+    }
+}
+/**
+ * Create a Firecrawl Scrape tool
+ */
+function firecrawlScrape(config) {
+    return {
+        name: 'firecrawlScrape',
+        description: 'Scrape a single web page and extract its content in LLM-ready format.',
+        parameters: {
+            type: 'object',
+            properties: {
+                url: {
+                    type: 'string',
+                    description: 'The URL to scrape',
+                },
+            },
+            required: ['url'],
+        },
+        execute: async (input, context) => {
+            const pkg = await loadFirecrawlPackage();
+            // Firecrawl uses a class-based API
+            const FirecrawlApp = pkg.default || pkg;
+            if (typeof FirecrawlApp === 'function') {
+                const app = new FirecrawlApp({ apiKey: process.env.FIRECRAWL_API_KEY });
+                const result = await app.scrapeUrl(input.url, config);
+                return {
+                    content: result.data?.markdown || '',
+                    markdown: result.data?.markdown,
+                    html: result.data?.html,
+                    links: result.data?.links,
+                    metadata: result.data?.metadata,
+                };
+            }
+            return { content: '' };
+        },
+    };
+}
+/**
+ * Create a Firecrawl Crawl tool
+ */
+function firecrawlCrawl(config) {
+    return {
+        name: 'firecrawlCrawl',
+        description: 'Crawl a website and extract content from multiple pages.',
+        parameters: {
+            type: 'object',
+            properties: {
+                url: {
+                    type: 'string',
+                    description: 'The starting URL to crawl',
+                },
+            },
+            required: ['url'],
+        },
+        execute: async (input, context) => {
+            const pkg = await loadFirecrawlPackage();
+            const FirecrawlApp = pkg.default || pkg;
+            if (typeof FirecrawlApp === 'function') {
+                const app = new FirecrawlApp({ apiKey: process.env.FIRECRAWL_API_KEY });
+                const result = await app.crawlUrl(input.url, config);
+                return {
+                    pages: (result.data || []).map(page => ({
+                        url: page.url,
+                        content: page.markdown || '',
+                        markdown: page.markdown,
+                    })),
+                };
+            }
+            return { pages: [] };
+        },
+    };
+}
+/**
+ * Factory functions for registry
+ */
+function createFirecrawlScrapeTool(config) {
+    return firecrawlScrape(config);
+}
+function createFirecrawlCrawlTool(config) {
+    return firecrawlCrawl(config);
+}

package/dist/tools/builtins/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Built-in Tools - Main Exports
+ *
+ * All built-in tool adapters with lazy loading.
+ */
+export { CODE_EXECUTION_METADATA } from './code-execution';
+export { TAVILY_METADATA } from './tavily';
+export { EXA_METADATA } from './exa';
+export { PERPLEXITY_METADATA } from './perplexity';
+export { PARALLEL_METADATA } from './parallel';
+export { FIRECRAWL_METADATA } from './firecrawl';
+export { SUPERAGENT_METADATA } from './superagent';
+export { VALYU_METADATA } from './valyu';
+export { BEDROCK_AGENTCORE_METADATA } from './bedrock-agentcore';
+export { AIRWEAVE_METADATA } from './airweave';
+export { CODE_MODE_METADATA } from './code-mode';
+export { codeExecution, createCodeExecutionTool } from './code-execution';
+export type { CodeExecutionConfig, CodeExecutionInput, CodeExecutionOutput } from './code-execution';
+export { tavilySearch, tavilyExtract, tavilyCrawl, createTavilySearchTool, createTavilyExtractTool, createTavilyCrawlTool } from './tavily';
+export type { TavilySearchConfig, TavilySearchInput, TavilySearchResult, TavilyExtractConfig, TavilyExtractInput, TavilyExtractResult, TavilyCrawlConfig, TavilyCrawlInput, TavilyCrawlResult } from './tavily';
+export { exaSearch, createExaSearchTool } from './exa';
+export type { ExaSearchConfig, ExaSearchInput, ExaSearchResult } from './exa';
+export { perplexitySearch, createPerplexitySearchTool } from './perplexity';
+export type { PerplexitySearchConfig, PerplexitySearchInput, PerplexitySearchResult } from './perplexity';
+export { parallelSearch, createParallelSearchTool } from './parallel';
+export type { ParallelSearchConfig, ParallelSearchInput, ParallelSearchResult } from './parallel';
+export { firecrawlScrape, firecrawlCrawl, createFirecrawlScrapeTool, createFirecrawlCrawlTool } from './firecrawl';
+export type { FirecrawlScrapeConfig, FirecrawlScrapeInput, FirecrawlScrapeResult, FirecrawlCrawlConfig, FirecrawlCrawlInput, FirecrawlCrawlResult } from './firecrawl';
+export { superagentGuard, superagentRedact, superagentVerify, createSuperagentGuardTool, createSuperagentRedactTool, createSuperagentVerifyTool } from './superagent';
+export type { GuardConfig, GuardInput, GuardResult, RedactConfig, RedactInput, RedactResult, VerifyConfig, VerifyInput, VerifyResult } from './superagent';
+export { valyuWebSearch, valyuFinanceSearch, valyuPaperSearch, valyuBioSearch, valyuPatentSearch, valyuSecSearch, valyuEconomicsSearch, valyuCompanyResearch, createValyuWebSearchTool, createValyuFinanceSearchTool, createValyuPaperSearchTool, createValyuBioSearchTool, createValyuPatentSearchTool, createValyuSecSearchTool, createValyuEconomicsSearchTool, createValyuCompanyResearchTool } from './valyu';
+export type { ValyuSearchConfig, ValyuSearchInput, ValyuSearchResult } from './valyu';
+export { bedrockCodeInterpreter, bedrockBrowserNavigate, bedrockBrowserClick, bedrockBrowserFill, createBedrockCodeInterpreterTool, createBedrockBrowserNavigateTool, createBedrockBrowserClickTool, createBedrockBrowserFillTool } from './bedrock-agentcore';
+export type { CodeInterpreterConfig, CodeInterpreterInput, CodeInterpreterResult, BrowserConfig, BrowserNavigateInput, BrowserClickInput, BrowserFillInput, BrowserResult } from './bedrock-agentcore';
+export { airweaveSearch, createAirweaveSearchTool } from './airweave';
+export type { AirweaveSearchConfig, AirweaveSearchInput, AirweaveSearchResult } from './airweave';
+export { codeMode, createCodeModeTool } from './code-mode';
+export type { CodeModeConfig, CodeModeInput, CodeModeResult } from './code-mode';
+export { registerCustomTool, createCustomTool, registerNpmTool, registerLocalTool, Tool } from './custom';
+export type { CustomToolConfig } from './custom';
+export declare const ALL_BUILTIN_METADATA: readonly [];
+/**
+ * Get all built-in tool metadata
+ */
+export declare function getAllBuiltinMetadata(): Promise<import("..").ToolMetadata[]>;