@codebolt/codeboltjs 5.0.8 → 5.1.10

package/dist/modules/environment.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A module for managing environments (create, start, stop, restart, etc.)
+ */
+declare const cbenvironment: {
+    listEnvironments: () => Promise<any>;
+    getEnvironment: (environmentId: string) => Promise<any>;
+    createEnvironment: (environmentData: {
+        name: string;
+        description?: string;
+        provider: any;
+        config?: any;
+    }) => Promise<any>;
+    updateEnvironment: (environmentId: string, updateData: any) => Promise<any>;
+    deleteEnvironment: (environmentId: string) => Promise<any>;
+    startEnvironment: (environmentId: string) => Promise<any>;
+    stopEnvironment: (environmentId: string) => Promise<any>;
+    restartEnvironment: (environmentId: string) => Promise<any>;
+    getEnvironmentStatus: (environmentId: string) => Promise<any>;
+    getRunningProviders: () => Promise<any>;
+    getLocalProviders: () => Promise<any>;
+    getEnvironmentStatistics: () => Promise<any>;
+    sendMessageToEnvironment: (environmentId: string, message: any) => Promise<any>;
+};
+export default cbenvironment;

package/dist/modules/environment.js

@@ -0,0 +1,51 @@
+"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"));
+/**
+ * A module for managing environments (create, start, stop, restart, etc.)
+ */
+const cbenvironment = {
+    listEnvironments: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ "type": "environment.listEnvironments" }, "listEnvironmentsResponse");
+    },
+    getEnvironment: (environmentId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ "type": "environment.getEnvironment", "params": { id: environmentId } }, "getEnvironmentResponse");
+    },
+    createEnvironment: (environmentData) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ "type": "environment.createEnvironment", "params": { environmentData } }, "createEnvironmentResponse");
+    },
+    updateEnvironment: (environmentId, updateData) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ "type": "environment.updateEnvironment", "params": { id: environmentId, updateData } }, "updateEnvironmentResponse");
+    },
+    deleteEnvironment: (environmentId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ "type": "environment.deleteEnvironment", "params": { id: environmentId } }, "deleteEnvironmentResponse");
+    },
+    startEnvironment: (environmentId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ "type": "environment.startEnvironment", "params": { id: environmentId } }, "startEnvironmentResponse");
+    },
+    stopEnvironment: (environmentId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ "type": "environment.stopEnvironment", "params": { id: environmentId } }, "stopEnvironmentResponse");
+    },
+    restartEnvironment: (environmentId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ "type": "environment.restartEnvironment", "params": { id: environmentId } }, "restartEnvironmentResponse");
+    },
+    getEnvironmentStatus: (environmentId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ "type": "environment.getEnvironmentStatus", "params": { id: environmentId } }, "getEnvironmentStatusResponse");
+    },
+    getRunningProviders: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ "type": "environment.getRunningProviders" }, "getRunningProvidersResponse");
+    },
+    getLocalProviders: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ "type": "environment.getLocalProviders" }, "getLocalProvidersResponse");
+    },
+    getEnvironmentStatistics: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ "type": "environment.getEnvironmentStatistics" }, "getEnvironmentStatisticsResponse");
+    },
+    sendMessageToEnvironment: (environmentId, message) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({ "type": "environment.sendMessageToEnvironment", "params": { id: environmentId, message } }, "sendMessageToEnvironmentResponse");
+    },
+};
+exports.default = cbenvironment;

package/dist/modules/mcp.js

