overai 1.4.0

package/dist/tools/builtins/parallel.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Parallel Web Search Tool
+ *
+ * Web search with extraction and ctx-zip capabilities.
+ * Package: @parallel-web/ai-sdk-tools
+ */
+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.PARALLEL_METADATA = void 0;
+exports.parallelSearch = parallelSearch;
+exports.createParallelSearchTool = createParallelSearchTool;
+const types_1 = require("../registry/types");
+exports.PARALLEL_METADATA = {
+    id: 'parallel',
+    displayName: 'Parallel Web Search',
+    description: 'Web search with extraction and context compression capabilities',
+    tags: ['search', 'web', 'extraction'],
+    requiredEnv: ['PARALLEL_API_KEY'],
+    optionalEnv: [],
+    install: {
+        npm: 'npm install @parallel-web/ai-sdk-tools',
+        pnpm: 'pnpm add @parallel-web/ai-sdk-tools',
+        yarn: 'yarn add @parallel-web/ai-sdk-tools',
+        bun: 'bun add @parallel-web/ai-sdk-tools',
+    },
+    docsSlug: 'tools/parallel',
+    capabilities: {
+        search: true,
+        extract: true,
+    },
+    packageName: '@parallel-web/ai-sdk-tools',
+};
+async function loadParallelPackage() {
+    if (!process.env.PARALLEL_API_KEY) {
+        throw new types_1.MissingEnvVarError(exports.PARALLEL_METADATA.id, 'PARALLEL_API_KEY', exports.PARALLEL_METADATA.docsSlug);
+    }
+    try {
+        // @ts-ignore - optional dependency
+        return await Promise.resolve().then(() => __importStar(require('@parallel-web/ai-sdk-tools')));
+    }
+    catch {
+        throw new types_1.MissingDependencyError(exports.PARALLEL_METADATA.id, exports.PARALLEL_METADATA.packageName, exports.PARALLEL_METADATA.install, exports.PARALLEL_METADATA.requiredEnv, exports.PARALLEL_METADATA.docsSlug);
+    }
+}
+/**
+ * Create a Parallel Search tool
+ */
+function parallelSearch(config) {
+    return {
+        name: 'parallelSearch',
+        description: 'Search the web using Parallel with content extraction capabilities.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The search query',
+                },
+            },
+            required: ['query'],
+        },
+        execute: async (input, context) => {
+            const pkg = await loadParallelPackage();
+            const searchFn = pkg.parallelSearch || pkg.search;
+            if (searchFn && typeof searchFn === 'function') {
+                const tool = searchFn(config);
+                if (tool && typeof tool.execute === 'function') {
+                    return await tool.execute(input);
+                }
+            }
+            return { results: [] };
+        },
+    };
+}
+/**
+ * Factory function for registry
+ */
+function createParallelSearchTool(config) {
+    return parallelSearch(config);
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Perplexity Search Tool
+ *
+ * Web search with real-time results powered by Perplexity.
+ * Package: @perplexity-ai/ai-sdk
+ */
+import type { ToolMetadata, PraisonTool } from '../registry/types';
+export declare const PERPLEXITY_METADATA: ToolMetadata;
+export interface PerplexitySearchConfig {
+    maxResults?: number;
+    recencyFilter?: 'hour' | 'day' | 'week' | 'month' | 'year';
+    domainFilter?: string[];
+}
+export interface PerplexitySearchInput {
+    query: string;
+}
+export interface PerplexitySearchResult {
+    results: Array<{
+        title: string;
+        url: string;
+        snippet: string;
+    }>;
+    answer?: string;
+}
+/**
+ * Create a Perplexity Search tool
+ */
+export declare function perplexitySearch(config?: PerplexitySearchConfig): PraisonTool<PerplexitySearchInput, PerplexitySearchResult>;
+/**
+ * Factory function for registry
+ */
+export declare function createPerplexitySearchTool(config?: PerplexitySearchConfig): PraisonTool<unknown, unknown>;

package/dist/tools/builtins/perplexity.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Perplexity Search Tool
+ *
+ * Web search with real-time results powered by Perplexity.
+ * Package: @perplexity-ai/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.PERPLEXITY_METADATA = void 0;
+exports.perplexitySearch = perplexitySearch;
+exports.createPerplexitySearchTool = createPerplexitySearchTool;
+const types_1 = require("../registry/types");
+exports.PERPLEXITY_METADATA = {
+    id: 'perplexity',
+    displayName: 'Perplexity Search',
+    description: 'Web search with real-time results and advanced filtering powered by Perplexity',
+    tags: ['search', 'web', 'realtime'],
+    requiredEnv: ['PERPLEXITY_API_KEY'],
+    optionalEnv: [],
+    install: {
+        npm: 'npm install @perplexity-ai/ai-sdk',
+        pnpm: 'pnpm add @perplexity-ai/ai-sdk',
+        yarn: 'yarn add @perplexity-ai/ai-sdk',
+        bun: 'bun add @perplexity-ai/ai-sdk',
+    },
+    docsSlug: 'tools/perplexity',
+    capabilities: {
+        search: true,
+    },
+    packageName: '@perplexity-ai/ai-sdk',
+};
+async function loadPerplexityPackage() {
+    if (!process.env.PERPLEXITY_API_KEY) {
+        throw new types_1.MissingEnvVarError(exports.PERPLEXITY_METADATA.id, 'PERPLEXITY_API_KEY', exports.PERPLEXITY_METADATA.docsSlug);
+    }
+    try {
+        // @ts-ignore - optional dependency
+        return await Promise.resolve().then(() => __importStar(require('@perplexity-ai/ai-sdk')));
+    }
+    catch {
+        throw new types_1.MissingDependencyError(exports.PERPLEXITY_METADATA.id, exports.PERPLEXITY_METADATA.packageName, exports.PERPLEXITY_METADATA.install, exports.PERPLEXITY_METADATA.requiredEnv, exports.PERPLEXITY_METADATA.docsSlug);
+    }
+}
+/**
+ * Create a Perplexity Search tool
+ */
+function perplexitySearch(config) {
+    return {
+        name: 'perplexitySearch',
+        description: 'Search the web using Perplexity for real-time information and answers.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The search query',
+                },
+            },
+            required: ['query'],
+        },
+        execute: async (input, context) => {
+            const pkg = await loadPerplexityPackage();
+            // Check for the search function
+            const searchFn = pkg.perplexitySearch || pkg.search;
+            if (searchFn && typeof searchFn === 'function') {
+                const tool = searchFn(config);
+                if (tool && typeof tool.execute === 'function') {
+                    return await tool.execute(input);
+                }
+            }
+            return { results: [] };
+        },
+    };
+}
+/**
+ * Factory function for registry
+ */
+function createPerplexitySearchTool(config) {
+    return perplexitySearch(config);
+}

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

