@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/modules/thread.js

@@ -0,0 +1,218 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("../core/websocket"));
+const crypto_1 = require("crypto");
+const backgroundChildThreads_1 = __importDefault(require("./backgroundChildThreads"));
+/**
+ * Thread service for managing conversation threads.
+ * This module provides a comprehensive API for thread management using thread-specific types.
+ */
+const threadService = {
+    /**
+     * Creates a new thread with comprehensive options.
+     * @param {CreateThreadOptions} options - The thread creation parameters
+     * @returns {Promise<CreateThreadResponse>} A promise that resolves with the thread creation response
+     */
+    createThread: async (options) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'threadEvent',
+            action: 'createThread',
+            requestId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'createThreadResponse');
+    },
+    /**
+     * Creates and immediately starts a new thread.
+     * @param {CreateAndStartThreadOptions} options - The thread creation and start parameters
+     * @returns {Promise<StartThreadResponse>} A promise that resolves with the thread start response
+     */
+    createAndStartThread: async (options) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'threadEvent',
+            action: 'createAndStartThread',
+            requestId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'startThreadResponse');
+    },
+    /**
+     * Creates a thread in the background and resolves when the agent starts or fails.
+     * @param {CreateAndStartThreadOptions} options - The thread creation and start parameters
+     * @returns {Promise<ThreadAgentStartedResponse | ThreadAgentStartFailedResponse>} A promise that resolves with ThreadAgentStarted or ThreadAgentStartFailed response
+     */
+    createThreadInBackground: async (options) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'threadEvent',
+            action: 'createAndStartThread',
+            requestId,
+            message: options
+        };
+        const response = await websocket_1.default.messageManager.sendAndWaitForResponse(event, 'ThreadAgentStarted');
+        // Add to appropriate map based on whether groupId is provided
+        // Add to appropriate map based on whether groupId is provided
+        if (response.threadId) {
+            backgroundChildThreads_1.default.addRunningAgent(response.threadId, response, options.groupId);
+        }
+        return response;
+    },
+    /**
+     * Retrieves a list of threads with optional filtering.
+     * @param {GetThreadListOptions} options - Optional filters for threads
+     * @returns {Promise<ListThreadsResponse>} A promise that resolves with the thread list response
+     */
+    getThreadList: async (options = {}) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'threadEvent',
+            action: 'getThreadList',
+            requestId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'listThreadsResponse');
+    },
+    /**
+     * Retrieves detailed information about a specific thread.
+     * @param {GetThreadDetailOptions} options - The thread detail options
+     * @returns {Promise<GetThreadResponse>} A promise that resolves with the thread detail response
+     */
+    getThreadDetail: async (options) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'threadEvent',
+            action: 'getThreadDetail',
+            requestId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getThreadResponse');
+    },
+    /**
+     * Starts a thread.
+     * @param {string} threadId - The thread ID to start
+     * @returns {Promise<StartThreadResponse>} A promise that resolves with the thread start response
+     */
+    startThread: async (threadId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'threadEvent',
+            action: 'startThread',
+            requestId,
+            message: {
+                threadId
+            }
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'startThreadResponse');
+    },
+    /**
+     * Updates an existing thread.
+     * @param {string} threadId - The thread ID to update
+     * @param {UpdateThreadOptions} updates - The thread update parameters
+     * @returns {Promise<UpdateThreadResponse>} A promise that resolves with the thread update response
+     */
+    updateThread: async (threadId, updates) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'threadEvent',
+            action: 'updateThread',
+            requestId,
+            message: {
+                threadId,
+                ...updates
+            }
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'updateThreadResponse');
+    },
+    /**
+     * Deletes a thread.
+     * @param {string} threadId - The thread ID to delete
+     * @returns {Promise<DeleteThreadResponse>} A promise that resolves with the thread deletion response
+     */
+    deleteThread: async (threadId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'threadEvent',
+            action: 'deleteThread',
+            requestId,
+            message: {
+                threadId
+            }
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'deleteThreadResponse');
+    },
+    /**
+     * Updates the status of a thread.
+     * @param {string} threadId - The thread ID
+     * @param {string} status - The new status
+     * @returns {Promise<UpdateThreadStatusResponse>} A promise that resolves with the thread status update response
+     */
+    updateThreadStatus: async (threadId, status) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'threadEvent',
+            action: 'updateThreadStatus',
+            requestId,
+            message: {
+                threadId,
+                status
+            }
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'updateThreadStatusResponse');
+    },
+    /**
+     * Retrieves messages for a specific thread.
+     * @param {GetThreadMessagesOptions} options - The thread messages options
+     * @returns {Promise<GetThreadMessagesResponse>} A promise that resolves with the thread messages response
+     */
+    getThreadMessages: async (options) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'threadEvent',
+            action: 'getThreadMessages',
+            requestId,
+            message: options
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getThreadMessagesResponse');
+    },
+    /**
+     * Retrieves file changes associated with a specific thread.
+     * @param {string} threadId - The thread ID
+     * @returns {Promise<any>} A promise that resolves with the file changes
+     */
+    getThreadFileChanges: async (threadId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'threadEvent',
+            action: 'getThreadFileChanges',
+            requestId,
+            message: {
+                threadId
+            }
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getThreadFileChangesResponse');
+    },
+    /**
+     * Retrieves file changes summary for ChangesSummaryPanel.
+     * Returns data in the format: { title, changes, files }
+     * @param {string} threadId - The thread ID
+     * @returns {Promise<any>} A promise that resolves with the file changes summary
+     */
+    getThreadFileChangesSummary: async (threadId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'threadEvent',
+            action: 'getThreadFileChangesSummary',
+            requestId,
+            message: {
+                threadId
+            }
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getThreadFileChangesSummaryResponse');
+    }
+};
+exports.default = threadService;

