overai 1.4.0

package/dist/integrations/computer-use.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Computer Use Integration
+ *
+ * Provides interfaces for computer use capabilities (browser/desktop control).
+ * By default, tools are safe no-ops that require explicit implementation.
+ */
+export interface ComputerUseConfig {
+    /** Enable browser control */
+    browser?: boolean;
+    /** Enable desktop control */
+    desktop?: boolean;
+    /** Require human approval for actions (default: true) */
+    requireApproval?: boolean;
+    /** Screenshot directory */
+    screenshotDir?: string;
+    /** Action timeout in ms (default: 30000) */
+    timeout?: number;
+    /** Custom tool implementations */
+    tools?: Partial<ComputerUseTools>;
+}
+export interface ComputerUseTools {
+    /** Take a screenshot */
+    screenshot: () => Promise<ScreenshotResult>;
+    /** Click at coordinates */
+    click: (x: number, y: number, button?: 'left' | 'right' | 'middle') => Promise<void>;
+    /** Double click at coordinates */
+    doubleClick: (x: number, y: number) => Promise<void>;
+    /** Type text */
+    type: (text: string) => Promise<void>;
+    /** Press a key or key combination */
+    key: (key: string) => Promise<void>;
+    /** Move mouse to coordinates */
+    moveMouse: (x: number, y: number) => Promise<void>;
+    /** Scroll */
+    scroll: (direction: 'up' | 'down' | 'left' | 'right', amount?: number) => Promise<void>;
+    /** Get screen size */
+    getScreenSize: () => Promise<{
+        width: number;
+        height: number;
+    }>;
+    /** Wait for a duration */
+    wait: (ms: number) => Promise<void>;
+    /** Execute a shell command (with approval) */
+    execute: (command: string) => Promise<string>;
+}
+export interface ScreenshotResult {
+    /** Base64-encoded image */
+    base64: string;
+    /** Image width */
+    width: number;
+    /** Image height */
+    height: number;
+    /** File path if saved */
+    path?: string;
+}
+export interface ComputerAction {
+    type: 'screenshot' | 'click' | 'doubleClick' | 'type' | 'key' | 'moveMouse' | 'scroll' | 'wait' | 'execute';
+    params?: any;
+    requiresApproval?: boolean;
+}
+/**
+ * Create a Computer Use agent with safe defaults.
+ *
+ * @example Basic usage (safe mode - no-op tools)
+ * ```typescript
+ * import { createComputerUse } from 'praisonai/integrations/computer-use';
+ *
+ * const computer = createComputerUse({
+ *   requireApproval: true
+ * });
+ *
+ * // Get tools for use with an agent
+ * const tools = computer.getTools();
+ * ```
+ *
+ * @example With Playwright browser control
+ * ```typescript
+ * import { chromium } from 'playwright';
+ * import { createComputerUse } from 'praisonai/integrations/computer-use';
+ *
+ * const browser = await chromium.launch();
+ * const page = await browser.newPage();
+ *
+ * const computer = createComputerUse({
+ *   browser: true,
+ *   tools: {
+ *     screenshot: async () => {
+ *       const buffer = await page.screenshot();
+ *       return {
+ *         base64: buffer.toString('base64'),
+ *         width: 1920,
+ *         height: 1080
+ *       };
+ *     },
+ *     click: async (x, y) => {
+ *       await page.mouse.click(x, y);
+ *     },
+ *     type: async (text) => {
+ *       await page.keyboard.type(text);
+ *     }
+ *   }
+ * });
+ * ```
+ */
+export declare function createComputerUse(config?: ComputerUseConfig): ComputerUseClient;
+export declare class ComputerUseClient {
+    private config;
+    private tools;
+    private approvalCallback?;
+    constructor(config?: ComputerUseConfig);
+    /**
+     * Set the approval callback for actions.
+     */
+    onApproval(callback: (action: ComputerAction) => Promise<boolean>): this;
+    /**
+     * No-op screenshot implementation.
+     */
+    private noOpScreenshot;
+    /**
+     * No-op action implementation.
+     */
+    private noOpAction;
+    /**
+     * No-op execute implementation.
+     */
+    private noOpExecute;
+    /**
+     * Request approval for an action.
+     */
+    private requestApproval;
+    /**
+     * Take a screenshot.
+     */
+    screenshot(): Promise<ScreenshotResult>;
+    /**
+     * Click at coordinates.
+     */
+    click(x: number, y: number, button?: 'left' | 'right' | 'middle'): Promise<void>;
+    /**
+     * Type text.
+     */
+    type(text: string): Promise<void>;
+    /**
+     * Press a key.
+     */
+    key(key: string): Promise<void>;
+    /**
+     * Execute a command.
+     */
+    execute(command: string): Promise<string>;
+    /**
+     * Get tools for use with an agent.
+     */
+    getTools(): Record<string, any>;
+}
+/**
+ * Create a simple approval prompt for CLI usage.
+ */
+export declare function createCLIApprovalPrompt(): (action: ComputerAction) => Promise<boolean>;
+/**
+ * Create a Computer Use agent with human-in-the-loop approval.
+ *
+ * @example
+ * ```typescript
+ * import { Agent } from 'praisonai';
+ * import { createComputerUseAgent } from 'praisonai/integrations/computer-use';
+ *
+ * const agent = await createComputerUseAgent({
+ *   instructions: 'You can control the computer to help the user',
+ *   approvalMode: 'cli' // or 'auto' for no approval
+ * });
+ *
+ * await agent.chat('Open a browser and search for AI news');
+ * ```
+ */
+export declare function createComputerUseAgent(options: {
+    instructions?: string;
+    model?: string;
+    approvalMode?: 'cli' | 'auto' | 'custom';
+    onApproval?: (action: ComputerAction) => Promise<boolean>;
+    tools?: Partial<ComputerUseTools>;
+}): Promise<any>;

