@codebolt/codeboltjs 5.0.8 → 5.0.9

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;

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