@@ -183,6 +183,9 @@ const codeboltMCP = {
      */
     executeTool: async (toolbox, toolName, params) => {
         // Handle local codebolt tools
+        if (toolbox == undefined) {
+            toolbox = "codebolt";
+        }
         if (isCodeboltToolbox(toolbox)) {
             // Extract actual tool name (in case it comes prefixed)
             const actualToolName = extractToolName(toolName);

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

@@ -24,10 +24,7 @@ class StartActionBlockInvocation extends base_tool_1.BaseToolInvocation {
                     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 };
+            return { llmContent: JSON.stringify(response), returnDisplay: JSON.stringify(response) };
         }
         catch (error) {
             return {

package/dist/tools/actionPlan/action-plan-create.js

@@ -12,7 +12,6 @@ class CreateActionPlanInvocation extends base_tool_1.BaseToolInvocation {
         super(params);
     }
     async execute(_signal) {
-        var _a;
         try {
             const { name, description, agentId, agentName, status, planId } = this.params;
             const response = await actionPlan_1.default.createActionPlan({ name, description, agentId, agentName, status, planId });
@@ -23,7 +22,7 @@ class CreateActionPlanInvocation extends base_tool_1.BaseToolInvocation {
                     error: { message: response.error || 'Unknown error', type: types_1.ToolErrorType.EXECUTION_FAILED },
                 };
             }
-            const content = `Action plan "${name}" created successfully. ID: ${(_a = response.plan) === null || _a === void 0 ? void 0 : _a.planId}`;
+            const content = JSON.stringify(response, null, 2);
             return { llmContent: content, returnDisplay: content };
         }
         catch (error) {

package/dist/tools/completion/attempt-completion.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Attempt Completion Tool - Signals the completion of a task
+ */
+import { BaseDeclarativeTool, ToolInvocation, ToolResult } from '../base-tool';
+/**
+ * Parameters for the AttemptCompletion tool
+ */
+export interface AttemptCompletionToolParams {
+    /**
+     * The final result of the task
+     */
+    result: Record<string, any>;
+    /**
+     * Optional explanation of the completion
+     */
+    explanation?: string;
+}
+/**
+ * Implementation of the AttemptCompletion tool
+ */
+export declare class AttemptCompletionTool extends BaseDeclarativeTool<AttemptCompletionToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: AttemptCompletionToolParams): ToolInvocation<AttemptCompletionToolParams, ToolResult>;
+}

package/dist/tools/completion/attempt-completion.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Attempt Completion Tool - Signals the completion of a task
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttemptCompletionTool = void 0;
+const base_tool_1 = require("../base-tool");
+class AttemptCompletionToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        return {
+            llmContent: JSON.stringify(this.params.result, null, 2),
+            returnDisplay: `Task Completed.\n\nResult:\n\`\`\`json\n${JSON.stringify(this.params.result, null, 2)}\n\`\`\``,
+        };
+    }
+}
+/**
+ * Implementation of the AttemptCompletion tool
+ */
+class AttemptCompletionTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(AttemptCompletionTool.Name, 'AttemptCompletion', 'Signals the completion of the task and returns the final result.', base_tool_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                result: {
+                    type: 'object',
+                    description: 'The final result of the task. The structure of this object should match the format specified in the system prompt.',
+                    additionalProperties: true,
+                },
+                explanation: {
+                    type: 'string',
+                    description: 'Optional explanation of why the task is receiving this result.',
+                },
+            },
+            required: ['result'],
+        });
+    }
+    createInvocation(params) {
+        return new AttemptCompletionToolInvocation(params);
+    }
+}
+exports.AttemptCompletionTool = AttemptCompletionTool;
+AttemptCompletionTool.Name = 'attempt_completion';

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

@@ -0,0 +1,3 @@
+import { AttemptCompletionTool } from './attempt-completion';
+export { AttemptCompletionTool, type AttemptCompletionToolParams, } from './attempt-completion';
+export declare const completionTools: AttemptCompletionTool[];

package/dist/tools/completion/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completionTools = exports.AttemptCompletionTool = void 0;
+const attempt_completion_1 = require("./attempt-completion");
+var attempt_completion_2 = require("./attempt-completion");
+Object.defineProperty(exports, "AttemptCompletionTool", { enumerable: true, get: function () { return attempt_completion_2.AttemptCompletionTool; } });
+exports.completionTools = [
+    new attempt_completion_1.AttemptCompletionTool(),
+];

package/dist/tools/environment/environment-create.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Environment Create Tool - Creates a new environment
+ * Wraps the SDK's cbenvironment.createEnvironment() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface EnvironmentCreateParams {
+    /** One sentence explanation of why this tool is being used */
+    explanation?: string;
+    /** The name of the environment */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Provider configuration (must match an available local provider) */
+    provider: any;
+    /** Optional additional configuration */
+    config?: any;
+}
+export declare class EnvironmentCreateTool extends BaseDeclarativeTool<EnvironmentCreateParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: EnvironmentCreateParams): ToolInvocation<EnvironmentCreateParams, ToolResult>;
+}

