overai 1.4.0

package/dist/tools/builtins/tavily.js

@@ -0,0 +1,285 @@
+"use strict";
+/**
+ * Tavily Tools (Search, Extract, Crawl, Map)
+ *
+ * Web search, content extraction, crawling, and site mapping.
+ * Package: @tavily/ai-sdk (uses @tavily/core internally)
+ */
+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.TAVILY_METADATA = void 0;
+exports.tavilySearch = tavilySearch;
+exports.tavilyExtract = tavilyExtract;
+exports.tavilyCrawl = tavilyCrawl;
+exports.getTavilyAISDKTool = getTavilyAISDKTool;
+exports.createTavilySearchTool = createTavilySearchTool;
+exports.createTavilyExtractTool = createTavilyExtractTool;
+exports.createTavilyCrawlTool = createTavilyCrawlTool;
+const types_1 = require("../registry/types");
+exports.TAVILY_METADATA = {
+    id: 'tavily',
+    displayName: 'Tavily',
+    description: 'Web search, content extraction, crawling, and site mapping powered by Tavily',
+    tags: ['search', 'web', 'extract', 'crawl'],
+    requiredEnv: ['TAVILY_API_KEY'],
+    optionalEnv: [],
+    install: {
+        npm: 'npm install @tavily/ai-sdk',
+        pnpm: 'pnpm add @tavily/ai-sdk',
+        yarn: 'yarn add @tavily/ai-sdk',
+        bun: 'bun add @tavily/ai-sdk',
+    },
+    docsSlug: 'tools/tavily',
+    capabilities: {
+        search: true,
+        extract: true,
+        crawl: true,
+    },
+    packageName: '@tavily/ai-sdk',
+};
+// Helper to check env and load package
+async function loadTavilyPackage() {
+    if (!process.env.TAVILY_API_KEY) {
+        throw new types_1.MissingEnvVarError(exports.TAVILY_METADATA.id, 'TAVILY_API_KEY', exports.TAVILY_METADATA.docsSlug);
+    }
+    try {
+        // @ts-ignore - optional dependency
+        return await Promise.resolve().then(() => __importStar(require('@tavily/ai-sdk')));
+    }
+    catch {
+        throw new types_1.MissingDependencyError(exports.TAVILY_METADATA.id, exports.TAVILY_METADATA.packageName, exports.TAVILY_METADATA.install, exports.TAVILY_METADATA.requiredEnv, exports.TAVILY_METADATA.docsSlug);
+    }
+}
+/**
+ * Create a Tavily Search tool
+ * Returns a PraisonTool that can be used with agents or directly
+ */
+function tavilySearch(config) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let cachedTool = null;
+    return {
+        name: 'tavilySearch',
+        description: 'Search the web for information using Tavily. Returns relevant results with content snippets and optional AI-generated answers.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The search query',
+                },
+                searchDepth: {
+                    type: 'string',
+                    description: 'Search depth: basic or advanced',
+                    enum: ['basic', 'advanced'],
+                },
+                timeRange: {
+                    type: 'string',
+                    description: 'Time range filter: year, month, week, or day',
+                    enum: ['year', 'month', 'week', 'day'],
+                },
+            },
+            required: ['query'],
+        },
+        execute: async (input, _context) => {
+            const pkg = await loadTavilyPackage();
+            // Create the AI SDK tool with config
+            if (!cachedTool) {
+                cachedTool = pkg.tavilySearch({
+                    apiKey: config?.apiKey || process.env.TAVILY_API_KEY,
+                    searchDepth: config?.searchDepth,
+                    topic: config?.topic,
+                    includeAnswer: config?.includeAnswer,
+                    maxResults: config?.maxResults,
+                    includeImages: config?.includeImages,
+                    timeRange: config?.timeRange,
+                    includeDomains: config?.includeDomains,
+                    excludeDomains: config?.excludeDomains,
+                });
+            }
+            // AI SDK tools have execute method - call with required params
+            const result = await cachedTool.execute({ query: input.query, searchDepth: input.searchDepth, timeRange: input.timeRange }, { toolCallId: 'tavily-search', messages: [] });
+            // Transform to our result type
+            return {
+                results: (result.results || []).map((r) => ({
+                    title: r.title,
+                    url: r.url,
+                    content: r.content,
+                    score: r.score,
+                })),
+                answer: result.answer,
+                images: result.images,
+                query: result.query,
+                responseTime: result.responseTime,
+            };
+        },
+    };
+}
+/**
+ * Create a Tavily Extract tool
+ */
+function tavilyExtract(config) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let cachedTool = null;
+    return {
+        name: 'tavilyExtract',
+        description: 'Extract structured content from web pages using Tavily. Provide URLs to extract their content.',
+        parameters: {
+            type: 'object',
+            properties: {
+                urls: {
+                    type: 'array',
+                    description: 'URLs to extract content from',
+                    items: { type: 'string' },
+                },
+                extractDepth: {
+                    type: 'string',
+                    description: 'Extraction depth: basic or advanced',
+                    enum: ['basic', 'advanced'],
+                },
+                query: {
+                    type: 'string',
+                    description: 'Optional query to focus extraction',
+                },
+            },
+            required: ['urls'],
+        },
+        execute: async (input, _context) => {
+            const pkg = await loadTavilyPackage();
+            if (!cachedTool) {
+                cachedTool = pkg.tavilyExtract({
+                    apiKey: config?.apiKey || process.env.TAVILY_API_KEY,
+                    extractDepth: config?.extractDepth,
+                });
+            }
+            const result = await cachedTool.execute({ urls: input.urls, extractDepth: input.extractDepth, query: input.query }, { toolCallId: 'tavily-extract', messages: [] });
+            return {
+                results: (result.results || []).map((r) => ({
+                    url: r.url,
+                    rawContent: r.rawContent,
+                })),
+            };
+        },
+    };
+}
+/**
+ * Create a Tavily Crawl tool
+ */
+function tavilyCrawl(config) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let cachedTool = null;
+    return {
+        name: 'tavilyCrawl',
+        description: 'Crawl a website using Tavily. Discovers and extracts content from multiple pages starting from a base URL.',
+        parameters: {
+            type: 'object',
+            properties: {
+                url: {
+                    type: 'string',
+                    description: 'The starting URL to crawl',
+                },
+                maxDepth: {
+                    type: 'number',
+                    description: 'Maximum crawl depth',
+                },
+                extractDepth: {
+                    type: 'string',
+                    description: 'Extraction depth: basic or advanced',
+                    enum: ['basic', 'advanced'],
+                },
+                instructions: {
+                    type: 'string',
+                    description: 'Instructions for the crawler',
+                },
+                allowExternal: {
+                    type: 'boolean',
+                    description: 'Allow crawling external links',
+                },
+            },
+            required: ['url'],
+        },
+        execute: async (input, _context) => {
+            const pkg = await loadTavilyPackage();
+            if (!cachedTool) {
+                cachedTool = pkg.tavilyCrawl({
+                    apiKey: config?.apiKey || process.env.TAVILY_API_KEY,
+                    maxDepth: config?.maxDepth,
+                    extractDepth: config?.extractDepth,
+                    instructions: config?.instructions,
+                    allowExternal: config?.allowExternal,
+                });
+            }
+            const result = await cachedTool.execute({ url: input.url, maxDepth: input.maxDepth, extractDepth: input.extractDepth, instructions: input.instructions, allowExternal: input.allowExternal }, { toolCallId: 'tavily-crawl', messages: [] });
+            return {
+                baseUrl: result.baseUrl || input.url,
+                results: (result.results || []).map((r) => ({
+                    url: r.url,
+                    rawContent: r.rawContent,
+                })),
+            };
+        },
+    };
+}
+/**
+ * Get the raw AI SDK tool for use with generateText
+ * This returns the native @tavily/ai-sdk tool
+ */
+async function getTavilyAISDKTool(type = 'search', config) {
+    const pkg = await loadTavilyPackage();
+    const apiKey = config?.apiKey || process.env.TAVILY_API_KEY;
+    switch (type) {
+        case 'search':
+            return pkg.tavilySearch({ apiKey, searchDepth: config?.searchDepth, topic: config?.topic });
+        case 'extract':
+            return pkg.tavilyExtract({ apiKey });
+        case 'crawl':
+            return pkg.tavilyCrawl({ apiKey });
+        case 'map':
+            return pkg.tavilyMap({ apiKey });
+        default:
+            return pkg.tavilySearch({ apiKey });
+    }
+}
+/**
+ * Factory functions for registry
+ */
+function createTavilySearchTool(config) {
+    return tavilySearch(config);
+}
+function createTavilyExtractTool(config) {
+    return tavilyExtract(config);
+}
+function createTavilyCrawlTool(config) {
+    return tavilyCrawl(config);
+}

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

