@codebolt/codeboltjs 5.0.7 → 5.0.9

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>;
-}

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

@@ -1,64 +0,0 @@
-"use strict";
-/**
- * Event Check Background Agent Completion Tool
- *
- * Checks if any background agent has completed (non-blocking).
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventCheckBackgroundAgentCompletionTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const codeboltEvent_1 = __importDefault(require("../../modules/codeboltEvent"));
-class EventCheckBackgroundAgentCompletionInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute(_signal) {
-        try {
-            const completion = codeboltEvent_1.default.checkForBackgroundAgentCompletion();
-            if (completion) {
-                const count = Array.isArray(completion) ? completion.length : 1;
-                return {
-                    llmContent: `Found ${count} completed background agent(s)`,
-                    returnDisplay: `Found ${count} completed agent(s)`,
-                };
-            }
-            else {
-                return {
-                    llmContent: 'No completed background agents found',
-                    returnDisplay: 'No completed agents',
-                };
-            }
-        }
-        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 checking background agent completion
- */
-class EventCheckBackgroundAgentCompletionTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super('event_check_background_agent_completion', 'Check Background Agent Completion', 'Checks if any background agent has completed (non-blocking). Returns completion data if available, or null.', types_1.Kind.Other, {
-            type: 'object',
-            properties: {},
-            required: [],
-        });
-    }
-    createInvocation(params) {
-        return new EventCheckBackgroundAgentCompletionInvocation(params);
-    }
-}
-exports.EventCheckBackgroundAgentCompletionTool = EventCheckBackgroundAgentCompletionTool;

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

@@ -1,19 +0,0 @@
-/**
- * Event Get Running Agent Count Tool
- *
- * Gets the number of currently running background agents.
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for getting running agent count (none required)
- */
-export interface EventGetRunningAgentCountParams {
-}
-/**
- * Tool for getting running agent count
- */
-export declare class EventGetRunningAgentCountTool extends BaseDeclarativeTool<EventGetRunningAgentCountParams, ToolResult> {
-    constructor();
-    protected createInvocation(params: EventGetRunningAgentCountParams): ToolInvocation<EventGetRunningAgentCountParams, ToolResult>;
-}

package/dist/tools/codeboltEvent/event-get-running-agent-count.js

@@ -1,55 +0,0 @@
-"use strict";
-/**
- * Event Get Running Agent Count Tool
- *
- * Gets the number of currently running background agents.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventGetRunningAgentCountTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const codeboltEvent_1 = __importDefault(require("../../modules/codeboltEvent"));
-class EventGetRunningAgentCountInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute(_signal) {
-        try {
-            const count = codeboltEvent_1.default.getRunningAgentCount();
-            return {
-                llmContent: `Currently ${count} running background agents`,
-                returnDisplay: `${count} running agents`,
-            };
-        }
-        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 getting running agent count
- */
-class EventGetRunningAgentCountTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super('event_get_running_agent_count', 'Get Running Agent Count', 'Gets the number of currently running background agents.', types_1.Kind.Other, {
-            type: 'object',
-            properties: {},
-            required: [],
-        });
-    }
-    createInvocation(params) {
-        return new EventGetRunningAgentCountInvocation(params);
-    }
-}
-exports.EventGetRunningAgentCountTool = EventGetRunningAgentCountTool;

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

@@ -1,19 +0,0 @@
-/**
- * Event On Background Agent Completion Tool
- *
- * Waits for background agent completion (blocking).
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for waiting for background agent completion (none required)
- */
-export interface EventOnBackgroundAgentCompletionParams {
-}
-/**
- * Tool for waiting for background agent completion
- */
-export declare class EventOnBackgroundAgentCompletionTool extends BaseDeclarativeTool<EventOnBackgroundAgentCompletionParams, ToolResult> {
-    constructor();
-    protected createInvocation(params: EventOnBackgroundAgentCompletionParams): ToolInvocation<EventOnBackgroundAgentCompletionParams, ToolResult>;
-}

package/dist/tools/codeboltEvent/event-on-background-agent-completion.js

@@ -1,56 +0,0 @@
-"use strict";
-/**
- * Event On Background Agent Completion Tool
- *
- * Waits for background agent completion (blocking).
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventOnBackgroundAgentCompletionTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const codeboltEvent_1 = __importDefault(require("../../modules/codeboltEvent"));
-class EventOnBackgroundAgentCompletionInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute(_signal) {
-        try {
-            const completion = await codeboltEvent_1.default.onBackgroundAgentCompletion();
-            const count = Array.isArray(completion) ? completion.length : 1;
-            return {
-                llmContent: `Background agent(s) completed: ${count} agent(s)`,
-                returnDisplay: `${count} agent(s) completed`,
-            };
-        }
-        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 waiting for background agent completion
- */
-class EventOnBackgroundAgentCompletionTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super('event_on_background_agent_completion', 'Wait for Background Agent Completion', 'Waits for background agent completion (blocking). Returns when an agent completes.', types_1.Kind.Other, {
-            type: 'object',
-            properties: {},
-            required: [],
-        });
-    }
-    createInvocation(params) {
-        return new EventOnBackgroundAgentCompletionInvocation(params);
-    }
-}
-exports.EventOnBackgroundAgentCompletionTool = EventOnBackgroundAgentCompletionTool;

package/dist/tools/codeboltEvent/event-wait-for-external-event.d.ts

@@ -1,19 +0,0 @@
-/**
- * Event Wait For External Event Tool
- *
- * Waits for any external event (Background Completion, Group Completion, Agent Event).
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for waiting for external event (none required)
- */
-export interface EventWaitForExternalEventParams {
-}
-/**
- * Tool for waiting for any external event
- */
-export declare class EventWaitForExternalEventTool extends BaseDeclarativeTool<EventWaitForExternalEventParams, ToolResult> {
-    constructor();
-    protected createInvocation(params: EventWaitForExternalEventParams): ToolInvocation<EventWaitForExternalEventParams, ToolResult>;
-}

package/dist/tools/codeboltEvent/event-wait-for-external-event.js

@@ -1,55 +0,0 @@
-"use strict";
-/**
- * Event Wait For External Event Tool
- *
- * Waits for any external event (Background Completion, Group Completion, Agent Event).
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventWaitForExternalEventTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const codeboltEvent_1 = __importDefault(require("../../modules/codeboltEvent"));
-class EventWaitForExternalEventInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute(_signal) {
-        try {
-            const event = await codeboltEvent_1.default.waitForAnyExternalEvent();
-            return {
-                llmContent: `External event received: ${event.type}`,
-                returnDisplay: `Event: ${event.type}`,
-            };
-        }
-        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 waiting for any external event
- */
-class EventWaitForExternalEventTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super('event_wait_for_external_event', 'Wait for External Event', 'Waits for any external event (Background Completion, Group Completion, or Agent Event). Returns the event type and data.', types_1.Kind.Other, {
-            type: 'object',
-            properties: {},
-            required: [],
-        });
-    }
-    createInvocation(params) {
-        return new EventWaitForExternalEventInvocation(params);
-    }
-}
-exports.EventWaitForExternalEventTool = EventWaitForExternalEventTool;