@codebolt/codeboltjs 2.0.13 → 2.0.16

package/dist/core/Codebolt.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import WebSocket from 'ws';
+import { type NotificationFunctions } from '../notificationfunctions';
 import type { UserMessage } from '../types/libFunctionTypes';
 /**
  * @class Codebolt
@@ -9,6 +10,7 @@ declare class Codebolt {
     websocket: WebSocket | null;
     private isReady;
     private readyPromise;
+    private readyHandlers;
     /**
      * @constructor
      * @description Initializes the websocket connection.
@@ -75,7 +77,23 @@ declare class Codebolt {
         diff: (commitHash: string) => Promise<import("../types/socketMessageTypes").GitDiffResponse>;
     };
     llm: {
-        inference: (message: string, llmrole: string) => Promise<import("../types/socketMessageTypes").LLMResponse>;
+        inference: (params: {
+            messages: import("../types/libFunctionTypes").Message[];
+            tools?: any[] | undefined;
+            tool_choice?: string | undefined;
+            full?: boolean | undefined;
+            llmrole?: string | undefined;
+            max_tokens?: number | undefined;
+            temperature?: number | undefined;
+            stream?: boolean | undefined;
+        }, llmrole?: string | undefined) => Promise<{
+            /**
+             * @constructor
+             * @description Initializes the websocket connection.
+             */
+            completion: any;
+        }>;
+        legacyInference: (message: string, llmrole: string) => Promise<import("../types/socketMessageTypes").LLMResponse>;
     };
     browser: {
         newPage: () => Promise<import("../types/socketMessageTypes").BrowserActionResponseData>;
@@ -218,17 +236,13 @@ declare class Codebolt {
         };
         parseText: (text: string) => {
             success: boolean;
-            parsed: string[]; /**
-             * @method isReady
-             * @description Checks if the Codebolt instance is ready for use.
-             * @returns {boolean} True if the instance is ready, false otherwise.
-             */
+            parsed: string[];
         };
         parseErrors: (output: any) => string[];
         parseWarnings: (output: any) => string[];
     };
     project: {
-        getProjectSettings: () => Promise<any>;
+        getProjectSettings: () => Promise<import("../types/socketMessageTypes").GetProjectSettingsResponse>;
         getProjectPath: () => Promise<import("../types/socketMessageTypes").GetProjectPathResponse>;
         getRepoMap: (message: any) => Promise<import("../types/socketMessageTypes").GetProjectPathResponse>;
         runProject: () => void;
@@ -236,22 +250,36 @@ declare class Codebolt {
     };
     dbmemory: {
         addKnowledge: (key: string, value: any) => Promise<import("../types/socketMessageTypes").MemorySetResponse>;
-        getKnowledge: (key: string) => Promise<import("../types/socketMessageTypes").MemoryGetResponse>; /**
-         * @constructor
-         * @description Initializes the websocket connection.
-         */
+        getKnowledge: (key: string) => Promise<import("../types/socketMessageTypes").MemoryGetResponse>;
     };
     cbstate: {
         getApplicationState: () => Promise<import("../types/commonTypes").ApplicationState>;
         addToAgentState: (key: string, value: string) => Promise<import("../types/socketMessageTypes").AddToAgentStateResponse>;
         getAgentState: () => Promise<import("../types/socketMessageTypes").GetAgentStateResponse>;
-        getProjectState: () => Promise<any>;
-        updateProjectState: (key: string, value: any) => Promise<any>;
+        getProjectState: () => Promise<import("../types/socketMessageTypes").GetProjectStateResponse>;
+        updateProjectState: (key: string, value: any) => Promise<import("../types/socketMessageTypes").UpdateProjectStateResponse>;
     };
     taskplaner: {
-        addTask: (task: string) => Promise<any>;
-        getTasks: () => Promise<any>;
-        updateTask: (task: string) => Promise<any>;
+        addTask: (params: import("../types/libFunctionTypes").TaskCreateOptions) => Promise<import("../types/commonTypes").TaskResponse>;
+        addSimpleTask: (task: string, agentId?: string) => Promise<import("../types/commonTypes").TaskResponse>;
+        getTasks: (filters?: import("../types/libFunctionTypes").TaskFilterOptions) => Promise<import("../types/commonTypes").TaskResponse>;
+        getTasksByAgent: (agentId: string) => Promise<import("../types/commonTypes").TaskResponse>;
+        getTasksByCategory: (category: string) => Promise<import("../types/commonTypes").TaskResponse>;
+        getAllAgents: () => Promise<import("../types/commonTypes").TaskResponse>;
+        updateTask: (params: import("../types/libFunctionTypes").TaskUpdateOptions) => Promise<import("../types/commonTypes").TaskResponse>;
+        updateSimpleTask: (taskId: string, task: string) => Promise<import("../types/commonTypes").TaskResponse>;
+        deleteTask: (taskId: string) => Promise<import("../types/commonTypes").TaskResponse>;
+        addSubTask: (params: import("../types/libFunctionTypes").AddSubTaskOptions) => Promise<import("../types/commonTypes").TaskResponse>;
+        updateSubTask: (params: import("../types/libFunctionTypes").UpdateSubTaskOptions) => Promise<import("../types/commonTypes").TaskResponse>;
+        deleteSubTask: (taskId: string, subtaskId: string) => Promise<import("../types/commonTypes").TaskResponse>;
+        createTasksFromMarkdown: (params: import("../types/libFunctionTypes").TaskMarkdownImportOptions) => Promise<import("../types/commonTypes").TaskResponse>;
+        exportTasksToMarkdown: (params?: import("../types/libFunctionTypes").TaskMarkdownExportOptions) => Promise<import("../types/commonTypes").TaskResponse>;
+        toggleTaskCompletion: (taskId: string, completed: boolean) => Promise<import("../types/commonTypes").TaskResponse>;
+        toggleSubTaskCompletion: (taskId: string, subtaskId: string, completed: boolean) => Promise<import("../types/commonTypes").TaskResponse>;
+        moveTaskToAgent: (taskId: string, newAgentId: string) => Promise<import("../types/commonTypes").TaskResponse>;
+        setTaskPriority: (taskId: string, priority: "low" | "medium" | "high") => Promise<import("../types/commonTypes").TaskResponse>;
+        addTaskTags: (taskId: string, tags: string[]) => Promise<import("../types/commonTypes").TaskResponse>;
+        createQuickTask: (title: string, agentId?: string, category?: string | undefined) => Promise<import("../types/commonTypes").TaskResponse>;
     };
     vectordb: {
         getVector: (key: string) => Promise<import("../types/socketMessageTypes").GetVectorResponse>;
@@ -289,10 +317,6 @@ declare class Codebolt {
     };
     agent: {
         findAgent: (task: string, maxResult: number | undefined, agents: never[] | undefined, agentLocaltion: import("../modules/agent").AgentLocation | undefined, getFrom: import("../modules/agent").FilterUsing.USE_VECTOR_DB) => Promise<import("../types/socketMessageTypes").FindAgentByTaskResponse>;
-        /**
-         * @constructor
-         * @description Initializes the websocket connection.
-         */
         startAgent: (agentId: string, task: string) => Promise<import("../types/socketMessageTypes").TaskCompletionResponse>;
         getAgentsList: (type?: import("../modules/agent").Agents) => Promise<import("../types/socketMessageTypes").ListAgentsResponse>;
         getAgentsDetail: (agentList?: never[]) => Promise<import("../types/socketMessageTypes").AgentsDetailResponse>;
@@ -300,6 +324,14 @@ declare class Codebolt {
     utils: {
         editFileAndApplyDiff: (filePath: string, diff: string, diffIdentifier: string, prompt: string, applyModel?: string | undefined) => Promise<import("../types/socketMessageTypes").FsEditFileAndApplyDiffResponse>;
     };
+    notify: NotificationFunctions;
+    /**
+     * Sets up a handler function to be executed when the WebSocket connection is established.
+     * If the connection is already established, the handler will be executed immediately.
+     * @param {Function} handler - The handler function to call when the connection is ready.
+     * @returns {void}
+     */
+    onReady(handler: () => void | Promise<void>): void;
     /**
      * Sets up a listener for incoming messages with a direct handler function.
      * @param {Function} handler - The handler function to call when a message is received.

package/dist/core/Codebolt.js

@@ -28,6 +28,7 @@ const history_1 = require("../modules/history");
 const mcp_1 = __importDefault(require("../modules/mcp"));
 const agent_1 = __importDefault(require("../modules/agent"));
 const utils_1 = __importDefault(require("../modules/utils"));
+const notificationfunctions_1 = require("../notificationfunctions");
 /**
  * @class Codebolt
  * @description This class provides a unified interface to interact with various modules.
@@ -40,6 +41,7 @@ class Codebolt {
     constructor() {
         this.websocket = null;
         this.isReady = false;
+        this.readyHandlers = [];
         this.fs = fs_1.default;
         this.git = git_1.default;
         this.llm = llm_1.default;
@@ -64,6 +66,7 @@ class Codebolt {
         this.mcp = mcp_1.default;
         this.agent = agent_1.default;
         this.utils = utils_1.default;
+        this.notify = notificationfunctions_1.notificationFunctions;
         console.log("Codebolt Agent initialized");
         this.readyPromise = this.initializeConnection();
     }
@@ -78,6 +81,15 @@ class Codebolt {
             this.websocket = websocket_1.default.getWebsocket;
             this.isReady = true;
             console.log("Codebolt WebSocket connection established");
+            // Execute all registered ready handlers
+            for (const handler of this.readyHandlers) {
+                try {
+                    await handler();
+                }
+                catch (error) {
+                    console.error('Error executing ready handler:', error);
+                }
+            }
         }
         catch (error) {
             console.error('Failed to initialize WebSocket connection:', error);
@@ -100,6 +112,32 @@ class Codebolt {
     get ready() {
         return this.isReady;
     }
+    /**
+     * Sets up a handler function to be executed when the WebSocket connection is established.
+     * If the connection is already established, the handler will be executed immediately.
+     * @param {Function} handler - The handler function to call when the connection is ready.
+     * @returns {void}
+     */
+    onReady(handler) {
+        if (this.isReady) {
+            // If already ready, execute the handler immediately
+            try {
+                const result = handler();
+                if (result instanceof Promise) {
+                    result.catch(error => {
+                        console.error('Error in ready handler:', error);
+                    });
+                }
+            }
+            catch (error) {
+                console.error('Error in ready handler:', error);
+            }
+        }
+        else {
+            // If not ready yet, add to the list of handlers to execute when ready
+            this.readyHandlers.push(handler);
+        }
+    }
     /**
      * Sets up a listener for incoming messages with a direct handler function.
      * @param {Function} handler - The handler function to call when a message is received.
@@ -115,19 +153,23 @@ class Codebolt {
                     try {
                         // Extract user-facing message from internal socket message
                         const userMessage = {
+                            type: response.type,
                             userMessage: response.message.userMessage,
                             currentFile: response.message.currentFile,
                             mentionedFiles: response.message.mentionedFiles || [],
                             mentionedFullPaths: response.message.mentionedFullPaths || [],
                             mentionedFolders: response.message.mentionedFolders || [],
                             uploadedImages: response.message.uploadedImages || [],
+                            mentionedMCPs: response.message.mentionedMCPs || [],
                             selectedAgent: {
                                 id: ((_a = response.message.selectedAgent) === null || _a === void 0 ? void 0 : _a.id) || '',
                                 name: ((_b = response.message.selectedAgent) === null || _b === void 0 ? void 0 : _b.name) || ''
                             },
                             messageId: response.message.messageId,
                             threadId: response.message.threadId,
-                            selection: response.message.selection
+                            selection: response.message.selection,
+                            remixPrompt: response.message.remixPrompt,
+                            mentionedAgents: response.message.mentionedAgents
                         };
                         const result = await handler(userMessage);
                         // Send processStoped with optional message

package/dist/core/messageManager.d.ts

@@ -8,7 +8,6 @@ import type { PendingRequest } from '../types/commonTypes';
 export declare class MessageManager extends EventEmitter {
     pendingRequests: Map<string, PendingRequest>;
     websocket: WebSocket | null;
-    requestCounter: number;
     /**
      * Initialize the message manager with a WebSocket instance
      */

package/dist/core/messageManager.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageManager = void 0;
 const events_1 = require("events");
+const uuid_1 = require("uuid");
 /**
  * Centralized message manager for handling WebSocket communications
  */
@@ -10,7 +11,6 @@ class MessageManager extends events_1.EventEmitter {
         super(...arguments);
         this.pendingRequests = new Map();
         this.websocket = null;
-        this.requestCounter = 0;
     }
     /**
      * Initialize the message manager with a WebSocket instance
@@ -70,7 +70,7 @@ class MessageManager extends events_1.EventEmitter {
                 reject(new Error('WebSocket is not initialized'));
                 return;
             }
-            const requestId = `req_${++this.requestCounter}_${Date.now()}`;
+            const requestId = (0, uuid_1.v4)();
             // Add requestId to the message if it doesn't have one
             const messageWithId = { ...message, requestId };
             // Parse multiple message types separated by pipe
@@ -110,6 +110,8 @@ class MessageManager extends events_1.EventEmitter {
      * Send a message without waiting for response
      */
     send(message) {
+        const requestId = (0, uuid_1.v4)();
+        message.requestId = requestId;
         if (!this.websocket) {
             throw new Error('WebSocket is not initialized');
         }

package/dist/core/websocket.js

@@ -65,7 +65,33 @@ class cbws {
         const parentAgentInstanceIdParam = process.env.parentAgentInstanceId ? `&parentAgentInstanceId=${process.env.parentAgentInstanceId}` : '';
         const agentTask = process.env.agentTask ? `&agentTask=${process.env.agentTask}` : '';
         const socketPort = process.env.SOCKET_PORT || '12345';
-        const wsUrl = `ws://localhost:${socketPort}/codebolt?id=${uniqueConnectionId}${agentIdParam}${parentIdParam}${parentAgentInstanceIdParam}${agentTask}${process.env.Is_Dev ? '&dev=true' : ''}`;
+        const serverUrl = process.env.CODEBOLT_SERVER_URL || 'localhost';
+        const threadToken = process.env.threadToken || null;
+        console.log('[WebSocket] Logging all relevant variables:');
+        console.log('uniqueConnectionId:', uniqueConnectionId);
+        console.log('initialMessage:', initialMessage);
+        console.log('agentIdParam:', agentIdParam);
+        console.log('parentIdParam:', parentIdParam);
+        console.log('parentAgentInstanceIdParam:', parentAgentInstanceIdParam);
+        console.log('agentTask:', agentTask);
+        console.log('socketPort:', socketPort);
+        console.log('serverUrl:', serverUrl);
+        console.log('threadToken:', threadToken);
+        console.log('[WebSocket] Environment variables check:');
+        console.log('process.env.agentId:', process.env.agentId);
+        console.log('process.env.threadToken:', process.env.threadToken);
+        console.log('process.env.parentId:', process.env.parentId);
+        console.log('process.env.agentTask:', process.env.agentTask);
+        const threadTokenParam = threadToken ? `&threadToken=${encodeURIComponent(threadToken)}` : '';
+        // Add all custom environment variables as URL parameters
+        const knownEnvVars = ['SOCKET_PORT', 'CODEBOLT_SERVER_URL', 'agentId', 'parentId', 'parentAgentInstanceId', 'agentTask', 'threadToken', 'Is_Dev', 'PATH', 'NODE_ENV', 'HOME', 'USER', 'SHELL'];
+        let customParams = '';
+        for (const [key, value] of Object.entries(process.env)) {
+            if (!knownEnvVars.includes(key) && value && !key.startsWith('npm_') && !key.startsWith('_')) {
+                customParams += `&${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+            }
+        }
+        const wsUrl = `ws://${serverUrl}:${socketPort}/codebolt?id=${uniqueConnectionId}${agentIdParam}${parentIdParam}${parentAgentInstanceIdParam}${agentTask}${threadTokenParam}${customParams}${process.env.Is_Dev ? '&dev=true' : ''}`;
         console.log('[WebSocket] Connecting to:', wsUrl);
         this.websocket = new ws_1.default(wsUrl);
         return new Promise((resolve, reject) => {

package/dist/modules/llm.d.ts

@@ -11,16 +11,36 @@ declare const cbllm: {
      * for the role is not found, it falls back to the default model for the current agent,
      * and ultimately to the default application-wide LLM if necessary.
      *
-     * @param message - The inference parameters including:
+     * @param params - The inference parameters including:
      *   - messages: Array of conversation messages
      *   - tools: Available tools for the model to use
      *   - tool_choice: How the model should use tools
-     *   - llmrole: The LLM role to determine which model to use
+     *   - full: Whether to return full response
      *   - max_tokens: Maximum number of tokens to generate
      *   - temperature: Temperature for response generation
      *   - stream: Whether to stream the response
      * @returns A promise that resolves with the LLM's response
      */
-    inference: (message: string, llmrole: string) => Promise<LLMResponse>;
+    inference: (params: {
+        messages: Message[];
+        tools?: any[];
+        tool_choice?: string;
+        full?: boolean;
+        llmrole?: string;
+        max_tokens?: number;
+        temperature?: number;
+        stream?: boolean;
+    }, llmrole?: string) => Promise<{
+        completion: any;
+    }>;
+    /**
+     * Legacy method for backward compatibility - converts simple string prompt to message format.
+     * @deprecated Use the new inference method with proper message format instead.
+     *
+     * @param {string} message - The input message or prompt to be sent to the LLM.
+     * @param {string} llmrole - The role of the LLM to determine which model to use.
+     * @returns {Promise<LLMResponse>} A promise that resolves with the LLM's response.
+     */
+    legacyInference: (message: string, llmrole: string) => Promise<LLMResponse>;
 };
 export default cbllm;

package/dist/modules/llm.js

@@ -14,17 +14,34 @@ const cbllm = {
      * for the role is not found, it falls back to the default model for the current agent,
      * and ultimately to the default application-wide LLM if necessary.
      *
-     * @param message - The inference parameters including:
+     * @param params - The inference parameters including:
      *   - messages: Array of conversation messages
      *   - tools: Available tools for the model to use
      *   - tool_choice: How the model should use tools
-     *   - llmrole: The LLM role to determine which model to use
+     *   - full: Whether to return full response
      *   - max_tokens: Maximum number of tokens to generate
      *   - temperature: Temperature for response generation
      *   - stream: Whether to stream the response
      * @returns A promise that resolves with the LLM's response
      */
-    inference: async (message, llmrole) => {
+    inference: async (params, llmrole) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "inference",
+            "message": {
+                prompt: params,
+                llmrole
+            },
+        }, "llmResponse");
+    },
+    /**
+     * Legacy method for backward compatibility - converts simple string prompt to message format.
+     * @deprecated Use the new inference method with proper message format instead.
+     *
+     * @param {string} message - The input message or prompt to be sent to the LLM.
+     * @param {string} llmrole - The role of the LLM to determine which model to use.
+     * @returns {Promise<LLMResponse>} A promise that resolves with the LLM's response.
+     */
+    legacyInference: async (message, llmrole) => {
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": "inference",
             "message": {

package/dist/modules/project.d.ts

@@ -1,13 +1,13 @@
-import { GetProjectPathResponse } from '../types/socketMessageTypes';
+import { GetProjectPathResponse, GetProjectSettingsResponse } from '../types/socketMessageTypes';
 /**
  * A module for interacting with project settings and paths.
  */
 declare const cbproject: {
     /**
      * Retrieves the project settings from the server.
-     * @returns {Promise<any>} A promise that resolves with the project settings response.
+     * @returns {Promise<GetProjectSettingsResponse>} A promise that resolves with the project settings response.
      */
-    getProjectSettings: () => Promise<any>;
+    getProjectSettings: () => Promise<GetProjectSettingsResponse>;
     /**
      * Retrieves the path of the current project.
      * @returns {Promise<GetProjectPathResponse>} A promise that resolves with the project path response.

package/dist/modules/project.js

@@ -10,7 +10,7 @@ const websocket_1 = __importDefault(require("../core/websocket"));
 const cbproject = {
     /**
      * Retrieves the project settings from the server.
-     * @returns {Promise<any>} A promise that resolves with the project settings response.
+     * @returns {Promise<GetProjectSettingsResponse>} A promise that resolves with the project settings response.
      */
     getProjectSettings: () => {
         return websocket_1.default.messageManager.sendAndWaitForResponse({

package/dist/modules/state.d.ts

@@ -1,4 +1,4 @@
-import { AddToAgentStateResponse, GetAgentStateResponse } from '../types/socketMessageTypes';
+import { AddToAgentStateResponse, GetAgentStateResponse, GetProjectStateResponse, UpdateProjectStateResponse } from '../types/socketMessageTypes';
 import { ApplicationState } from '../types/commonTypes';
 declare const cbstate: {
     /**
@@ -22,11 +22,13 @@ declare const cbstate: {
      * Retrieves the current project state from the server via WebSocket.
      * @returns {Promise<GetProjectStateResponse>} A promise that resolves with the project's state.
      */
-    getProjectState: () => Promise<any>;
+    getProjectState: () => Promise<GetProjectStateResponse>;
     /**
      * Updates the project state on the server via WebSocket.
+     * @param {string} key - The key to update in the project state.
+     * @param {any} value - The value to set for the key.
      * @returns {Promise<UpdateProjectStateResponse>} A promise that resolves with the response to the update request.
      */
-    updateProjectState: (key: string, value: any) => Promise<any>;
+    updateProjectState: (key: string, value: any) => Promise<UpdateProjectStateResponse>;
 };
 export default cbstate;

package/dist/modules/state.js

@@ -53,6 +53,8 @@ const cbstate = {
     },
     /**
      * Updates the project state on the server via WebSocket.
+     * @param {string} key - The key to update in the project state.
+     * @param {any} value - The value to set for the key.
      * @returns {Promise<UpdateProjectStateResponse>} A promise that resolves with the response to the update request.
      */
     updateProjectState: async (key, value) => {

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;