@@ -0,0 +1,66 @@
+/**
+ * Superagent Security Tools
+ *
+ * AI security guardrails: Guard, Redact, Verify.
+ * Package: @superagent-ai/ai-sdk
+ */
+import type { ToolMetadata, PraisonTool } from '../registry/types';
+export declare const SUPERAGENT_METADATA: ToolMetadata;
+export interface GuardConfig {
+    strictMode?: boolean;
+}
+export interface GuardInput {
+    text: string;
+}
+export interface GuardResult {
+    safe: boolean;
+    threats: string[];
+    decision: {
+        status: 'allow' | 'block';
+        violationTypes?: string[];
+    };
+}
+export interface RedactConfig {
+    entities?: string[];
+}
+export interface RedactInput {
+    text: string;
+}
+export interface RedactResult {
+    redactedText: string;
+    entities: Array<{
+        type: string;
+        original: string;
+        replacement: string;
+    }>;
+}
+export interface VerifyConfig {
+    strictMode?: boolean;
+}
+export interface VerifyInput {
+    claim: string;
+    sources: string[];
+}
+export interface VerifyResult {
+    verified: boolean;
+    confidence: number;
+    evidence: string[];
+}
+/**
+ * Create a Superagent Guard tool
+ */
+export declare function superagentGuard(config?: GuardConfig): PraisonTool<GuardInput, GuardResult>;
+/**
+ * Create a Superagent Redact tool
+ */
+export declare function superagentRedact(config?: RedactConfig): PraisonTool<RedactInput, RedactResult>;
+/**
+ * Create a Superagent Verify tool
+ */
+export declare function superagentVerify(config?: VerifyConfig): PraisonTool<VerifyInput, VerifyResult>;
+/**
+ * Factory functions for registry
+ */
+export declare function createSuperagentGuardTool(config?: GuardConfig): PraisonTool<unknown, unknown>;
+export declare function createSuperagentRedactTool(config?: RedactConfig): PraisonTool<unknown, unknown>;
+export declare function createSuperagentVerifyTool(config?: VerifyConfig): PraisonTool<unknown, unknown>;

package/dist/tools/builtins/superagent.js

