@codebolt/codeboltjs 5.0.8 → 5.1.10

package/dist/tools/codeboltEvent/index.d.ts

@@ -1,19 +0,0 @@
-/**
- * Codebolt Event Tools
- *
- * Tools for event handling and coordination.
- */
-export { EventAddRunningAgentTool } from './event-add-running-agent';
-export { EventGetRunningAgentCountTool } from './event-get-running-agent-count';
-export { EventCheckBackgroundAgentCompletionTool } from './event-check-background-agent-completion';
-export { EventOnBackgroundAgentCompletionTool } from './event-on-background-agent-completion';
-export { EventWaitForExternalEventTool } from './event-wait-for-external-event';
-import { EventAddRunningAgentTool } from './event-add-running-agent';
-import { EventGetRunningAgentCountTool } from './event-get-running-agent-count';
-import { EventCheckBackgroundAgentCompletionTool } from './event-check-background-agent-completion';
-import { EventOnBackgroundAgentCompletionTool } from './event-on-background-agent-completion';
-import { EventWaitForExternalEventTool } from './event-wait-for-external-event';
-/**
- * Array of all codebolt event tools
- */
-export declare const codeboltEventTools: (EventAddRunningAgentTool | EventGetRunningAgentCountTool | EventCheckBackgroundAgentCompletionTool | EventOnBackgroundAgentCompletionTool | EventWaitForExternalEventTool)[];

package/dist/tools/codeboltEvent/index.js

@@ -1,33 +0,0 @@
-"use strict";
-/**
- * Codebolt Event Tools
- *
- * Tools for event handling and coordination.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.codeboltEventTools = exports.EventWaitForExternalEventTool = exports.EventOnBackgroundAgentCompletionTool = exports.EventCheckBackgroundAgentCompletionTool = exports.EventGetRunningAgentCountTool = exports.EventAddRunningAgentTool = void 0;
-var event_add_running_agent_1 = require("./event-add-running-agent");
-Object.defineProperty(exports, "EventAddRunningAgentTool", { enumerable: true, get: function () { return event_add_running_agent_1.EventAddRunningAgentTool; } });
-var event_get_running_agent_count_1 = require("./event-get-running-agent-count");
-Object.defineProperty(exports, "EventGetRunningAgentCountTool", { enumerable: true, get: function () { return event_get_running_agent_count_1.EventGetRunningAgentCountTool; } });
-var event_check_background_agent_completion_1 = require("./event-check-background-agent-completion");
-Object.defineProperty(exports, "EventCheckBackgroundAgentCompletionTool", { enumerable: true, get: function () { return event_check_background_agent_completion_1.EventCheckBackgroundAgentCompletionTool; } });
-var event_on_background_agent_completion_1 = require("./event-on-background-agent-completion");
-Object.defineProperty(exports, "EventOnBackgroundAgentCompletionTool", { enumerable: true, get: function () { return event_on_background_agent_completion_1.EventOnBackgroundAgentCompletionTool; } });
-var event_wait_for_external_event_1 = require("./event-wait-for-external-event");
-Object.defineProperty(exports, "EventWaitForExternalEventTool", { enumerable: true, get: function () { return event_wait_for_external_event_1.EventWaitForExternalEventTool; } });
-const event_add_running_agent_2 = require("./event-add-running-agent");
-const event_get_running_agent_count_2 = require("./event-get-running-agent-count");
-const event_check_background_agent_completion_2 = require("./event-check-background-agent-completion");
-const event_on_background_agent_completion_2 = require("./event-on-background-agent-completion");
-const event_wait_for_external_event_2 = require("./event-wait-for-external-event");
-/**
- * Array of all codebolt event tools
- */
-exports.codeboltEventTools = [
-    new event_add_running_agent_2.EventAddRunningAgentTool(),
-    new event_get_running_agent_count_2.EventGetRunningAgentCountTool(),
-    new event_check_background_agent_completion_2.EventCheckBackgroundAgentCompletionTool(),
-    new event_on_background_agent_completion_2.EventOnBackgroundAgentCompletionTool(),
-    new event_wait_for_external_event_2.EventWaitForExternalEventTool(),
-];

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

@@ -1,32 +0,0 @@
-/**
- * Event Add Running Agent Tool - Adds a running background agent to tracking
- * Wraps the SDK's codeboltEvent.addRunningAgent() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the EventAddRunningAgent tool
- */
-export interface EventAddRunningAgentParams {
-    /**
-     * The thread ID of the background agent
-     */
-    thread_id: string;
-    /**
-     * The agent data to store
-     */
-    data: any;
-    /**
-     * Optional group ID for grouping agents
-     */
-    group_id?: string;
-}
-/**
- * Tool for adding a running background agent to tracking
- */
-export declare class EventAddRunningAgentTool extends BaseDeclarativeTool<EventAddRunningAgentParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected validateToolParamValues(params: EventAddRunningAgentParams): string | null;
-    protected createInvocation(params: EventAddRunningAgentParams): ToolInvocation<EventAddRunningAgentParams, ToolResult>;
-}

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

