@codebolt/codeboltjs 2.0.12 → 2.0.15

package/dist/modules/task.d.ts

@@ -1,23 +1,138 @@
+import type { Task, SubTask, TaskResponse, TaskCreateOptions, TaskUpdateOptions, AddSubTaskOptions, UpdateSubTaskOptions, TaskFilterOptions, TaskMarkdownImportOptions, TaskMarkdownExportOptions } from '../types';
 /**
- * Manages task operations via WebSocket communication.
+ * Enhanced task planner with agent-based organization and comprehensive task management.
  */
 declare const taskplaner: {
     /**
-     * Adds a task using a WebSocket message.
-     * @param {string} task - The task to be added.
-     * @returns {Promise<AddTaskResponse>} A promise that resolves with the response from the add task event.
+     * 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: (task: string) => Promise<any>;
+    addTask: (params: TaskCreateOptions) => Promise<TaskResponse>;
     /**
-     * Retrieves all tasks using a WebSocket message.
-     * @returns {Promise<GetTasksResponse>} A promise that resolves with the response from the get tasks event.
+     * 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.
      */
-    getTasks: () => Promise<any>;
+    addSimpleTask: (task: string, agentId?: string) => Promise<TaskResponse>;
     /**
-     * Updates an existing task using a WebSocket message.
+     * 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: (filters?: TaskFilterOptions) => Promise<TaskResponse>;
+    /**
+     * 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: (agentId: string) => Promise<TaskResponse>;
+    /**
+     * Retrieves tasks by category.
+     * @param {string} category - The category name.
+     * @returns {Promise<TaskResponse>} A promise that resolves with tasks in the specified category.
+     */
+    getTasksByCategory: (category: string) => Promise<TaskResponse>;
+    /**
+     * Retrieves all available agents.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the list of all agents.
+     */
+    getAllAgents: () => Promise<TaskResponse>;
+    /**
+     * 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: (params: TaskUpdateOptions) => Promise<TaskResponse>;
+    /**
+     * Updates an existing task using legacy string parameter.
+     * @param {string} taskId - The task ID.
      * @param {string} task - The updated task information.
-     * @returns {Promise<UpdateTasksResponse>} A promise that resolves with the response from the update task event.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
+     */
+    updateSimpleTask: (taskId: string, task: string) => Promise<TaskResponse>;
+    /**
+     * 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: (taskId: string) => Promise<TaskResponse>;
+    /**
+     * 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: (params: AddSubTaskOptions) => Promise<TaskResponse>;
+    /**
+     * 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: (params: UpdateSubTaskOptions) => Promise<TaskResponse>;
+    /**
+     * 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: (taskId: string, subtaskId: string) => Promise<TaskResponse>;
+    /**
+     * 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: (params: TaskMarkdownImportOptions) => Promise<TaskResponse>;
+    /**
+     * 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: (params?: TaskMarkdownExportOptions) => Promise<TaskResponse>;
+    /**
+     * 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: (taskId: string, completed: boolean) => Promise<TaskResponse>;
+    /**
+     * 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: (taskId: string, subtaskId: string, completed: boolean) => Promise<TaskResponse>;
+    /**
+     * 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: (taskId: string, newAgentId: string) => Promise<TaskResponse>;
+    /**
+     * 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: (taskId: string, priority: 'low' | 'medium' | 'high') => Promise<TaskResponse>;
+    /**
+     * 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: (taskId: string, tags: string[]) => Promise<TaskResponse>;
+    /**
+     * 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.
      */
-    updateTask: (task: string) => Promise<any>;
+    createQuickTask: (title: string, agentId?: string, category?: string) => Promise<TaskResponse>;
 };
+export type { Task, SubTask, TaskResponse, TaskCreateOptions, TaskUpdateOptions, AddSubTaskOptions, UpdateSubTaskOptions, TaskFilterOptions, TaskMarkdownImportOptions, TaskMarkdownExportOptions };
 export default taskplaner;

package/dist/modules/task.js

