@codebolt/codeboltjs 5.0.7 → 5.0.9

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

@@ -1,94 +0,0 @@
-"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/orchestration/thread-create-start.d.ts

@@ -1,16 +0,0 @@
-/**
- * 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/orchestration/thread-create-start.js

@@ -1,85 +0,0 @@
-"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/orchestration/thread-create.d.ts

@@ -1,16 +0,0 @@
-/**
- * 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/orchestration/thread-create.js

@@ -1,85 +0,0 @@
-"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/orchestration/thread-delete.d.ts

@@ -1,16 +0,0 @@
-/**
- * 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>;
-}

package/dist/tools/orchestration/thread-delete.js

@@ -1,77 +0,0 @@
-"use strict";
-/**
- * Thread Delete Tool - Deletes a thread
- * Wraps the SDK's threadService.deleteThread() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ThreadDeleteTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const thread_1 = __importDefault(require("../../modules/thread"));
-class ThreadDeleteInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        var _a;
-        try {
-            const response = await thread_1.default.deleteThread(this.params.threadId);
-            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 deletion failed';
-                return {
-                    llmContent: `Thread deletion failed: ${errorMsg}`,
-                    returnDisplay: `Error: ${errorMsg}`,
-                    error: {
-                        message: errorMsg,
-                        type: types_1.ToolErrorType.EXECUTION_FAILED,
-                    },
-                };
-            }
-            return {
-                llmContent: `Deleted thread: ${this.params.threadId}`,
-                returnDisplay: `Deleted thread: ${this.params.threadId}`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error deleting thread: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-class ThreadDeleteTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(ThreadDeleteTool.Name, 'ThreadDelete', 'Deletes a thread by its ID.', types_1.Kind.Delete, {
-            properties: {
-                threadId: {
-                    description: 'The ID of the thread to delete.',
-                    type: 'string',
-                },
-            },
-            required: ['threadId'],
-            type: 'object',
-        });
-    }
-    validateToolParamValues(params) {
-        if (!params.threadId || params.threadId.trim() === '') {
-            return "'threadId' is required";
-        }
-        return null;
-    }
-    createInvocation(params) {
-        return new ThreadDeleteInvocation(params);
-    }
-}
-exports.ThreadDeleteTool = ThreadDeleteTool;
-ThreadDeleteTool.Name = 'thread_delete';

package/dist/tools/orchestration/thread-get-messages.d.ts

@@ -1,24 +0,0 @@
-/**
- * Thread Get Messages Tool - Retrieves messages for a specific thread
- * Wraps the SDK's threadService.getThreadMessages() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-export interface ThreadGetMessagesParams {
-    /** The thread ID to get messages for */
-    threadId: string;
-    /** Optional limit on number of messages */
-    limit?: number;
-    /** Optional offset for pagination */
-    offset?: number;
-    /** Optional: include only messages before this timestamp */
-    before?: string;
-    /** Optional: include only messages after this timestamp */
-    after?: string;
-}
-export declare class ThreadGetMessagesTool extends BaseDeclarativeTool<ThreadGetMessagesParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected validateToolParamValues(params: ThreadGetMessagesParams): string | null;
-    protected createInvocation(params: ThreadGetMessagesParams): ToolInvocation<ThreadGetMessagesParams, ToolResult>;
-}

package/dist/tools/orchestration/thread-get-messages.js