package/dist/integrations/computer-use.js

@@ -0,0 +1,356 @@
+"use strict";
+/**
+ * Computer Use Integration
+ *
+ * Provides interfaces for computer use capabilities (browser/desktop control).
+ * By default, tools are safe no-ops that require explicit implementation.
+ */
+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.ComputerUseClient = void 0;
+exports.createComputerUse = createComputerUse;
+exports.createCLIApprovalPrompt = createCLIApprovalPrompt;
+exports.createComputerUseAgent = createComputerUseAgent;
+/**
+ * Create a Computer Use agent with safe defaults.
+ *
+ * @example Basic usage (safe mode - no-op tools)
+ * ```typescript
+ * import { createComputerUse } from 'praisonai/integrations/computer-use';
+ *
+ * const computer = createComputerUse({
+ *   requireApproval: true
+ * });
+ *
+ * // Get tools for use with an agent
+ * const tools = computer.getTools();
+ * ```
+ *
+ * @example With Playwright browser control
+ * ```typescript
+ * import { chromium } from 'playwright';
+ * import { createComputerUse } from 'praisonai/integrations/computer-use';
+ *
+ * const browser = await chromium.launch();
+ * const page = await browser.newPage();
+ *
+ * const computer = createComputerUse({
+ *   browser: true,
+ *   tools: {
+ *     screenshot: async () => {
+ *       const buffer = await page.screenshot();
+ *       return {
+ *         base64: buffer.toString('base64'),
+ *         width: 1920,
+ *         height: 1080
+ *       };
+ *     },
+ *     click: async (x, y) => {
+ *       await page.mouse.click(x, y);
+ *     },
+ *     type: async (text) => {
+ *       await page.keyboard.type(text);
+ *     }
+ *   }
+ * });
+ * ```
+ */
+function createComputerUse(config = {}) {
+    return new ComputerUseClient(config);
+}
+class ComputerUseClient {
+    constructor(config = {}) {
+        this.config = {
+            requireApproval: true,
+            timeout: 30000,
+            ...config,
+        };
+        // Initialize with safe no-op tools
+        this.tools = {
+            screenshot: config.tools?.screenshot || this.noOpScreenshot,
+            click: config.tools?.click || this.noOpAction,
+            doubleClick: config.tools?.doubleClick || this.noOpAction,
+            type: config.tools?.type || this.noOpAction,
+            key: config.tools?.key || this.noOpAction,
+            moveMouse: config.tools?.moveMouse || this.noOpAction,
+            scroll: config.tools?.scroll || this.noOpAction,
+            getScreenSize: config.tools?.getScreenSize || (async () => ({ width: 1920, height: 1080 })),
+            wait: config.tools?.wait || (async (ms) => new Promise(r => setTimeout(r, ms))),
+            execute: config.tools?.execute || this.noOpExecute,
+        };
+    }
+    /**
+     * Set the approval callback for actions.
+     */
+    onApproval(callback) {
+        this.approvalCallback = callback;
+        return this;
+    }
+    /**
+     * No-op screenshot implementation.
+     */
+    async noOpScreenshot() {
+        console.warn('Computer Use: screenshot() called but no implementation provided');
+        return {
+            base64: '',
+            width: 0,
+            height: 0,
+        };
+    }
+    /**
+     * No-op action implementation.
+     */
+    async noOpAction(...args) {
+        console.warn('Computer Use: action called but no implementation provided', args);
+    }
+    /**
+     * No-op execute implementation.
+     */
+    async noOpExecute(command) {
+        console.warn('Computer Use: execute() called but no implementation provided');
+        return `[No-op] Would execute: ${command}`;
+    }
+    /**
+     * Request approval for an action.
+     */
+    async requestApproval(action) {
+        if (!this.config.requireApproval) {
+            return true;
+        }
+        if (this.approvalCallback) {
+            return await this.approvalCallback(action);
+        }
+        // Default: deny if no callback
+        console.warn('Computer Use: Action requires approval but no callback set', action);
+        return false;
+    }
+    /**
+     * Take a screenshot.
+     */
+    async screenshot() {
+        const action = { type: 'screenshot' };
+        if (!(await this.requestApproval(action))) {
+            throw new Error('Screenshot action denied');
+        }
+        return await this.tools.screenshot();
+    }
+    /**
+     * Click at coordinates.
+     */
+    async click(x, y, button = 'left') {
+        const action = { type: 'click', params: { x, y, button }, requiresApproval: true };
+        if (!(await this.requestApproval(action))) {
+            throw new Error('Click action denied');
+        }
+        await this.tools.click(x, y, button);
+    }
+    /**
+     * Type text.
+     */
+    async type(text) {
+        const action = { type: 'type', params: { text }, requiresApproval: true };
+        if (!(await this.requestApproval(action))) {
+            throw new Error('Type action denied');
+        }
+        await this.tools.type(text);
+    }
+    /**
+     * Press a key.
+     */
+    async key(key) {
+        const action = { type: 'key', params: { key }, requiresApproval: true };
+        if (!(await this.requestApproval(action))) {
+            throw new Error('Key action denied');
+        }
+        await this.tools.key(key);
+    }
+    /**
+     * Execute a command.
+     */
+    async execute(command) {
+        const action = { type: 'execute', params: { command }, requiresApproval: true };
+        if (!(await this.requestApproval(action))) {
+            throw new Error('Execute action denied');
+        }
+        return await this.tools.execute(command);
+    }
+    /**
+     * Get tools for use with an agent.
+     */
+    getTools() {
+        return {
+            computer_screenshot: {
+                description: 'Take a screenshot of the current screen',
+                parameters: { type: 'object', properties: {} },
+                execute: async () => {
+                    const result = await this.screenshot();
+                    return JSON.stringify({ width: result.width, height: result.height, hasImage: !!result.base64 });
+                },
+            },
+            computer_click: {
+                description: 'Click at specific coordinates on the screen',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        x: { type: 'number', description: 'X coordinate' },
+                        y: { type: 'number', description: 'Y coordinate' },
+                        button: { type: 'string', enum: ['left', 'right', 'middle'], description: 'Mouse button' },
+                    },
+                    required: ['x', 'y'],
+                },
+                execute: async ({ x, y, button }) => {
+                    await this.click(x, y, button);
+                    return 'Clicked successfully';
+                },
+            },
+            computer_type: {
+                description: 'Type text using the keyboard',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        text: { type: 'string', description: 'Text to type' },
+                    },
+                    required: ['text'],
+                },
+                execute: async ({ text }) => {
+                    await this.type(text);
+                    return 'Typed successfully';
+                },
+            },
+            computer_key: {
+                description: 'Press a key or key combination (e.g., "Enter", "Control+C")',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        key: { type: 'string', description: 'Key or key combination to press' },
+                    },
+                    required: ['key'],
+                },
+                execute: async ({ key }) => {
+                    await this.key(key);
+                    return 'Key pressed successfully';
+                },
+            },
+            computer_scroll: {
+                description: 'Scroll the screen',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        direction: { type: 'string', enum: ['up', 'down', 'left', 'right'] },
+                        amount: { type: 'number', description: 'Scroll amount in pixels' },
+                    },
+                    required: ['direction'],
+                },
+                execute: async ({ direction, amount }) => {
+                    const action = { type: 'scroll', params: { direction, amount }, requiresApproval: true };
+                    if (!(await this.requestApproval(action))) {
+                        throw new Error('Scroll action denied');
+                    }
+                    await this.tools.scroll(direction, amount);
+                    return 'Scrolled successfully';
+                },
+            },
+            computer_execute: {
+                description: 'Execute a shell command (requires approval)',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        command: { type: 'string', description: 'Shell command to execute' },
+                    },
+                    required: ['command'],
+                },
+                execute: async ({ command }) => {
+                    const result = await this.execute(command);
+                    return result;
+                },
+            },
+        };
+    }
+}
+exports.ComputerUseClient = ComputerUseClient;
+/**
+ * Create a simple approval prompt for CLI usage.
+ */
+function createCLIApprovalPrompt() {
+    return async (action) => {
+        const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve) => {
+            const actionDesc = `${action.type}${action.params ? `: ${JSON.stringify(action.params)}` : ''}`;
+            rl.question(`\n⚠️  Approve action: ${actionDesc}? (y/n) `, (answer) => {
+                rl.close();
+                resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+            });
+        });
+    };
+}
+/**
+ * Create a Computer Use agent with human-in-the-loop approval.
+ *
+ * @example
+ * ```typescript
+ * import { Agent } from 'praisonai';
+ * import { createComputerUseAgent } from 'praisonai/integrations/computer-use';
+ *
+ * const agent = await createComputerUseAgent({
+ *   instructions: 'You can control the computer to help the user',
+ *   approvalMode: 'cli' // or 'auto' for no approval
+ * });
+ *
+ * await agent.chat('Open a browser and search for AI news');
+ * ```
+ */
+async function createComputerUseAgent(options) {
+    const { Agent } = await Promise.resolve().then(() => __importStar(require('../agent/simple')));
+    const computer = createComputerUse({
+        requireApproval: options.approvalMode !== 'auto',
+        tools: options.tools,
+    });
+    if (options.approvalMode === 'cli') {
+        computer.onApproval(createCLIApprovalPrompt());
+    }
+    else if (options.approvalMode === 'custom' && options.onApproval) {
+        computer.onApproval(options.onApproval);
+    }
+    const computerTools = computer.getTools();
+    return new Agent({
+        instructions: options.instructions || 'You are a computer use assistant. You can take screenshots, click, type, and execute commands to help the user.',
+        llm: options.model || 'gpt-4o',
+        tools: Object.values(computerTools),
+    });
+}