package/dist/modules/todo.d.ts

@@ -1 +1,84 @@
-export {};
+import { AddTodoResponse, UpdateTodoResponse, GetTodoListResponse, GetAllIncompleteTodosResponse, ExportTodosResponse, ImportTodosResponse } from '@codebolt/types/sdk';
+/**
+ * @module cbtodo
+ * @description This module provides functionality to interact with the todo lists.
+ */
+declare const cbtodo: {
+    /**
+     * @function addTodo
+     * @description Adds a new todo item.
+     * @param {Object} params - The parameters for adding a todo.
+     * @param {string} params.title - The title of the todo.
+     * @param {'high' | 'medium' | 'low'} [params.priority] - The priority of the todo.
+     * @param {string[]} [params.tags] - Tags for the todo.
+     * @returns {Promise<AddTodoResponse>} A promise that resolves with the server response.
+     */
+    addTodo: (params: {
+        title: string;
+        priority?: "high" | "medium" | "low";
+        tags?: string[];
+    }) => Promise<AddTodoResponse>;
+    /**
+     * @function updateTodo
+     * @description Updates an existing todo item.
+     * @param {Object} params - The parameters for updating a todo.
+     * @param {string} params.id - The ID of the todo to update.
+     * @param {string} [params.title] - The new title.
+     * @param {'pending' | 'processing' | 'completed' | 'cancelled'} [params.status] - The new status.
+     * @param {'high' | 'medium' | 'low'} [params.priority] - The new priority.
+     * @param {string[]} [params.tags] - The new tags.
+     * @returns {Promise<UpdateTodoResponse>} A promise that resolves with the server response.
+     */
+    updateTodo: (params: {
+        id: string;
+        title?: string;
+        status?: "pending" | "processing" | "completed" | "cancelled";
+        priority?: "high" | "medium" | "low";
+        tags?: string[];
+    }) => Promise<UpdateTodoResponse>;
+    /**
+     * @function getTodoList
+     * @description Retrieves the todo list.
+     * @param {any} [params] - The parameters for getting the todo list.
+     * @returns {Promise<GetTodoListResponse>} A promise that resolves with the server response.
+     */
+    getTodoList: (params?: any) => Promise<GetTodoListResponse>;
+    /**
+     * @function getAllIncompleteTodos
+     * @description Retrieves all incomplete todo items.
+     * @param {any} [params] - The parameters for retrieval.
+     * @returns {Promise<GetAllIncompleteTodosResponse>} A promise that resolves with the server response.
+     */
+    getAllIncompleteTodos: () => Promise<GetAllIncompleteTodosResponse>;
+    /**
+     * @function exportTodos
+     * @description Exports todos in the specified format.
+     * @param {Object} params - The parameters for exporting todos.
+     * @param {'json' | 'markdown'} [params.format] - The export format.
+     * @param {string} [params.listId] - Optional list ID to filter.
+     * @param {string[]} [params.status] - Optional status filter.
+     * @returns {Promise<ExportTodosResponse>} A promise that resolves with the exported data.
+     */
+    exportTodos: (params?: {
+        format?: "json" | "markdown";
+        listId?: string;
+        status?: string[];
+    }) => Promise<ExportTodosResponse>;
+    /**
+     * @function importTodos
+     * @description Imports todos from the specified format.
+     * @param {Object} params - The parameters for importing todos.
+     * @param {string} params.data - The import data (JSON or markdown).
+     * @param {'json' | 'markdown'} [params.format] - The format of the import data.
+     * @param {'replace' | 'merge'} [params.mergeStrategy] - How to handle existing todos.
+     * @param {string} [params.listId] - Optional target list ID.
+     * @returns {Promise<ImportTodosResponse>} A promise that resolves with the import result.
+     */
+    importTodos: (params: {
+        data: string;
+        format?: "json" | "markdown";
+        mergeStrategy?: "replace" | "merge";
+        listId?: string;
+    }) => Promise<ImportTodosResponse>;
+};
+export default cbtodo;

