@codebolt/codeboltjs 2.2.1 → 2.2.2

package/dist/modules/task.js

@@ -1,292 +1,560 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const websocket_1 = __importDefault(require("../core/websocket"));
+// Import new task service types from common/types package
+// import type {
+//     // Task event schemas
+// } from '@codebolt/types';
+// // Import response types
+// import type {
+//     TaskResponse,
+//     TaskListResponse,
+//     StepResponse,
+//     StepListResponse,
+//     TaskMessagesResponse,
+//     ActiveStepResponse,
+//     SendSteeringMessageResponse,
+//     DeleteTaskResponse,
+//     CanTaskStartResponse,
+//     TaskStatsResponse,
+//     CreateTaskResponse,
+//     GetTaskListResponse,
+//     AddStepToTaskResponse,
+//     GetTaskDetailResponse,
+//     GetTaskMessagesResponse,
+//     GetAllStepsResponse,
+//     GetCurrentRunningStepResponse,
+//     UpdateStepStatusResponse,
+//     CompleteStepResponse,
+//     UpdateTaskResponse,
+//     CompleteTaskResponse,
+//     GetTasksDependentOnResponse,
+//     GetTasksReadyToStartResponse,
+//     GetTaskDependencyChainResponse,
+//     GetTaskStatsResponse,
+//     Task,
+//     ExtendedTask,
+//     ExtendedStep,
+//     TaskMessage
+// } from '@codebolt/types/wstypes/app-to-agent-ws/taskServiceResponses';
 /**
- * Enhanced task planner with agent-based organization and comprehensive task management.
+ * Enhanced task service with comprehensive task and step management.
+ * This module provides a modern API for task management based on the new task service schemas.
  */
