@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/tools/search/search-files.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * Search Files Tool - Searches file contents using regex
+ * Wraps the SDK's cbfs.searchFiles() method
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchFilesTool = void 0;
+const path = __importStar(require("path"));
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fs_1 = __importDefault(require("../../modules/fs"));
+const chat_1 = __importDefault(require("../../modules/chat"));
+class SearchFilesToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    toolLocations() {
+        return [{ path: this.params.path }];
+    }
+    async execute() {
+        var _a;
+        try {
+            if (this.params.explanation) {
+                chat_1.default.sendMessage(this.params.explanation);
+            }
+            // Call the SDK's fs module
+            const response = await fs_1.default.searchFiles(this.params.path, this.params.regex, this.params.file_pattern || '*');
+            if (!response.success) {
+                const errorMsg = typeof response.error === 'string'
+                    ? response.error
+                    : ((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Unknown error';
+                return {
+                    llmContent: `Error searching files: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.GREP_EXECUTION_ERROR,
+                    },
+                };
+            }
+            // Format the results
+            // SearchFilesResponse has results?: Array<{path, matches: Array<{line, content, lineNumber}>}>
+            const results = response.results || [];
+            if (results.length === 0) {
+                return {
+                    llmContent: `No matches found for regex: "${this.params.regex}"`,
+                    returnDisplay: `No matches found`,
+                };
+            }
+            const totalMatches = results.reduce((sum, r) => { var _a; return sum + (((_a = r.matches) === null || _a === void 0 ? void 0 : _a.length) || 0); }, 0);
+            let output = `Found ${totalMatches} match(es) in ${results.length} file(s) for regex: "${this.params.regex}"\n\n`;
+            for (const result of results) {
+                output += `--- ${result.path} ---\n`;
+                if (result.matches && Array.isArray(result.matches)) {
+                    for (const match of result.matches) {
+                        const lineNum = match.line || match.lineNumber || '?';
+                        output += `${lineNum}: ${match.content}\n`;
+                    }
+                }
+                output += '\n';
+            }
+            return {
+                llmContent: output,
+                returnDisplay: `Found ${totalMatches} match(es) in ${results.length} file(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error searching files: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the SearchFiles tool logic
+ */
+class SearchFilesTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(SearchFilesTool.Name, 'SearchFiles', `Searches for content in files using regex patterns. Finds matching lines and their locations. Use this to find specific code patterns, text, or structures across the codebase.`, types_1.Kind.Search, {
+            properties: {
+                explanation: {
+                    description: "One sentence explanation as to why this tool is being used, and how it contributes to the goal.",
+                    type: 'string',
+                },
+                path: {
+                    description: 'The absolute path to the directory to search within.',
+                    type: 'string',
+                },
+                regex: {
+                    description: 'The regex pattern to search for in file contents.',
+                    type: 'string',
+                },
+                file_pattern: {
+                    description: "Optional glob pattern to filter which files to search (e.g., '*.ts', '*.{js,jsx}'). Defaults to all files.",
+                    type: 'string',
+                },
+            },
+            required: ['path', 'regex'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (params.path.trim() === '') {
+            return "The 'path' parameter must be non-empty.";
+        }
+        if (!path.isAbsolute(params.path)) {
+            return `Path must be absolute, but was relative: ${params.path}.`;
+        }
+        if (params.regex.trim() === '') {
+            return "The 'regex' parameter must be non-empty.";
+        }
+        // Validate regex syntax
+        try {
+            new RegExp(params.regex);
+        }
+        catch (e) {
+            return `Invalid regex pattern: ${e.message}`;
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new SearchFilesToolInvocation(params);
+    }
+}
+exports.SearchFilesTool = SearchFilesTool;
+SearchFilesTool.Name = 'search_files';

package/dist/tools/search/search-mcp-tool.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Search MCP Tool - Searches for available MCP tools
+ * Wraps the SDK's codebaseSearch.searchMcpTool() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the SearchMcpTool tool
+ */
+export interface SearchMcpToolToolParams {
+    /**
+     * One sentence explanation of why this tool is being used
+     */
+    explanation?: string;
+    /**
+     * The search query to find relevant MCP tools
+     */
+    query: string;
+    /**
+     * Optional tags to filter the search results
+     */
+    tags?: string[];
+}
+/**
+ * Implementation of the SearchMcpTool tool logic
+ */
+export declare class SearchMcpToolTool extends BaseDeclarativeTool<SearchMcpToolToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: SearchMcpToolToolParams): string | null;
+    protected createInvocation(params: SearchMcpToolToolParams): ToolInvocation<SearchMcpToolToolParams, ToolResult>;
+}

package/dist/tools/search/search-mcp-tool.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * Search MCP Tool - Searches for available MCP tools
+ * Wraps the SDK's codebaseSearch.searchMcpTool() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchMcpToolTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const codebaseSearch_1 = __importDefault(require("../../modules/codebaseSearch"));
+const chat_1 = __importDefault(require("../../modules/chat"));
+class SearchMcpToolToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            if (this.params.explanation) {
+                chat_1.default.sendMessage(this.params.explanation);
+            }
+            // Call the SDK's codebaseSearch module
+            const response = await codebaseSearch_1.default.searchMcpTool(this.params.query, this.params.tags);
+            // McpToolSearchResponse has {success, results: any[], message?}
+            if (!response.success) {
+                const errorMsg = response.message || 'Unknown error';
+                return {
+                    llmContent: `Error searching MCP tools: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.MCP_TOOL_ERROR,
+                    },
+                };
+            }
+            // Format the results - results is any[]
+            const tools = response.results || [];
+            if (tools.length === 0) {
+                return {
+                    llmContent: `No MCP tools found for query: "${this.params.query}"`,
+                    returnDisplay: `No tools found`,
+                };
+            }
+            let output = `Found ${tools.length} MCP tool(s) for: "${this.params.query}"\n\n`;
+            for (const tool of tools) {
+                const name = tool.name || tool.toolName;
+                const server = tool.server || tool.serverName || tool.mcpName;
+                const description = tool.description;
+                const score = tool.score || tool.relevance;
+                output += `--- ${server ? `${server}::` : ''}${name}${score ? ` (score: ${score.toFixed(2)})` : ''} ---\n`;
+                if (description) {
+                    output += `${description}\n`;
+                }
+                if (tool.parameters || tool.inputSchema) {
+                    output += `Parameters: ${JSON.stringify(tool.parameters || tool.inputSchema, null, 2)}\n`;
+                }
+                output += '\n';
+            }
+            return {
+                llmContent: output,
+                returnDisplay: `Found ${tools.length} MCP tool(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error searching MCP tools: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the SearchMcpTool tool logic
+ */
+class SearchMcpToolTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(SearchMcpToolTool.Name, 'SearchMcpTool', `Searches for available MCP (Model Context Protocol) tools that can help with a task. Use this to discover what tools are available and their capabilities.`, types_1.Kind.Search, {
+            properties: {
+                explanation: {
+                    description: "One sentence explanation as to why this tool is being used, and how it contributes to the goal.",
+                    type: 'string',
+                },
+                query: {
+                    description: "Description of what you need a tool for (e.g., 'send email', 'database query', 'file conversion').",
+                    type: 'string',
+                },
+                tags: {
+                    description: "Optional tags to filter results (e.g., ['database', 'api']).",
+                    type: 'array',
+                    items: { type: 'string' },
+                },
+            },
+            required: ['query'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (params.query.trim() === '') {
+            return "The 'query' parameter must be non-empty.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new SearchMcpToolToolInvocation(params);
+    }
+}
+exports.SearchMcpToolTool = SearchMcpToolTool;
+SearchMcpToolTool.Name = 'search_mcp_tool';

package/dist/tools/search/web-search.d.ts

@@ -0,0 +1,11 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface WebSearchParams {
+    query: string;
+    engine?: string;
+    explanation?: string;
+}
+export declare class WebSearchTool extends BaseDeclarativeTool<WebSearchParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: WebSearchParams): ToolInvocation<WebSearchParams, ToolResult>;
+}

package/dist/tools/search/web-search.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSearchTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const search_1 = __importDefault(require("../../modules/search"));
+class WebSearchInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const result = await search_1.default.search(this.params.query);
+            return {
+                llmContent: `Web search results:\n${result}`,
+                returnDisplay: `Search completed for: ${this.params.query}`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class WebSearchTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('search_web', 'Web Search', 'Perform a web search', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+                engine: { type: 'string', description: 'Search engine' },
+                explanation: { type: 'string', description: 'Explanation' },
+            },
+            required: ['query'],
+        });
+    }
+    createInvocation(params) {
+        return new WebSearchInvocation(params);
+    }
+}
+exports.WebSearchTool = WebSearchTool;

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

@@ -0,0 +1,17 @@
+/**
+ * Side Execution tools
+ */
+export { SideExecutionStartActionBlockTool, type SideExecutionStartActionBlockParams } from './side-exec-start-action-block';
+export { SideExecutionStartCodeTool, type SideExecutionStartCodeParams } from './side-exec-start-code';
+export { SideExecutionStopTool, type SideExecutionStopParams } from './side-exec-stop';
+export { SideExecutionListActionBlocksTool, type SideExecutionListActionBlocksParams } from './side-exec-list-action-blocks';
+export { SideExecutionGetStatusTool, type SideExecutionGetStatusParams } from './side-exec-get-status';
+import { SideExecutionStartActionBlockTool } from './side-exec-start-action-block';
+import { SideExecutionStartCodeTool } from './side-exec-start-code';
+import { SideExecutionStopTool } from './side-exec-stop';
+import { SideExecutionListActionBlocksTool } from './side-exec-list-action-blocks';
+import { SideExecutionGetStatusTool } from './side-exec-get-status';
+/**
+ * All side execution tools
+ */
+export declare const sideExecutionTools: (SideExecutionStartActionBlockTool | SideExecutionStartCodeTool | SideExecutionStopTool | SideExecutionListActionBlocksTool | SideExecutionGetStatusTool)[];

package/dist/tools/sideExecution/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Side Execution tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sideExecutionTools = exports.SideExecutionGetStatusTool = exports.SideExecutionListActionBlocksTool = exports.SideExecutionStopTool = exports.SideExecutionStartCodeTool = exports.SideExecutionStartActionBlockTool = void 0;
+var side_exec_start_action_block_1 = require("./side-exec-start-action-block");
+Object.defineProperty(exports, "SideExecutionStartActionBlockTool", { enumerable: true, get: function () { return side_exec_start_action_block_1.SideExecutionStartActionBlockTool; } });
+var side_exec_start_code_1 = require("./side-exec-start-code");
+Object.defineProperty(exports, "SideExecutionStartCodeTool", { enumerable: true, get: function () { return side_exec_start_code_1.SideExecutionStartCodeTool; } });
+var side_exec_stop_1 = require("./side-exec-stop");
+Object.defineProperty(exports, "SideExecutionStopTool", { enumerable: true, get: function () { return side_exec_stop_1.SideExecutionStopTool; } });
+var side_exec_list_action_blocks_1 = require("./side-exec-list-action-blocks");
+Object.defineProperty(exports, "SideExecutionListActionBlocksTool", { enumerable: true, get: function () { return side_exec_list_action_blocks_1.SideExecutionListActionBlocksTool; } });
+var side_exec_get_status_1 = require("./side-exec-get-status");
+Object.defineProperty(exports, "SideExecutionGetStatusTool", { enumerable: true, get: function () { return side_exec_get_status_1.SideExecutionGetStatusTool; } });
+// Create instances for convenience
+const side_exec_start_action_block_2 = require("./side-exec-start-action-block");
+const side_exec_start_code_2 = require("./side-exec-start-code");
+const side_exec_stop_2 = require("./side-exec-stop");
+const side_exec_list_action_blocks_2 = require("./side-exec-list-action-blocks");
+const side_exec_get_status_2 = require("./side-exec-get-status");
+/**
+ * All side execution tools
+ */
+exports.sideExecutionTools = [
+    new side_exec_start_action_block_2.SideExecutionStartActionBlockTool(),
+    new side_exec_start_code_2.SideExecutionStartCodeTool(),
+    new side_exec_stop_2.SideExecutionStopTool(),
+    new side_exec_list_action_blocks_2.SideExecutionListActionBlocksTool(),
+    new side_exec_get_status_2.SideExecutionGetStatusTool(),
+];

package/dist/tools/sideExecution/side-exec-get-status.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Side Execution Get Status Tool - Gets the status of a side execution
+ * Wraps the SDK's codeboltSideExecution.getStatus() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the SideExecutionGetStatus tool
+ */
+export interface SideExecutionGetStatusParams {
+    /**
+     * ID of the side execution
+     */
+    side_execution_id: string;
+}
+/**
+ * Tool for getting the status of a side execution
+ */
+export declare class SideExecutionGetStatusTool extends BaseDeclarativeTool<SideExecutionGetStatusParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: SideExecutionGetStatusParams): string | null;
+    protected createInvocation(params: SideExecutionGetStatusParams): ToolInvocation<SideExecutionGetStatusParams, ToolResult>;
+}

package/dist/tools/sideExecution/side-exec-get-status.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Side Execution Get Status Tool - Gets the status of a side execution
+ * Wraps the SDK's codeboltSideExecution.getStatus() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SideExecutionGetStatusTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const sideExecution_1 = __importDefault(require("../../modules/sideExecution"));
+class SideExecutionGetStatusInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await sideExecution_1.default.getStatus(this.params.side_execution_id);
+            if (response.error) {
+                const errorMsg = response.error || 'Failed to get side execution status';
+                return {
+                    llmContent: `Failed to get side execution status: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const status = response.status || 'unknown';
+            const result = response.result;
+            const startTime = response.startTime;
+            const endTime = response.endTime;
+            let llmContent = `Side Execution Status\n`;
+            llmContent += `ID: ${this.params.side_execution_id}\n`;
+            llmContent += `Status: ${status}\n`;
+            if (startTime) {
+                llmContent += `Start Time: ${startTime}\n`;
+            }
+            if (endTime) {
+                llmContent += `End Time: ${endTime}\n`;
+            }
+            if (result !== undefined) {
+                llmContent += `Result: ${typeof result === 'object' ? JSON.stringify(result, null, 2) : result}\n`;
+            }
+            return {
+                llmContent,
+                returnDisplay: `Status: ${status}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error getting side execution status: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Tool for getting the status of a side execution
+ */
+class SideExecutionGetStatusTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(SideExecutionGetStatusTool.Name, 'Get Side Execution Status', 'Get the status of a side execution by its ID.', types_1.Kind.Read, {
+            type: 'object',
+            properties: {
+                side_execution_id: {
+                    type: 'string',
+                    description: 'ID of the side execution'
+                }
+            },
+            required: ['side_execution_id']
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.side_execution_id || params.side_execution_id.trim() === '') {
+            return "The 'side_execution_id' parameter must be non-empty.";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new SideExecutionGetStatusInvocation(params);
+    }
+}
+exports.SideExecutionGetStatusTool = SideExecutionGetStatusTool;
+SideExecutionGetStatusTool.Name = 'side_execution_get_status';

package/dist/tools/sideExecution/side-exec-list-action-blocks.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Side Execution List Action Blocks Tool - Lists all available ActionBlocks
+ * Wraps the SDK's codeboltSideExecution.listActionBlocks() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the SideExecutionListActionBlocks tool
+ */
+export interface SideExecutionListActionBlocksParams {
+    /**
+     * Optional project path to search for ActionBlocks
+     */
+    project_path?: string;
+}
+/**
+ * Tool for listing all available ActionBlocks
+ */
+export declare class SideExecutionListActionBlocksTool extends BaseDeclarativeTool<SideExecutionListActionBlocksParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: SideExecutionListActionBlocksParams): ToolInvocation<SideExecutionListActionBlocksParams, ToolResult>;
+}

package/dist/tools/sideExecution/side-exec-list-action-blocks.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Side Execution List Action Blocks Tool - Lists all available ActionBlocks
+ * Wraps the SDK's codeboltSideExecution.listActionBlocks() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SideExecutionListActionBlocksTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const sideExecution_1 = __importDefault(require("../../modules/sideExecution"));
+class SideExecutionListActionBlocksInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const response = await sideExecution_1.default.listActionBlocks(this.params.project_path);
+            if (response.error) {
+                const errorMsg = response.error || 'Failed to list ActionBlocks';
+                return {
+                    llmContent: `Failed to list ActionBlocks: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const actionBlocks = response.actionBlocks || response.blocks || [];
+            const count = actionBlocks.length;
+            let llmContent = `Found ${count} ActionBlock(s)`;
+            if (this.params.project_path) {
+                llmContent += ` in project: ${this.params.project_path}`;
+            }
+            llmContent += '\n\n';
+            if (count > 0) {
+                llmContent += 'ActionBlocks:\n';
+                for (const block of actionBlocks) {
+                    const name = block.name || block.path || 'Unknown';
+                    const description = block.description || '';
+                    llmContent += `- ${name}${description ? `: ${description}` : ''}\n`;
+                }
+            }
+            return {
+                llmContent,
+                returnDisplay: `Found ${count} ActionBlock(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error listing ActionBlocks: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Tool for listing all available ActionBlocks
+ */
+class SideExecutionListActionBlocksTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(SideExecutionListActionBlocksTool.Name, 'List ActionBlocks', 'List all available ActionBlocks that can be used for side execution. Optionally filter by project path.', types_1.Kind.Read, {
+            type: 'object',
+            properties: {
+                project_path: {
+                    type: 'string',
+                    description: 'Optional project path to search for ActionBlocks'
+                }
+            },
+            required: []
+        });
+    }
+    createInvocation(params) {
+        return new SideExecutionListActionBlocksInvocation(params);
+    }
+}
+exports.SideExecutionListActionBlocksTool = SideExecutionListActionBlocksTool;
+SideExecutionListActionBlocksTool.Name = 'side_execution_list_action_blocks';