package/dist/modules/todo.js

@@ -1,9 +1,107 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const cbTodo = {
-    createTodos: () => {
+const websocket_1 = __importDefault(require("../core/websocket"));
+const enum_1 = require("@codebolt/types/enum");
+/**
+ * @module cbtodo
+ * @description This module provides functionality to interact with the todo lists.
+ */
+const cbtodo = {
+    /**
+     * @function addTodo
+     * @description Adds a new todo item.
+     * @param {Object} params - The parameters for adding a todo.
+     * @param {string} params.title - The title of the todo.
+     * @param {'high' | 'medium' | 'low'} [params.priority] - The priority of the todo.
+     * @param {string[]} [params.tags] - Tags for the todo.
+     * @returns {Promise<AddTodoResponse>} A promise that resolves with the server response.
+     */
+    addTodo: (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.TODO_EVENT,
+            "action": enum_1.TodoAction.ADD_TODO,
+            "message": params
+        }, enum_1.TodoResponseType.ADD_TODO_RESPONSE);
+    },
+    /**
+     * @function updateTodo
+     * @description Updates an existing todo item.
+     * @param {Object} params - The parameters for updating a todo.
+     * @param {string} params.id - The ID of the todo to update.
+     * @param {string} [params.title] - The new title.
+     * @param {'pending' | 'processing' | 'completed' | 'cancelled'} [params.status] - The new status.
+     * @param {'high' | 'medium' | 'low'} [params.priority] - The new priority.
+     * @param {string[]} [params.tags] - The new tags.
+     * @returns {Promise<UpdateTodoResponse>} A promise that resolves with the server response.
+     */
+    updateTodo: (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.TODO_EVENT,
+            "action": enum_1.TodoAction.UPDATE_TODO,
+            "message": params
+        }, enum_1.TodoResponseType.UPDATE_TODO_RESPONSE);
+    },
+    /**
+     * @function getTodoList
+     * @description Retrieves the todo list.
+     * @param {any} [params] - The parameters for getting the todo list.
+     * @returns {Promise<GetTodoListResponse>} A promise that resolves with the server response.
+     */
+    getTodoList: (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.TODO_EVENT,
+            "action": enum_1.TodoAction.GET_TODO_LIST,
+            "message": params || {}
+        }, enum_1.TodoResponseType.GET_TODO_LIST_RESPONSE);
+    },
+    /**
+     * @function getAllIncompleteTodos
+     * @description Retrieves all incomplete todo items.
+     * @param {any} [params] - The parameters for retrieval.
+     * @returns {Promise<GetAllIncompleteTodosResponse>} A promise that resolves with the server response.
+     */
+    getAllIncompleteTodos: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.TODO_EVENT,
+            "action": enum_1.TodoAction.GET_ALL_INCOMPLETE_TODOS,
+            "message": {}
+        }, enum_1.TodoResponseType.GET_ALL_INCOMPLETE_TODOS_RESPONSE);
+    },
+    /**
+     * @function exportTodos
+     * @description Exports todos in the specified format.
+     * @param {Object} params - The parameters for exporting todos.
+     * @param {'json' | 'markdown'} [params.format] - The export format.
+     * @param {string} [params.listId] - Optional list ID to filter.
+     * @param {string[]} [params.status] - Optional status filter.
+     * @returns {Promise<ExportTodosResponse>} A promise that resolves with the exported data.
+     */
+    exportTodos: (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.TODO_EVENT,
+            "action": enum_1.TodoAction.EXPORT_TODOS,
+            "message": params || {}
+        }, enum_1.TodoResponseType.EXPORT_TODOS_RESPONSE);
     },
