@codebolt/codeboltjs 5.0.8 → 5.0.9

package/dist/modules/codeboltEvent.js

@@ -1,217 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-// codeboltEvent.ts
-const websocket_1 = __importDefault(require("../core/websocket"));
-const crypto_1 = require("crypto");
-// Event state maps - Internal use only
-const runningBackgroundAgents = new Map();
-const completedBackgroundAgents = new Map();
-const agentEventMap = new Map();
-const groupedAgentCompletionMap = new Map();
-const backgroundAgentGroups = new Map();
-// Helper to cleanup group membership
-const cleanupAgentGroup = (threadId) => {
-    for (const [groupId, agents] of backgroundAgentGroups.entries()) {
-        if (agents.has(threadId)) {
-            agents.delete(threadId);
-            if (agents.size === 0) {
-                backgroundAgentGroups.delete(groupId);
-            }
-        }
-    }
-};
-// Handler for background agent completion messages
-const handleBackgroundAgentCompletion = (message) => {
-    // Add to completed queue for orchestrator to process
-    completedBackgroundAgents.set(message.threadId, message);
-    // Remove from running map since agent is now complete
-    runningBackgroundAgents.delete(message.threadId);
-    // Clean up any group associations
-    cleanupAgentGroup(message.threadId);
-};
-// Subscribe to message types
-const agentEventSubscription = websocket_1.default.messageManager.subscribe('agentEvent');
-agentEventSubscription.on('message', (message) => {
-    const eventId = (0, crypto_1.randomUUID)();
-    agentEventMap.set(eventId, message);
-});
-// Subscribe to background agent completion - primary message type
-const backgroundAgentSubscription = websocket_1.default.messageManager.subscribe('startThreadResponse');
-backgroundAgentSubscription.on('message', handleBackgroundAgentCompletion);
-// Also subscribe to ThreadCompleted as an alternative message type for background agent completion
-const threadCompletedSubscription = websocket_1.default.messageManager.subscribe('ThreadCompleted');
-threadCompletedSubscription.on('message', (message) => {
-    // Only handle if this thread was a background agent
-    if (runningBackgroundAgents.has(message.threadId)) {
-        handleBackgroundAgentCompletion(message);
-        // Also emit on the backgroundAgentSubscription for waitForAnyExternalEvent
-        backgroundAgentSubscription.emit('message', message);
-    }
-});
-const groupedAgentSubscription = websocket_1.default.messageManager.subscribe('backgroundGroupedAgentCompletion');
-groupedAgentSubscription.on('message', (message) => {
-    groupedAgentCompletionMap.set(message.threadId, message);
-});
-/**
- * Codebolt Event module for handling external events.
- * This module provides APIs for waiting on and checking for various event types.
- */
-const codeboltEvent = {
-    /**
-     * Adds a running background agent to tracking.
-     * @param {string} threadId - The thread ID
-     * @param {any} data - The agent data
-     * @param {string} [groupId] - Optional group ID
-     */
-    addRunningAgent: (threadId, data, groupId) => {
-        runningBackgroundAgents.set(threadId, data);
-        if (groupId) {
-            if (!backgroundAgentGroups.has(groupId)) {
-                backgroundAgentGroups.set(groupId, new Set());
-            }
-            backgroundAgentGroups.get(groupId).add(threadId);
-        }
-    },
-    /**
-     * Gets the number of currently running background agents.
-     * @returns {number} The count
-     */
-    getRunningAgentCount: () => {
-        return runningBackgroundAgents.size;
-    },
-    /**
-     * Checks if any background agent has completed.
-     * @returns {any} The completion data if available, or null
-     */
-    checkForBackgroundAgentCompletion: () => {
-        if (completedBackgroundAgents.size > 0) {
-            const values = Array.from(completedBackgroundAgents.values());
-            completedBackgroundAgents.clear();
-            return values;
-        }
-        return null;
-    },
-    /**
-     * Waits for background agent completion.
-     * @returns {Promise<any>} A promise that resolves with the completion data
-     */
-    onBackgroundAgentCompletion: async () => {
-        const completion = codeboltEvent.checkForBackgroundAgentCompletion();
-        if (completion)
-            return completion;
-        return new Promise((resolve) => {
-            backgroundAgentSubscription.once('message', () => {
-                const data = codeboltEvent.checkForBackgroundAgentCompletion();
-                resolve(data);
-            });
-        });
-    },
-    /**
-     * Checks if any grouped background agent has completed.
-     * @returns {any} The completion data if available, or null
-     */
-    checkForBackgroundGroupedAgentCompletion: () => {
-        if (groupedAgentCompletionMap.size > 0) {
-            const [key, value] = groupedAgentCompletionMap.entries().next().value || [];
-            if (key) {
-                groupedAgentCompletionMap.delete(key);
-                return value;
-            }
-        }
-        return null;
-    },
-    /**
-     * Waits for grouped background agent completion.
-     * @returns {Promise<any>} A promise that resolves with the completion data
-     */
-    onBackgroundGroupedAgentCompletion: async () => {
-        const completion = codeboltEvent.checkForBackgroundGroupedAgentCompletion();
-        if (completion)
-            return completion;
-        return new Promise((resolve) => {
-            groupedAgentSubscription.once('message', () => {
-                const data = codeboltEvent.checkForBackgroundGroupedAgentCompletion();
-                resolve(data);
-            });
-        });
-    },
-    /**
-     * Checks if any agent event has been received.
-     * @returns {any} The event data if available, or null
-     */
-    checkForAgentEventReceived: () => {
-        if (agentEventMap.size > 0) {
-            const [key, value] = agentEventMap.entries().next().value || [];
-            if (key) {
-                agentEventMap.delete(key);
-                return value;
-            }
-        }
-        return null;
-    },
-    /**
-     * Waits for an agent event.
-     * @returns {Promise<any>} A promise that resolves with the event data
-     */
-    onAgentEventReceived: async () => {
-        const event = codeboltEvent.checkForAgentEventReceived();
-        if (event)
-            return event;
-        return new Promise((resolve) => {
-            agentEventSubscription.once('message', () => {
-                const data = codeboltEvent.checkForAgentEventReceived();
-                resolve(data);
-            });
-        });
-    },
-    /**
-     * Waits for any external event (Background Completion, Group Completion, Agent Event).
-     * @returns {Promise<{ type: string, data: any }>} A promise that resolves with the event object
-     */
-    waitForAnyExternalEvent: async () => {
-        // Check functions mapped to their return type strings
-        const checks = [
-            { fn: () => codeboltEvent.checkForBackgroundAgentCompletion(), type: 'backgroundAgentCompletion' },
-            { fn: () => codeboltEvent.checkForBackgroundGroupedAgentCompletion(), type: 'backgroundGroupedAgentCompletion' },
-            { fn: () => codeboltEvent.checkForAgentEventReceived(), type: 'agentEventReceived' }
-        ];
-        for (const { fn, type } of checks) {
-            const data = fn();
-            if (data)
-                return { type, data };
-        }
-        return new Promise((resolve) => {
-            const cleanup = () => {
-                backgroundAgentSubscription.removeListener('message', onBgComplete);
-                groupedAgentSubscription.removeListener('message', onGroupComplete);
-                agentEventSubscription.removeListener('message', onAgentEvent);
-            };
-            const onBgComplete = () => {
-                // Must unhook first to avoid multi-resolution
-                cleanup();
-                // We must yield slightly to ensure handleBackgroundAgentCompletion has processed the event?
-                // Actually, handleBackgroundAgentCompletion attaches first, so it runs first on the same emitter. 
-                // That should be safe synchronously.
-                const data = codeboltEvent.checkForBackgroundAgentCompletion();
-                resolve({ type: 'backgroundAgentCompletion', data });
-            };
-            const onGroupComplete = () => {
-                cleanup();
-                const data = codeboltEvent.checkForBackgroundGroupedAgentCompletion();
-                resolve({ type: 'backgroundGroupedAgentCompletion', data });
-            };
-            const onAgentEvent = () => {
-                cleanup();
-                const data = codeboltEvent.checkForAgentEventReceived();
-                resolve({ type: 'agentEventReceived', data });
-            };
-            backgroundAgentSubscription.once('message', onBgComplete);
-            groupedAgentSubscription.once('message', onGroupComplete);
-            agentEventSubscription.once('message', onAgentEvent);
-        });
-    }
-};
-exports.default = codeboltEvent;

