@codebolt/codeboltjs 5.0.2 → 5.0.4

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

@@ -0,0 +1,16 @@
+/**
+ * Task Get Tool - Gets details of a specific task
+ * Wraps the SDK's taskService.getTaskDetail() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface TaskGetParams {
+    /** The task ID to get details for */
+    task_id: string;
+}
+export declare class TaskGetTool extends BaseDeclarativeTool<TaskGetParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: TaskGetParams): string | null;
+    protected createInvocation(params: TaskGetParams): ToolInvocation<TaskGetParams, ToolResult>;
+}

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

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Task Get Tool - Gets details of a specific task
+ * Wraps the SDK's taskService.getTaskDetail() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskGetTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const task_1 = __importDefault(require("../../modules/task"));
+class TaskGetInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            const response = await task_1.default.getTaskDetail({ taskId: this.params.task_id });
+            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 retrieval failed';
+                return {
+                    llmContent: `Task retrieval failed: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.TASK_NOT_FOUND,
+                    },
+                };
+            }
+            let output = `Retrieved task: ${this.params.task_id}`;
+            const resp = response;
+            if (resp.task) {
+                const task = resp.task;
+                output += `\n\nTask Details:\n`;
+                output += `ID: ${task.id}\n`;
+                output += `Title: ${task.title || task.name || 'N/A'}\n`;
+                output += `Description: ${task.description || 'N/A'}\n`;
+                output += `Status: ${task.status || 'pending'}\n`;
+                if (task.assignedTo)
+                    output += `Assigned To: ${task.assignedTo}\n`;
+            }
+            return {
+                llmContent: output,
+                returnDisplay: `Retrieved task: ${this.params.task_id}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error getting task: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+class TaskGetTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(TaskGetTool.Name, 'TaskGet', 'Retrieves details of a specific task.', types_1.Kind.Read, {
+            properties: {
+                task_id: {
+                    description: 'The ID of the task to retrieve.',
+                    type: 'string',
+                },
+            },
+            required: ['task_id'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.task_id || params.task_id.trim() === '') {
+            return "'task_id' is required for task get";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new TaskGetInvocation(params);
+    }
+}
+exports.TaskGetTool = TaskGetTool;
+TaskGetTool.Name = 'task_get';

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

@@ -0,0 +1,13 @@
+/**
+ * Task List Tool - Lists all tasks
+ * Wraps the SDK's taskService.getTaskList() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface TaskListParams {
+}
+export declare class TaskListTool extends BaseDeclarativeTool<TaskListParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: TaskListParams): ToolInvocation<TaskListParams, ToolResult>;
+}

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

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Task List Tool - Lists all tasks
+ * Wraps the SDK's taskService.getTaskList() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskListTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const task_1 = __importDefault(require("../../modules/task"));
+class TaskListInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            const response = await task_1.default.getTaskList({});
+            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 list retrieval failed';
+                return {
+                    llmContent: `Task list retrieval failed: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.EXECUTION_FAILED,
+                    },
+                };
+            }
+            let output = 'Retrieved task list';
+            const resp = response;
+            if (resp.tasks) {
+                output += `\n\nTasks (${resp.tasks.length}):\n`;
+                for (const task of resp.tasks) {
+                    output += `- [${task.status || 'pending'}] ${task.title || task.name || task.id}: ${task.description || ''}\n`;
+                }
+            }
+            return {
+                llmContent: output,
+                returnDisplay: 'Retrieved task list',
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error listing tasks: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+class TaskListTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(TaskListTool.Name, 'TaskList', 'Retrieves a list of all tasks.', types_1.Kind.Read, {
+            properties: {},
+            required: [],
+            type: 'object',
+        });
+    }
+    createInvocation(params) {
+        return new TaskListInvocation(params);
+    }
+}
+exports.TaskListTool = TaskListTool;
+TaskListTool.Name = 'task_list';

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

@@ -0,0 +1,52 @@
+/**
+ * Task Management Tool - Manages tasks
+ * Wraps the SDK's taskService methods
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Supported task actions
+ */
+export type TaskActionType = 'create' | 'update' | 'delete' | 'list' | 'get' | 'assign_agent' | 'execute';
+/**
+ * Parameters for the TaskManagement tool
+ */
+export interface TaskManagementToolParams {
+    /**
+     * The task action to perform
+     */
+    action: TaskActionType;
+    /**
+     * Task ID (required for update, delete, get, assign_agent, execute)
+     */
+    task_id?: string;
+    /**
+     * Task title (for create)
+     */
+    title?: string;
+    /**
+     * Task description (for create/update)
+     */
+    description?: string;
+    /**
+     * Task status (for update)
+     */
+    status?: string;
+    /**
+     * Agent ID (for assign_agent/execute)
+     */
+    agent_id?: string;
+    /**
+     * Thread ID (for create)
+     */
+    thread_id?: string;
+}
+/**
+ * Implementation of the TaskManagement tool logic
+ */
+export declare class TaskManagementTool extends BaseDeclarativeTool<TaskManagementToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: TaskManagementToolParams): string | null;
+    protected createInvocation(params: TaskManagementToolParams): ToolInvocation<TaskManagementToolParams, ToolResult>;
+}

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

@@ -0,0 +1,231 @@
+"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

@@ -0,0 +1,22 @@
+/**
+ * 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

@@ -0,0 +1,96 @@
+"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

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