-    getTodos: (taskId) => {
+    /**
+     * @function importTodos
+     * @description Imports todos from the specified format.
+     * @param {Object} params - The parameters for importing todos.
+     * @param {string} params.data - The import data (JSON or markdown).
+     * @param {'json' | 'markdown'} [params.format] - The format of the import data.
+     * @param {'replace' | 'merge'} [params.mergeStrategy] - How to handle existing todos.
+     * @param {string} [params.listId] - Optional target list ID.
+     * @returns {Promise<ImportTodosResponse>} A promise that resolves with the import result.
+     */
+    importTodos: (params) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.TODO_EVENT,
+            "action": enum_1.TodoAction.IMPORT_TODOS,
+            "message": params
+        }, enum_1.TodoResponseType.IMPORT_TODOS_RESPONSE);
     }
 };
-module.exports = cbTodo;
+exports.default = cbtodo;

package/dist/tools/actionBlock/action-block-get-detail.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Get ActionBlock Detail Tool
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface GetActionBlockDetailParams {
+    actionBlockName: string;
+    explanation?: string;
+}
+export declare class GetActionBlockDetailTool extends BaseDeclarativeTool<GetActionBlockDetailParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: GetActionBlockDetailParams): ToolInvocation<GetActionBlockDetailParams, ToolResult>;
+}

package/dist/tools/actionBlock/action-block-get-detail.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * Get ActionBlock Detail Tool
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetActionBlockDetailTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const actionBlock_1 = __importDefault(require("../../modules/actionBlock"));
+class GetActionBlockDetailInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await actionBlock_1.default.getDetail(this.params.actionBlockName);
+            if (!response.success || !response.actionBlock) {
+                return {
+                    llmContent: `Error: ${response.error || 'Not found'}`,
+                    returnDisplay: `Error: ${response.error || 'Not found'}`,
+                    error: { message: response.error || 'Not found', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const b = response.actionBlock;
+            const content = `ActionBlock: ${b.name}\nVersion: ${b.version}\nDescription: ${b.description}\nType: ${b.type}\nPath: ${b.path}`;
+            return { llmContent: content, returnDisplay: content };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class GetActionBlockDetailTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('actionBlock_getDetail', 'Get ActionBlock Details', 'Get detailed information about an ActionBlock', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                actionBlockName: { type: 'string', description: 'ActionBlock name' },
+                explanation: { type: 'string', description: 'Explanation' },
+            },
+            required: ['actionBlockName'],
+        });
+    }
+    createInvocation(params) {
+        return new GetActionBlockDetailInvocation(params);
+    }
+}
+exports.GetActionBlockDetailTool = GetActionBlockDetailTool;

package/dist/tools/actionBlock/action-block-list.d.ts

