@codebolt/codeboltjs 5.0.8 → 5.0.9

package/dist/tools/orchestration/task-management.js

@@ -1,231 +0,0 @@
-"use strict";
-/**
- * Task Management Tool - Manages tasks
- * Wraps the SDK's taskService methods
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskManagementTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const task_1 = __importDefault(require("../../modules/task"));
-class TaskManagementToolInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        var _a;
-        try {
-            const action = this.params.action;
-            let response;
-            let successMessage;
-            switch (action) {
-                case 'create':
-                    if (!this.params.title) {
-                        return this.createError("'title' is required for create action");
-                    }
-                    // CreateTaskOptions expects 'name' not 'title'
-                    response = await task_1.default.createTask({
-                        name: this.params.title,
-                        description: this.params.description,
-                        threadId: this.params.thread_id || '',
-                    });
-                    successMessage = `Created task: ${this.params.title}`;
-                    break;
-                case 'update':
-                    if (!this.params.task_id) {
-                        return this.createError("'task_id' is required for update action");
-                    }
-                    // UpdateTaskOptions uses 'name' and 'completed'
-                    response = await task_1.default.updateTask(this.params.task_id, {
-                        name: this.params.description,
-                        completed: this.params.status === 'completed',
-                    });
-                    successMessage = `Updated task: ${this.params.task_id}`;
-                    break;
-                case 'delete':
-                    if (!this.params.task_id) {
-                        return this.createError("'task_id' is required for delete action");
-                    }
-                    response = await task_1.default.deleteTask(this.params.task_id);
-                    successMessage = `Deleted task: ${this.params.task_id}`;
-                    break;
-                case 'list':
-                    response = await task_1.default.getTaskList({});
-                    successMessage = 'Retrieved task list';
-                    break;
-                case 'get':
-                    if (!this.params.task_id) {
-                        return this.createError("'task_id' is required for get action");
-                    }
-                    response = await task_1.default.getTaskDetail({ taskId: this.params.task_id });
-                    successMessage = `Retrieved task: ${this.params.task_id}`;
-                    break;
-                case 'assign_agent':
-                    if (!this.params.task_id) {
-                        return this.createError("'task_id' is required for assign_agent action");
-                    }
-                    if (!this.params.agent_id) {
-                        return this.createError("'agent_id' is required for assign_agent action");
-                    }
-                    response = await task_1.default.assignAgentToTask(this.params.task_id, this.params.agent_id);
-                    successMessage = `Assigned agent ${this.params.agent_id} to task ${this.params.task_id}`;
-                    break;
-                case 'execute':
-                    if (!this.params.task_id) {
-                        return this.createError("'task_id' is required for execute action");
-                    }
-                    if (!this.params.agent_id) {
-                        return this.createError("'agent_id' is required for execute action");
-                    }
-                    response = await task_1.default.executeTaskWithAgent(this.params.task_id, this.params.agent_id);
-                    successMessage = `Executing task ${this.params.task_id} with agent ${this.params.agent_id}`;
-                    break;
-                default:
-                    return this.createError(`Unknown action: ${action}`);
-            }
-            // Check for errors
-            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) || 'Task operation failed';
-                return {
-                    llmContent: `Task ${action} failed: ${errorMsg}`,
-                    returnDisplay: `Error: ${errorMsg}`,
-                    error: {
-                        message: errorMsg,
-                        type: types_1.ToolErrorType.TASK_NOT_FOUND,
-                    },
-                };
-            }
-            // Format output
-            let output = successMessage;
-            if (action === 'list' && response.tasks) {
-                output += `\n\nTasks (${response.tasks.length}):\n`;
-                for (const task of response.tasks) {
-                    output += `- [${task.status || 'pending'}] ${task.title || task.id}: ${task.description || ''}\n`;
-                }
-            }
-            else if (action === 'get' && response.task) {
-                const task = response.task;
-                output += `\n\nTask Details:\n`;
-                output += `ID: ${task.id}\n`;
-                output += `Title: ${task.title}\n`;
-                output += `Description: ${task.description || 'N/A'}\n`;
-                output += `Status: ${task.status || 'pending'}\n`;
-                if (task.assignedTo)
-                    output += `Assigned To: ${task.assignedTo}\n`;
-            }
-            else if (response.task) {
-                output += `\n\nTask ID: ${response.task.id || response.taskId}`;
-            }
-            else if (response.taskId) {
-                output += `\n\nTask ID: ${response.taskId}`;
-            }
-            return {
-                llmContent: output,
-                returnDisplay: successMessage,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error executing task ${this.params.action}: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-    createError(message) {
-        return {
-            llmContent: `Error: ${message}`,
-            returnDisplay: `Error: ${message}`,
-            error: {
-                message,
-                type: types_1.ToolErrorType.INVALID_TOOL_PARAMS,
-            },
-        };
-    }
-}
-/**
- * Implementation of the TaskManagement tool logic
- */
-class TaskManagementTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(TaskManagementTool.Name, 'TaskManagement', `Manages tasks - create, update, delete, list, get, assign agents, and execute tasks. Use this for task scheduling and workflow management.`, types_1.Kind.Other, {
-            properties: {
-                action: {
-                    description: "The task action: 'create', 'update', 'delete', 'list', 'get', 'assign_agent', or 'execute'.",
-                    type: 'string',
-                    enum: ['create', 'update', 'delete', 'list', 'get', 'assign_agent', 'execute'],
-                },
-                task_id: {
-                    description: 'Task ID (required for update, delete, get, assign_agent, execute).',
-                    type: 'string',
-                },
-                title: {
-                    description: 'Task title (required for create).',
-                    type: 'string',
-                },
-                description: {
-                    description: 'Task description (for create/update).',
-                    type: 'string',
-                },
-                status: {
-                    description: 'Task status (for update).',
-                    type: 'string',
-                },
-                agent_id: {
-                    description: 'Agent ID (required for assign_agent/execute).',
-                    type: 'string',
-                },
-                thread_id: {
-                    description: 'Thread ID (for create).',
-                    type: 'string',
-                },
-            },
-            required: ['action'],
-            type: 'object',
-        });
-    }
-    validateToolParamValues(params) {
-        const validActions = ['create', 'update', 'delete', 'list', 'get', 'assign_agent', 'execute'];
-        if (!validActions.includes(params.action)) {
-            return `Invalid action: ${params.action}. Must be one of: ${validActions.join(', ')}`;
-        }
-        switch (params.action) {
-            case 'create':
-                if (!params.title) {
-                    return "'title' is required for create action";
-                }
-                break;
-            case 'update':
-            case 'delete':
-            case 'get':
-                if (!params.task_id) {
-                    return `'task_id' is required for ${params.action} action`;
-                }
-                break;
-            case 'assign_agent':
-            case 'execute':
-                if (!params.task_id) {
-                    return `'task_id' is required for ${params.action} action`;
-                }
-                if (!params.agent_id) {
-                    return `'agent_id' is required for ${params.action} action`;
-                }
-                break;
-        }
-        return null;
-    }
-    createInvocation(params) {
-        return new TaskManagementToolInvocation(params);
-    }
-}
-exports.TaskManagementTool = TaskManagementTool;
-TaskManagementTool.Name = 'create_task';

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