@@ -1,77 +0,0 @@
-"use strict";
-/**
- * Event Add Running Agent Tool - Adds a running background agent to tracking
- * Wraps the SDK's codeboltEvent.addRunningAgent() method
- */
-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() {
-        try {
-            codeboltEvent_1.default.addRunningAgent(this.params.thread_id, this.params.data, this.params.group_id);
-            let llmContent = `Background agent added to tracking.\nThread ID: ${this.params.thread_id}`;
-            if (this.params.group_id) {
-                llmContent += `\nGroup ID: ${this.params.group_id}`;
-            }
-            return {
-                llmContent,
-                returnDisplay: `Agent added: ${this.params.thread_id}`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error adding running agent: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-/**
- * Tool for adding a running background agent to tracking
- */
-class EventAddRunningAgentTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(EventAddRunningAgentTool.Name, 'Add Running Agent', 'Add a running background agent to the tracking system. This allows monitoring and waiting for agent completion.', types_1.Kind.Other, {
-            type: 'object',
-            properties: {
-                thread_id: {
-                    type: 'string',
-                    description: 'The thread ID of the background agent'
-                },
-                data: {
-                    description: 'The agent data to store'
-                },
-                group_id: {
-                    type: 'string',
-                    description: 'Optional group ID for grouping agents'
-                }
-            },
-            required: ['thread_id', 'data']
-        });
-    }
-    validateToolParamValues(params) {
-        if (!params.thread_id || params.thread_id.trim() === '') {
-            return "The 'thread_id' parameter must be non-empty.";
-        }
-        return null;
-    }
-    createInvocation(params) {
-        return new EventAddRunningAgentInvocation(params);
-    }
-}
-exports.EventAddRunningAgentTool = EventAddRunningAgentTool;
-EventAddRunningAgentTool.Name = 'event_add_running_agent';

package/dist/tools/event/event-check-agent-event.d.ts

@@ -1,19 +0,0 @@
-/**
- * Event Check Agent Event Tool - Checks if any agent event has been received
- * Wraps the SDK's codeboltEvent.checkForAgentEventReceived() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the EventCheckAgentEvent tool
- */
-export interface EventCheckAgentEventParams {
-}
-/**
- * Tool for checking if any agent event has been received
- */
-export declare class EventCheckAgentEventTool extends BaseDeclarativeTool<EventCheckAgentEventParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected createInvocation(params: EventCheckAgentEventParams): ToolInvocation<EventCheckAgentEventParams, ToolResult>;
-}

package/dist/tools/event/event-check-agent-event.js

@@ -1,63 +0,0 @@
-"use strict";
-/**
- * Event Check Agent Event Tool - Checks if any agent event has been received
- * Wraps the SDK's codeboltEvent.checkForAgentEventReceived() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventCheckAgentEventTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const codeboltEvent_1 = __importDefault(require("../../modules/codeboltEvent"));
-class EventCheckAgentEventInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        try {
-            const event = codeboltEvent_1.default.checkForAgentEventReceived();
-            if (event === null) {
-                return {
-                    llmContent: 'No agent events available.',
-                    returnDisplay: 'No events',
-                };
-            }
-            let llmContent = `Agent event found.\n\n`;
-            llmContent += JSON.stringify(event, null, 2);
-            return {
-                llmContent,
-                returnDisplay: 'Found agent event',
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error checking for agent event: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-/**
- * Tool for checking if any agent event has been received
- */
-class EventCheckAgentEventTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(EventCheckAgentEventTool.Name, 'Check for Agent Event', 'Check if any agent event has been received. Returns event data if available, null otherwise. This is a non-blocking check.', types_1.Kind.Read, {
-            type: 'object',
-            properties: {},
-            required: []
-        });
-    }
-    createInvocation(params) {
-        return new EventCheckAgentEventInvocation(params);
-    }
-}
-exports.EventCheckAgentEventTool = EventCheckAgentEventTool;
-EventCheckAgentEventTool.Name = 'event_check_agent_event';

package/dist/tools/event/event-check-completion.d.ts

