@codebolt/codeboltjs 5.0.7 → 5.0.9

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

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

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