package/dist/tools/browser/browser-action.d.ts

@@ -1,56 +0,0 @@
-/**
- * Browser Action Tool - Performs browser automation actions
- * Wraps the SDK's cbbrowser methods
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Supported browser actions
- */
-export type BrowserActionType = 'navigate' | 'screenshot' | 'click' | 'type' | 'scroll' | 'get_content' | 'get_html' | 'get_markdown' | 'get_url' | 'close' | 'enter' | 'search';
-/**
- * Parameters for the BrowserAction tool
- */
-export interface BrowserActionToolParams {
-    /**
-     * The browser action to perform
-     */
-    action: BrowserActionType;
-    /**
-     * URL for navigate action
-     */
-    url?: string;
-    /**
-     * Element ID for click/type/search actions
-     */
-    element_id?: string;
-    /**
-     * Text for type action
-     */
-    text?: string;
-    /**
-     * Query for search action
-     */
-    query?: string;
-    /**
-     * Scroll direction ('up', 'down', 'left', 'right')
-     */
-    direction?: string;
-    /**
-     * Pixels to scroll
-     */
-    pixels?: string;
-    /**
-     * Browser instance ID (optional)
-     */
-    instance_id?: string;
-}
-/**
- * Implementation of the BrowserAction tool logic
- */
-export declare class BrowserActionTool extends BaseDeclarativeTool<BrowserActionToolParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected validateToolParamValues(params: BrowserActionToolParams): string | null;
-    protected createInvocation(params: BrowserActionToolParams): ToolInvocation<BrowserActionToolParams, ToolResult>;
-}