@@ -5,46 +5,288 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const websocket_1 = __importDefault(require("../core/websocket"));
 /**
- * Manages task operations via WebSocket communication.
+ * Enhanced task planner with agent-based organization and comprehensive task management.
  */
 const taskplaner = {
     /**
-     * Adds a task using a WebSocket message.
-     * @param {string} task - The task to be added.
-     * @returns {Promise<AddTaskResponse>} A promise that resolves with the response from the add task event.
+     * 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 (task) => {
+    addTask: async (params) => {
+        const { title, agentId = 'default-agent', description, phase, category, priority, tags } = params;
         return websocket_1.default.messageManager.sendAndWaitForResponse({
-            "type": "taskEvent",
-            "action": "addTask",
+            type: "taskEvent",
+            action: "addTask",
+            agentId: agentId,
             message: {
-                "task": task
+                title: title,
+                description: description,
+                phase: phase,
+                category: category,
+                priority: priority,
+                tags: tags
             }
         }, "addTaskResponse");
     },
     /**
-     * Retrieves all tasks using a WebSocket message.
-     * @returns {Promise<GetTasksResponse>} A promise that resolves with the response from the get tasks event.
+     * 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.
      */
-    getTasks: async () => {
+    addSimpleTask: async (task, agentId = 'default-agent') => {
         return websocket_1.default.messageManager.sendAndWaitForResponse({
-            "type": "taskEvent",
-            "action": "getTasks"
+            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");
     },
     /**
-     * Updates an existing task using a WebSocket message.
+     * 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<UpdateTasksResponse>} A promise that resolves with the response from the update task event.
+     * @returns {Promise<TaskResponse>} A promise that resolves with the response from the update task event.
      */
-    updateTask: async (task) => {
+    updateSimpleTask: async (taskId, task) => {
         return websocket_1.default.messageManager.sendAndWaitForResponse({
-            "type": "taskEvent",
-            "action": "updateTask",
+            type: "taskEvent",
+            action: "updateTask",
             message: {
-                "task": task
+                taskId: taskId,
+                task: task
             }
-        }, "updateTaskResponse");
+        }, "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'
+        });
     }
 };
 exports.default = taskplaner;

package/dist/notificationfunctions/agent.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Agent Notification Functions
+ *
+ * This module provides functions for sending agent-related notifications,
+ * including subagent task operations and completions.
+ */
+import { AgentNotifications } from '../types/notificationFunctions/agent';
+/**
+ * Sends a request to start a subagent task
+ *
+ * @param parentAgentId - The parent agent ID
+ * @param subagentId - The subagent ID
+ * @param task - The task description
+ * @param priority - Optional task priority
+ * @param dependencies - Optional array of dependencies
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 1.1 - WHEN I call `codebolt.notify.agent.StartSubagentTaskRequestNotify()` THEN the system SHALL send a StartSubagentTaskRequestNotification via WebSocket
+ */
+export declare function StartSubagentTaskRequestNotify(parentAgentId: string, subagentId: string, task: string, priority?: string, dependencies?: string[], toolUseId?: string): void;
+/**
+ * Sends a response to a subagent task request
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 1.2 - WHEN I call `codebolt.notify.agent.StartSubagentTaskResponseNotify()` THEN the system SHALL send a StartSubagentTaskResponseNotification via WebSocket
+ */
+export declare function StartSubagentTaskResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Notifies that a subagent task has been completed
+ *
+ * @param parentAgentId - The parent agent ID
+ * @param subagentId - The subagent ID
+ * @param taskId - The task ID
+ * @param result - The task result
+ * @param status - The task status
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 1.3 - WHEN I call `codebolt.notify.agent.SubagentTaskCompletedNotify()` THEN the system SHALL send a SubagentTaskCompletedNotification via WebSocket
+ */
+export declare function SubagentTaskCompletedNotify(parentAgentId: string, subagentId: string, taskId: string, result: any, status: string, toolUseId?: string): void;
+/**
+ * Agent notification functions object
+ */
+export declare const agentNotifications: AgentNotifications;
+export default agentNotifications;

package/dist/notificationfunctions/agent.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * Agent Notification Functions
+ *
+ * This module provides functions for sending agent-related notifications,
+ * including subagent task operations and completions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentNotifications = exports.SubagentTaskCompletedNotify = exports.StartSubagentTaskResponseNotify = exports.StartSubagentTaskRequestNotify = void 0;
+const utils_1 = require("./utils");
+/**
+ * Sends a request to start a subagent task
+ *
+ * @param parentAgentId - The parent agent ID
+ * @param subagentId - The subagent ID
+ * @param task - The task description
+ * @param priority - Optional task priority
+ * @param dependencies - Optional array of dependencies
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 1.1 - WHEN I call `codebolt.notify.agent.StartSubagentTaskRequestNotify()` THEN the system SHALL send a StartSubagentTaskRequestNotification via WebSocket
+ */
+function StartSubagentTaskRequestNotify(parentAgentId, subagentId, task, priority, dependencies, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ parentAgentId, subagentId, task }, ['parentAgentId', 'subagentId', 'task'], 'agent.StartSubagentTaskRequestNotify')) {
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "agentnotify",
+        action: "startSubagentTaskRequest",
+        data: {
+            parentAgentId: parentAgentId,
+            subagentId: subagentId,
+            task: task,
+            priority: priority,
+            dependencies: dependencies
+        }
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'agent.StartSubagentTaskRequestNotify');
+}
+exports.StartSubagentTaskRequestNotify = StartSubagentTaskRequestNotify;
+/**
+ * Sends a response to a subagent task request
+ *
+ * @param content - The response content (string or any object)
+ * @param isError - Whether this is an error response (default: false)
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 1.2 - WHEN I call `codebolt.notify.agent.StartSubagentTaskResponseNotify()` THEN the system SHALL send a StartSubagentTaskResponseNotification via WebSocket
+ */
+function StartSubagentTaskResponseNotify(content, isError = false, toolUseId) {
+    // Validate content is provided
+    if (content === null || content === undefined) {
+        console.error('[NotificationFunctions] Content is required for agent.StartSubagentTaskResponseNotify');
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "agentnotify",
+        action: "startSubagentTaskResult",
+        content: content,
+        isError: isError
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'agent.StartSubagentTaskResponseNotify');
+}
+exports.StartSubagentTaskResponseNotify = StartSubagentTaskResponseNotify;
+/**
+ * Notifies that a subagent task has been completed
+ *
+ * @param parentAgentId - The parent agent ID
+ * @param subagentId - The subagent ID
+ * @param taskId - The task ID
+ * @param result - The task result
+ * @param status - The task status
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ *
+ * Requirements: 1.3 - WHEN I call `codebolt.notify.agent.SubagentTaskCompletedNotify()` THEN the system SHALL send a SubagentTaskCompletedNotification via WebSocket
+ */
+function SubagentTaskCompletedNotify(parentAgentId, subagentId, taskId, result, status, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ parentAgentId, subagentId, taskId, result, status }, ['parentAgentId', 'subagentId', 'taskId', 'result', 'status'], 'agent.SubagentTaskCompletedNotify')) {
+        return;
+    }
+    // Create the notification
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "agentnotify",
+        action: "subagentTaskCompleted",
+        data: {
+            parentAgentId: parentAgentId,
+            subagentId: subagentId,
+            taskId: taskId,
+            result: result,
+            status: status
+        }
+    };
+    // Send the notification
+    (0, utils_1.sendNotification)(notification, 'agent.SubagentTaskCompletedNotify');
+}
+exports.SubagentTaskCompletedNotify = SubagentTaskCompletedNotify;
+/**
+ * Agent notification functions object
+ */
+exports.agentNotifications = {
+    StartSubagentTaskRequestNotify,
+    StartSubagentTaskResponseNotify,
+    SubagentTaskCompletedNotify
+};
+// Default export
+exports.default = exports.agentNotifications;