@@ -0,0 +1,13 @@
+/**
+ * List ActionBlocks Tool
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface ListActionBlocksParams {
+    filterType?: 'filesystem' | 'runtime' | 'builtin';
+    explanation?: string;
+}
+export declare class ListActionBlocksTool extends BaseDeclarativeTool<ListActionBlocksParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: ListActionBlocksParams): ToolInvocation<ListActionBlocksParams, ToolResult>;
+}

package/dist/tools/actionBlock/action-block-list.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * List ActionBlocks Tool
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListActionBlocksTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const actionBlock_1 = __importDefault(require("../../modules/actionBlock"));
+class ListActionBlocksInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const filter = this.params.filterType ? { type: this.params.filterType } : undefined;
+            const response = await actionBlock_1.default.list(filter);
+            if (!response.success) {
+                return {
+                    llmContent: `Error: ${response.error}`,
+                    returnDisplay: `Error: ${response.error}`,
+                    error: { message: response.error || 'Unknown error', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const blocks = response.actionBlocks || [];
+            const content = `Found ${blocks.length} ActionBlocks:\n${blocks.map(b => `- ${b.name} (v${b.version}): ${b.description}`).join('\n')}`;
+            return { llmContent: content, returnDisplay: content };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class ListActionBlocksTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('actionBlock_list', 'List ActionBlocks', 'List all available ActionBlocks', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                filterType: { type: 'string', enum: ['filesystem', 'runtime', 'builtin'], description: 'Filter by type' },
+                explanation: { type: 'string', description: 'Explanation' },
+            },
+        });
+    }
+    createInvocation(params) {
+        return new ListActionBlocksInvocation(params);
+    }
+}
+exports.ListActionBlocksTool = ListActionBlocksTool;

package/dist/tools/actionBlock/action-block-start.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Start ActionBlock Tool
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface StartActionBlockParams {
+    actionBlockName: string;
+    params?: Record<string, any>;
+    explanation?: string;
+}
+export declare class StartActionBlockTool extends BaseDeclarativeTool<StartActionBlockParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: StartActionBlockParams): ToolInvocation<StartActionBlockParams, ToolResult>;
+}

package/dist/tools/actionBlock/action-block-start.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Start ActionBlock Tool
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartActionBlockTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const actionBlock_1 = __importDefault(require("../../modules/actionBlock"));
+class StartActionBlockInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await actionBlock_1.default.start(this.params.actionBlockName, this.params.params);
+            if (!response.success) {
+                return {
+                    llmContent: `Error: ${response.error}`,
+                    returnDisplay: `Error: ${response.error}`,
+                    error: { message: response.error || 'Unknown error', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const content = response.sideExecutionId
+                ? `ActionBlock "${this.params.actionBlockName}" started. ID: ${response.sideExecutionId}`
+                : `ActionBlock "${this.params.actionBlockName}" started`;
+            return { llmContent: content, returnDisplay: content };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class StartActionBlockTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('actionBlock_start', 'Start ActionBlock', 'Start an ActionBlock by name', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                actionBlockName: { type: 'string', description: 'ActionBlock name' },
+                params: { type: 'object', description: 'Optional parameters' },
+                explanation: { type: 'string', description: 'Explanation' },
+            },
+            required: ['actionBlockName'],
+        });
+    }
+    createInvocation(params) {
+        return new StartActionBlockInvocation(params);
+    }
+}
+exports.StartActionBlockTool = StartActionBlockTool;

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

@@ -0,0 +1,7 @@
+import { ListActionBlocksTool } from './action-block-list';
+import { GetActionBlockDetailTool } from './action-block-get-detail';
+import { StartActionBlockTool } from './action-block-start';
+export declare const actionBlockTools: (ListActionBlocksTool | GetActionBlockDetailTool | StartActionBlockTool)[];
+export * from './action-block-list';
+export * from './action-block-get-detail';
+export * from './action-block-start';

package/dist/tools/actionBlock/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actionBlockTools = void 0;
+const action_block_list_1 = require("./action-block-list");
+const action_block_get_detail_1 = require("./action-block-get-detail");
+const action_block_start_1 = require("./action-block-start");
+exports.actionBlockTools = [
+    new action_block_list_1.ListActionBlocksTool(),
+    new action_block_get_detail_1.GetActionBlockDetailTool(),
+    new action_block_start_1.StartActionBlockTool(),
+];
+__exportStar(require("./action-block-list"), exports);
+__exportStar(require("./action-block-get-detail"), exports);
+__exportStar(require("./action-block-start"), exports);