package/dist/tools/browser/browser-action.js

@@ -1,265 +0,0 @@
-"use strict";
-/**
- * Browser Action Tool - Performs browser automation actions
- * Wraps the SDK's cbbrowser methods
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BrowserActionTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const browser_1 = __importDefault(require("../../modules/browser"));
-class BrowserActionToolInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        var _a;
-        try {
-            const action = this.params.action;
-            const options = this.params.instance_id ? { instanceId: this.params.instance_id } : undefined;
-            let response;
-            let successMessage;
-            switch (action) {
-                case 'navigate':
-                    if (!this.params.url) {
-                        return this.createError("'url' is required for navigate action");
-                    }
-                    response = await browser_1.default.goToPage(this.params.url, options);
-                    successMessage = `Navigated to ${this.params.url}`;
-                    break;
-                case 'screenshot':
-                    response = await browser_1.default.screenshot(options);
-                    successMessage = 'Screenshot taken';
-                    break;
-                case 'click':
-                    if (!this.params.element_id) {
-                        return this.createError("'element_id' is required for click action");
-                    }
-                    response = await browser_1.default.click(this.params.element_id, options);
-                    successMessage = `Clicked element: ${this.params.element_id}`;
-                    break;
-                case 'type':
-                    if (!this.params.element_id) {
-                        return this.createError("'element_id' is required for type action");
-                    }
-                    if (!this.params.text) {
-                        return this.createError("'text' is required for type action");
-                    }
-                    response = await browser_1.default.type(this.params.element_id, this.params.text, options);
-                    successMessage = `Typed text into element: ${this.params.element_id}`;
-                    break;
-                case 'scroll':
-                    if (!this.params.direction) {
-                        return this.createError("'direction' is required for scroll action");
-                    }
-                    if (!this.params.pixels) {
-                        return this.createError("'pixels' is required for scroll action");
-                    }
-                    response = await browser_1.default.scroll(this.params.direction, this.params.pixels, options);
-                    successMessage = `Scrolled ${this.params.direction} by ${this.params.pixels} pixels`;
-                    break;
-                case 'get_content':
-                    response = await browser_1.default.getContent(options);
-                    successMessage = 'Retrieved page content';
-                    break;
-                case 'get_html':
-                    response = await browser_1.default.getHTML(options);
-                    successMessage = 'Retrieved page HTML';
-                    break;
-                case 'get_markdown':
-                    response = await browser_1.default.getMarkdown(options);
-                    successMessage = 'Retrieved page as Markdown';
-                    break;
-                case 'get_url':
-                    response = await browser_1.default.getUrl(options);
-                    successMessage = 'Retrieved current URL';
-                    break;
-                case 'close':
-                    await browser_1.default.close(options);
-                    return {
-                        llmContent: 'Browser closed successfully',
-                        returnDisplay: 'Browser closed',
-                    };
-                case 'enter':
-                    response = await browser_1.default.enter(options);
-                    successMessage = 'Pressed Enter';
-                    break;
-                case 'search':
-                    if (!this.params.element_id) {
-                        return this.createError("'element_id' is required for search action");
-                    }
-                    if (!this.params.query) {
-                        return this.createError("'query' is required for search action");
-                    }
-                    response = await browser_1.default.search(this.params.element_id, this.params.query, options);
-                    successMessage = `Searched for: ${this.params.query}`;
-                    break;
-                default:
-                    return this.createError(`Unknown action: ${action}`);
-            }
-            // Check for errors
-            if (response && !response.success && response.success !== undefined) {
-                const errorMsg = typeof response.error === 'string'
-                    ? response.error
-                    : ((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Browser operation failed';
-                return {
-                    llmContent: `Browser ${action} failed: ${errorMsg}`,
-                    returnDisplay: `Error: ${errorMsg}`,
-                    error: {
-                        message: errorMsg,
-                        type: types_1.ToolErrorType.BROWSER_EXECUTION_ERROR,
-                    },
-                };
-            }
-            // Format output based on action
-            let output = successMessage;
-            if (action === 'get_url' && response.url) {
-                output = `Current URL: ${response.url}`;
-            }
-            else if (action === 'get_content' && response.content) {
-                output = `Page content:\n\n${this.truncate(response.content, 5000)}`;
-            }
-            else if (action === 'get_html' && response.html) {
-                output = `HTML content:\n\n${this.truncate(response.html, 5000)}`;
-            }
-            else if (action === 'get_markdown' && response.markdown) {
-                output = `Markdown content:\n\n${response.markdown}`;
-            }
-            else if (action === 'screenshot' && response.screenshot) {
-                output = 'Screenshot captured successfully.\n\n[Screenshot data available]';
-            }
-            else if (response && response.result) {
-                output += '\n\n' + (typeof response.result === 'string' ? response.result : JSON.stringify(response.result, null, 2));
-            }
-            return {
-                llmContent: output,
-                returnDisplay: successMessage,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error executing browser ${this.params.action}: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-    createError(message) {
-        return {
-            llmContent: `Error: ${message}`,
-            returnDisplay: `Error: ${message}`,
-            error: {
-                message,
-                type: types_1.ToolErrorType.INVALID_TOOL_PARAMS,
-            },
-        };
-    }
-    truncate(text, maxLength) {
-        if (text.length <= maxLength)
-            return text;
-        return text.substring(0, maxLength) + '\n\n... (content truncated)';
-    }
-}
-/**
- * Implementation of the BrowserAction tool logic
- */
-class BrowserActionTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(BrowserActionTool.Name, 'BrowserAction', `Performs browser automation actions like navigating to URLs, taking screenshots, clicking elements, typing text, scrolling, and extracting page content. Use this for web automation and scraping tasks.`, types_1.Kind.Execute, {
-            properties: {
-                action: {
-                    description: "The browser action to perform: 'navigate', 'screenshot', 'click', 'type', 'scroll', 'get_content', 'get_html', 'get_markdown', 'get_url', 'close', 'enter', or 'search'.",
-                    type: 'string',
-                    enum: ['navigate', 'screenshot', 'click', 'type', 'scroll', 'get_content', 'get_html', 'get_markdown', 'get_url', 'close', 'enter', 'search'],
-                },
-                url: {
-                    description: "URL to navigate to (required for 'navigate' action).",
-                    type: 'string',
-                },
-                element_id: {
-                    description: "Element ID to interact with (required for 'click', 'type', 'search' actions).",
-                    type: 'string',
-                },
-                text: {
-                    description: "Text to type (required for 'type' action).",
-                    type: 'string',
-                },
-                query: {
-                    description: "Search query (required for 'search' action).",
-                    type: 'string',
-                },
-                direction: {
-                    description: "Scroll direction: 'up', 'down', 'left', 'right' (required for 'scroll' action).",
-                    type: 'string',
-                    enum: ['up', 'down', 'left', 'right'],
-                },
-                pixels: {
-                    description: "Number of pixels to scroll (required for 'scroll' action).",
-                    type: 'string',
-                },
-                instance_id: {
-                    description: 'Optional browser instance ID for multi-instance support.',
-                    type: 'string',
-                },
-            },
-            required: ['action'],
-            type: 'object',
-        });
-    }
-    validateToolParamValues(params) {
-        const validActions = ['navigate', 'screenshot', 'click', 'type', 'scroll', 'get_content', 'get_html', 'get_markdown', 'get_url', 'close', 'enter', 'search'];
-        if (!validActions.includes(params.action)) {
-            return `Invalid action: ${params.action}. Must be one of: ${validActions.join(', ')}`;
-        }
-        // Action-specific validation
-        switch (params.action) {
-            case 'navigate':
-                if (!params.url) {
-                    return "'url' is required for navigate action";
-                }
-                break;
-            case 'click':
-                if (!params.element_id) {
-                    return "'element_id' is required for click action";
-                }
-                break;
-            case 'type':
-                if (!params.element_id) {
-                    return "'element_id' is required for type action";
-                }
-                if (!params.text) {
-                    return "'text' is required for type action";
-                }
-                break;
-            case 'scroll':
-                if (!params.direction) {
-                    return "'direction' is required for scroll action";
-                }
-                if (!params.pixels) {
-                    return "'pixels' is required for scroll action";
-                }
-                break;
-            case 'search':
-                if (!params.element_id) {
-                    return "'element_id' is required for search action";
-                }
-                if (!params.query) {
-                    return "'query' is required for search action";
-                }
-                break;
-        }
-        return null;
-    }
-    createInvocation(params) {
-        return new BrowserActionToolInvocation(params);
-    }
-}
-exports.BrowserActionTool = BrowserActionTool;
-BrowserActionTool.Name = 'browser_action';

