overai 1.4.0

package/dist/tools/base.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * BaseTool - Abstract base class for creating custom tools (plugins)
+ *
+ * This provides the same extensibility pattern as Python's BaseTool.
+ * External developers can create plugins by extending BaseTool.
+ *
+ * Usage:
+ *   import { BaseTool } from 'praisonai';
+ *
+ *   class MyTool extends BaseTool {
+ *     name = 'my_tool';
+ *     description = 'Does something useful';
+ *
+ *     async run(params: { query: string }): Promise<string> {
+ *       return `Result for ${params.query}`;
+ *     }
+ *   }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTool = exports.ToolValidationError = void 0;
+exports.validateTool = validateTool;
+exports.createTool = createTool;
+class ToolValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ToolValidationError';
+    }
+}
+exports.ToolValidationError = ToolValidationError;
+/**
+ * Abstract base class for all PraisonAI tools.
+ *
+ * Subclass this to create custom tools that can be:
+ * - Used directly by agents
+ * - Distributed as npm packages (plugins)
+ * - Auto-discovered via package.json
+ */
+class BaseTool {
+    constructor() {
+        /** Tool version string */
+        this.version = '1.0.0';
+    }
+    /**
+     * Allow tool to be called directly like a function.
+     */
+    async execute(params) {
+        return this.run(params);
+    }
+    /**
+     * Execute tool with error handling, returning ToolResult.
+     */
+    async safeRun(params) {
+        try {
+            const output = await this.run(params);
+            return { output, success: true };
+        }
+        catch (error) {
+            return {
+                output: null,
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    /**
+     * Get OpenAI-compatible function schema for this tool.
+     */
+    getSchema() {
+        return {
+            type: 'function',
+            function: {
+                name: this.name,
+                description: this.description,
+                parameters: this.parameters || { type: 'object', properties: {}, required: [] }
+            }
+        };
+    }
+    /**
+     * Validate the tool configuration.
+     */
+    validate() {
+        const errors = [];
+        if (!this.name || typeof this.name !== 'string') {
+            errors.push("Tool must have a non-empty string 'name'");
+        }
+        if (!this.description || typeof this.description !== 'string') {
+            errors.push("Tool must have a non-empty string 'description'");
+        }
+        if (errors.length > 0) {
+            throw new ToolValidationError(`Tool '${this.name}' validation failed: ${errors.join('; ')}`);
+        }
+        return true;
+    }
+    toString() {
+        return `${this.constructor.name}(name='${this.name}')`;
+    }
+}
+exports.BaseTool = BaseTool;
+/**
+ * Validate any tool-like object.
+ */
+function validateTool(tool) {
+    if (tool instanceof BaseTool) {
+        return tool.validate();
+    }
+    if (typeof tool === 'function' || (tool && typeof tool.run === 'function')) {
+        const name = tool.name || tool.__name__;
+        if (!name) {
+            throw new ToolValidationError('Tool must have a name');
+        }
+        return true;
+    }
+    throw new ToolValidationError(`Invalid tool type: ${typeof tool}`);
+}
+/**
+ * Create a simple tool from a function (alternative to class-based approach)
+ */
+function createTool(config) {
+    return {
+        name: config.name,
+        description: config.description,
+        version: '1.0.0',
+        parameters: config.parameters,
+        run: config.run,
+        execute: async (params) => config.run(params),
+        safeRun: async (params) => {
+            try {
+                const output = await config.run(params);
+                return { output, success: true };
+            }
+            catch (error) {
+                return { output: null, success: false, error: error.message };
+            }
+        },
+        getSchema: () => ({
+            type: 'function',
+            function: {
+                name: config.name,
+                description: config.description,
+                parameters: config.parameters || { type: 'object', properties: {}, required: [] }
+            }
+        }),
+        validate: () => true,
+        toString: () => `Tool(name='${config.name}')`
+    };
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Airweave Tool
+ *
+ * Context retrieval and semantic search across connected data sources.
+ * Package: @airweave/sdk
+ */
+import type { ToolMetadata, PraisonTool } from '../registry/types';
+export declare const AIRWEAVE_METADATA: ToolMetadata;
+export interface AirweaveSearchConfig {
+    limit?: number;
+    threshold?: number;
+    sources?: string[];
+}
+export interface AirweaveSearchInput {
+    query: string;
+}
+export interface AirweaveSearchResult {
+    results: Array<{
+        content: string;
+        source: string;
+        score: number;
+        metadata?: Record<string, unknown>;
+    }>;
+}
+/**
+ * Create an Airweave Search tool
+ */
+export declare function airweaveSearch(config?: AirweaveSearchConfig): PraisonTool<AirweaveSearchInput, AirweaveSearchResult>;
+/**
+ * Factory function for registry
+ */
+export declare function createAirweaveSearchTool(config?: AirweaveSearchConfig): PraisonTool<unknown, unknown>;

package/dist/tools/builtins/airweave.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * Airweave Tool
+ *
+ * Context retrieval and semantic search across connected data sources.
+ * Package: @airweave/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.AIRWEAVE_METADATA = void 0;
+exports.airweaveSearch = airweaveSearch;
+exports.createAirweaveSearchTool = createAirweaveSearchTool;
+const types_1 = require("../registry/types");
+exports.AIRWEAVE_METADATA = {
+    id: 'airweave',
+    displayName: 'Airweave',
+    description: 'Context retrieval and semantic search across connected data sources for RAG applications',
+    tags: ['rag', 'semantic-search', 'retrieval', 'context'],
+    requiredEnv: ['AIRWEAVE_API_KEY'],
+    optionalEnv: ['AIRWEAVE_BASE_URL'],
+    install: {
+        npm: 'npm install @airweave/sdk',
+        pnpm: 'pnpm add @airweave/sdk',
+        yarn: 'yarn add @airweave/sdk',
+        bun: 'bun add @airweave/sdk',
+    },
+    docsSlug: 'tools/airweave',
+    capabilities: {
+        rag: true,
+        search: true,
+    },
+    packageName: '@airweave/sdk',
+};
+async function loadAirweavePackage() {
+    if (!process.env.AIRWEAVE_API_KEY) {
+        throw new types_1.MissingEnvVarError(exports.AIRWEAVE_METADATA.id, 'AIRWEAVE_API_KEY', exports.AIRWEAVE_METADATA.docsSlug);
+    }
+    try {
+        return await Promise.resolve().then(() => __importStar(require('@airweave/sdk')));
+    }
+    catch {
+        throw new types_1.MissingDependencyError(exports.AIRWEAVE_METADATA.id, exports.AIRWEAVE_METADATA.packageName, exports.AIRWEAVE_METADATA.install, exports.AIRWEAVE_METADATA.requiredEnv, exports.AIRWEAVE_METADATA.docsSlug);
+    }
+}
+/**
+ * Create an Airweave Search tool
+ */
+function airweaveSearch(config) {
+    return {
+        name: 'airweaveSearch',
+        description: 'Search across connected data sources using semantic search. Returns relevant context for RAG applications.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The search query',
+                },
+            },
+            required: ['query'],
+        },
+        execute: async (input, context) => {
+            const pkg = await loadAirweavePackage();
+            // Airweave SDK uses a client-based API
+            const AirweaveClient = pkg.AirweaveClient ||
+                pkg.Airweave ||
+                pkg.default;
+            if (AirweaveClient && typeof AirweaveClient === 'function') {
+                const client = new AirweaveClient({
+                    apiKey: process.env.AIRWEAVE_API_KEY,
+                    baseUrl: process.env.AIRWEAVE_BASE_URL,
+                });
+                const result = await client.search(input.query, config);
+                return {
+                    results: result.results || [],
+                };
+            }
+            return { results: [] };
+        },
+    };
+}
+/**
+ * Factory function for registry
+ */
+function createAirweaveSearchTool(config) {
+    return airweaveSearch(config);
+}

package/dist/tools/builtins/bedrock-agentcore.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Amazon Bedrock AgentCore Tools
+ *
+ * Code Interpreter and Browser automation powered by AWS.
+ * Package: bedrock-agentcore
+ */
+import type { ToolMetadata, PraisonTool } from '../registry/types';
+export declare const BEDROCK_AGENTCORE_METADATA: ToolMetadata;
+export interface CodeInterpreterConfig {
+    language?: 'python' | 'javascript' | 'typescript';
+    timeout?: number;
+}
+export interface CodeInterpreterInput {
+    code: string;
+}
+export interface CodeInterpreterResult {
+    output: string;
+    success: boolean;
+    error?: string;
+}
+export interface BrowserConfig {
+    headless?: boolean;
+    timeout?: number;
+}
+export interface BrowserNavigateInput {
+    url: string;
+}
+export interface BrowserClickInput {
+    selector: string;
+}
+export interface BrowserFillInput {
+    selector: string;
+    value: string;
+}
+export interface BrowserResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+/**
+ * Create a Bedrock Code Interpreter tool
+ */
+export declare function bedrockCodeInterpreter(config?: CodeInterpreterConfig): PraisonTool<CodeInterpreterInput, CodeInterpreterResult>;
+/**
+ * Create a Bedrock Browser Navigate tool
+ */
+export declare function bedrockBrowserNavigate(config?: BrowserConfig): PraisonTool<BrowserNavigateInput, BrowserResult>;
+/**
+ * Create a Bedrock Browser Click tool
+ */
+export declare function bedrockBrowserClick(config?: BrowserConfig): PraisonTool<BrowserClickInput, BrowserResult>;
+/**
+ * Create a Bedrock Browser Fill tool
+ */
+export declare function bedrockBrowserFill(config?: BrowserConfig): PraisonTool<BrowserFillInput, BrowserResult>;
+/**
+ * Factory functions for registry
+ */
+export declare function createBedrockCodeInterpreterTool(config?: CodeInterpreterConfig): PraisonTool<unknown, unknown>;
+export declare function createBedrockBrowserNavigateTool(config?: BrowserConfig): PraisonTool<unknown, unknown>;
+export declare function createBedrockBrowserClickTool(config?: BrowserConfig): PraisonTool<unknown, unknown>;
+export declare function createBedrockBrowserFillTool(config?: BrowserConfig): PraisonTool<unknown, unknown>;

package/dist/tools/builtins/bedrock-agentcore.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * Amazon Bedrock AgentCore Tools
+ *
+ * Code Interpreter and Browser automation powered by AWS.
+ * Package: bedrock-agentcore
+ */
+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.BEDROCK_AGENTCORE_METADATA = void 0;
+exports.bedrockCodeInterpreter = bedrockCodeInterpreter;
+exports.bedrockBrowserNavigate = bedrockBrowserNavigate;
+exports.bedrockBrowserClick = bedrockBrowserClick;
+exports.bedrockBrowserFill = bedrockBrowserFill;
+exports.createBedrockCodeInterpreterTool = createBedrockCodeInterpreterTool;
+exports.createBedrockBrowserNavigateTool = createBedrockBrowserNavigateTool;
+exports.createBedrockBrowserClickTool = createBedrockBrowserClickTool;
+exports.createBedrockBrowserFillTool = createBedrockBrowserFillTool;
+const types_1 = require("../registry/types");
+exports.BEDROCK_AGENTCORE_METADATA = {
+    id: 'bedrock-agentcore',
+    displayName: 'Amazon Bedrock AgentCore',
+    description: 'Code interpreter and browser automation powered by AWS Bedrock AgentCore',
+    tags: ['sandbox', 'code', 'browser', 'aws'],
+    requiredEnv: [], // Uses AWS credentials from environment/config
+    optionalEnv: ['AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY', 'AWS_REGION'],
+    install: {
+        npm: 'npm install bedrock-agentcore',
+        pnpm: 'pnpm add bedrock-agentcore',
+        yarn: 'yarn add bedrock-agentcore',
+        bun: 'bun add bedrock-agentcore',
+    },
+    docsSlug: 'tools/bedrock-agentcore',
+    capabilities: {
+        sandbox: true,
+        code: true,
+        browser: true,
+    },
+    packageName: 'bedrock-agentcore',
+};
+async function loadBedrockPackage() {
+    try {
+        // @ts-ignore - Optional dependency
+        return await Promise.resolve().then(() => __importStar(require('bedrock-agentcore')));
+    }
+    catch {
+        throw new types_1.MissingDependencyError(exports.BEDROCK_AGENTCORE_METADATA.id, exports.BEDROCK_AGENTCORE_METADATA.packageName, exports.BEDROCK_AGENTCORE_METADATA.install, exports.BEDROCK_AGENTCORE_METADATA.requiredEnv, exports.BEDROCK_AGENTCORE_METADATA.docsSlug);
+    }
+}
+/**
+ * Create a Bedrock Code Interpreter tool
+ */
+function bedrockCodeInterpreter(config) {
+    return {
+        name: 'bedrockCodeInterpreter',
+        description: 'Execute code in a secure AWS-managed sandbox. Supports Python, JavaScript, and TypeScript.',
+        parameters: {
+            type: 'object',
+            properties: {
+                code: {
+                    type: 'string',
+                    description: 'The code to execute',
+                },
+            },
+            required: ['code'],
+        },
+        execute: async (input, context) => {
+            const pkg = await loadBedrockPackage();
+            // Try to get CodeInterpreterTools from the package
+            const CodeInterpreterTools = pkg.CodeInterpreterTools;
+            if (CodeInterpreterTools && typeof CodeInterpreterTools === 'function') {
+                const interpreter = new CodeInterpreterTools();
+                // Find the execute code tool
+                const executeTool = interpreter.tools?.executeCode;
+                if (executeTool && typeof executeTool.execute === 'function') {
+                    const result = await executeTool.execute(input);
+                    return {
+                        output: String(result),
+                        success: true,
+                    };
+                }
+            }
+            return { output: '', success: false, error: 'Code interpreter not available' };
+        },
+    };
+}
+/**
+ * Create a Bedrock Browser Navigate tool
+ */
+function bedrockBrowserNavigate(config) {
+    return {
+        name: 'bedrockBrowserNavigate',
+        description: 'Navigate to a URL using cloud-based browser automation.',
+        parameters: {
+            type: 'object',
+            properties: {
+                url: {
+                    type: 'string',
+                    description: 'The URL to navigate to',
+                },
+            },
+            required: ['url'],
+        },
+        execute: async (input, context) => {
+            const pkg = await loadBedrockPackage();
+            const BrowserTools = pkg.BrowserTools;
+            if (BrowserTools && typeof BrowserTools === 'function') {
+                const browser = new BrowserTools();
+                const navigateTool = browser.tools?.navigate;
+                if (navigateTool && typeof navigateTool.execute === 'function') {
+                    await navigateTool.execute(input);
+                    return { success: true };
+                }
+            }
+            return { success: false, error: 'Browser tools not available' };
+        },
+    };
+}
+/**
+ * Create a Bedrock Browser Click tool
+ */
+function bedrockBrowserClick(config) {
+    return {
+        name: 'bedrockBrowserClick',
+        description: 'Click an element on the page using a CSS selector.',
+        parameters: {
+            type: 'object',
+            properties: {
+                selector: {
+                    type: 'string',
+                    description: 'CSS selector for the element to click',
+                },
+            },
+            required: ['selector'],
+        },
+        execute: async (input, context) => {
+            const pkg = await loadBedrockPackage();
+            const BrowserTools = pkg.BrowserTools;
+            if (BrowserTools && typeof BrowserTools === 'function') {
+                const browser = new BrowserTools();
+                const clickTool = browser.tools?.click;
+                if (clickTool && typeof clickTool.execute === 'function') {
+                    await clickTool.execute(input);
+                    return { success: true };
+                }
+            }
+            return { success: false, error: 'Browser tools not available' };
+        },
+    };
+}
+/**
+ * Create a Bedrock Browser Fill tool
+ */
+function bedrockBrowserFill(config) {
+    return {
+        name: 'bedrockBrowserFill',
+        description: 'Fill a form field with text using a CSS selector.',
+        parameters: {
+            type: 'object',
+            properties: {
+                selector: {
+                    type: 'string',
+                    description: 'CSS selector for the input element',
+                },
+                value: {
+                    type: 'string',
+                    description: 'The value to fill in',
+                },
+            },
+            required: ['selector', 'value'],
+        },
+        execute: async (input, context) => {
+            const pkg = await loadBedrockPackage();
+            const BrowserTools = pkg.BrowserTools;
+            if (BrowserTools && typeof BrowserTools === 'function') {
+                const browser = new BrowserTools();
+                const fillTool = browser.tools?.fill;
+                if (fillTool && typeof fillTool.execute === 'function') {
+                    await fillTool.execute(input);
+                    return { success: true };
+                }
+            }
+            return { success: false, error: 'Browser tools not available' };
+        },
+    };
+}
+/**
+ * Factory functions for registry
+ */
+function createBedrockCodeInterpreterTool(config) {
+    return bedrockCodeInterpreter(config);
+}
+function createBedrockBrowserNavigateTool(config) {
+    return bedrockBrowserNavigate(config);
+}
+function createBedrockBrowserClickTool(config) {
+    return bedrockBrowserClick(config);
+}
+function createBedrockBrowserFillTool(config) {
+    return bedrockBrowserFill(config);
+}

package/dist/tools/builtins/code-execution.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Code Execution Tool (Vercel Sandbox)
+ *
+ * Execute Python code in a sandboxed Vercel environment.
+ * Package: ai-sdk-tool-code-execution
+ */
+import type { ToolMetadata, PraisonTool } from '../registry/types';
+export declare const CODE_EXECUTION_METADATA: ToolMetadata;
+export interface CodeExecutionConfig {
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Execution timeout in ms */
+    timeoutMs?: number;
+}
+export interface CodeExecutionInput {
+    /** Python code to execute */
+    code: string;
+}
+export interface CodeExecutionOutput {
+    /** Execution result/output */
+    result: string;
+    /** Standard output */
+    stdout?: string;
+    /** Standard error */
+    stderr?: string;
+    /** Execution success */
+    success: boolean;
+}
+/**
+ * Create a Code Execution tool instance
+ */
+export declare function codeExecution(config?: CodeExecutionConfig): PraisonTool<CodeExecutionInput, CodeExecutionOutput>;
+/**
+ * Factory function for registry
+ */
+export declare function createCodeExecutionTool(config?: CodeExecutionConfig): PraisonTool<unknown, unknown>;