@codebolt/codeboltjs 5.0.9 → 5.1.12

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

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

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * Environment Provider Tools - Get local and running providers
+ * Wraps the SDK's cbenvironment.getLocalProviders() and getRunningProviders() methods
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentGetRunningProvidersTool = exports.EnvironmentGetLocalProvidersTool = 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 EnvironmentGetLocalProvidersInvocation 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.getLocalProviders();
+            if (response && response.success === false) {
+                const errorMsg = response.error || 'Failed to get local providers';
+                return {
+                    llmContent: `Failed to get local providers: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: { message: errorMsg, type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const providers = ((_a = response.data) === null || _a === void 0 ? void 0 : _a.providers) || [];
+            let output = `Found ${providers.length} local provider(s):\n`;
+            for (const p of providers) {
+                output += `- ${p.name || p.unique_id || 'Unknown'} (${p.unique_id || p.providerId || 'N/A'})\n`;
+            }
+            return {
+                llmContent: output,
+                returnDisplay: `Found ${providers.length} local provider(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error getting local providers: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: { message: errorMessage, type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class EnvironmentGetLocalProvidersTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(EnvironmentGetLocalProvidersTool.Name, 'EnvironmentGetLocalProviders', 'Gets all available local environment providers.', 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 EnvironmentGetLocalProvidersInvocation(params);
+    }
+}
+exports.EnvironmentGetLocalProvidersTool = EnvironmentGetLocalProvidersTool;
+EnvironmentGetLocalProvidersTool.Name = 'environment_get_local_providers';
+class EnvironmentGetRunningProvidersInvocation 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.getRunningProviders();
+            if (response && response.success === false) {
+                const errorMsg = response.error || 'Failed to get running providers';
+                return {
+                    llmContent: `Failed to get running providers: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: { message: errorMsg, type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const providers = ((_a = response.data) === null || _a === void 0 ? void 0 : _a.providers) || [];
+            let output = `${providers.length} running provider(s):\n`;
+            for (const p of providers) {
+                output += `- ${typeof p === 'string' ? p : (p.name || p.id || JSON.stringify(p))}\n`;
+            }
+            return {
+                llmContent: output,
+                returnDisplay: `${providers.length} running provider(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error getting running providers: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: { message: errorMessage, type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class EnvironmentGetRunningProvidersTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(EnvironmentGetRunningProvidersTool.Name, 'EnvironmentGetRunningProviders', 'Gets all currently running environment providers.', 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 EnvironmentGetRunningProvidersInvocation(params);
+    }
+}
+exports.EnvironmentGetRunningProvidersTool = EnvironmentGetRunningProvidersTool;
+EnvironmentGetRunningProvidersTool.Name = 'environment_get_running_providers';

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

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

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

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Environment Restart Tool - Restarts an environment provider
+ * Wraps the SDK's cbenvironment.restartEnvironment() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentRestartTool = 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 EnvironmentRestartInvocation 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.restartEnvironment(this.params.environmentId);
+            if (response && response.success === false) {
+                const errorMsg = response.error || 'Failed to restart environment';
+                return {
+                    llmContent: `Failed to restart environment: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: { message: errorMsg, type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            return {
+                llmContent: `Environment ${this.params.environmentId} restarted successfully. ${response.message || ''}`,
+                returnDisplay: `Restarted environment: ${this.params.environmentId}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error restarting environment: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: { message: errorMessage, type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class EnvironmentRestartTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(EnvironmentRestartTool.Name, 'EnvironmentRestart', 'Restarts an environment by ID (stops then starts the provider).', 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',
+                },
+                environmentId: {
+                    description: 'The ID of the environment to restart.',
+                    type: 'string',
+                },
+            },
+            required: ['environmentId'],
+            type: 'object',
+        });
+    }
+    createInvocation(params) {
+        return new EnvironmentRestartInvocation(params);
+    }
+}
+exports.EnvironmentRestartTool = EnvironmentRestartTool;
+EnvironmentRestartTool.Name = 'environment_restart';

package/dist/tools/environment/environment-send-message.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Environment Send Message Tool - Sends a message to an environment provider
+ * Wraps the SDK's cbenvironment.sendMessageToEnvironment() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface EnvironmentSendMessageParams {
+    /** One sentence explanation of why this tool is being used */
+    explanation?: string;
+    /** The ID of the environment to send the message to */
+    environmentId: string;
+    /** The message to send to the environment provider */
+    message: any;
+}
+export declare class EnvironmentSendMessageTool extends BaseDeclarativeTool<EnvironmentSendMessageParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: EnvironmentSendMessageParams): ToolInvocation<EnvironmentSendMessageParams, ToolResult>;
+}

package/dist/tools/environment/environment-send-message.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Environment Send Message Tool - Sends a message to an environment provider
+ * Wraps the SDK's cbenvironment.sendMessageToEnvironment() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentSendMessageTool = 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 EnvironmentSendMessageInvocation 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.sendMessageToEnvironment(this.params.environmentId, this.params.message);
+            if (response && response.success === false) {
+                const errorMsg = response.error || response.message || 'Failed to send message to environment';
+                return {
+                    llmContent: `Failed to send message to environment: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: { message: errorMsg, type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            return {
+                llmContent: `Message sent to environment ${this.params.environmentId} successfully.`,
+                returnDisplay: `Message sent to environment: ${this.params.environmentId}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error sending message to environment: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: { message: errorMessage, type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class EnvironmentSendMessageTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(EnvironmentSendMessageTool.Name, 'EnvironmentSendMessage', 'Sends a message to an environment provider.', 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',
+                },
+                environmentId: {
+                    description: 'The ID of the environment to send the message to.',
+                    type: 'string',
+                },
+                message: {
+                    description: 'The message to send to the environment provider.',
+                    type: 'object',
+                },
+            },
+            required: ['environmentId', 'message'],
+            type: 'object',
+        });
+    }
+    createInvocation(params) {
+        return new EnvironmentSendMessageInvocation(params);
+    }
+}
+exports.EnvironmentSendMessageTool = EnvironmentSendMessageTool;
+EnvironmentSendMessageTool.Name = 'environment_send_message';