package/dist/integrations/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * PraisonAI Integrations
+ * Extensions for vector stores, observability, and voice
+ */
+export * from './vector';
+export * from './observability';
+export * from './voice';

package/dist/integrations/index.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * PraisonAI Integrations
+ * Extensions for vector stores, observability, and voice
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Vector Store Integrations
+__exportStar(require("./vector"), exports);
+// Observability Integrations
+__exportStar(require("./observability"), exports);
+// Voice Integrations
+__exportStar(require("./voice"), exports);

package/dist/integrations/observability/base.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Base Observability - Abstract class for observability integrations
+ * Supports tracing, logging, and metrics
+ */
+export interface Span {
+    id: string;
+    traceId: string;
+    parentId?: string;
+    name: string;
+    startTime: number;
+    endTime?: number;
+    status: 'ok' | 'error' | 'unset';
+    attributes: Record<string, any>;
+    events: SpanEvent[];
+}
+export interface SpanEvent {
+    name: string;
+    timestamp: number;
+    attributes?: Record<string, any>;
+}
+export interface TraceContext {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+}
+export interface LogEntry {
+    level: 'debug' | 'info' | 'warn' | 'error';
+    message: string;
+    timestamp: number;
+    traceId?: string;
+    spanId?: string;
+    attributes?: Record<string, any>;
+}
+export interface Metric {
+    name: string;
+    value: number;
+    type: 'counter' | 'gauge' | 'histogram';
+    timestamp: number;
+    tags?: Record<string, string>;
+}
+/**
+ * Abstract base class for observability providers
+ */
+export declare abstract class BaseObservabilityProvider {
+    readonly name: string;
+    constructor(name: string);
+    /**
+     * Start a new span
+     */
+    abstract startSpan(name: string, attributes?: Record<string, any>, parentContext?: TraceContext): Span;
+    /**
+     * End a span
+     */
+    abstract endSpan(span: Span, status?: 'ok' | 'error', error?: Error): void;
+    /**
+     * Add event to span
+     */
+    abstract addSpanEvent(span: Span, name: string, attributes?: Record<string, any>): void;
+    /**
+     * Log a message
+     */
+    abstract log(entry: LogEntry): void;
+    /**
+     * Record a metric
+     */
+    abstract recordMetric(metric: Metric): void;
+    /**
+     * Flush all pending data
+     */
+    abstract flush(): Promise<void>;
+    /**
+     * Shutdown the provider
+     */
+    abstract shutdown(): Promise<void>;
+    /**
+     * Helper to create trace context
+     */
+    protected createTraceContext(span: Span): TraceContext;
+    /**
+     * Generate unique ID
+     */
+    protected generateId(): string;
+}
+/**
+ * Console-based observability provider for development
+ */
+export declare class ConsoleObservabilityProvider extends BaseObservabilityProvider {
+    private spans;
+    private verbose;
+    constructor(config?: {
+        verbose?: boolean;
+    });
+    startSpan(name: string, attributes?: Record<string, any>, parentContext?: TraceContext): Span;
+    endSpan(span: Span, status?: 'ok' | 'error', error?: Error): void;
+    addSpanEvent(span: Span, name: string, attributes?: Record<string, any>): void;
+    log(entry: LogEntry): void;
+    recordMetric(metric: Metric): void;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+/**
+ * Memory-based observability provider for testing
+ */
+export declare class MemoryObservabilityProvider extends BaseObservabilityProvider {
+    spans: Span[];
+    logs: LogEntry[];
+    metrics: Metric[];
+    constructor();
+    startSpan(name: string, attributes?: Record<string, any>, parentContext?: TraceContext): Span;
+    endSpan(span: Span, status?: 'ok' | 'error', error?: Error): void;
+    addSpanEvent(span: Span, name: string, attributes?: Record<string, any>): void;
+    log(entry: LogEntry): void;
+    recordMetric(metric: Metric): void;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    getSpansByName(name: string): Span[];
+    getLogsByLevel(level: LogEntry['level']): LogEntry[];
+    getMetricsByName(name: string): Metric[];
+}
+export declare function createConsoleObservability(config?: {
+    verbose?: boolean;
+}): ConsoleObservabilityProvider;
+export declare function createMemoryObservability(): MemoryObservabilityProvider;