@@ -1,122 +0,0 @@
-"use strict";
-/**
- * Thread Get Messages Tool - Retrieves messages for a specific thread
- * Wraps the SDK's threadService.getThreadMessages() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ThreadGetMessagesTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const thread_1 = __importDefault(require("../../modules/thread"));
-class ThreadGetMessagesInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        var _a, _b;
-        try {
-            const options = {
-                taskId: this.params.threadId,
-            };
-            if (this.params.limit !== undefined) {
-                options.limit = this.params.limit;
-            }
-            if (this.params.offset !== undefined) {
-                options.offset = this.params.offset;
-            }
-            if (this.params.before !== undefined) {
-                options.before = this.params.before;
-            }
-            if (this.params.after !== undefined) {
-                options.after = this.params.after;
-            }
-            const response = await thread_1.default.getThreadMessages(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) || 'Failed to retrieve thread messages';
-                return {
-                    llmContent: `Failed to retrieve thread messages: ${errorMsg}`,
-                    returnDisplay: `Error: ${errorMsg}`,
-                    error: {
-                        message: errorMsg,
-                        type: types_1.ToolErrorType.EXECUTION_FAILED,
-                    },
-                };
-            }
-            const resp = response;
-            let output = `Messages for thread: ${this.params.threadId}`;
-            if (resp.messages) {
-                output += `\n\nMessages (${resp.messages.length}):\n${JSON.stringify(resp.messages, null, 2)}`;
-            }
-            else {
-                output += `\n\nResponse: ${JSON.stringify(resp, null, 2)}`;
-            }
-            return {
-                llmContent: output,
-                returnDisplay: `Retrieved ${((_b = resp.messages) === null || _b === void 0 ? void 0 : _b.length) || 0} messages`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error retrieving thread messages: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-class ThreadGetMessagesTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(ThreadGetMessagesTool.Name, 'ThreadGetMessages', 'Retrieves messages for a specific thread with optional pagination.', types_1.Kind.Read, {
-            properties: {
-                threadId: {
-                    description: 'The ID of the thread to get messages for.',
-                    type: 'string',
-                },
-                limit: {
-                    description: 'Optional limit on number of messages to retrieve.',
-                    type: 'number',
-                },
-                offset: {
-                    description: 'Optional offset for pagination.',
-                    type: 'number',
-                },
-                before: {
-                    description: 'Optional: include only messages before this timestamp.',
-                    type: 'string',
-                },
-                after: {
-                    description: 'Optional: include only messages after this timestamp.',
-                    type: 'string',
-                },
-            },
-            required: ['threadId'],
-            type: 'object',
-        });
-    }
-    validateToolParamValues(params) {
-        if (!params.threadId || params.threadId.trim() === '') {
-            return "'threadId' is required";
-        }
-        if (params.limit !== undefined && params.limit < 0) {
-            return "'limit' must be a non-negative number";
-        }
-        if (params.offset !== undefined && params.offset < 0) {
-            return "'offset' must be a non-negative number";
-        }
-        return null;
-    }
-    createInvocation(params) {
-        return new ThreadGetMessagesInvocation(params);
-    }
-}
-exports.ThreadGetMessagesTool = ThreadGetMessagesTool;
-ThreadGetMessagesTool.Name = 'thread_get_messages';

package/dist/tools/orchestration/thread-get.d.ts

@@ -1,16 +0,0 @@
-/**
- * Thread Get Tool - Retrieves detailed information about a specific thread
- * Wraps the SDK's threadService.getThreadDetail() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-export interface ThreadGetParams {
-    /** The thread ID to retrieve */
-    threadId: string;
-}
-export declare class ThreadGetTool extends BaseDeclarativeTool<ThreadGetParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected validateToolParamValues(params: ThreadGetParams): string | null;
-    protected createInvocation(params: ThreadGetParams): ToolInvocation<ThreadGetParams, ToolResult>;
-}

package/dist/tools/orchestration/thread-get.js

@@ -1,85 +0,0 @@
-"use strict";
-/**
- * Thread Get Tool - Retrieves detailed information about a specific thread
- * Wraps the SDK's threadService.getThreadDetail() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ThreadGetTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const thread_1 = __importDefault(require("../../modules/thread"));
-class ThreadGetInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        var _a;
-        try {
-            const response = await thread_1.default.getThreadDetail({ taskId: this.params.threadId });
-            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) || 'Failed to retrieve thread details';
-                return {
-                    llmContent: `Failed to retrieve thread details: ${errorMsg}`,
-                    returnDisplay: `Error: ${errorMsg}`,
-                    error: {
-                        message: errorMsg,
-                        type: types_1.ToolErrorType.EXECUTION_FAILED,
-                    },
-                };
-            }
-            const resp = response;
-            let output = `Thread details for: ${this.params.threadId}`;
-            if (resp.thread) {
-                output += `\n\nThread: ${JSON.stringify(resp.thread, null, 2)}`;
-            }
-            else {
-                output += `\n\nResponse: ${JSON.stringify(resp, null, 2)}`;
-            }
-            return {
-                llmContent: output,
-                returnDisplay: `Retrieved thread: ${this.params.threadId}`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error retrieving thread details: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-class ThreadGetTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(ThreadGetTool.Name, 'ThreadGet', 'Retrieves detailed information about a specific thread.', types_1.Kind.Read, {
-            properties: {
-                threadId: {
-                    description: 'The ID of the thread to retrieve.',
-                    type: 'string',
-                },
-            },
-            required: ['threadId'],
-            type: 'object',
-        });
-    }
-    validateToolParamValues(params) {
-        if (!params.threadId || params.threadId.trim() === '') {
-            return "'threadId' is required";
-        }
-        return null;
-    }
-    createInvocation(params) {
-        return new ThreadGetInvocation(params);
-    }
-}
-exports.ThreadGetTool = ThreadGetTool;
-ThreadGetTool.Name = 'thread_get';

package/dist/tools/orchestration/thread-list.d.ts

@@ -1,16 +0,0 @@
-/**
- * Thread List Tool - Retrieves a list of threads
- * Wraps the SDK's threadService.getThreadList() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-export interface ThreadListParams {
-    /** Optional filtering options */
-    options?: Record<string, any>;
-}
-export declare class ThreadListTool extends BaseDeclarativeTool<ThreadListParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected validateToolParamValues(params: ThreadListParams): string | null;
-    protected createInvocation(params: ThreadListParams): ToolInvocation<ThreadListParams, ToolResult>;
-}