@@ -1,22 +0,0 @@
-/**
- * Task Update Tool - Updates an existing task
- * Wraps the SDK's taskService.updateTask() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-export interface TaskUpdateParams {
-    /** The task ID to update */
-    task_id: string;
-    /** New name for the task */
-    name?: string;
-    /** Whether the task is completed */
-    completed?: boolean;
-    /** Task status */
-    status?: string;
-}
-export declare class TaskUpdateTool extends BaseDeclarativeTool<TaskUpdateParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected validateToolParamValues(params: TaskUpdateParams): string | null;
-    protected createInvocation(params: TaskUpdateParams): ToolInvocation<TaskUpdateParams, ToolResult>;
-}

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

@@ -1,96 +0,0 @@
-"use strict";
-/**
- * Task Update Tool - Updates an existing task
- * Wraps the SDK's taskService.updateTask() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskUpdateTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const task_1 = __importDefault(require("../../modules/task"));
-class TaskUpdateInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        var _a;
-        try {
-            const updates = {};
-            if (this.params.name !== undefined)
-                updates.name = this.params.name;
-            if (this.params.completed !== undefined)
-                updates.completed = this.params.completed;
-            if (this.params.status !== undefined)
-                updates.completed = this.params.status === 'completed';
-            const response = await task_1.default.updateTask(this.params.task_id, 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) || 'Task update failed';
-                return {
-                    llmContent: `Task update failed: ${errorMsg}`,
-                    returnDisplay: `Error: ${errorMsg}`,
-                    error: {
-                        message: errorMsg,
-                        type: types_1.ToolErrorType.TASK_NOT_FOUND,
-                    },
-                };
-            }
-            return {
-                llmContent: `Updated task: ${this.params.task_id}`,
-                returnDisplay: `Updated task: ${this.params.task_id}`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error updating task: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-class TaskUpdateTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(TaskUpdateTool.Name, 'TaskUpdate', 'Updates an existing task.', types_1.Kind.Other, {
-            properties: {
-                task_id: {
-                    description: 'The ID of the task to update.',
-                    type: 'string',
-                },
-                name: {
-                    description: 'New name for the task.',
-                    type: 'string',
-                },
-                completed: {
-                    description: 'Whether the task is completed.',
-                    type: 'boolean',
-                },
-                status: {
-                    description: "Task status (e.g., 'completed', 'pending').",
-                    type: 'string',
-                },
-            },
-            required: ['task_id'],
-            type: 'object',
-        });
-    }
-    validateToolParamValues(params) {
-        if (!params.task_id || params.task_id.trim() === '') {
-            return "'task_id' is required for task update";
-        }
-        return null;
-    }
-    createInvocation(params) {
-        return new TaskUpdateInvocation(params);
-    }
-}
-exports.TaskUpdateTool = TaskUpdateTool;
-TaskUpdateTool.Name = 'task_update';

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

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