package/dist/tools/environment/environment-create.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Environment Create Tool - Creates a new environment
+ * Wraps the SDK's cbenvironment.createEnvironment() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentCreateTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const environment_1 = __importDefault(require("../../modules/environment"));
+const chat_1 = __importDefault(require("../../modules/chat"));
+class EnvironmentCreateInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            if (this.params.explanation) {
+                chat_1.default.sendMessage(this.params.explanation);
+            }
+            const response = await environment_1.default.createEnvironment({
+                name: this.params.name,
+                description: this.params.description,
+                provider: this.params.provider,
+                config: this.params.config,
+            });
+            if (response && response.success === false) {
+                const errorMsg = response.error || 'Failed to create environment';
+                return {
+                    llmContent: `Failed to create environment: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: { message: errorMsg, type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const env = (_a = response.data) === null || _a === void 0 ? void 0 : _a.environment;
+            const output = `Environment created successfully.\nName: ${(env === null || env === void 0 ? void 0 : env.name) || this.params.name}\nID: ${(env === null || env === void 0 ? void 0 : env.id) || 'N/A'}\n${response.message || ''}`;
+            return {
+                llmContent: output,
+                returnDisplay: `Created environment: ${(env === null || env === void 0 ? void 0 : env.name) || this.params.name}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error creating environment: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: { message: errorMessage, type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class EnvironmentCreateTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(EnvironmentCreateTool.Name, 'EnvironmentCreate', 'Creates a new environment with the specified name and provider. The provider must be from the available local providers list.', types_1.Kind.Execute, {
+            properties: {
+                explanation: {
+                    description: "One sentence explanation as to why this tool is being used, and how it contributes to the goal.",
+                    type: 'string',
+                },
+                name: {
+                    description: 'The name of the environment to create.',
+                    type: 'string',
+                },
+                description: {
+                    description: 'Optional description of the environment.',
+                    type: 'string',
+                },
+                provider: {
+                    description: 'Provider configuration object. Must include at least a name or unique_id matching an available local provider.',
+                    type: 'object',
+                },
+                config: {
+                    description: 'Optional additional configuration.',
+                    type: 'object',
+                },
+            },
+            required: ['name', 'provider'],
+            type: 'object',
+        });
+    }
+    createInvocation(params) {
+        return new EnvironmentCreateInvocation(params);
+    }
+}
+exports.EnvironmentCreateTool = EnvironmentCreateTool;
+EnvironmentCreateTool.Name = 'environment_create';

package/dist/tools/environment/environment-delete.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Environment Delete Tool - Deletes an environment
+ * Wraps the SDK's cbenvironment.deleteEnvironment() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface EnvironmentDeleteParams {
+    /** One sentence explanation of why this tool is being used */
+    explanation?: string;
+    /** The ID of the environment to delete */
+    environmentId: string;
+}
+export declare class EnvironmentDeleteTool extends BaseDeclarativeTool<EnvironmentDeleteParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: EnvironmentDeleteParams): ToolInvocation<EnvironmentDeleteParams, ToolResult>;
+}

package/dist/tools/environment/environment-delete.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Environment Delete Tool - Deletes an environment
+ * Wraps the SDK's cbenvironment.deleteEnvironment() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentDeleteTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const environment_1 = __importDefault(require("../../modules/environment"));
+const chat_1 = __importDefault(require("../../modules/chat"));
+class EnvironmentDeleteInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            if (this.params.explanation) {
+                chat_1.default.sendMessage(this.params.explanation);
+            }
+            const response = await environment_1.default.deleteEnvironment(this.params.environmentId);
+            if (response && response.success === false) {
+                const errorMsg = response.error || response.message || 'Failed to delete environment';
+                return {
+                    llmContent: `Failed to delete environment: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: { message: errorMsg, type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            return {
+                llmContent: `Environment ${this.params.environmentId} deleted successfully.`,
+                returnDisplay: `Deleted environment: ${this.params.environmentId}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error deleting environment: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: { message: errorMessage, type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class EnvironmentDeleteTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(EnvironmentDeleteTool.Name, 'EnvironmentDelete', 'Deletes an environment by ID.', types_1.Kind.Delete, {
+            properties: {
+                explanation: {
+                    description: "One sentence explanation as to why this tool is being used, and how it contributes to the goal.",
+                    type: 'string',
+                },
+                environmentId: {
+                    description: 'The ID of the environment to delete.',
+                    type: 'string',
+                },
+            },
+            required: ['environmentId'],
+            type: 'object',
+        });
+    }
+    createInvocation(params) {
+        return new EnvironmentDeleteInvocation(params);
+    }
+}
+exports.EnvironmentDeleteTool = EnvironmentDeleteTool;
+EnvironmentDeleteTool.Name = 'environment_delete';

package/dist/tools/environment/environment-get.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Environment Get Tool - Gets an environment by ID
+ * Wraps the SDK's cbenvironment.getEnvironment() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface EnvironmentGetParams {
+    /** One sentence explanation of why this tool is being used */
+    explanation?: string;
+    /** The ID of the environment to retrieve */
+    environmentId: string;
+}
+export declare class EnvironmentGetTool extends BaseDeclarativeTool<EnvironmentGetParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: EnvironmentGetParams): ToolInvocation<EnvironmentGetParams, ToolResult>;
+}