-const taskplaner = {
-    /**
-     * Adds a new task with enhanced parameters.
-     * @param {TaskCreateOptions} params - The task parameters including title, agentId, description, etc.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the add task event.
-     */
-    addTask: async (params) => {
-        const { title, agentId = 'default-agent', description, phase, category, priority, tags } = params;
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "addTask",
-            agentId: agentId,
-            message: {
-                title: title,
-                description: description,
-                phase: phase,
-                category: category,
-                priority: priority,
-                tags: tags
-            }
-        }, "addTaskResponse");
-    },
-    /**
-     * Adds a task using simple string parameter (legacy support).
-     * @param {string} task - The task title.
-     * @param {string} agentId - The agent ID (optional, defaults to 'default-agent').
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the add task event.
-     */
-    addSimpleTask: async (task, agentId = 'default-agent') => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "addTask",
-            agentId: agentId,
-            message: {
-                task: task
-            }
-        }, "addTaskResponse");
-    },
-    /**
-     * Retrieves all tasks with optional filtering.
-     * @param {TaskFilterOptions} filters - Optional filters for agentId, category, phase, etc.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the get tasks event.
-     */
-    getTasks: async (filters = {}) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "getTasks",
-            message: filters
-        }, "getTasksResponse");
-    },
-    /**
-     * Retrieves tasks for a specific agent.
-     * @param {string} agentId - The agent ID.
-     * @returns {Promise<TaskResponse>} A promise that resolves with tasks for the specified agent.
-     */
-    getTasksByAgent: async (agentId) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "getTasksByAgent",
-            message: {
-                agentId: agentId
-            }
-        }, "getTasksByAgentResponse");
-    },
-    /**
-     * Retrieves tasks by category.
-     * @param {string} category - The category name.
-     * @returns {Promise<TaskResponse>} A promise that resolves with tasks in the specified category.
-     */
-    getTasksByCategory: async (category) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "getTasksByCategory",
-            message: {
-                category: category
-            }
-        }, "getTasksByCategoryResponse");
-    },
-    /**
-     * Retrieves all available agents.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the list of all agents.
-     */
-    getAllAgents: async () => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "getAllAgents"
-        }, "getAllAgentsResponse");
-    },
-    /**
-     * Updates an existing task.
-     * @param {TaskUpdateOptions} params - The task update parameters.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
-     */
-    updateTask: async (params) => {
-        const { taskId, ...updates } = params;
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "updateTask",
-            message: {
-                taskId: taskId,
-                ...updates
-            }
-        }, "updateTasksResponse");
-    },
-    /**
-     * Updates an existing task using legacy string parameter.
-     * @param {string} taskId - The task ID.
-     * @param {string} task - The updated task information.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
-     */
-    updateSimpleTask: async (taskId, task) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "updateTask",
-            message: {
-                taskId: taskId,
-                task: task
-            }
-        }, "updateTasksResponse");
-    },
-    /**
-     * Deletes a task.
-     * @param {string} taskId - The task ID to delete.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the delete task event.
-     */
-    deleteTask: async (taskId) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "deleteTask",
-            message: {
-                taskId: taskId
-            }
-        }, "deleteTaskResponse");
-    },
-    /**
-     * Adds a subtask to an existing task.
-     * @param {AddSubTaskOptions} params - The subtask parameters.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the add subtask event.
-     */
-    addSubTask: async (params) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "addSubTask",
-            message: params
-        }, "addSubTaskResponse");
-    },
-    /**
-     * Updates an existing subtask.
-     * @param {UpdateSubTaskOptions} params - The subtask update parameters.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update subtask event.
-     */
-    updateSubTask: async (params) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "updateSubTask",
-            message: params
-        }, "updateSubTaskResponse");
-    },
-    /**
-     * Deletes a subtask.
-     * @param {string} taskId - The parent task ID.
-     * @param {string} subtaskId - The subtask ID to delete.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the delete subtask event.
-     */
-    deleteSubTask: async (taskId, subtaskId) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "deleteSubTask",
-            message: {
-                taskId: taskId,
-                subtaskId: subtaskId
-            }
-        }, "deleteSubTaskResponse");
-    },
-    /**
-     * Creates tasks from markdown content.
-     * @param {TaskMarkdownImportOptions} params - The markdown parameters including content, agentId, phase, and category.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the create tasks from markdown event.
-     */
-    createTasksFromMarkdown: async (params) => {
-        const { markdown, agentId = 'default-agent', phase, category } = params;
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "createTasksFromMarkdown",
-            agentId: agentId,
-            message: {
-                markdown: markdown,
-                phase: phase,
-                category: category
-            }
-        }, "createTasksFromMarkdownResponse");
-    },
-    /**
-     * Exports tasks to markdown format.
-     * @param {TaskMarkdownExportOptions} params - The export parameters including optional phase, agentId, and category filters.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the markdown content.
-     */
-    exportTasksToMarkdown: async (params = {}) => {
-        return websocket_1.default.messageManager.sendAndWaitForResponse({
-            type: "taskEvent",
-            action: "exportTasksToMarkdown",
-            message: params
-        }, "exportTasksToMarkdownResponse");
-    },
-    /**
-     * Utility function to toggle task completion status.
-     * @param {string} taskId - The task ID.
-     * @param {boolean} completed - The new completion status.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
-     */
-    toggleTaskCompletion: async (taskId, completed) => {
-        return taskplaner.updateTask({
-            taskId: taskId,
-            completed: completed
-        });
-    },
-    /**
-     * Utility function to toggle subtask completion status.
-     * @param {string} taskId - The parent task ID.
-     * @param {string} subtaskId - The subtask ID.
-     * @param {boolean} completed - The new completion status.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update subtask event.
-     */
-    toggleSubTaskCompletion: async (taskId, subtaskId, completed) => {
-        return taskplaner.updateSubTask({
-            taskId: taskId,
-            subtaskId: subtaskId,
-            completed: completed
-        });
-    },
-    /**
-     * Utility function to move a task to a different agent.
-     * @param {string} taskId - The task ID.
-     * @param {string} newAgentId - The new agent ID.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
-     */
-    moveTaskToAgent: async (taskId, newAgentId) => {
-        return taskplaner.updateTask({
-            taskId: taskId,
-            agentId: newAgentId
-        });
-    },
-    /**
-     * Utility function to set task priority.
-     * @param {string} taskId - The task ID.
-     * @param {'low' | 'medium' | 'high'} priority - The priority level.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
-     */
-    setTaskPriority: async (taskId, priority) => {
-        return taskplaner.updateTask({
-            taskId: taskId,
-            priority: priority
-        });
-    },
-    /**
-     * Utility function to add tags to a task.
-     * @param {string} taskId - The task ID.
-     * @param {string[]} tags - The tags to add.
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
-     */
-    addTaskTags: async (taskId, tags) => {
-        return taskplaner.updateTask({
-            taskId: taskId,
-            tags: tags
-        });
-    },
-    /**
-     * Utility function to create a quick task with minimal parameters.
-     * @param {string} title - The task title.
-     * @param {string} agentId - The agent ID (optional, defaults to 'default-agent').
-     * @param {string} category - The category (optional).
-     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the add task event.
-     */
-    createQuickTask: async (title, agentId = 'default-agent', category) => {
-        return taskplaner.addTask({
-            title: title,
-            agentId: agentId,
-            category: category,
-            priority: 'medium'
-        });
-    }
+const taskService = {
+// /**
+//  * Creates a new task with comprehensive options.
+//  * @param {CreateTaskOptions} options - The task creation parameters
+//  * @returns {Promise<CreateTaskResponse>} A promise that resolves with the task creation response
+//  */
+// createTask: async (options: CreateTaskOptions): Promise<CreateTaskResponse> => {
+//     const requestId = randomUUID();
+//     const event: CreateTaskEvent = {
+//         type: 'taskEvent',
+//         action: 'createTask',
+//         requestId,
+//         agentId: options.threadId, // Using threadId as agentId for now
+//         threadId: options.threadId,
+//         message: options
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'createTaskResponse'
+//     );
+// },
+// /**
+//  * Creates a simple task with minimal parameters (legacy compatibility).
+//  * @param {string} taskName - The task name
+//  * @param {string} threadId - The thread ID (defaults to 'default-thread')
+//  * @returns {Promise<CreateTaskResponse>} A promise that resolves with the task creation response
+//  */
+// createSimpleTask: async (taskName: string, threadId: string = 'default-thread'): Promise<CreateTaskResponse> => {
+//     const options: CreateTaskOptions = {
+//         threadId,
+//         name: taskName,
+//         taskType: 'interactive',
+//         executionType: 'manual',
+//         environmentType: 'local',
+//         startOption: 'manual'
+//     };
+//     return taskService.createTask(options);
+// },
+// /**
+//  * Retrieves a list of tasks with optional filtering.
+//  * @param {GetTaskListOptions} options - Optional filters for tasks
+//  * @returns {Promise<GetTaskListResponse>} A promise that resolves with the task list response
+//  */
+// getTaskList: async (options: GetTaskListOptions = {}): Promise<GetTaskListResponse> => {
+//     const requestId = randomUUID();
+//     const event: GetTaskListEvent = {
+//         type: 'taskEvent',
+//         action: 'getTaskList',
+//         requestId,
+//         message: options
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'getTaskListResponse'
+//     );
+// },
+// /**
+//  * Retrieves detailed information about a specific task.
+//  * @param {GetTaskDetailOptions} options - The task detail options
+//  * @returns {Promise<GetTaskDetailResponse>} A promise that resolves with the task detail response
+//  */
+// getTaskDetail: async (options: GetTaskDetailOptions): Promise<GetTaskDetailResponse> => {
+//     const requestId = randomUUID();
+//     const event: GetTaskDetailEvent = {
+//         type: 'taskEvent',
+//         action: 'getTaskDetail',
+//         requestId,
+//         message: options
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'getTaskDetailResponse'
+//     );
+// },
+// /**
+//  * Adds a step to an existing task.
+//  * @param {AddStepToTaskOptions} options - The step addition options
+//  * @returns {Promise<AddStepToTaskResponse>} A promise that resolves with the step addition response
+//  */
+// addStepToTask: async (options: AddStepToTaskOptions): Promise<AddStepToTaskResponse> => {
+//     const requestId = randomUUID();
+//     const event: AddStepToTaskEvent = {
+//         type: 'taskEvent',
+//         action: 'addStepToTask',
+//         requestId,
+//         message: options
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'addStepToTaskResponse'
+//     );
+// },
+// /**
+//  * Retrieves messages for a specific task.
+//  * @param {GetTaskMessagesOptions} options - The task messages options
+//  * @returns {Promise<GetTaskMessagesResponse>} A promise that resolves with the task messages response
+//  */
+// getTaskMessages: async (options: GetTaskMessagesOptions): Promise<GetTaskMessagesResponse> => {
+//     const requestId = randomUUID();
+//     const event: GetTaskMessagesEvent = {
+//         type: 'taskEvent',
+//         action: 'getTaskMessages',
+//         requestId,
+//         message: options
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'getTaskMessagesResponse'
+//     );
+// },
+// /**
+//  * Updates an existing task.
+//  * @param {string} taskId - The task ID to update
+//  * @param {UpdateTaskOptions} updates - The task update parameters
+//  * @returns {Promise<UpdateTaskResponse>} A promise that resolves with the task update response
+//  */
+// updateTask: async (taskId: string, updates: UpdateTaskOptions): Promise<UpdateTaskResponse> => {
+//     const requestId = randomUUID();
+//     const event: UpdateTaskEvent = {
+//         type: 'taskEvent',
+//         action: 'updateTask',
+//         requestId,
+//         message: {
+//             taskId,
+//             ...updates
+//         }
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'updateTaskResponse'
+//     );
+// },
+// /**
+//  * Updates a task with simple name change (legacy compatibility).
+//  * @param {string} taskId - The task ID
+//  * @param {string} taskName - The new task name
+//  * @returns {Promise<UpdateTaskResponse>} A promise that resolves with the task update response
+//  */
+// updateSimpleTask: async (taskId: string, taskName: string): Promise<UpdateTaskResponse> => {
+//     return taskService.updateTask(taskId, {
+//         name: taskName
+//     });
+// },
+// /**
+//  * Deletes a task.
+//  * @param {string} taskId - The task ID to delete
+//  * @returns {Promise<DeleteTaskResponse>} A promise that resolves with the task deletion response
+//  */
+// deleteTask: async (taskId: string): Promise<DeleteTaskResponse> => {
+//     const requestId = randomUUID();
+//     const event: DeleteTaskEvent = {
+//         type: 'taskEvent',
+//         action: 'deleteTask',
+//         requestId,
+//         message: {
+//             taskId
+//         }
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'deleteTaskResponse'
+//     );
+// },
+// /**
+//  * Completes a task.
+//  * @param {string} taskId - The task ID to complete
+//  * @returns {Promise<CompleteTaskResponse>} A promise that resolves with the task completion response
+//  */
+// completeTask: async (taskId: string): Promise<CompleteTaskResponse> => {
+//     const requestId = randomUUID();
+//     const event: CompleteTaskEvent = {
+//         type: 'taskEvent',
+//         action: 'completeTask',
+//         requestId,
+//         message: {
+//             taskId
+//         }
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'completeTaskResponse'
+//     );
+// },
+// /**
+//  * Retrieves all steps with optional filtering.
+//  * @param {GetAllStepsOptions} options - Optional filters for steps
+//  * @returns {Promise<GetAllStepsResponse>} A promise that resolves with the steps response
+//  */
+// getAllSteps: async (options: GetAllStepsOptions = {}): Promise<GetAllStepsResponse> => {
+//     const requestId = randomUUID();
+//     const event: GetAllStepsEvent = {
+//         type: 'taskEvent',
+//         action: 'getAllSteps',
+//         requestId,
+//         message: options
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'getAllStepsResponse'
+//     );
+// },
+// /**
+//  * Gets the currently running step for a task or agent.
+//  * @param {GetActiveStepOptions} options - Options for getting active step
+//  * @returns {Promise<GetCurrentRunningStepResponse>} A promise that resolves with the active step response
+//  */
+// getCurrentRunningStep: async (options: GetActiveStepOptions = {}): Promise<GetCurrentRunningStepResponse> => {
+//     const requestId = randomUUID();
+//     const event: GetCurrentRunningStepEvent = {
+//         type: 'taskEvent',
+//         action: 'getCurrentRunningStep',
+//         requestId,
+//         message: options
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'getCurrentRunningStepResponse'
+//     );
+// },
+// /**
+//  * Updates the status of a specific step.
+//  * @param {UpdateStepStatusOptions} options - The step status update options
+//  * @returns {Promise<UpdateStepStatusResponse>} A promise that resolves with the step update response
+//  */
+// updateStepStatus: async (options: UpdateStepStatusOptions): Promise<UpdateStepStatusResponse> => {
+//     const requestId = randomUUID();
+//     const event: UpdateStepStatusEvent = {
+//         type: 'taskEvent',
+//         action: 'updateStepStatus',
+//         requestId,
+//         message: options
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'updateStepStatusResponse'
+//     );
+// },
+// /**
+//  * Completes a specific step.
+//  * @param {CompleteStepOptions} options - The step completion options
+//  * @returns {Promise<CompleteStepResponse>} A promise that resolves with the step completion response
+//  */
+// completeStep: async (options: CompleteStepOptions): Promise<CompleteStepResponse> => {
+//     const requestId = randomUUID();
+//     const event: CompleteStepEvent = {
+//         type: 'taskEvent',
+//         action: 'completeStep',
+//         requestId,
+//         message: options
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'completeStepResponse'
+//     );
+// },
+// /**
+//  * Sends a steering message to a running step.
+//  * @param {SendSteeringMessageOptions} options - The steering message options
+//  * @returns {Promise<SendSteeringMessageResponse>} A promise that resolves with the steering message response
+//  */
+// sendSteeringMessage: async (options: SendSteeringMessageOptions): Promise<SendSteeringMessageResponse> => {
+//     const requestId = randomUUID();
+//     const event: SendSteeringMessageEvent = {
+//         type: 'taskEvent',
+//         action: 'sendSteeringMessage',
+//         requestId,
+//         message: options
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'sendSteeringMessageResponse'
+//     );
+// },
+// /**
+//  * Checks if a task can start based on its dependencies.
+//  * @param {string} taskId - The task ID to check
+//  * @returns {Promise<CanTaskStartResponse>} A promise that resolves with the task start capability response
+//  */
+// canTaskStart: async (taskId: string): Promise<CanTaskStartResponse> => {
+//     const requestId = randomUUID();
+//     const event: CanTaskStartEvent = {
+//         type: 'taskEvent',
+//         action: 'canTaskStart',
+//         requestId,
+//         message: {
+//             taskId
+//         }
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'canTaskStartResponse'
+//     );
+// },
+// /**
+//  * Gets tasks that depend on a specific task.
+//  * @param {string} taskId - The task ID to check dependencies for
+//  * @returns {Promise<GetTasksDependentOnResponse>} A promise that resolves with the dependent tasks response
+//  */
+// getTasksDependentOn: async (taskId: string): Promise<GetTasksDependentOnResponse> => {
+//     const requestId = randomUUID();
+//     const event: GetTasksDependentOnEvent = {
+//         type: 'taskEvent',
+//         action: 'getTasksDependentOn',
+//         requestId,
+//         message: {
+//             taskId
+//         }
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'getTasksDependentOnResponse'
+//     );
+// },
+// /**
+//  * Gets tasks that are ready to start.
+//  * @param {GetTasksReadyToStartOptions} options - Optional filters for ready tasks
+//  * @returns {Promise<GetTasksReadyToStartResponse>} A promise that resolves with the ready tasks response
+//  */
+// getTasksReadyToStart: async (options: GetTasksReadyToStartOptions = {}): Promise<GetTasksReadyToStartResponse> => {
+//     const requestId = randomUUID();
+//     const event: GetTasksReadyToStartEvent = {
+//         type: 'taskEvent',
+//         action: 'getTasksReadyToStart',
+//         requestId,
+//         message: options
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'getTasksReadyToStartResponse'
+//     );
+// },
+// /**
+//  * Gets the dependency chain for a specific task.
+//  * @param {string} taskId - The task ID to get dependency chain for
+//  * @returns {Promise<GetTaskDependencyChainResponse>} A promise that resolves with the dependency chain response
+//  */
+// getTaskDependencyChain: async (taskId: string): Promise<GetTaskDependencyChainResponse> => {
+//     const requestId = randomUUID();
+//     const event: GetTaskDependencyChainEvent = {
+//         type: 'taskEvent',
+//         action: 'getTaskDependencyChain',
+//         requestId,
+//         message: {
+//             taskId
+//         }
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'getTaskDependencyChainResponse'
+//     );
+// },
+// /**
+//  * Gets task statistics.
+//  * @param {GetTaskStatsOptions} options - Optional filters for task stats
+//  * @returns {Promise<GetTaskStatsResponse>} A promise that resolves with the task stats response
+//  */
+// getTaskStats: async (options: GetTaskStatsOptions = {}): Promise<GetTaskStatsResponse> => {
+//     const requestId = randomUUID();
+//     const event: GetTaskStatsEvent = {
+//         type: 'taskEvent',
+//         action: 'getTaskStats',
+//         requestId,
+//         message: options
+//     };
+//     return cbws.messageManager.sendAndWaitForResponse(
+//         event,
+//         'getTaskStatsResponse'
+//     );
+// },
+// // ================================
+// // Utility Functions
+// // ================================
+// /**
+//  * Utility function to toggle task completion status.
+//  * @param {string} taskId - The task ID
+//  * @param {boolean} completed - The new completion status
+//  * @returns {Promise<UpdateTaskResponse>} A promise that resolves with the task update response
+//  */
+// toggleTaskCompletion: async (taskId: string, completed: boolean): Promise<UpdateTaskResponse> => {
+//     return taskService.updateTask(taskId, {
+//         completed: completed
+//     });
+// },
+// /**
+//  * Utility function to create a quick task with minimal parameters.
+//  * @param {string} name - The task name
+//  * @param {string} threadId - The thread ID (defaults to 'default-thread')
+//  * @returns {Promise<CreateTaskResponse>} A promise that resolves with the task creation response
+//  */
+// createQuickTask: async (name: string, threadId: string = 'default-thread'): Promise<CreateTaskResponse> => {
+//     return taskService.createTask({
+//         threadId,
+//         name,
+//         taskType: 'interactive',
+//         executionType: 'immediate',
+//         environmentType: 'local',
+//         startOption: 'immediately'
+//     });
+// },
+// // ================================
+// // Legacy Compatibility Functions
+// // ================================
+// /**
+//  * Legacy function: Adds a task (mapped to createTask)
+//  * @deprecated Use createTask instead
+//  */
+// addTask: async (params: LegacyTaskCreateOptions): Promise<CreateTaskResponse> => {
+//     const options: CreateTaskOptions = {
+//         threadId: params.agentId || 'default-thread',
+//         name: params.title,
+//         taskType: 'interactive',
+//         executionType: 'manual',
+//         environmentType: 'local',
+//         startOption: 'manual'
+//     };
+//     return taskService.createTask(options);
+// },
+// /**
+//  * Legacy function: Gets tasks (mapped to getTaskList)
+//  * @deprecated Use getTaskList instead
+//  */
+// getTasks: async (filters: TaskFilterOptions = {}): Promise<GetTaskListResponse> => {
+//     const options: GetTaskListOptions = {
+//         threadId: filters.agentId,
+//         status: 'all'
+//     };
+//     return taskService.getTaskList(options);
+// },
+// /**
+//  * Legacy function: Gets tasks by agent (mapped to getTaskList with threadId filter)
+//  * @deprecated Use getTaskList with threadId filter instead
+//  */
+// getTasksByAgent: async (agentId: string): Promise<GetTaskListResponse> => {
+//     return taskService.getTaskList({
+//         threadId: agentId
+//     });
+// },
+// /**
+//  * Legacy function: Gets tasks by category (use getTaskList with custom filtering)
+//  * @deprecated Use getTaskList instead
+//  */
+// getTasksByCategory: async (category: string): Promise<GetTaskListResponse> => {
+//     // Note: The new API doesn't have category filtering built-in
+//     // This would need to be implemented as post-processing
+//     return taskService.getTaskList();
+// }
 };