@@ -0,0 +1,65 @@
+/**
+ * Valyu Domain Search Tools
+ *
+ * Specialized search for finance, papers, bio, patents, SEC, economics, and company research.
+ * Package: @valyu/ai-sdk
+ */
+import type { ToolMetadata, PraisonTool } from '../registry/types';
+export declare const VALYU_METADATA: ToolMetadata;
+export interface ValyuSearchConfig {
+    maxNumResults?: number;
+}
+export interface ValyuSearchInput {
+    query: string;
+}
+export interface ValyuSearchResult {
+    results: Array<{
+        title: string;
+        url: string;
+        content: string;
+        source?: string;
+    }>;
+}
+/**
+ * Create a Valyu Web Search tool
+ */
+export declare function valyuWebSearch(config?: ValyuSearchConfig): PraisonTool<ValyuSearchInput, ValyuSearchResult>;
+/**
+ * Create a Valyu Finance Search tool
+ */
+export declare function valyuFinanceSearch(config?: ValyuSearchConfig): PraisonTool<ValyuSearchInput, ValyuSearchResult>;
+/**
+ * Create a Valyu Paper Search tool
+ */
+export declare function valyuPaperSearch(config?: ValyuSearchConfig): PraisonTool<ValyuSearchInput, ValyuSearchResult>;
+/**
+ * Create a Valyu Bio Search tool
+ */
+export declare function valyuBioSearch(config?: ValyuSearchConfig): PraisonTool<ValyuSearchInput, ValyuSearchResult>;
+/**
+ * Create a Valyu Patent Search tool
+ */
+export declare function valyuPatentSearch(config?: ValyuSearchConfig): PraisonTool<ValyuSearchInput, ValyuSearchResult>;
+/**
+ * Create a Valyu SEC Search tool
+ */
+export declare function valyuSecSearch(config?: ValyuSearchConfig): PraisonTool<ValyuSearchInput, ValyuSearchResult>;
+/**
+ * Create a Valyu Economics Search tool
+ */
+export declare function valyuEconomicsSearch(config?: ValyuSearchConfig): PraisonTool<ValyuSearchInput, ValyuSearchResult>;
+/**
+ * Create a Valyu Company Research tool
+ */
+export declare function valyuCompanyResearch(config?: ValyuSearchConfig): PraisonTool<ValyuSearchInput, ValyuSearchResult>;
+/**
+ * Factory functions for registry
+ */
+export declare function createValyuWebSearchTool(config?: ValyuSearchConfig): PraisonTool<unknown, unknown>;
+export declare function createValyuFinanceSearchTool(config?: ValyuSearchConfig): PraisonTool<unknown, unknown>;
+export declare function createValyuPaperSearchTool(config?: ValyuSearchConfig): PraisonTool<unknown, unknown>;
+export declare function createValyuBioSearchTool(config?: ValyuSearchConfig): PraisonTool<unknown, unknown>;
+export declare function createValyuPatentSearchTool(config?: ValyuSearchConfig): PraisonTool<unknown, unknown>;
+export declare function createValyuSecSearchTool(config?: ValyuSearchConfig): PraisonTool<unknown, unknown>;
+export declare function createValyuEconomicsSearchTool(config?: ValyuSearchConfig): PraisonTool<unknown, unknown>;
+export declare function createValyuCompanyResearchTool(config?: ValyuSearchConfig): PraisonTool<unknown, unknown>;