@@ -1,19 +0,0 @@
-/**
- * Event Check Completion Tool - Checks if any background agent has completed
- * Wraps the SDK's codeboltEvent.checkForBackgroundAgentCompletion() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the EventCheckCompletion tool
- */
-export interface EventCheckCompletionParams {
-}
-/**
- * Tool for checking if any background agent has completed
- */
-export declare class EventCheckCompletionTool extends BaseDeclarativeTool<EventCheckCompletionParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected createInvocation(params: EventCheckCompletionParams): ToolInvocation<EventCheckCompletionParams, ToolResult>;
-}

package/dist/tools/event/event-check-completion.js

@@ -1,73 +0,0 @@
-"use strict";
-/**
- * Event Check Completion Tool - Checks if any background agent has completed
- * Wraps the SDK's codeboltEvent.checkForBackgroundAgentCompletion() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventCheckCompletionTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const codeboltEvent_1 = __importDefault(require("../../modules/codeboltEvent"));
-class EventCheckCompletionInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        try {
-            const completions = codeboltEvent_1.default.checkForBackgroundAgentCompletion();
-            if (completions === null) {
-                return {
-                    llmContent: 'No background agent completions available.',
-                    returnDisplay: 'No completions',
-                };
-            }
-            const count = Array.isArray(completions) ? completions.length : 1;
-            let llmContent = `Found ${count} background agent completion(s).\n\n`;
-            if (Array.isArray(completions)) {
-                for (let i = 0; i < completions.length; i++) {
-                    const completion = completions[i];
-                    llmContent += `Completion ${i + 1}:\n`;
-                    llmContent += JSON.stringify(completion, null, 2) + '\n\n';
-                }
-            }
-            else {
-                llmContent += JSON.stringify(completions, null, 2);
-            }
-            return {
-                llmContent,
-                returnDisplay: `Found ${count} completion(s)`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error checking for background agent completion: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-/**
- * Tool for checking if any background agent has completed
- */
-class EventCheckCompletionTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(EventCheckCompletionTool.Name, 'Check Background Agent Completion', 'Check if any background agent has completed. Returns completion data if available, null otherwise. This is a non-blocking check.', types_1.Kind.Read, {
-            type: 'object',
-            properties: {},
-            required: []
-        });
-    }
-    createInvocation(params) {
-        return new EventCheckCompletionInvocation(params);
-    }
-}
-exports.EventCheckCompletionTool = EventCheckCompletionTool;
-EventCheckCompletionTool.Name = 'event_check_completion';

package/dist/tools/event/event-check-grouped-completion.d.ts

@@ -1,19 +0,0 @@
-/**
- * Event Check Grouped Completion Tool - Checks if any grouped background agent has completed
- * Wraps the SDK's codeboltEvent.checkForBackgroundGroupedAgentCompletion() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the EventCheckGroupedCompletion tool
- */
-export interface EventCheckGroupedCompletionParams {
-}
-/**
- * Tool for checking if any grouped background agent has completed
- */
-export declare class EventCheckGroupedCompletionTool extends BaseDeclarativeTool<EventCheckGroupedCompletionParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected createInvocation(params: EventCheckGroupedCompletionParams): ToolInvocation<EventCheckGroupedCompletionParams, ToolResult>;
-}

package/dist/tools/event/event-check-grouped-completion.js

@@ -1,63 +0,0 @@
-"use strict";
-/**
- * Event Check Grouped Completion Tool - Checks if any grouped background agent has completed
- * Wraps the SDK's codeboltEvent.checkForBackgroundGroupedAgentCompletion() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventCheckGroupedCompletionTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const codeboltEvent_1 = __importDefault(require("../../modules/codeboltEvent"));
-class EventCheckGroupedCompletionInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        try {
-            const completion = codeboltEvent_1.default.checkForBackgroundGroupedAgentCompletion();
-            if (completion === null) {
-                return {
-                    llmContent: 'No grouped background agent completions available.',
-                    returnDisplay: 'No grouped completions',
-                };
-            }
-            let llmContent = `Grouped background agent completion found.\n\n`;
-            llmContent += JSON.stringify(completion, null, 2);
-            return {
-                llmContent,
-                returnDisplay: 'Found grouped completion',
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error checking for grouped background agent completion: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-/**
- * Tool for checking if any grouped background agent has completed
- */
-class EventCheckGroupedCompletionTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(EventCheckGroupedCompletionTool.Name, 'Check Grouped Agent Completion', 'Check if any grouped background agent has completed. Returns completion data if available, null otherwise. This is a non-blocking check.', types_1.Kind.Read, {
-            type: 'object',
-            properties: {},
-            required: []
-        });
-    }
-    createInvocation(params) {
-        return new EventCheckGroupedCompletionInvocation(params);
-    }
-}
-exports.EventCheckGroupedCompletionTool = EventCheckGroupedCompletionTool;
-EventCheckGroupedCompletionTool.Name = 'event_check_grouped_completion';

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

