@codebolt/codeboltjs 5.0.2 → 5.0.4

package/dist/tools/testing/test-suite-list.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Test Suite List Tool - Lists all test suites
+ * Wraps the SDK's cbautoTesting.listSuites() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestSuiteListTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const autoTesting_1 = __importDefault(require("../../modules/autoTesting"));
+class TestSuiteListToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            const response = await autoTesting_1.default.listSuites(this.params.filters);
+            const suites = ((_a = response.payload) === null || _a === void 0 ? void 0 : _a.suites) || [];
+            if (suites.length === 0) {
+                return {
+                    llmContent: 'No test suites found.',
+                    returnDisplay: 'No test suites found',
+                };
+            }
+            const suiteList = suites.map(suite => { var _a; return `- ${suite.name} (ID: ${suite.id})\n  Description: ${suite.description || 'N/A'}\n  Test Cases: ${((_a = suite.testCaseIds) === null || _a === void 0 ? void 0 : _a.length) || 0}`; }).join('\n\n');
+            return {
+                llmContent: `Found ${suites.length} test suite(s):\n\n${suiteList}`,
+                returnDisplay: `Listed ${suites.length} test suite(s)`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error listing test suites: ${errorMessage}`,
+                returnDisplay: `Error listing test suites: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the TestSuiteList tool logic
+ */
+class TestSuiteListTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(TestSuiteListTool.Name, 'TestSuiteList', 'Lists all available test suites with their names, descriptions, and test case counts.', types_1.Kind.Read, {
+            properties: {
+                filters: {
+                    description: 'Optional filters for listing suites (reserved for future use).',
+                    type: 'object',
+                },
+            },
+            required: [],
+            type: 'object',
+        });
+    }
+    createInvocation(params) {
+        return new TestSuiteListToolInvocation(params);
+    }
+}
+exports.TestSuiteListTool = TestSuiteListTool;
+TestSuiteListTool.Name = 'test_suite_list';

package/dist/tools/testing/test-suite-update.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Test Suite Update Tool - Updates an existing test suite
+ * Wraps the SDK's cbautoTesting.updateSuite() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the TestSuiteUpdate tool
+ */
+export interface TestSuiteUpdateToolParams {
+    /**
+     * The ID of the test suite to update
+     */
+    suite_id: string;
+    /**
+     * Optional new name for the test suite
+     */
+    name?: string;
+    /**
+     * Optional new description for the test suite
+     */
+    description?: string;
+    /**
+     * Optional new array of test case IDs
+     */
+    test_case_ids?: string[];
+}
+/**
+ * Implementation of the TestSuiteUpdate tool logic
+ */
+export declare class TestSuiteUpdateTool extends BaseDeclarativeTool<TestSuiteUpdateToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: TestSuiteUpdateToolParams): string | null;
+    protected createInvocation(params: TestSuiteUpdateToolParams): ToolInvocation<TestSuiteUpdateToolParams, ToolResult>;
+}