@@ -0,0 +1,187 @@
+"use strict";
+/**
+ * Superagent Security Tools
+ *
+ * AI security guardrails: Guard, Redact, Verify.
+ * Package: @superagent-ai/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.SUPERAGENT_METADATA = void 0;
+exports.superagentGuard = superagentGuard;
+exports.superagentRedact = superagentRedact;
+exports.superagentVerify = superagentVerify;
+exports.createSuperagentGuardTool = createSuperagentGuardTool;
+exports.createSuperagentRedactTool = createSuperagentRedactTool;
+exports.createSuperagentVerifyTool = createSuperagentVerifyTool;
+const types_1 = require("../registry/types");
+exports.SUPERAGENT_METADATA = {
+    id: 'superagent',
+    displayName: 'Superagent Security',
+    description: 'AI security guardrails: prompt injection protection, PII/PHI redaction, claim verification',
+    tags: ['security', 'guardrails', 'pii', 'prompt-injection', 'verification'],
+    requiredEnv: ['SUPERAGENT_API_KEY'],
+    optionalEnv: [],
+    install: {
+        npm: 'npm install @superagent-ai/ai-sdk',
+        pnpm: 'pnpm add @superagent-ai/ai-sdk',
+        yarn: 'yarn add @superagent-ai/ai-sdk',
+        bun: 'bun add @superagent-ai/ai-sdk',
+    },
+    docsSlug: 'tools/superagent',
+    capabilities: {
+        security: true,
+    },
+    packageName: '@superagent-ai/ai-sdk',
+};
+async function loadSuperagentPackage() {
+    if (!process.env.SUPERAGENT_API_KEY) {
+        throw new types_1.MissingEnvVarError(exports.SUPERAGENT_METADATA.id, 'SUPERAGENT_API_KEY', exports.SUPERAGENT_METADATA.docsSlug);
+    }
+    try {
+        // @ts-ignore - Optional dependency
+        return await Promise.resolve().then(() => __importStar(require('@superagent-ai/ai-sdk')));
+    }
+    catch {
+        throw new types_1.MissingDependencyError(exports.SUPERAGENT_METADATA.id, exports.SUPERAGENT_METADATA.packageName, exports.SUPERAGENT_METADATA.install, exports.SUPERAGENT_METADATA.requiredEnv, exports.SUPERAGENT_METADATA.docsSlug);
+    }
+}
+/**
+ * Create a Superagent Guard tool
+ */
+function superagentGuard(config) {
+    return {
+        name: 'guard',
+        description: 'Check text for security threats like prompt injection, jailbreaks, and data exfiltration attempts.',
+        parameters: {
+            type: 'object',
+            properties: {
+                text: {
+                    type: 'string',
+                    description: 'The text to analyze for security threats',
+                },
+            },
+            required: ['text'],
+        },
+        execute: async (input, context) => {
+            const pkg = await loadSuperagentPackage();
+            const guardFn = pkg.guard;
+            if (guardFn && typeof guardFn === 'function') {
+                const tool = guardFn(config);
+                if (tool && typeof tool.execute === 'function') {
+                    return await tool.execute(input);
+                }
+            }
+            return { safe: true, threats: [], decision: { status: 'allow' } };
+        },
+    };
+}
+/**
+ * Create a Superagent Redact tool
+ */
+function superagentRedact(config) {
+    return {
+        name: 'redact',
+        description: 'Remove sensitive data (PII, PHI, secrets) from text. Redacts SSNs, emails, phone numbers, credit cards, etc.',
+        parameters: {
+            type: 'object',
+            properties: {
+                text: {
+                    type: 'string',
+                    description: 'The text to redact sensitive information from',
+                },
+            },
+            required: ['text'],
+        },
+        execute: async (input, context) => {
+            const pkg = await loadSuperagentPackage();
+            const redactFn = pkg.redact;
+            if (redactFn && typeof redactFn === 'function') {
+                const tool = redactFn(config);
+                if (tool && typeof tool.execute === 'function') {
+                    return await tool.execute(input);
+                }
+            }
+            return { redactedText: input.text, entities: [] };
+        },
+    };
+}
+/**
+ * Create a Superagent Verify tool
+ */
+function superagentVerify(config) {
+    return {
+        name: 'verify',
+        description: 'Verify claims against source materials. Check if statements are supported by provided evidence.',
+        parameters: {
+            type: 'object',
+            properties: {
+                claim: {
+                    type: 'string',
+                    description: 'The claim to verify',
+                },
+                sources: {
+                    type: 'array',
+                    description: 'Source materials to verify against',
+                    items: { type: 'string' },
+                },
+            },
+            required: ['claim', 'sources'],
+        },
+        execute: async (input, context) => {
+            const pkg = await loadSuperagentPackage();
+            const verifyFn = pkg.verify;
+            if (verifyFn && typeof verifyFn === 'function') {
+                const tool = verifyFn(config);
+                if (tool && typeof tool.execute === 'function') {
+                    return await tool.execute(input);
+                }
+            }
+            return { verified: false, confidence: 0, evidence: [] };
+        },
+    };
+}
+/**
+ * Factory functions for registry
+ */
+function createSuperagentGuardTool(config) {
+    return superagentGuard(config);
+}
+function createSuperagentRedactTool(config) {
+    return superagentRedact(config);
+}
+function createSuperagentVerifyTool(config) {
+    return superagentVerify(config);
+}

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

