@codebolt/codeboltjs 5.0.8 → 5.0.9

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

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

@@ -1,85 +0,0 @@
-"use strict";
-/**
- * Thread List Tool - Retrieves a list of threads
- * Wraps the SDK's threadService.getThreadList() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ThreadListTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const thread_1 = __importDefault(require("../../modules/thread"));
-class ThreadListInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        var _a, _b;
-        try {
-            const response = await thread_1.default.getThreadList(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) || 'Failed to retrieve thread list';
-                return {
-                    llmContent: `Failed to retrieve thread list: ${errorMsg}`,
-                    returnDisplay: `Error: ${errorMsg}`,
-                    error: {
-                        message: errorMsg,
-                        type: types_1.ToolErrorType.EXECUTION_FAILED,
-                    },
-                };
-            }
-            const resp = response;
-            let output = 'Thread list retrieved successfully';
-            if (resp.threads) {
-                output += `\n\nThreads (${resp.threads.length}):\n${JSON.stringify(resp.threads, null, 2)}`;
-            }
-            else {
-                output += `\n\nResponse: ${JSON.stringify(resp, null, 2)}`;
-            }
-            return {
-                llmContent: output,
-                returnDisplay: `Retrieved ${((_b = resp.threads) === null || _b === void 0 ? void 0 : _b.length) || 0} threads`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error retrieving thread list: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-class ThreadListTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(ThreadListTool.Name, 'ThreadList', 'Retrieves a list of threads with optional filtering.', types_1.Kind.Read, {
-            properties: {
-                options: {
-                    description: 'Optional filtering options for the thread list.',
-                    type: 'object',
-                },
-            },
-            required: [],
-            type: 'object',
-        });
-    }
-    validateToolParamValues(params) {
-        if (params.options !== undefined && typeof params.options !== 'object') {
-            return "'options' must be an object if provided";
-        }
-        return null;
-    }
-    createInvocation(params) {
-        return new ThreadListInvocation(params);
-    }
-}
-exports.ThreadListTool = ThreadListTool;
-ThreadListTool.Name = 'thread_list';

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

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

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

@@ -1,82 +0,0 @@
-"use strict";
-/**
- * Thread Start Tool - Starts a thread
- * Wraps the SDK's threadService.startThread() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ThreadStartTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const thread_1 = __importDefault(require("../../modules/thread"));
-class ThreadStartInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        var _a;
-        try {
-            const response = await thread_1.default.startThread(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 start failed';
-                return {
-                    llmContent: `Thread start failed: ${errorMsg}`,
-                    returnDisplay: `Error: ${errorMsg}`,
-                    error: {
-                        message: errorMsg,
-                        type: types_1.ToolErrorType.EXECUTION_FAILED,
-                    },
-                };
-            }
-            const resp = response;
-            let output = `Started thread: ${this.params.threadId}`;
-            if (resp.thread) {
-                output += `\n\nThread: ${JSON.stringify(resp.thread, null, 2)}`;
-            }
-            return {
-                llmContent: output,
-                returnDisplay: `Started thread: ${this.params.threadId}`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error starting thread: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-class ThreadStartTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(ThreadStartTool.Name, 'ThreadStart', 'Starts a thread by its ID.', types_1.Kind.Execute, {
-            properties: {
-                threadId: {
-                    description: 'The ID of the thread to start.',
-                    type: 'string',
-                },
-            },
-            required: ['threadId'],
-            type: 'object',
-        });
-    }
-    validateToolParamValues(params) {
-        if (!params.threadId || params.threadId.trim() === '') {
-            return "'threadId' is required";
-        }
-        return null;
-    }
-    createInvocation(params) {
-        return new ThreadStartInvocation(params);
-    }
-}
-exports.ThreadStartTool = ThreadStartTool;
-ThreadStartTool.Name = 'thread_start';

package/dist/tools/orchestration/thread-update-status.d.ts

@@ -1,18 +0,0 @@
-/**
- * Thread Update Status Tool - Updates the status of a thread
- * Wraps the SDK's threadService.updateThreadStatus() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-export interface ThreadUpdateStatusParams {
-    /** The thread ID to update status for */
-    threadId: string;
-    /** The new status for the thread */
-    status: string;
-}
-export declare class ThreadUpdateStatusTool extends BaseDeclarativeTool<ThreadUpdateStatusParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected validateToolParamValues(params: ThreadUpdateStatusParams): string | null;
-    protected createInvocation(params: ThreadUpdateStatusParams): ToolInvocation<ThreadUpdateStatusParams, ToolResult>;
-}

package/dist/tools/orchestration/thread-update-status.js

@@ -1,89 +0,0 @@
-"use strict";
-/**
- * Thread Update Status Tool - Updates the status of a thread
- * Wraps the SDK's threadService.updateThreadStatus() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ThreadUpdateStatusTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const thread_1 = __importDefault(require("../../modules/thread"));
-class ThreadUpdateStatusInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        var _a;
-        try {
-            const response = await thread_1.default.updateThreadStatus(this.params.threadId, this.params.status);
-            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 status update failed';
-                return {
-                    llmContent: `Thread status update failed: ${errorMsg}`,
-                    returnDisplay: `Error: ${errorMsg}`,
-                    error: {
-                        message: errorMsg,
-                        type: types_1.ToolErrorType.EXECUTION_FAILED,
-                    },
-                };
-            }
-            const resp = response;
-            let output = `Updated thread status: ${this.params.threadId} -> ${this.params.status}`;
-            if (resp.thread) {
-                output += `\n\nThread: ${JSON.stringify(resp.thread, null, 2)}`;
-            }
-            return {
-                llmContent: output,
-                returnDisplay: `Updated status to: ${this.params.status}`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error updating thread status: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-class ThreadUpdateStatusTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(ThreadUpdateStatusTool.Name, 'ThreadUpdateStatus', 'Updates the status of a thread.', types_1.Kind.Edit, {
-            properties: {
-                threadId: {
-                    description: 'The ID of the thread to update status for.',
-                    type: 'string',
-                },
-                status: {
-                    description: 'The new status for the thread.',
-                    type: 'string',
-                },
-            },
-            required: ['threadId', 'status'],
-            type: 'object',
-        });
-    }
-    validateToolParamValues(params) {
-        if (!params.threadId || params.threadId.trim() === '') {
-            return "'threadId' is required";
-        }
-        if (!params.status || params.status.trim() === '') {
-            return "'status' is required";
-        }
-        return null;
-    }
-    createInvocation(params) {
-        return new ThreadUpdateStatusInvocation(params);
-    }
-}
-exports.ThreadUpdateStatusTool = ThreadUpdateStatusTool;
-ThreadUpdateStatusTool.Name = 'thread_update_status';

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

@@ -1,18 +0,0 @@
-/**
- * Thread Update Tool - Updates an existing thread
- * Wraps the SDK's threadService.updateThread() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-export interface ThreadUpdateParams {
-    /** The thread ID to update */
-    threadId: string;
-    /** The updates to apply to the thread */
-    updates: Record<string, any>;
-}
-export declare class ThreadUpdateTool extends BaseDeclarativeTool<ThreadUpdateParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected validateToolParamValues(params: ThreadUpdateParams): string | null;
-    protected createInvocation(params: ThreadUpdateParams): ToolInvocation<ThreadUpdateParams, ToolResult>;
-}