package/dist/tools/codeboltEvent/event-add-running-agent.d.ts

@@ -1,25 +0,0 @@
-/**
- * Event Add Running Agent Tool
- *
- * Adds a running background agent to tracking.
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for adding a running agent
- */
-export interface EventAddRunningAgentParams {
-    /** The thread ID */
-    threadId: string;
-    /** The agent data */
-    data: any;
-    /** Optional group ID */
-    groupId?: string;
-}
-/**
- * Tool for adding a running agent
- */
-export declare class EventAddRunningAgentTool extends BaseDeclarativeTool<EventAddRunningAgentParams, ToolResult> {
-    constructor();
-    protected createInvocation(params: EventAddRunningAgentParams): ToolInvocation<EventAddRunningAgentParams, ToolResult>;
-}

package/dist/tools/codeboltEvent/event-add-running-agent.js

@@ -1,69 +0,0 @@
-"use strict";
-/**
- * Event Add Running Agent Tool
- *
- * Adds a running background agent to tracking.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventAddRunningAgentTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const codeboltEvent_1 = __importDefault(require("../../modules/codeboltEvent"));
-class EventAddRunningAgentInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute(_signal) {
-        try {
-            codeboltEvent_1.default.addRunningAgent(this.params.threadId, this.params.data, this.params.groupId);
-            const groupInfo = this.params.groupId ? ` to group ${this.params.groupId}` : '';
-            return {
-                llmContent: `Successfully added running agent ${this.params.threadId}${groupInfo}`,
-                returnDisplay: `Added running agent ${this.params.threadId}`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            return {
-                llmContent: `Error: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-/**
- * Tool for adding a running agent
- */
-class EventAddRunningAgentTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super('event_add_running_agent', 'Add Running Agent', 'Adds a running background agent to tracking with optional group ID.', types_1.Kind.Other, {
-            type: 'object',
-            properties: {
-                threadId: {
-                    type: 'string',
-                    description: 'The thread ID',
-                },
-                data: {
-                    type: 'object',
-                    description: 'The agent data',
-                },
-                groupId: {
-                    type: 'string',
-                    description: 'Optional group ID',
-                },
-            },
-            required: ['threadId', 'data'],
-        });
-    }
-    createInvocation(params) {
-        return new EventAddRunningAgentInvocation(params);
-    }
-}
-exports.EventAddRunningAgentTool = EventAddRunningAgentTool;

package/dist/tools/codeboltEvent/event-check-background-agent-completion.d.ts

@@ -1,19 +0,0 @@
-/**
- * Event Check Background Agent Completion Tool
- *
- * Checks if any background agent has completed (non-blocking).
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for checking background agent completion (none required)
- */
-export interface EventCheckBackgroundAgentCompletionParams {
-}
-/**
- * Tool for checking background agent completion
- */
-export declare class EventCheckBackgroundAgentCompletionTool extends BaseDeclarativeTool<EventCheckBackgroundAgentCompletionParams, ToolResult> {
-    constructor();
-    protected createInvocation(params: EventCheckBackgroundAgentCompletionParams): ToolInvocation<EventCheckBackgroundAgentCompletionParams, ToolResult>;
-}