package/dist/tools/environment/environment-start-agent.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Environment Start Agent Tool - Starts an agent in an environment
+ * Wraps the SDK's cbenvironment.startAgentInEnvironment() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface EnvironmentStartAgentParams {
+    /** One sentence explanation of why this tool is being used */
+    explanation?: string;
+    /** The ID of the environment to run the agent in */
+    environmentId: string;
+    /** The ID of the agent to start. If not provided, uses the default agent. */
+    agentId?: string;
+    /** The task/instruction for the agent */
+    task: string;
+    /** Optional thread ID for conversation context tracking */
+    threadId?: string;
+}
+export declare class EnvironmentStartAgentTool extends BaseDeclarativeTool<EnvironmentStartAgentParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: EnvironmentStartAgentParams): ToolInvocation<EnvironmentStartAgentParams, ToolResult>;
+}

package/dist/tools/environment/environment-start-agent.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Environment Start Agent Tool - Starts an agent in an environment
+ * Wraps the SDK's cbenvironment.startAgentInEnvironment() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvironmentStartAgentTool = 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 EnvironmentStartAgentInvocation 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.startAgentInEnvironment(this.params.environmentId, this.params.task, (_a = this.params.agentId) !== null && _a !== void 0 ? _a : undefined, this.params.threadId);
+            if (response && response.success === false) {
+                const errorMsg = response.error || 'Failed to start agent in environment';
+                return {
+                    llmContent: `Failed to start agent in environment: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: { message: errorMsg, type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            return {
+                llmContent: `Agent ${this.params.agentId} started in environment ${this.params.environmentId} successfully. ${response.message || ''}`,
+                returnDisplay: `Started agent ${this.params.agentId} in environment ${this.params.environmentId}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error starting agent in environment: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: { message: errorMessage, type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class EnvironmentStartAgentTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(EnvironmentStartAgentTool.Name, 'EnvironmentStartAgent', 'Starts an agent in a specified environment. Sends the task to the environment provider which launches and runs the agent.', 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',
+                },
+                environmentId: {
+                    description: 'The ID of the environment to run the agent in.',
+                    type: 'string',
+                },
+                agentId: {
+                    description: 'The ID of the agent to start. If not provided, uses the default agent.',
+                    type: 'string',
+                },
+                task: {
+                    description: 'The task or instruction for the agent to execute.',
+                    type: 'string',
+                },
+                threadId: {
+                    description: 'Optional thread ID for tracking conversation context.',
+                    type: 'string',
+                },
+            },
+            required: ['environmentId', 'task'],
+            type: 'object',
+        });
+    }
+    createInvocation(params) {
+        return new EnvironmentStartAgentInvocation(params);
+    }
+}
+exports.EnvironmentStartAgentTool = EnvironmentStartAgentTool;
+EnvironmentStartAgentTool.Name = 'environment_start_agent';

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

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