package/dist/tools/builtins/valyu.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * Valyu Domain Search Tools
+ *
+ * Specialized search for finance, papers, bio, patents, SEC, economics, and company research.
+ * Package: @valyu/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.VALYU_METADATA = void 0;
+exports.valyuWebSearch = valyuWebSearch;
+exports.valyuFinanceSearch = valyuFinanceSearch;
+exports.valyuPaperSearch = valyuPaperSearch;
+exports.valyuBioSearch = valyuBioSearch;
+exports.valyuPatentSearch = valyuPatentSearch;
+exports.valyuSecSearch = valyuSecSearch;
+exports.valyuEconomicsSearch = valyuEconomicsSearch;
+exports.valyuCompanyResearch = valyuCompanyResearch;
+exports.createValyuWebSearchTool = createValyuWebSearchTool;
+exports.createValyuFinanceSearchTool = createValyuFinanceSearchTool;
+exports.createValyuPaperSearchTool = createValyuPaperSearchTool;
+exports.createValyuBioSearchTool = createValyuBioSearchTool;
+exports.createValyuPatentSearchTool = createValyuPatentSearchTool;
+exports.createValyuSecSearchTool = createValyuSecSearchTool;
+exports.createValyuEconomicsSearchTool = createValyuEconomicsSearchTool;
+exports.createValyuCompanyResearchTool = createValyuCompanyResearchTool;
+const types_1 = require("../registry/types");
+exports.VALYU_METADATA = {
+    id: 'valyu',
+    displayName: 'Valyu Domain Search',
+    description: 'Specialized search for finance, academic papers, bio, patents, SEC filings, economics, and company research',
+    tags: ['search', 'finance', 'papers', 'patents', 'sec', 'economics', 'research'],
+    requiredEnv: ['VALYU_API_KEY'],
+    optionalEnv: [],
+    install: {
+        npm: 'npm install @valyu/ai-sdk',
+        pnpm: 'pnpm add @valyu/ai-sdk',
+        yarn: 'yarn add @valyu/ai-sdk',
+        bun: 'bun add @valyu/ai-sdk',
+    },
+    docsSlug: 'tools/valyu',
+    capabilities: {
+        search: true,
+    },
+    packageName: '@valyu/ai-sdk',
+};
+async function loadValyuPackage() {
+    if (!process.env.VALYU_API_KEY) {
+        throw new types_1.MissingEnvVarError(exports.VALYU_METADATA.id, 'VALYU_API_KEY', exports.VALYU_METADATA.docsSlug);
+    }
+    try {
+        // @ts-ignore - optional dependency
+        return await Promise.resolve().then(() => __importStar(require('@valyu/ai-sdk')));
+    }
+    catch {
+        throw new types_1.MissingDependencyError(exports.VALYU_METADATA.id, exports.VALYU_METADATA.packageName, exports.VALYU_METADATA.install, exports.VALYU_METADATA.requiredEnv, exports.VALYU_METADATA.docsSlug);
+    }
+}
+// Helper to create a Valyu search tool
+function createValyuTool(name, description, searchFnName, config) {
+    return {
+        name,
+        description,
+        parameters: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The search query',
+                },
+            },
+            required: ['query'],
+        },
+        execute: async (input, context) => {
+            const pkg = await loadValyuPackage();
+            const searchFn = pkg[searchFnName];
+            if (searchFn && typeof searchFn === 'function') {
+                const tool = searchFn(config);
+                if (tool && typeof tool.execute === 'function') {
+                    return await tool.execute(input);
+                }
+            }
+            return { results: [] };
+        },
+    };
+}
+/**
+ * Create a Valyu Web Search tool
+ */
+function valyuWebSearch(config) {
+    return createValyuTool('valyuWebSearch', 'Search the web using Valyu for general information.', 'webSearch', config);
+}
+/**
+ * Create a Valyu Finance Search tool
+ */
+function valyuFinanceSearch(config) {
+    return createValyuTool('valyuFinanceSearch', 'Search financial data including stock prices, earnings, insider transactions, dividends, balance sheets, and income statements.', 'financeSearch', config);
+}
+/**
+ * Create a Valyu Paper Search tool
+ */
+function valyuPaperSearch(config) {
+    return createValyuTool('valyuPaperSearch', 'Search academic papers from PubMed, arXiv, bioRxiv, medRxiv, and other scholarly sources.', 'paperSearch', config);
+}
+/**
+ * Create a Valyu Bio Search tool
+ */
+function valyuBioSearch(config) {
+    return createValyuTool('valyuBioSearch', 'Search clinical trials, FDA drug labels, and peer-reviewed biomedical research.', 'bioSearch', config);
+}
+/**
+ * Create a Valyu Patent Search tool
+ */
+function valyuPatentSearch(config) {
+    return createValyuTool('valyuPatentSearch', 'Search USPTO full-text patents and related intellectual property.', 'patentSearch', config);
+}
+/**
+ * Create a Valyu SEC Search tool
+ */
+function valyuSecSearch(config) {
+    return createValyuTool('valyuSecSearch', 'Search SEC filings including 10-K, 10-Q, 8-K, and regulatory disclosures.', 'secSearch', config);
+}
+/**
+ * Create a Valyu Economics Search tool
+ */
+function valyuEconomicsSearch(config) {
+    return createValyuTool('valyuEconomicsSearch', 'Search economic indicators from BLS, FRED, World Bank, USAspending, and more.', 'economicsSearch', config);
+}
+/**
+ * Create a Valyu Company Research tool
+ */
+function valyuCompanyResearch(config) {
+    return createValyuTool('valyuCompanyResearch', 'Comprehensive company research and intelligence reports.', 'companyResearch', config);
+}
+/**
+ * Factory functions for registry
+ */
+function createValyuWebSearchTool(config) {
+    return valyuWebSearch(config);
+}
+function createValyuFinanceSearchTool(config) {
+    return valyuFinanceSearch(config);
+}
+function createValyuPaperSearchTool(config) {
+    return valyuPaperSearch(config);
+}
+function createValyuBioSearchTool(config) {
+    return valyuBioSearch(config);
+}
+function createValyuPatentSearchTool(config) {
+    return valyuPatentSearch(config);
+}
+function createValyuSecSearchTool(config) {
+    return valyuSecSearch(config);
+}
+function createValyuEconomicsSearchTool(config) {
+    return valyuEconomicsSearch(config);
+}
+function createValyuCompanyResearchTool(config) {
+    return valyuCompanyResearch(config);
+}