@@ -1,19 +0,0 @@
-/**
- * Event Get Running Agent Count Tool - Gets the number of currently running background agents
- * Wraps the SDK's codeboltEvent.getRunningAgentCount() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the EventGetRunningCount tool
- */
-export interface EventGetRunningCountParams {
-}
-/**
- * Tool for getting the number of currently running background agents
- */
-export declare class EventGetRunningCountTool extends BaseDeclarativeTool<EventGetRunningCountParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected createInvocation(params: EventGetRunningCountParams): ToolInvocation<EventGetRunningCountParams, ToolResult>;
-}

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

@@ -1,55 +0,0 @@
-"use strict";
-/**
- * Event Get Running Agent Count Tool - Gets the number of currently running background agents
- * Wraps the SDK's codeboltEvent.getRunningAgentCount() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventGetRunningCountTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const codeboltEvent_1 = __importDefault(require("../../modules/codeboltEvent"));
-class EventGetRunningCountInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        try {
-            const count = codeboltEvent_1.default.getRunningAgentCount();
-            return {
-                llmContent: `Currently running background agents: ${count}`,
-                returnDisplay: `Running agents: ${count}`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error getting running agent count: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-/**
- * Tool for getting the number of currently running background agents
- */
-class EventGetRunningCountTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(EventGetRunningCountTool.Name, 'Get Running Agent Count', 'Get the number of currently running background agents.', types_1.Kind.Read, {
-            type: 'object',
-            properties: {},
-            required: []
-        });
-    }
-    createInvocation(params) {
-        return new EventGetRunningCountInvocation(params);
-    }
-}
-exports.EventGetRunningCountTool = EventGetRunningCountTool;
-EventGetRunningCountTool.Name = 'event_get_running_count';

package/dist/tools/event/event-on-agent-event.d.ts

@@ -1,19 +0,0 @@
-/**
- * Event On Agent Event Tool - Waits for an agent event
- * Wraps the SDK's codeboltEvent.onAgentEventReceived() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the EventOnAgentEvent tool
- */
-export interface EventOnAgentEventParams {
-}
-/**
- * Tool for waiting for an agent event
- */
-export declare class EventOnAgentEventTool extends BaseDeclarativeTool<EventOnAgentEventParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected createInvocation(params: EventOnAgentEventParams): ToolInvocation<EventOnAgentEventParams, ToolResult>;
-}

package/dist/tools/event/event-on-agent-event.js

@@ -1,63 +0,0 @@
-"use strict";
-/**
- * Event On Agent Event Tool - Waits for an agent event
- * Wraps the SDK's codeboltEvent.onAgentEventReceived() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventOnAgentEventTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const codeboltEvent_1 = __importDefault(require("../../modules/codeboltEvent"));
-class EventOnAgentEventInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        try {
-            const event = await codeboltEvent_1.default.onAgentEventReceived();
-            if (event === null) {
-                return {
-                    llmContent: 'No agent event received.',
-                    returnDisplay: 'No event',
-                };
-            }
-            let llmContent = `Agent event received.\n\n`;
-            llmContent += JSON.stringify(event, null, 2);
-            return {
-                llmContent,
-                returnDisplay: 'Received agent event',
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error waiting for agent event: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-/**
- * Tool for waiting for an agent event
- */
-class EventOnAgentEventTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(EventOnAgentEventTool.Name, 'Wait for Agent Event', 'Wait for an agent event to be received. This is a blocking call that resolves when an agent event arrives.', types_1.Kind.Other, {
-            type: 'object',
-            properties: {},
-            required: []
-        });
-    }
-    createInvocation(params) {
-        return new EventOnAgentEventInvocation(params);
-    }
-}
-exports.EventOnAgentEventTool = EventOnAgentEventTool;
-EventOnAgentEventTool.Name = 'event_on_agent_event';

package/dist/tools/event/event-on-completion.d.ts

@@ -1,19 +0,0 @@
-/**
- * Event On Completion Tool - Waits for background agent completion
- * Wraps the SDK's codeboltEvent.onBackgroundAgentCompletion() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the EventOnCompletion tool
- */
-export interface EventOnCompletionParams {
-}
-/**
- * Tool for waiting for background agent completion
- */
-export declare class EventOnCompletionTool extends BaseDeclarativeTool<EventOnCompletionParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected createInvocation(params: EventOnCompletionParams): ToolInvocation<EventOnCompletionParams, ToolResult>;
-}