package/dist/tools/environment/environment-get.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Environment Get Tool - Gets an environment by ID
+ * Wraps the SDK's cbenvironment.getEnvironment() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentGetTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const environment_1 = __importDefault(require("../../modules/environment"));
+const chat_1 = __importDefault(require("../../modules/chat"));
+class EnvironmentGetInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a, _b;
+        try {
+            if (this.params.explanation) {
+                chat_1.default.sendMessage(this.params.explanation);
+            }
+            const response = await environment_1.default.getEnvironment(this.params.environmentId);
+            if (response && response.success === false) {
+                const errorMsg = response.error || 'Environment not found';
+                return {
+                    llmContent: `Failed to get environment: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: { message: errorMsg, type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const env = (_a = response.data) === null || _a === void 0 ? void 0 : _a.environment;
+            const output = `Environment: ${(env === null || env === void 0 ? void 0 : env.name) || 'N/A'} (ID: ${(env === null || env === void 0 ? void 0 : env.id) || this.params.environmentId})\nProvider: ${((_b = env === null || env === void 0 ? void 0 : env.provider) === null || _b === void 0 ? void 0 : _b.name) || 'N/A'}\n${JSON.stringify(env, null, 2)}`;
+            return {
+                llmContent: output,
+                returnDisplay: `Retrieved environment: ${(env === null || env === void 0 ? void 0 : env.name) || this.params.environmentId}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error getting environment: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: { message: errorMessage, type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class EnvironmentGetTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(EnvironmentGetTool.Name, 'EnvironmentGet', 'Gets an environment by its ID.', types_1.Kind.Read, {
+            properties: {
+                explanation: {
+                    description: "One sentence explanation as to why this tool is being used, and how it contributes to the goal.",
+                    type: 'string',
+                },
+                environmentId: {
+                    description: 'The ID of the environment to retrieve.',
+                    type: 'string',
+                },
+            },
+            required: ['environmentId'],
+            type: 'object',
+        });
+    }
+    createInvocation(params) {
+        return new EnvironmentGetInvocation(params);
+    }
+}
+exports.EnvironmentGetTool = EnvironmentGetTool;
+EnvironmentGetTool.Name = 'environment_get';

package/dist/tools/environment/environment-list.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Environment List Tool - Lists all environments
+ * Wraps the SDK's cbenvironment.listEnvironments() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface EnvironmentListParams {
+    /** One sentence explanation of why this tool is being used */
+    explanation?: string;
+}
+export declare class EnvironmentListTool extends BaseDeclarativeTool<EnvironmentListParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: EnvironmentListParams): ToolInvocation<EnvironmentListParams, ToolResult>;
+}

package/dist/tools/environment/environment-list.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Environment List Tool - Lists all environments
+ * Wraps the SDK's cbenvironment.listEnvironments() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentListTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const environment_1 = __importDefault(require("../../modules/environment"));
+const chat_1 = __importDefault(require("../../modules/chat"));
+class EnvironmentListInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a, _b;
+        try {
+            if (this.params.explanation) {
+                chat_1.default.sendMessage(this.params.explanation);
+            }
+            const response = await environment_1.default.listEnvironments();
+            if (response && response.success === false) {
+                const errorMsg = response.error || 'Failed to list environments';
+                return {
+                    llmContent: `Failed to list environments: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: { message: errorMsg, type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const environments = ((_a = response.data) === null || _a === void 0 ? void 0 : _a.environments) || [];
+            let output = `Retrieved ${environments.length} environment(s):\n`;
+            for (const env of environments) {
+                output += `- ${env.id}: ${env.name} (provider: ${((_b = env.provider) === null || _b === void 0 ? void 0 : _b.name) || 'N/A'})\n`;
+            }
+            return {
+                llmContent: output,
+                returnDisplay: `Listed ${environments.length} environment(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error listing environments: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: { message: errorMessage, type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class EnvironmentListTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(EnvironmentListTool.Name, 'EnvironmentList', 'Lists all environments.', types_1.Kind.Read, {
+            properties: {
+                explanation: {
+                    description: "One sentence explanation as to why this tool is being used, and how it contributes to the goal.",
+                    type: 'string',
+                },
+            },
+            required: [],
+            type: 'object',
+        });
+    }
+    createInvocation(params) {
+        return new EnvironmentListInvocation(params);
+    }
+}
+exports.EnvironmentListTool = EnvironmentListTool;
+EnvironmentListTool.Name = 'environment_list';

package/dist/tools/environment/environment-providers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Environment Provider Tools - Get local and running providers
+ * Wraps the SDK's cbenvironment.getLocalProviders() and getRunningProviders() methods
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface EnvironmentGetLocalProvidersParams {
+    /** One sentence explanation of why this tool is being used */
+    explanation?: string;
+}
+export declare class EnvironmentGetLocalProvidersTool extends BaseDeclarativeTool<EnvironmentGetLocalProvidersParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: EnvironmentGetLocalProvidersParams): ToolInvocation<EnvironmentGetLocalProvidersParams, ToolResult>;
+}
+export interface EnvironmentGetRunningProvidersParams {
+    /** One sentence explanation of why this tool is being used */
+    explanation?: string;
+}
+export declare class EnvironmentGetRunningProvidersTool extends BaseDeclarativeTool<EnvironmentGetRunningProvidersParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: EnvironmentGetRunningProvidersParams): ToolInvocation<EnvironmentGetRunningProvidersParams, ToolResult>;
+}