package/dist/tools/decorator.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Tool Decorator and Registry - Type-safe tool creation and management
+ */
+export interface ToolParameters {
+    type: 'object';
+    properties: Record<string, {
+        type: string;
+        description?: string;
+        enum?: string[];
+        default?: any;
+    }>;
+    required?: string[];
+}
+export interface ToolConfig<TParams = any, TResult = any> {
+    name: string;
+    description?: string;
+    parameters?: ToolParameters | any;
+    category?: string;
+    execute: (params: TParams, context?: ToolContext) => Promise<TResult> | TResult;
+}
+export interface ToolContext {
+    agentName?: string;
+    sessionId?: string;
+    runId?: string;
+    signal?: AbortSignal;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: ToolParameters;
+    category?: string;
+}
+/**
+ * Tool class - Represents an executable tool
+ */
+export declare class FunctionTool<TParams = any, TResult = any> {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: ToolParameters;
+    readonly category?: string;
+    private readonly executeFn;
+    constructor(config: ToolConfig<TParams, TResult>);
+    private normalizeParameters;
+    private zodToJsonSchema;
+    private zodFieldToJsonSchema;
+    execute(params: TParams, context?: ToolContext): Promise<TResult>;
+    /**
+     * Get the tool definition for LLM
+     */
+    getDefinition(): ToolDefinition;
+    /**
+     * Get OpenAI-compatible tool format
+     */
+    toOpenAITool(): {
+        type: 'function';
+        function: {
+            name: string;
+            description: string;
+            parameters: any;
+        };
+    };
+}
+/**
+ * Create a tool from a configuration object
+ */
+export declare function tool<TParams = any, TResult = any>(config: ToolConfig<TParams, TResult>): FunctionTool<TParams, TResult>;
+/**
+ * Tool Registry - Manages tool registration and lookup
+ */
+export declare class ToolRegistry {
+    private tools;
+    register(tool: FunctionTool, options?: {
+        overwrite?: boolean;
+    }): this;
+    get(name: string): FunctionTool | undefined;
+    has(name: string): boolean;
+    list(): FunctionTool[];
+    getByCategory(category: string): FunctionTool[];
+    getDefinitions(): ToolDefinition[];
+    toOpenAITools(): Array<{
+        type: 'function';
+        function: any;
+    }>;
+    delete(name: string): boolean;
+    clear(): void;
+}
+export declare function getRegistry(): ToolRegistry;
+export declare function registerTool(tool: FunctionTool, options?: {
+    overwrite?: boolean;
+}): void;
+export declare function getTool(name: string): FunctionTool | undefined;