-exports.default = taskplaner;
+// // ================================
+// // Type Exports
+// // ================================
+// Export new types
+// export type {
+//     // New task service types
+//     Task,
+//     ExtendedTask,
+//     Step,
+//     ExtendedStep,
+//     TaskMessage,
+//     Metadata,
+//     CreateTaskOptions,
+//     UpdateTaskOptions,
+//     GetTaskListOptions,
+//     AddStepToTaskOptions,
+//     GetTaskDetailOptions,
+//     GetTaskMessagesOptions,
+//     UpdateStepStatusOptions,
+//     CompleteStepOptions,
+//     SendSteeringMessageOptions,
+//     GetAllStepsOptions,
+//     GetActiveStepOptions,
+//     DeleteTaskOptions,
+//     CompleteTaskOptions,
+//     CanTaskStartOptions,
+//     GetTasksDependentOnOptions,
+//     GetTasksReadyToStartOptions,
+//     GetTaskDependencyChainOptions,
+//     GetTaskStatsOptions,
+//     // Response types
+//     TaskResponse,
+//     TaskListResponse,
+//     StepResponse,
+//     StepListResponse,
+//     TaskMessagesResponse,
+//     ActiveStepResponse,
+//     SendSteeringMessageResponse,
+//     DeleteTaskResponse,
+//     CanTaskStartResponse,
+//     TaskStatsResponse,
+//     CreateTaskResponse,
+//     GetTaskListResponse,
+//     AddStepToTaskResponse,
+//     GetTaskDetailResponse,
+//     GetTaskMessagesResponse,
+//     GetAllStepsResponse,
+//     GetCurrentRunningStepResponse,
+//     UpdateStepStatusResponse,
+//     CompleteStepResponse,
+//     UpdateTaskResponse,
+//     CompleteTaskResponse,
+//     GetTasksDependentOnResponse,
+//     GetTasksReadyToStartResponse,
+//     GetTaskDependencyChainResponse,
+//     GetTaskStatsResponse
+// };
+// // Export legacy types for backward compatibility
+// export type {
+//     LegacyTask as Task_Legacy,
+//     LegacySubTask as SubTask,
+//     LegacyTaskResponse as TaskResponse_Legacy,
+//     LegacyTaskCreateOptions as TaskCreateOptions_Legacy,
+//     LegacyTaskUpdateOptions as TaskUpdateOptions_Legacy,
+//     AddSubTaskOptions,
+//     UpdateSubTaskOptions,
+//     TaskFilterOptions,
+//     TaskMarkdownImportOptions,
+//     TaskMarkdownExportOptions
+// };
+// export default taskService;