@@ -0,0 +1,99 @@
+/**
+ * Tavily Tools (Search, Extract, Crawl, Map)
+ *
+ * Web search, content extraction, crawling, and site mapping.
+ * Package: @tavily/ai-sdk (uses @tavily/core internally)
+ */
+import type { ToolMetadata, PraisonTool } from '../registry/types';
+export declare const TAVILY_METADATA: ToolMetadata;
+export interface TavilySearchConfig {
+    apiKey?: string;
+    searchDepth?: 'basic' | 'advanced';
+    topic?: 'general' | 'news' | 'finance';
+    includeAnswer?: boolean;
+    maxResults?: number;
+    includeImages?: boolean;
+    timeRange?: 'year' | 'month' | 'week' | 'day';
+    includeDomains?: string[];
+    excludeDomains?: string[];
+}
+export interface TavilySearchInput {
+    query: string;
+    searchDepth?: 'basic' | 'advanced';
+    timeRange?: 'year' | 'month' | 'week' | 'day';
+}
+export interface TavilySearchResult {
+    results: Array<{
+        title: string;
+        url: string;
+        content: string;
+        score?: number;
+    }>;
+    answer?: string;
+    images?: Array<{
+        url: string;
+        description?: string;
+    }>;
+    query?: string;
+    responseTime?: number;
+}
+export interface TavilyExtractConfig {
+    apiKey?: string;
+    extractDepth?: 'basic' | 'advanced';
+}
+export interface TavilyExtractInput {
+    urls: string[];
+    extractDepth?: 'basic' | 'advanced';
+    query?: string;
+}
+export interface TavilyExtractResult {
+    results: Array<{
+        url: string;
+        rawContent: string;
+    }>;
+}
+export interface TavilyCrawlConfig {
+    apiKey?: string;
+    maxDepth?: number;
+    extractDepth?: 'basic' | 'advanced';
+    instructions?: string;
+    allowExternal?: boolean;
+}
+export interface TavilyCrawlInput {
+    url: string;
+    maxDepth?: number;
+    extractDepth?: 'basic' | 'advanced';
+    instructions?: string;
+    allowExternal?: boolean;
+}
+export interface TavilyCrawlResult {
+    baseUrl: string;
+    results: Array<{
+        url: string;
+        rawContent: string;
+    }>;
+}
+/**
+ * Create a Tavily Search tool
+ * Returns a PraisonTool that can be used with agents or directly
+ */
+export declare function tavilySearch(config?: TavilySearchConfig): PraisonTool<TavilySearchInput, TavilySearchResult>;
+/**
+ * Create a Tavily Extract tool
+ */
+export declare function tavilyExtract(config?: TavilyExtractConfig): PraisonTool<TavilyExtractInput, TavilyExtractResult>;
+/**
+ * Create a Tavily Crawl tool
+ */
+export declare function tavilyCrawl(config?: TavilyCrawlConfig): PraisonTool<TavilyCrawlInput, TavilyCrawlResult>;
+/**
+ * Get the raw AI SDK tool for use with generateText
+ * This returns the native @tavily/ai-sdk tool
+ */
+export declare function getTavilyAISDKTool(type?: 'search' | 'extract' | 'crawl' | 'map', config?: TavilySearchConfig): Promise<any>;
+/**
+ * Factory functions for registry
+ */
+export declare function createTavilySearchTool(config?: TavilySearchConfig): PraisonTool<unknown, unknown>;
+export declare function createTavilyExtractTool(config?: TavilyExtractConfig): PraisonTool<unknown, unknown>;
+export declare function createTavilyCrawlTool(config?: TavilyCrawlConfig): PraisonTool<unknown, unknown>;