package/dist/tools/testing/test-suite-update.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * Test Suite Update Tool - Updates an existing test suite
+ * Wraps the SDK's cbautoTesting.updateSuite() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestSuiteUpdateTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const autoTesting_1 = __importDefault(require("../../modules/autoTesting"));
+class TestSuiteUpdateToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a, _b;
+        try {
+            const response = await autoTesting_1.default.updateSuite({
+                id: this.params.suite_id,
+                name: this.params.name,
+                description: this.params.description,
+                testCaseIds: this.params.test_case_ids,
+            });
+            const suite = (_a = response.payload) === null || _a === void 0 ? void 0 : _a.suite;
+            if (!suite) {
+                return {
+                    llmContent: `Error updating test suite: Suite with ID '${this.params.suite_id}' not found or update failed`,
+                    returnDisplay: `Error updating test suite: ${this.params.suite_id}`,
+                    error: {
+                        message: `Suite with ID '${this.params.suite_id}' not found or update failed`,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            return {
+                llmContent: `Successfully updated test suite:\nID: ${suite.id}\nName: ${suite.name}\nDescription: ${suite.description || 'N/A'}\nTest Cases: ${((_b = suite.testCaseIds) === null || _b === void 0 ? void 0 : _b.length) || 0}`,
+                returnDisplay: `Updated test suite: ${suite.name} (ID: ${suite.id})`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error updating test suite: ${errorMessage}`,
+                returnDisplay: `Error updating test suite: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the TestSuiteUpdate tool logic
+ */
+class TestSuiteUpdateTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(TestSuiteUpdateTool.Name, 'TestSuiteUpdate', 'Updates an existing test suite with new name, description, or test case associations.', types_1.Kind.Edit, {
+            properties: {
+                suite_id: {
+                    description: 'The ID of the test suite to update.',
+                    type: 'string',
+                },
+                name: {
+                    description: 'Optional new name for the test suite.',
+                    type: 'string',
+                },
+                description: {
+                    description: 'Optional new description for the test suite.',
+                    type: 'string',
+                },
+                test_case_ids: {
+                    description: 'Optional new array of test case IDs to associate with the suite.',
+                    type: 'array',
+                    items: { type: 'string' },
+                },
+            },
+            required: ['suite_id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.suite_id || params.suite_id.trim() === '') {
+            return "The 'suite_id' parameter must be non-empty.";
+        }
+        // Ensure at least one update field is provided
+        if (!params.name && !params.description && !params.test_case_ids) {
+            return 'At least one of name, description, or test_case_ids must be provided for update.';
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new TestSuiteUpdateToolInvocation(params);
+    }
+}
+exports.TestSuiteUpdateTool = TestSuiteUpdateTool;
+TestSuiteUpdateTool.Name = 'test_suite_update';

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

@@ -0,0 +1,27 @@
+/**
+ * Thread tools - Tools for thread management
+ */
+export { ThreadCreateTool, type ThreadCreateParams } from './thread-create';
+export { ThreadCreateStartTool, type ThreadCreateStartParams } from './thread-create-start';
+export { ThreadCreateBackgroundTool, type ThreadCreateBackgroundParams } from './thread-create-background';
+export { ThreadListTool, type ThreadListParams } from './thread-list';
+export { ThreadGetTool, type ThreadGetParams } from './thread-get';
+export { ThreadStartTool, type ThreadStartParams } from './thread-start';
+export { ThreadUpdateTool, type ThreadUpdateParams } from './thread-update';
+export { ThreadDeleteTool, type ThreadDeleteParams } from './thread-delete';
+export { ThreadGetMessagesTool, type ThreadGetMessagesParams } from './thread-get-messages';
+export { ThreadUpdateStatusTool, type ThreadUpdateStatusParams } from './thread-update-status';
+import { ThreadCreateTool } from './thread-create';
+import { ThreadCreateStartTool } from './thread-create-start';
+import { ThreadCreateBackgroundTool } from './thread-create-background';
+import { ThreadListTool } from './thread-list';
+import { ThreadGetTool } from './thread-get';
+import { ThreadStartTool } from './thread-start';
+import { ThreadUpdateTool } from './thread-update';
+import { ThreadDeleteTool } from './thread-delete';
+import { ThreadGetMessagesTool } from './thread-get-messages';
+import { ThreadUpdateStatusTool } from './thread-update-status';
+/**
+ * All thread tools
+ */
+export declare const threadTools: (ThreadCreateTool | ThreadCreateStartTool | ThreadCreateBackgroundTool | ThreadListTool | ThreadGetTool | ThreadStartTool | ThreadUpdateTool | ThreadDeleteTool | ThreadGetMessagesTool | ThreadUpdateStatusTool)[];

package/dist/tools/thread/index.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Thread tools - Tools for thread management
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.threadTools = exports.ThreadUpdateStatusTool = exports.ThreadGetMessagesTool = exports.ThreadDeleteTool = exports.ThreadUpdateTool = exports.ThreadStartTool = exports.ThreadGetTool = exports.ThreadListTool = exports.ThreadCreateBackgroundTool = exports.ThreadCreateStartTool = exports.ThreadCreateTool = void 0;
+var thread_create_1 = require("./thread-create");
+Object.defineProperty(exports, "ThreadCreateTool", { enumerable: true, get: function () { return thread_create_1.ThreadCreateTool; } });
+var thread_create_start_1 = require("./thread-create-start");
+Object.defineProperty(exports, "ThreadCreateStartTool", { enumerable: true, get: function () { return thread_create_start_1.ThreadCreateStartTool; } });
+var thread_create_background_1 = require("./thread-create-background");
+Object.defineProperty(exports, "ThreadCreateBackgroundTool", { enumerable: true, get: function () { return thread_create_background_1.ThreadCreateBackgroundTool; } });
+var thread_list_1 = require("./thread-list");
+Object.defineProperty(exports, "ThreadListTool", { enumerable: true, get: function () { return thread_list_1.ThreadListTool; } });
+var thread_get_1 = require("./thread-get");
+Object.defineProperty(exports, "ThreadGetTool", { enumerable: true, get: function () { return thread_get_1.ThreadGetTool; } });
+var thread_start_1 = require("./thread-start");
+Object.defineProperty(exports, "ThreadStartTool", { enumerable: true, get: function () { return thread_start_1.ThreadStartTool; } });
+var thread_update_1 = require("./thread-update");
+Object.defineProperty(exports, "ThreadUpdateTool", { enumerable: true, get: function () { return thread_update_1.ThreadUpdateTool; } });
+var thread_delete_1 = require("./thread-delete");
+Object.defineProperty(exports, "ThreadDeleteTool", { enumerable: true, get: function () { return thread_delete_1.ThreadDeleteTool; } });
+var thread_get_messages_1 = require("./thread-get-messages");
+Object.defineProperty(exports, "ThreadGetMessagesTool", { enumerable: true, get: function () { return thread_get_messages_1.ThreadGetMessagesTool; } });
+var thread_update_status_1 = require("./thread-update-status");
+Object.defineProperty(exports, "ThreadUpdateStatusTool", { enumerable: true, get: function () { return thread_update_status_1.ThreadUpdateStatusTool; } });
+const thread_create_2 = require("./thread-create");
+const thread_create_start_2 = require("./thread-create-start");
+const thread_create_background_2 = require("./thread-create-background");
+const thread_list_2 = require("./thread-list");
+const thread_get_2 = require("./thread-get");
+const thread_start_2 = require("./thread-start");
+const thread_update_2 = require("./thread-update");
+const thread_delete_2 = require("./thread-delete");
+const thread_get_messages_2 = require("./thread-get-messages");
+const thread_update_status_2 = require("./thread-update-status");
+/**
+ * All thread tools
+ */
+exports.threadTools = [
+    new thread_create_2.ThreadCreateTool(),
+    new thread_create_start_2.ThreadCreateStartTool(),
+    new thread_create_background_2.ThreadCreateBackgroundTool(),
+    new thread_list_2.ThreadListTool(),
+    new thread_get_2.ThreadGetTool(),
+    new thread_start_2.ThreadStartTool(),
+    new thread_update_2.ThreadUpdateTool(),
+    new thread_delete_2.ThreadDeleteTool(),
+    new thread_get_messages_2.ThreadGetMessagesTool(),
+    new thread_update_status_2.ThreadUpdateStatusTool(),
+];

package/dist/tools/thread/thread-create-background.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Thread Create Background Tool - Creates a thread in the background
+ * Wraps the SDK's threadService.createThreadInBackground() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface ThreadCreateBackgroundParams {
+    /** Thread creation options */
+    options: Record<string, any>;
+    /** Optional group ID for the thread */
+    groupId?: string;
+}
+export declare class ThreadCreateBackgroundTool extends BaseDeclarativeTool<ThreadCreateBackgroundParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: ThreadCreateBackgroundParams): string | null;
+    protected createInvocation(params: ThreadCreateBackgroundParams): ToolInvocation<ThreadCreateBackgroundParams, ToolResult>;
+}

package/dist/tools/thread/thread-create-background.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * Thread Create Background Tool - Creates a thread in the background
+ * Wraps the SDK's threadService.createThreadInBackground() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadCreateBackgroundTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const thread_1 = __importDefault(require("../../modules/thread"));
+class ThreadCreateBackgroundInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            // Include groupId in options if provided
+            const optionsWithGroup = {
+                ...this.params.options,
+                groupId: this.params.groupId,
+            };
+            const response = await thread_1.default.createThreadInBackground(optionsWithGroup);
+            if (response && !response.success && response.success !== undefined) {
+                const errorMsg = typeof response.error === 'string'
+                    ? response.error
+                    : ((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Thread creation in background failed';
+                return {
+                    llmContent: `Thread creation in background failed: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const resp = response;
+            let output = 'Created thread in background successfully';
+            if (resp.threadId) {
+                output += `\n\nThread ID: ${resp.threadId}`;
+            }
+            if (this.params.groupId) {
+                output += `\nGroup ID: ${this.params.groupId}`;
+            }
+            return {
+                llmContent: output,
+                returnDisplay: 'Thread created in background successfully',
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error creating thread in background: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+class ThreadCreateBackgroundTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(ThreadCreateBackgroundTool.Name, 'ThreadCreateBackground', 'Creates a thread in the background and resolves when the agent starts or fails.', types_1.Kind.Execute, {
+            properties: {
+                options: {
+                    description: 'Thread creation options object containing thread parameters.',
+                    type: 'object',
+                },
+                groupId: {
+                    description: 'Optional group ID for organizing threads.',
+                    type: 'string',
+                },
+            },
+            required: ['options'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.options || typeof params.options !== 'object') {
+            return "'options' is required and must be an object";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new ThreadCreateBackgroundInvocation(params);
+    }
+}
+exports.ThreadCreateBackgroundTool = ThreadCreateBackgroundTool;
+ThreadCreateBackgroundTool.Name = 'thread_create_background';

package/dist/tools/thread/thread-create-start.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Thread Create Start Tool - Creates and immediately starts a new thread
+ * Wraps the SDK's threadService.createAndStartThread() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface ThreadCreateStartParams {
+    /** Thread creation and start options */
+    options: Record<string, any>;
+}
+export declare class ThreadCreateStartTool extends BaseDeclarativeTool<ThreadCreateStartParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: ThreadCreateStartParams): string | null;
+    protected createInvocation(params: ThreadCreateStartParams): ToolInvocation<ThreadCreateStartParams, ToolResult>;
+}

package/dist/tools/thread/thread-create-start.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Thread Create Start Tool - Creates and immediately starts a new thread
+ * Wraps the SDK's threadService.createAndStartThread() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadCreateStartTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const thread_1 = __importDefault(require("../../modules/thread"));
+class ThreadCreateStartInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            const response = await thread_1.default.createAndStartThread(this.params.options);
+            if (response && !response.success && response.success !== undefined) {
+                const errorMsg = typeof response.error === 'string'
+                    ? response.error
+                    : ((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Thread creation and start failed';
+                return {
+                    llmContent: `Thread creation and start failed: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const resp = response;
+            let output = 'Created and started thread successfully';
+            if (resp.threadId) {
+                output += `\n\nThread ID: ${resp.threadId}`;
+            }
+            if (resp.thread) {
+                output += `\n\nThread: ${JSON.stringify(resp.thread, null, 2)}`;
+            }
+            return {
+                llmContent: output,
+                returnDisplay: 'Thread created and started successfully',
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error creating and starting thread: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+class ThreadCreateStartTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(ThreadCreateStartTool.Name, 'ThreadCreateStart', 'Creates and immediately starts a new thread with the specified options.', types_1.Kind.Execute, {
+            properties: {
+                options: {
+                    description: 'Thread creation and start options object containing thread parameters.',
+                    type: 'object',
+                },
+            },
+            required: ['options'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.options || typeof params.options !== 'object') {
+            return "'options' is required and must be an object";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new ThreadCreateStartInvocation(params);
+    }
+}
+exports.ThreadCreateStartTool = ThreadCreateStartTool;
+ThreadCreateStartTool.Name = 'thread_create_start';

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

@@ -0,0 +1,16 @@
+/**
+ * Thread Create Tool - Creates a new thread
+ * Wraps the SDK's threadService.createThread() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface ThreadCreateParams {
+    /** Thread creation options */
+    options: Record<string, any>;
+}
+export declare class ThreadCreateTool extends BaseDeclarativeTool<ThreadCreateParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: ThreadCreateParams): string | null;
+    protected createInvocation(params: ThreadCreateParams): ToolInvocation<ThreadCreateParams, ToolResult>;
+}

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

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Thread Create Tool - Creates a new thread
+ * Wraps the SDK's threadService.createThread() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThreadCreateTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const thread_1 = __importDefault(require("../../modules/thread"));
+class ThreadCreateInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            const response = await thread_1.default.createThread(this.params.options);
+            if (response && !response.success && response.success !== undefined) {
+                const errorMsg = typeof response.error === 'string'
+                    ? response.error
+                    : ((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Thread creation failed';
+                return {
+                    llmContent: `Thread creation failed: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            const resp = response;
+            let output = 'Created thread successfully';
+            if (resp.threadId) {
+                output += `\n\nThread ID: ${resp.threadId}`;
+            }
+            if (resp.thread) {
+                output += `\n\nThread: ${JSON.stringify(resp.thread, null, 2)}`;
+            }
+            return {
+                llmContent: output,
+                returnDisplay: 'Thread created successfully',
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error creating thread: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+class ThreadCreateTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(ThreadCreateTool.Name, 'ThreadCreate', 'Creates a new thread with the specified options.', types_1.Kind.Edit, {
+            properties: {
+                options: {
+                    description: 'Thread creation options object containing thread parameters.',
+                    type: 'object',
+                },
+            },
+            required: ['options'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.options || typeof params.options !== 'object') {
+            return "'options' is required and must be an object";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new ThreadCreateInvocation(params);
+    }
+}
+exports.ThreadCreateTool = ThreadCreateTool;
+ThreadCreateTool.Name = 'thread_create';

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

@@ -0,0 +1,16 @@
+/**
+ * Thread Delete Tool - Deletes a thread
+ * Wraps the SDK's threadService.deleteThread() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface ThreadDeleteParams {
+    /** The thread ID to delete */
+    threadId: string;
+}
+export declare class ThreadDeleteTool extends BaseDeclarativeTool<ThreadDeleteParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: ThreadDeleteParams): string | null;
+    protected createInvocation(params: ThreadDeleteParams): ToolInvocation<ThreadDeleteParams, ToolResult>;
+}