@codebolt/codeboltjs 4.0.2 → 5.0.0

package/dist/core/Codebolt.d.ts

@@ -11,6 +11,8 @@ declare class Codebolt {
     private isReady;
     private readyPromise;
     private readyHandlers;
+    private messageQueue;
+    private messageResolvers;
     /**
      * @constructor
      * @description Initializes the websocket connection.
@@ -35,19 +37,19 @@ declare class Codebolt {
      */
     get ready(): boolean;
     fs: {
-        createFile: (fileName: string, source: string, filePath: string) => Promise<FlatUserMessage>;
-        createFolder: (folderName: string, folderPath: string) => Promise<FlatUserMessage>;
-        readFile: (filePath: string) => Promise<FlatUserMessage>;
-        updateFile: (filename: string, filePath: string, newContent: string) => Promise<FlatUserMessage>;
-        deleteFile: (filename: string, filePath: string) => Promise<FlatUserMessage>;
-        deleteFolder: (foldername: string, folderpath: string) => Promise<FlatUserMessage>;
-        listFile: (folderPath: string, isRecursive?: boolean) => Promise<FlatUserMessage>;
-        listCodeDefinitionNames: (path: string) => Promise<FlatUserMessage>;
-        searchFiles: (path: string, regex: string, filePattern: string) => Promise<FlatUserMessage>;
+        createFile: (fileName: string, source: string, filePath: string) => Promise<import("@codebolt/types/sdk").CreateFileResponse>;
+        createFolder: (folderName: string, folderPath: string) => Promise<import("@codebolt/types/sdk").CreateFolderResponse>;
+        readFile: (filePath: string) => Promise<import("@codebolt/types/sdk").ReadFileResponse>;
+        updateFile: (filename: string, filePath: string, newContent: string) => Promise<import("@codebolt/types/sdk").UpdateFileResponse>;
+        deleteFile: (filename: string, filePath: string) => Promise<import("@codebolt/types/sdk").DeleteFileResponse>;
+        deleteFolder: (foldername: string, folderpath: string) => Promise<import("@codebolt/types/sdk").DeleteFolderResponse>;
+        listFile: (folderPath: string, isRecursive?: boolean) => Promise<import("@codebolt/types/sdk").FileListResponse>;
+        listCodeDefinitionNames: (path: string) => Promise<import("@codebolt/types/sdk").ListCodeDefinitionsResponse>;
+        searchFiles: (path: string, regex: string, filePattern: string) => Promise<import("@codebolt/types/sdk").SearchFilesResponse>;
         writeToFile: (relPath: string, newContent: string) => Promise<any>;
-        grepSearch: (path: string, query: string, includePattern?: string, excludePattern?: string, caseSensitive?: boolean) => Promise<FlatUserMessage>;
-        fileSearch: (query: string) => Promise<FlatUserMessage>;
-        editFileWithDiff: (targetFile: string, codeEdit: string, diffIdentifier: string, prompt: string, applyModel?: string) => Promise<FlatUserMessage>;
+        grepSearch: (path: string, query: string, includePattern?: string, excludePattern?: string, caseSensitive?: boolean) => Promise<import("@codebolt/types/sdk").GrepSearchResponse>;
+        fileSearch: (query: string) => Promise<import("@codebolt/types/sdk").FileSearchResponse>;
+        editFileWithDiff: (targetFile: string, codeEdit: string, diffIdentifier: string, prompt: string, applyModel?: string) => Promise<import("@codebolt/types/sdk").EditFileAndApplyDiffResponse>;
         readManyFiles: (params: {
             paths: string[];
             include?: string[];
@@ -59,7 +61,7 @@ declare class Codebolt {
             include_metadata?: boolean;
             separator_format?: string;
             notifyUser?: boolean;
-        }) => Promise<FlatUserMessage>;
+        }) => Promise<import("@codebolt/types/sdk").ReadManyFilesResponse>;
         listDirectory: (params: {
             path: string;
             ignore?: string[];
@@ -67,55 +69,55 @@ declare class Codebolt {
             detailed?: boolean;
             limit?: number;
             notifyUser?: boolean;
-        }) => Promise<FlatUserMessage>;
+        }) => Promise<import("@codebolt/types/sdk").ListDirectoryResponse>;
     };
     git: {
-        init: (path: string) => Promise<FlatUserMessage>;
-        pull: () => Promise<FlatUserMessage>;
-        push: () => Promise<FlatUserMessage>;
-        status: () => Promise<FlatUserMessage>;
-        addAll: () => Promise<FlatUserMessage>;
-        commit: (message: string) => Promise<FlatUserMessage>;
-        checkout: (branch: string) => Promise<FlatUserMessage>;
-        branch: (branch: string) => Promise<FlatUserMessage>;
-        logs: (path: string) => Promise<FlatUserMessage>;
-        diff: (commitHash: string) => Promise<FlatUserMessage>;
+        init: (path: string) => Promise<import("@codebolt/types/sdk").GitInitResponse>;
+        pull: () => Promise<import("@codebolt/types/sdk").GitPullResponse>;
+        push: () => Promise<import("@codebolt/types/sdk").GitPushResponse>;
+        status: () => Promise<import("@codebolt/types/sdk").GitStatusResponse>;
+        addAll: () => Promise<import("@codebolt/types/sdk").AddResponse>;
+        commit: (message: string) => Promise<import("@codebolt/types/sdk").GitCommitResponse>;
+        checkout: (branch: string) => Promise<import("@codebolt/types/sdk").GitCheckoutResponse>;
+        branch: (branch: string) => Promise<import("@codebolt/types/sdk").GitBranchResponse>;
+        logs: (path: string) => Promise<import("@codebolt/types/sdk").GitLogsResponse>;
+        diff: (commitHash: string) => Promise<import("@codebolt/types/sdk").GitDiffResponse>;
     };
     llm: {
-        inference: (params: FlatUserMessage) => Promise<{
-            completion: FlatUserMessage;
+        inference: (params: import("@codebolt/types/sdk").LLMInferenceParams) => Promise<{
+            completion: import("@codebolt/types/sdk").LLMCompletion;
         }>;
         getModelConfig: (modelId?: string) => Promise<{
-            config: FlatUserMessage | null;
+            config: import("@codebolt/types/sdk").LLMModelConfig | null;
             success: boolean;
             error?: string;
         }>;
     };
     browser: {
-        newPage: () => Promise<FlatUserMessage>;
-        getUrl: () => Promise<FlatUserMessage>;
-        goToPage: (url: string) => Promise<FlatUserMessage>;
-        screenshot: () => Promise<FlatUserMessage>;
-        getHTML: () => Promise<FlatUserMessage>;
-        getMarkdown: () => Promise<FlatUserMessage>;
+        newPage: () => Promise<import("@codebolt/types/sdk").BrowserActionResponseData>;
+        getUrl: () => Promise<import("@codebolt/types/sdk").UrlResponse>;
+        goToPage: (url: string) => Promise<import("@codebolt/types/sdk").GoToPageResponse>;
+        screenshot: () => Promise<import("@codebolt/types/sdk").BrowserScreenshotResponse>;
+        getHTML: () => Promise<import("@codebolt/types/sdk").HtmlReceived>;
+        getMarkdown: () => Promise<import("@codebolt/types/sdk").GetMarkdownResponse>;
         getPDF: () => void;
         pdfToText: () => void;
-        getContent: () => Promise<FlatUserMessage>;
-        getSnapShot: () => Promise<FlatUserMessage>;
-        getBrowserInfo: () => Promise<FlatUserMessage>;
-        extractText: () => Promise<FlatUserMessage>;
+        getContent: () => Promise<import("@codebolt/types/sdk").GetContentResponse>;
+        getSnapShot: () => Promise<import("@codebolt/types/sdk").BrowserSnapshotResponse>;
+        getBrowserInfo: () => Promise<import("@codebolt/types/sdk").BrowserInfoResponse>;
+        extractText: () => Promise<import("@codebolt/types/sdk").ExtractTextResponse>;
         close: () => void;
-        scroll: (direction: string, pixels: string) => Promise<FlatUserMessage>;
-        type: (elementid: string, text: string) => Promise<FlatUserMessage>;
-        click: (elementid: string) => Promise<FlatUserMessage>;
-        enter: () => Promise<FlatUserMessage>;
-        search: (elementid: string, query: string) => Promise<FlatUserMessage>;
+        scroll: (direction: string, pixels: string) => Promise<import("@codebolt/types/sdk").BrowserActionResponseData>;
+        type: (elementid: string, text: string) => Promise<import("@codebolt/types/sdk").BrowserActionResponseData>;
+        click: (elementid: string) => Promise<import("@codebolt/types/sdk").BrowserActionResponseData>;
+        enter: () => Promise<import("@codebolt/types/sdk").BrowserActionResponseData>;
+        search: (elementid: string, query: string) => Promise<import("@codebolt/types/sdk").BrowserActionResponseData>;
     };
     chat: {
-        getChatHistory: (threadId: string) => Promise<FlatUserMessage>;
+        getChatHistory: (threadId: string) => Promise<import("@codebolt/types/sdk").ChatMessage>;
         setRequestHandler: (handler: (request: any, response: (data: any) => void) => Promise<void> | void) => void;
-        sendMessage: (message: string, payload: any) => void;
-        waitforReply: (message: string) => Promise<FlatUserMessage>;
+        sendMessage: (message: string, payload?: any) => void;
+        waitforReply: (message: string) => Promise<import("@codebolt/types/sdk").UserMessage>;
         processStarted: (onStopClicked?: (message: any) => void) => {
             stopProcess: () => void;
             cleanup: () => void;
@@ -150,8 +152,8 @@ declare class Codebolt {
             eventNames(): (string | symbol)[];
         };
         executeCommand: (command: string, returnEmptyStringOnSuccess?: boolean) => Promise<any>;
-        executeCommandRunUntilError: (command: string, executeInMain?: boolean) => Promise<FlatUserMessage>;
-        sendManualInterrupt(): Promise<FlatUserMessage>;
+        executeCommandRunUntilError: (command: string, executeInMain?: boolean) => Promise<import("@codebolt/types/sdk").CommandError>;
+        sendManualInterrupt(): Promise<import("@codebolt/types/sdk").TerminalInterruptResponse>;
         executeCommandWithStream(command: string, executeInMain?: boolean): {
             cleanup?: () => void;
             [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
@@ -174,9 +176,9 @@ declare class Codebolt {
     };
     codeutils: {
         getAllFilesAsMarkDown: () => Promise<string>;
-        performMatch: (matcherDefinition: object, problemPatterns: any[], problems?: any[]) => Promise<FlatUserMessage>;
-        getMatcherList: () => Promise<FlatUserMessage>;
-        matchDetail: (matcher: string) => Promise<FlatUserMessage>;
+        performMatch: (matcherDefinition: object, problemPatterns: any[], problems?: any[]) => Promise<import("@codebolt/types/sdk").MatchProblemResponse>;
+        getMatcherList: () => Promise<import("@codebolt/types/sdk").GetMatcherListTreeResponse>;
+        matchDetail: (matcher: string) => Promise<import("@codebolt/types/sdk").getMatchDetail>;
     };
     crawler: {
         start: () => void;
@@ -208,108 +210,148 @@ declare class Codebolt {
         parseWarnings: (output: import("../modules/outputparsers").ParsableOutput) => string[];
     };
     project: {
-        getProjectSettings: () => Promise<FlatUserMessage>;
-        getProjectPath: () => Promise<FlatUserMessage>;
-        getRepoMap: (message: any) => Promise<FlatUserMessage>;
+        getProjectSettings: () => Promise<import("@codebolt/types/sdk").GetProjectSettingsResponse>;
+        getProjectPath: () => Promise<import("@codebolt/types/sdk").GetProjectPathResponse>;
+        getRepoMap: (message: any) => Promise<import("@codebolt/types/sdk").GetProjectPathResponse>;
         runProject: () => void;
         getEditorFileStatus: () => Promise<any>;
     };
     dbmemory: {
-        addKnowledge: (key: string, value: FlatUserMessage) => Promise<FlatUserMessage>;
-        getKnowledge: (key: string) => Promise<FlatUserMessage>;
+        addKnowledge: (key: string, value: import("@codebolt/types/sdk").MemoryValue) => Promise<import("@codebolt/types/sdk").MemorySetResponse>;
+        getKnowledge: (key: string) => Promise<import("@codebolt/types/sdk").MemoryGetResponse>;
     };
     cbstate: {
         getApplicationState: () => Promise<import("../types/commonTypes").ApplicationState>;
-        addToAgentState: (key: string, value: string) => Promise<FlatUserMessage>;
-        getAgentState: () => Promise<FlatUserMessage>;
-        getProjectState: () => Promise<FlatUserMessage>;
-        updateProjectState: (key: string, value: any) => Promise<FlatUserMessage>;
+        addToAgentState: (key: string, value: string) => Promise<import("@codebolt/types/sdk").AddToAgentStateResponse>;
+        getAgentState: () => Promise<import("@codebolt/types/sdk").GetAgentStateResponse>;
+        getProjectState: () => Promise<import("@codebolt/types/sdk").GetProjectStateResponse>;
+        updateProjectState: (key: string, value: any) => Promise<import("@codebolt/types/sdk").UpdateProjectStateResponse>;
     };
     task: {
-        createTask: (options: FlatUserMessage) => Promise<FlatUserMessage>;
-        createSimpleTask: (taskName: string, threadId?: string) => Promise<FlatUserMessage>;
-        getTaskList: (options?: FlatUserMessage) => Promise<FlatUserMessage>;
-        getTaskDetail: (options: FlatUserMessage) => Promise<FlatUserMessage>;
-        addStepToTask: (options: FlatUserMessage) => Promise<FlatUserMessage>;
-        getTaskMessages: (options: FlatUserMessage) => Promise<FlatUserMessage>;
-        updateTask: (taskId: string, updates: FlatUserMessage) => Promise<FlatUserMessage>;
-        updateSimpleTask: (taskId: string, taskName: string) => Promise<FlatUserMessage>;
-        deleteTask: (taskId: string) => Promise<FlatUserMessage>;
-        completeTask: (taskId: string) => Promise<FlatUserMessage>;
-        startTask: (taskId: string) => Promise<FlatUserMessage>;
-        getAllSteps: (options?: FlatUserMessage) => Promise<FlatUserMessage>;
-        getCurrentRunningStep: (options?: FlatUserMessage) => Promise<FlatUserMessage>;
-        updateStepStatus: (options: FlatUserMessage) => Promise<FlatUserMessage>;
-        completeStep: (options: FlatUserMessage) => Promise<FlatUserMessage>;
-        sendSteeringMessage: (options: FlatUserMessage) => Promise<FlatUserMessage>;
-        canTaskStart: (taskId: string) => Promise<FlatUserMessage>;
-        getTasksDependentOn: (taskId: string) => Promise<FlatUserMessage>;
-        getTasksReadyToStart: (options?: FlatUserMessage) => Promise<FlatUserMessage>;
-        getTaskDependencyChain: (taskId: string) => Promise<FlatUserMessage>;
-        getTaskStats: (options?: FlatUserMessage) => Promise<FlatUserMessage>;
-        toggleTaskCompletion: (taskId: string, completed: boolean) => Promise<FlatUserMessage>;
-        createQuickTask: (name: string, threadId?: string) => Promise<FlatUserMessage>;
-        getTasksStartedByMe: (userId: string, options?: FlatUserMessage) => Promise<FlatUserMessage>;
-        addTask: (params: import("../types/libFunctionTypes").TaskCreateOptions) => Promise<FlatUserMessage>;
-        getTasks: (filters?: import("../types/libFunctionTypes").TaskFilterOptions) => Promise<FlatUserMessage>;
-        getTasksByAgent: (agentId: string) => Promise<FlatUserMessage>;
-        getTasksByCategory: (category: string) => Promise<FlatUserMessage>;
-        attachJsonMemoryToTask: (taskId: string, memoryId: string) => Promise<any>;
-        attachMarktownMemoryJToTask: (taskId: string, memoryId: string) => Promise<any>;
-        attachToDoToTask: (taskId: string, todoId: string) => Promise<any>;
-        getAttachedTodos: (taskId: string) => Promise<any>;
-        getAttachedJsonMemory: (taskId: string) => Promise<any>;
-        getAttachedMarkdownMemory: (taskId: string) => Promise<any>;
+        createTask: (options: import("node_modules/@codebolt/types/dist/wstypes/agent-to-app-ws/actions/taskEventSchemas").CreateTaskOptions) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").CreateTaskResponse>;
+        createSimpleTask: (taskName: string, threadId?: string) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").CreateTaskResponse>;
+        getTaskList: (options?: import("node_modules/@codebolt/types/dist/wstypes/agent-to-app-ws/actions/taskEventSchemas").GetTaskListOptions) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").GetTaskListResponse>;
+        getTaskDetail: (options: import("node_modules/@codebolt/types/dist/wstypes/agent-to-app-ws/actions/taskEventSchemas").GetTaskDetailOptions) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").GetTaskDetailResponse>;
+        addStepToTask: (options: import("node_modules/@codebolt/types/dist/wstypes/agent-to-app-ws/actions/taskEventSchemas").AddStepToTaskOptions) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").AddStepToTaskResponse>;
+        getTaskMessages: (options: import("node_modules/@codebolt/types/dist/wstypes/agent-to-app-ws/actions/taskEventSchemas").GetTaskMessagesOptions) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").GetTaskMessagesResponse>;
+        updateTask: (taskId: string, updates: import("node_modules/@codebolt/types/dist/wstypes/agent-to-app-ws/actions/taskEventSchemas").UpdateTaskOptions) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").UpdateTaskResponse>;
+        updateSimpleTask: (taskId: string, taskName: string) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").UpdateTaskResponse>;
+        deleteTask: (taskId: string) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").DeleteTaskResponse>;
+        completeTask: (taskId: string) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").CompleteTaskResponse>;
+        startTask: (taskId: string) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").StartTaskResponse>;
+        getAllSteps: (options?: import("node_modules/@codebolt/types/dist/wstypes/agent-to-app-ws/actions/taskEventSchemas").GetAllStepsOptions) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").GetAllStepsResponse>;
+        getCurrentRunningStep: (options?: import("node_modules/@codebolt/types/dist/wstypes/agent-to-app-ws/actions/taskEventSchemas").GetActiveStepOptions) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").GetCurrentRunningStepResponse>;
+        updateStepStatus: (options: import("node_modules/@codebolt/types/dist/wstypes/agent-to-app-ws/actions/taskEventSchemas").UpdateStepStatusOptions) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").UpdateStepStatusResponse>;
+        completeStep: (options: import("node_modules/@codebolt/types/dist/wstypes/agent-to-app-ws/actions/taskEventSchemas").CompleteStepOptions) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").CompleteStepResponse>;
+        sendSteeringMessage: (options: import("node_modules/@codebolt/types/dist/wstypes/agent-to-app-ws/actions/taskEventSchemas").SendSteeringMessageOptions) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").SendSteeringMessageResponse>;
+        canTaskStart: (taskId: string) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").CanTaskStartResponse>;
+        getTasksDependentOn: (taskId: string) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").GetTasksDependentOnResponse>;
+        getTasksReadyToStart: (options?: import("node_modules/@codebolt/types/dist/wstypes/agent-to-app-ws/actions/taskEventSchemas").GetTasksReadyToStartOptions) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").GetTasksReadyToStartResponse>;
+        getTaskDependencyChain: (taskId: string) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").GetTaskDependencyChainResponse>;
+        getTaskStats: (options?: import("node_modules/@codebolt/types/dist/wstypes/agent-to-app-ws/actions/taskEventSchemas").GetTaskStatsOptions) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").GetTaskStatsResponse>;
+        toggleTaskCompletion: (taskId: string, completed: boolean) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").UpdateTaskResponse>;
+        createQuickTask: (name: string, threadId?: string) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").CreateTaskResponse>;
+        getTasksStartedByMe: (userId: string, options?: import("node_modules/@codebolt/types/dist/wstypes/agent-to-app-ws/actions/taskEventSchemas").GetTaskListOptions) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").GetTaskListResponse>;
+        addTask: (params: import("../types/libFunctionTypes").TaskCreateOptions) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").CreateTaskResponse>;
+        getTasks: (filters?: import("../types/libFunctionTypes").TaskFilterOptions) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").GetTaskListResponse>;
+        getTasksByAgent: (agentId: string) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").GetTaskListResponse>;
+        getTasksByCategory: (category: string) => Promise<import("node_modules/@codebolt/types/dist/wstypes/app-to-agent-ws/taskServiceResponses").GetTaskListResponse>;
+        attachMemoryToTask: (taskId: string, memoryId: string) => Promise<any>;
+        getAttachedMemoryForTask: (taskId: string) => Promise<any>;
+        createTaskGroup: (groupName: string, description: string) => Promise<any>;
     };
     vectordb: {
-        getVector: (key: string) => Promise<FlatUserMessage>;
-        addVectorItem: (item: any) => Promise<FlatUserMessage>;
-        queryVectorItem: (key: string) => Promise<FlatUserMessage>;
-        queryVectorItems: (items: [], dbPath: string) => Promise<FlatUserMessage>;
+        getVector: (key: string) => Promise<import("@codebolt/types/sdk").GetVectorResponse>;
+        addVectorItem: (item: any) => Promise<import("@codebolt/types/sdk").AddVectorItemResponse>;
+        queryVectorItem: (key: string) => Promise<import("@codebolt/types/sdk").QueryVectorItemResponse>;
+        queryVectorItems: (items: [], dbPath: string) => Promise<import("@codebolt/types/sdk").QueryVectorItemResponse>;
     };
     debug: {
-        debug: (log: string, type: import("../modules/debug").logType) => Promise<FlatUserMessage>;
-        openDebugBrowser: (url: string, port: number) => Promise<FlatUserMessage>;
+        debug: (log: string, type: import("../modules/debug").logType) => Promise<import("@codebolt/types/sdk").DebugAddLogResponse>;
+        openDebugBrowser: (url: string, port: number) => Promise<import("@codebolt/types/sdk").OpenDebugBrowserResponse>;
     };
     tokenizer: {
-        addToken: (key: string) => Promise<FlatUserMessage>;
-        getToken: (key: string) => Promise<FlatUserMessage>;
+        addToken: (key: string) => Promise<import("@codebolt/types/sdk").AddTokenResponse>;
+        getToken: (key: string) => Promise<import("@codebolt/types/sdk").GetTokenResponse>;
     };
     chatSummary: {
-        summarizeAll: () => Promise<FlatUserMessage>;
+        summarizeAll: () => Promise<import("@codebolt/types/sdk").GetSummarizeAllResponse>;
         summarize: (messages: {
             role: string;
             content: string;
-        }[], depth: number) => Promise<FlatUserMessage>;
+        }[], depth: number) => Promise<import("@codebolt/types/sdk").GetSummarizeResponse>;
     };
     mcp: {
-        getEnabledMCPServers: () => Promise<FlatUserMessage>;
-        getLocalMCPServers: () => Promise<FlatUserMessage>;
-        getMentionedMCPServers: (userMessage: FlatUserMessage) => Promise<FlatUserMessage>;
-        searchAvailableMCPServers: (query: string) => Promise<FlatUserMessage>;
-        listMcpFromServers: (toolBoxes: string[]) => Promise<FlatUserMessage>;
-        configureMCPServer: (name: string, config: FlatUserMessage) => Promise<FlatUserMessage>;
+        getEnabledMCPServers: () => Promise<import("@codebolt/types/sdk").GetEnabledToolBoxesResponse>;
+        getLocalMCPServers: () => Promise<import("@codebolt/types/sdk").GetLocalToolBoxesResponse>;
+        getMentionedMCPServers: (userMessage: import("@codebolt/types/sdk").MCPUserMessage) => Promise<import("@codebolt/types/sdk").GetAvailableToolBoxesResponse>;
+        searchAvailableMCPServers: (query: string) => Promise<import("@codebolt/types/sdk").SearchAvailableToolBoxesResponse>;
+        listMcpFromServers: (toolBoxes: string[]) => Promise<import("@codebolt/types/sdk").ListToolsFromToolBoxesResponse>;
+        configureMCPServer: (name: string, config: import("@codebolt/types/sdk").MCPConfiguration) => Promise<import("@codebolt/types/sdk").ConfigureToolBoxResponse>;
         getTools: (tools: {
             toolbox: string;
             toolName: string;
-        }[]) => Promise<FlatUserMessage>;
-        executeTool: (toolbox: string, toolName: string, params: FlatUserMessage) => Promise<FlatUserMessage>;
+        }[]) => Promise<import("@codebolt/types/sdk").GetToolsResponse>;
+        executeTool: (toolbox: string, toolName: string, params: import("@codebolt/types/sdk").ToolParameters) => Promise<import("@codebolt/types/sdk").ExecuteToolResponse>;
     };
     agent: {
-        findAgent: (task: string, maxResult: number | undefined, agents: never[] | undefined, agentLocaltion: FlatUserMessage, getFrom: FlatUserMessage) => Promise<FlatUserMessage>;
-        startAgent: (agentId: string, task: string) => Promise<FlatUserMessage>;
-        getAgentsList: (type?: FlatUserMessage) => Promise<FlatUserMessage>;
-        getAgentsDetail: (agentList?: never[]) => Promise<FlatUserMessage>;
+        findAgent: (task: string, maxResult: number | undefined, agents: never[] | undefined, agentLocaltion: import("@codebolt/types/enum").AgentLocation | undefined, getFrom: import("@codebolt/types/enum").FilterUsing.USE_VECTOR_DB) => Promise<import("@codebolt/types/sdk").FindAgentByTaskResponse>;
+        startAgent: (agentId: string, task: string) => Promise<import("@codebolt/types/sdk").TaskCompletionResponse>;
+        getAgentsList: (type?: import("@codebolt/types/enum").Agents) => Promise<import("@codebolt/types/sdk").ListAgentsResponse>;
+        getAgentsDetail: (agentList?: never[]) => Promise<import("@codebolt/types/sdk").AgentsDetailResponse>;
     };
     utils: {
-        editFileAndApplyDiff: (filePath: string, diff: string, diffIdentifier: string, prompt: string, applyModel?: string) => Promise<FlatUserMessage>;
+        editFileAndApplyDiff: (filePath: string, diff: string, diffIdentifier: string, prompt: string, applyModel?: string) => Promise<import("@codebolt/types/sdk").FsEditFileAndApplyDiffResponse>;
     };
     notify: NotificationFunctions;
+    memory: {
+        json: {
+            save: (json: any) => Promise<import("../modules/memory").SaveMemoryResponse>;
+            update: (memoryId: string, json: any) => Promise<import("../modules/memory").UpdateMemoryResponse>;
+            delete: (memoryId: string) => Promise<import("../modules/memory").DeleteMemoryResponse>;
+            list: (filters?: Record<string, unknown>) => Promise<import("../modules/memory").ListMemoryResponse>;
+        };
+        todo: {
+            save: (todo: import("@codebolt/types/agent-to-app-ws-schema").TodoData, metadata?: Record<string, unknown>) => Promise<import("../modules/memory").SaveMemoryResponse>;
+            update: (memoryId: string, todo: import("@codebolt/types/agent-to-app-ws-schema").TodoItem) => Promise<import("../modules/memory").UpdateMemoryResponse>;
+            delete: (memoryId: string) => Promise<import("../modules/memory").DeleteMemoryResponse>;
+            list: (filters?: Record<string, unknown>) => Promise<import("../modules/memory").ListMemoryResponse>;
+        };
+        markdown: {
+            save: (markdown: string, metadata?: Record<string, unknown>) => Promise<import("../modules/memory").SaveMemoryResponse>;
+            update: (memoryId: string, markdown: string, metadata?: Record<string, unknown>) => Promise<import("../modules/memory").UpdateMemoryResponse>;
+            delete: (memoryId: string) => Promise<import("../modules/memory").DeleteMemoryResponse>;
+            list: (filters?: Record<string, unknown>) => Promise<import("../modules/memory").ListMemoryResponse>;
+        };
+    };
+    actionPlan: {
+        getAllPlans: () => Promise<any>;
+        getPlanDetail: (planId: string) => Promise<any>;
+        getActionPlanDetail: (planId: string) => Promise<any>;
+        createActionPlan: (payload: {
+            name: string;
+            description?: string;
+            agentId?: string;
+            agentName?: string;
+            status?: string;
+            planId?: string;
+        }) => Promise<any>;
+        updateActionPlan: (planId: string, updateData: any) => Promise<any>;
+        addTaskToActionPlan: (planId: string, task: {
+            name: string;
+            description?: string;
+            priority?: string;
+            taskType?: string;
+            [key: string]: any;
+        }) => Promise<any>;
+        startTaskStep: (planId: string, taskId: string) => Promise<any>;
+        startTaskStepWithListener: (planId: string, taskId: string, onResponse: (response: any) => void) => () => void;
+    };
     /**
      * User message utilities for accessing current user message and context
      */
     userMessage: {
-        getCurrent: () => any;
+        getCurrent: () => FlatUserMessage | undefined;
         getText: () => string;
         getMentionedMCPs: () => string[];
         getMentionedFiles: () => string[];
@@ -321,7 +363,7 @@ declare class Codebolt {
         getSelection: () => string | undefined;
         getMessageId: () => string | undefined;
         getThreadId: () => string | undefined;
-        getProcessingConfig: () => AgentProcessingConfig;
+        getProcessingConfig: () => import("@codebolt/types/sdk").AgentProcessingConfig;
         isProcessingEnabled: (type: "processMentionedMCPs" | "processRemixPrompt" | "processMentionedFiles" | "processMentionedAgents") => boolean;
         setSessionData: (key: string, value: any) => void;
         getSessionData: (key: string) => any;
@@ -337,6 +379,19 @@ declare class Codebolt {
      * @returns {void}
      */
     onReady(handler: () => void | Promise<void>): void;
+    /**
+     * Waits for and returns the next incoming message.
+     * If a message is already in the queue, returns it immediately.
+     * Otherwise, waits for the next message to arrive.
+     * @returns {Promise<FlatUserMessage>} A promise that resolves with the next message
+     */
+    getMessage(): Promise<FlatUserMessage>;
+    /**
+     * Handles an incoming message by either resolving a waiting promise
+     * or adding it to the queue if no promises are waiting.
+     * @private
+     */
+    private handleIncomingMessage;
     /**
      * 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

@@ -25,8 +25,10 @@ const debug_1 = __importDefault(require("../modules/debug"));
 const tokenizer_1 = __importDefault(require("../modules/tokenizer"));
 const history_1 = require("../modules/history");
 const mcp_1 = __importDefault(require("../modules/mcp"));
+const memory_1 = __importDefault(require("../modules/memory"));
 const agent_1 = __importDefault(require("../modules/agent"));
 const utils_1 = __importDefault(require("../modules/utils"));
+const actionPlan_1 = __importDefault(require("../modules/actionPlan"));
 const notificationfunctions_1 = require("../notificationfunctions");
 const user_message_manager_1 = require("../modules/user-message-manager");
 const user_message_utilities_1 = require("../modules/user-message-utilities");
@@ -43,6 +45,8 @@ class Codebolt {
         this.websocket = null;
         this.isReady = false;
         this.readyHandlers = [];
+        this.messageQueue = [];
+        this.messageResolvers = [];
         this.fs = fs_1.default;
         this.git = git_1.default;
         this.llm = llm_1.default;
@@ -67,6 +71,8 @@ class Codebolt {
         this.agent = agent_1.default;
         this.utils = utils_1.default;
         this.notify = notificationfunctions_1.notificationFunctions;
+        this.memory = memory_1.default;
+        this.actionPlan = actionPlan_1.default;
         /**
          * User message utilities for accessing current user message and context
          */
@@ -142,6 +148,39 @@ class Codebolt {
             this.readyHandlers.push(handler);
         }
     }
+    /**
+     * Waits for and returns the next incoming message.
+     * If a message is already in the queue, returns it immediately.
+     * Otherwise, waits for the next message to arrive.
+     * @returns {Promise<FlatUserMessage>} A promise that resolves with the next message
+     */
+    getMessage() {
+        // If there are queued messages, return the first one
+        if (this.messageQueue.length > 0) {
+            const message = this.messageQueue.shift();
+            return Promise.resolve(message);
+        }
+        // Otherwise, create a new promise that will be resolved when a message arrives
+        return new Promise((resolve) => {
+            this.messageResolvers.push(resolve);
+        });
+    }
+    /**
+     * Handles an incoming message by either resolving a waiting promise
+     * or adding it to the queue if no promises are waiting.
+     * @private
+     */
+    handleIncomingMessage(message) {
+        if (this.messageResolvers.length > 0) {
+            // If there are waiting resolvers, resolve the first one
+            const resolver = this.messageResolvers.shift();
+            resolver(message);
+        }
+        else {
+            // Otherwise, add to the queue
+            this.messageQueue.push(message);
+        }
+    }
     /**
      * 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.
@@ -178,6 +217,9 @@ class Codebolt {
                         };
                         // Automatically save the user message globally
                         user_message_manager_1.userMessageManager.saveMessage(userMessage);
+                        // Handle the message in the queue system
+                        this.handleIncomingMessage(userMessage);
+                        // Call the original handler
                         const result = await handler(userMessage);
                         // Send processStoped with optional message
                         const message = {

package/dist/modules/actionPlan.d.ts

@@ -0,0 +1,68 @@
+declare const codeboltActionPlan: {
+    /**
+     * Get all action plans
+     * @returns Promise with all action plans
+     */
+    getAllPlans: () => Promise<any>;
+    /**
+     * Get action plan detail by ID
+     * @param planId - The ID of the action plan
+     * @returns Promise with action plan details
+     */
+    getPlanDetail: (planId: string) => Promise<any>;
+    /**
+     * Get action plan detail by ID (alternative method)
+     * @param planId - The ID of the action plan
+     * @returns Promise with action plan details
+     */
+    getActionPlanDetail: (planId: string) => Promise<any>;
+    /**
+     * Create a new action plan
+     * @param payload - Action plan creation data (name, description, agentId, agentName, status, planId)
+     * @returns Promise with created action plan
+     */
+    createActionPlan: (payload: {
+        name: string;
+        description?: string;
+        agentId?: string;
+        agentName?: string;
+        status?: string;
+        planId?: string;
+    }) => Promise<any>;
+    /**
+     * Update an existing action plan
+     * @param planId - The ID of the action plan to update
+     * @param updateData - Data to update in the action plan
+     * @returns Promise with updated action plan
+     */
+    updateActionPlan: (planId: string, updateData: any) => Promise<any>;
+    /**
+     * Add a task to an action plan
+     * @param planId - The ID of the action plan
+     * @param task - Task data to add (name, description, priority, taskType, etc.)
+     * @returns Promise with added task and updated action plan
+     */
+    addTaskToActionPlan: (planId: string, task: {
+        name: string;
+        description?: string;
+        priority?: string;
+        taskType?: string;
+        [key: string]: any;
+    }) => Promise<any>;
+    /**
+     * Start/execute a task step in an action plan
+     * @param planId - The ID of the action plan
+     * @param taskId - The ID of the task to start
+     * @returns Promise with task execution status
+     */
+    startTaskStep: (planId: string, taskId: string) => Promise<any>;
+    /**
+     * Start/execute a task step in an action plan with event listener
+     * @param planId - The ID of the action plan
+     * @param taskId - The ID of the task to start
+     * @param onResponse - Callback function that will be called when receiving responses for this task
+     * @returns Cleanup function to remove the event listener
+     */
+    startTaskStepWithListener: (planId: string, taskId: string, onResponse: (response: any) => void) => () => void;
+};
+export default codeboltActionPlan;

package/dist/modules/actionPlan.js

@@ -0,0 +1,125 @@
+"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"));
+const enum_1 = require("@codebolt/types/enum");
+const codeboltActionPlan = {
+    /**
+     * Get all action plans
+     * @returns Promise with all action plans
+     */
+    getAllPlans: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.ACTION_PLAN,
+            "action": enum_1.ActionPlanAction.GETALL_ACTION_PLAN,
+        }, enum_1.ActionPlanResponseType.GETALL_ACTION_PLAN_RESPONSE);
+    },
+    /**
+     * Get action plan detail by ID
+     * @param planId - The ID of the action plan
+     * @returns Promise with action plan details
+     */
+    getPlanDetail: (planId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.ACTION_PLAN,
+            "action": enum_1.ActionPlanAction.GET_PLAN_DETAIL,
+            message: { planId }
+        }, enum_1.ActionPlanResponseType.GET_PLAN_DETAIL_RESPONSE);
+    },
+    /**
+     * Get action plan detail by ID (alternative method)
+     * @param planId - The ID of the action plan
+     * @returns Promise with action plan details
+     */
+    getActionPlanDetail: (planId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.ACTION_PLAN,
+            "action": enum_1.ActionPlanAction.GET_ACTION_PLAN_DETAIL,
+            message: { planId }
+        }, enum_1.ActionPlanResponseType.GET_ACTION_PLAN_DETAIL_RESPONSE);
+    },
+    /**
+     * Create a new action plan
+     * @param payload - Action plan creation data (name, description, agentId, agentName, status, planId)
+     * @returns Promise with created action plan
+     */
+    createActionPlan: (payload) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.ACTION_PLAN,
+            "action": enum_1.ActionPlanAction.CREATE_ACTION_PLAN,
+            message: payload
+        }, enum_1.ActionPlanResponseType.CREATE_ACTION_PLAN_RESPONSE);
+    },
+    /**
+     * Update an existing action plan
+     * @param planId - The ID of the action plan to update
+     * @param updateData - Data to update in the action plan
+     * @returns Promise with updated action plan
+     */
+    updateActionPlan: (planId, updateData) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.ACTION_PLAN,
+            "action": enum_1.ActionPlanAction.UPDATE_ACTION_PLAN,
+            message: { planId, ...updateData }
+        }, enum_1.ActionPlanResponseType.UPDATE_ACTION_PLAN_RESPONSE);
+    },
+    /**
+     * Add a task to an action plan
+     * @param planId - The ID of the action plan
+     * @param task - Task data to add (name, description, priority, taskType, etc.)
+     * @returns Promise with added task and updated action plan
+     */
+    addTaskToActionPlan: (planId, task) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.ACTION_PLAN,
+            "action": enum_1.ActionPlanAction.ADD_TASK_TO_ACTION_PLAN,
+            message: { planId, task }
+        }, enum_1.ActionPlanResponseType.ADD_TASK_TO_ACTION_PLAN_RESPONSE);
+    },
+    /**
+     * Start/execute a task step in an action plan
+     * @param planId - The ID of the action plan
+     * @param taskId - The ID of the task to start
+     * @returns Promise with task execution status
+     */
+    startTaskStep: (planId, taskId) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": enum_1.EventType.ACTION_PLAN,
+            "action": enum_1.ActionPlanAction.START_TASK_STEP,
+            message: { planId, taskId }
+        }, enum_1.ActionPlanResponseType.START_TASK_STEP_RESPONSE);
+    },
+    /**
+     * Start/execute a task step in an action plan with event listener
+     * @param planId - The ID of the action plan
+     * @param taskId - The ID of the task to start
+     * @param onResponse - Callback function that will be called when receiving responses for this task
+     * @returns Cleanup function to remove the event listener
+     */
+    startTaskStepWithListener: (planId, taskId, onResponse) => {
+        // Set up event listener
+        const listener = (response) => {
+            // Filter responses related to this specific task
+            if (response.type === enum_1.ActionPlanResponseType.START_TASK_STEP_RESPONSE) {
+                if ((response === null || response === void 0 ? void 0 : response.taskId) === taskId) {
+                    onResponse(response);
+                }
+            }
+        };
+        // Add the listener to the message manager
+        websocket_1.default.messageManager.on('message', listener);
+        // Send the request
+        websocket_1.default.messageManager.send({
+            "type": enum_1.EventType.ACTION_PLAN,
+            "action": enum_1.ActionPlanAction.START_TASK_STEP,
+            message: { planId, taskId }
+        });
+        // Return cleanup function to remove the listener
+        return () => {
+            websocket_1.default.messageManager.off('message', listener);
+        };
+    }
+};
+exports.default = codeboltActionPlan;

package/dist/modules/agent.d.ts

@@ -6,7 +6,7 @@ declare const codeboltAgent: {
      * @param {string} task - The task for which an agent is needed.
      * @returns {Promise<FindAgentByTaskResponse>} A promise that resolves with the agent details.
      */
-    findAgent: (task: string, maxResult: number | undefined, agents: never[] | undefined, agentLocaltion: AgentLocation, getFrom: FilterUsing.USE_VECTOR_DB) => Promise<FindAgentByTaskResponse>;
+    findAgent: (task: string, maxResult: number | undefined, agents: never[] | undefined, agentLocaltion: AgentLocation | undefined, getFrom: FilterUsing.USE_VECTOR_DB) => Promise<FindAgentByTaskResponse>;
     /**
      * Starts an agent for the specified task.
      * @param {string} task - The task for which the agent should be started.

package/dist/modules/chat.d.ts

@@ -18,7 +18,7 @@ declare const cbchat: {
      * Sends a message through the WebSocket connection.
      * @param {string} message - The message to be sent.
      */
-    sendMessage: (message: string, payload: any) => void;
+    sendMessage: (message: string, payload?: any) => void;
     /**
      * Waits for a reply to a sent message.
      * @param {string} message - The message for which a reply is expected.

package/dist/modules/memory.d.ts

@@ -1,3 +1,4 @@
+import type { TodoItem, TodoData } from '@codebolt/types/agent-to-app-ws-schema';
 export interface BaseMemoryResponse {
     requestId: string;
     success?: boolean;
@@ -29,6 +30,12 @@ declare const cbmemory: {
         delete: (memoryId: string) => Promise<DeleteMemoryResponse>;
         list: (filters?: Record<string, unknown>) => Promise<ListMemoryResponse>;
     };
+    todo: {
+        save: (todo: TodoData, metadata?: Record<string, unknown>) => Promise<SaveMemoryResponse>;
+        update: (memoryId: string, todo: TodoItem) => Promise<UpdateMemoryResponse>;
+        delete: (memoryId: string) => Promise<DeleteMemoryResponse>;
+        list: (filters?: Record<string, unknown>) => Promise<ListMemoryResponse>;
+    };
     markdown: {
         save: (markdown: string, metadata?: Record<string, unknown>) => Promise<SaveMemoryResponse>;
         update: (memoryId: string, markdown: string, metadata?: Record<string, unknown>) => Promise<UpdateMemoryResponse>;

package/dist/modules/memory.js

@@ -8,22 +8,20 @@ const crypto_1 = require("crypto");
 const cbmemory = {
     json: {
         save: (json) => {
-            const requestId = (0, crypto_1.randomUUID)();
             const event = {
                 type: 'memoryEvent',
                 action: 'saveMemory',
-                requestId,
+                requestId: (0, crypto_1.randomUUID)(),
                 format: 'json',
                 json
             };
             return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'saveMemoryResponse');
         },
         update: (memoryId, json) => {
-            const requestId = (0, crypto_1.randomUUID)();
             const event = {
                 type: 'memoryEvent',
                 action: 'updateMemory',
-                requestId,
+                requestId: (0, crypto_1.randomUUID)(),
                 format: 'json',
                 memoryId,
                 json
@@ -31,35 +29,76 @@ const cbmemory = {
             return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'updateMemoryResponse');
         },
         delete: (memoryId) => {
-            const requestId = (0, crypto_1.randomUUID)();
             const event = {
                 type: 'memoryEvent',
                 action: 'deleteMemory',
-                requestId,
+                requestId: (0, crypto_1.randomUUID)(),
                 format: 'json',
                 memoryId
             };
             return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'deleteMemoryResponse');
         },
         list: (filters = {}) => {
-            const requestId = (0, crypto_1.randomUUID)();
             const event = {
                 type: 'memoryEvent',
                 action: 'listMemory',
-                requestId,
+                requestId: (0, crypto_1.randomUUID)(),
                 format: 'json',
                 filters
             };
             return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'listMemoryResponse');
         }
     },
+    todo: {
+        save: (todo, metadata = {}) => {
+            const event = {
+                type: 'memoryEvent',
+                action: 'saveMemory',
+                requestId: (0, crypto_1.randomUUID)(),
+                format: 'todo',
+                todo,
+                metadata
+            };
+            return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'saveMemoryResponse');
+        },
+        update: (memoryId, todo) => {
+            const event = {
+                type: 'memoryEvent',
+                action: 'updateMemory',
+                requestId: (0, crypto_1.randomUUID)(),
+                format: 'todo',
+                memoryId,
+                todo
+            };
+            return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'updateMemoryResponse');
+        },
+        delete: (memoryId) => {
+            const event = {
+                type: 'memoryEvent',
+                action: 'deleteMemory',
+                requestId: (0, crypto_1.randomUUID)(),
+                format: 'todo',
+                memoryId
+            };
+            return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'deleteMemoryResponse');
+        },
+        list: (filters = {}) => {
+            const event = {
+                type: 'memoryEvent',
+                action: 'listMemory',
+                requestId: (0, crypto_1.randomUUID)(),
+                format: 'todo',
+                filters
+            };
+            return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'listMemoryResponse');
+        }
+    },
     markdown: {
         save: (markdown, metadata = {}) => {
-            const requestId = (0, crypto_1.randomUUID)();
             const event = {
                 type: 'memoryEvent',
                 action: 'saveMemory',
-                requestId,
+                requestId: (0, crypto_1.randomUUID)(),
                 format: 'markdown',
                 markdown,
                 metadata
@@ -67,11 +106,10 @@ const cbmemory = {
             return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'saveMemoryResponse');
         },
         update: (memoryId, markdown, metadata = {}) => {
-            const requestId = (0, crypto_1.randomUUID)();
             const event = {
                 type: 'memoryEvent',
                 action: 'updateMemory',
-                requestId,
+                requestId: (0, crypto_1.randomUUID)(),
                 format: 'markdown',
                 memoryId,
                 markdown,
@@ -80,22 +118,20 @@ const cbmemory = {
             return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'updateMemoryResponse');
         },
         delete: (memoryId) => {
-            const requestId = (0, crypto_1.randomUUID)();
             const event = {
                 type: 'memoryEvent',
                 action: 'deleteMemory',
-                requestId,
+                requestId: (0, crypto_1.randomUUID)(),
                 format: 'markdown',
                 memoryId
             };
             return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'deleteMemoryResponse');
         },
         list: (filters = {}) => {
-            const requestId = (0, crypto_1.randomUUID)();
             const event = {
                 type: 'memoryEvent',
                 action: 'listMemory',
-                requestId,
+                requestId: (0, crypto_1.randomUUID)(),
                 format: 'markdown',
                 filters
             };

package/dist/modules/task.d.ts

@@ -176,12 +176,9 @@ declare const taskService: {
      * @deprecated Use getTaskList instead
      */
     getTasksByCategory: (category: string) => Promise<GetTaskListResponse>;
-    attachJsonMemoryToTask: (taskId: string, memoryId: string) => Promise<any>;
-    attachMarktownMemoryJToTask: (taskId: string, memoryId: string) => Promise<any>;
-    attachToDoToTask: (taskId: string, todoId: string) => Promise<any>;
-    getAttachedTodos: (taskId: string) => Promise<any>;
-    getAttachedJsonMemory: (taskId: string) => Promise<any>;
-    getAttachedMarkdownMemory: (taskId: string) => Promise<any>;
+    attachMemoryToTask: (taskId: string, memoryId: string) => Promise<any>;
+    getAttachedMemoryForTask: (taskId: string) => Promise<any>;
+    createTaskGroup: (groupName: string, description: string) => Promise<any>;
 };
 export type { Task, ExtendedTask, Step, ExtendedStep, TaskMessage, MessageData, ResponseMessageData, TaskStats, CreateTaskOptions, UpdateTaskOptions, GetTaskListOptions, AddStepToTaskOptions, GetTaskDetailOptions, GetTaskMessagesOptions, UpdateStepStatusOptions, CompleteStepOptions, SendSteeringMessageOptions, GetAllStepsOptions, GetActiveStepOptions, DeleteTaskOptions, CompleteTaskOptions, StartTaskOptions, CanTaskStartOptions, GetTasksDependentOnOptions, GetTasksReadyToStartOptions, GetTaskDependencyChainOptions, GetTaskStatsOptions, TaskResponse, TaskListResponse, StepResponse, StepListResponse, TaskMessagesResponse, ActiveStepResponse, SendSteeringMessageResponse, DeleteTaskResponse, CanTaskStartResponse, TaskStatsResponse, CreateTaskResponse, GetTaskListResponse, AddStepToTaskResponse, GetTaskDetailResponse, GetTaskMessagesResponse, GetAllStepsResponse, GetCurrentRunningStepResponse, UpdateStepStatusResponse, CompleteStepResponse, UpdateTaskResponse, CompleteTaskResponse, StartTaskResponse, GetTasksDependentOnResponse, GetTasksReadyToStartResponse, GetTaskDependencyChainResponse, GetTaskStatsResponse, Position, FlowData };
 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 };

package/dist/modules/task.js

@@ -437,68 +437,37 @@ const taskService = {
         // This would need to be implemented as post-processing
         return taskService.getTaskList();
     },
-    attachJsonMemoryToTask: (taskId, memoryId) => {
+    attachMemoryToTask: (taskId, memoryId) => {
         const requestId = (0, crypto_1.randomUUID)();
         const event = {
             type: 'taskEvent',
-            action: 'attachJsonMemoryToTask',
+            action: 'attachMemoryToTask',
             requestId,
             taskId,
             memoryId
         };
-        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'attachJsonMemoryToTaskResponse');
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'attachMemoryToTaskResponse');
     },
-    attachMarktownMemoryJToTask: (taskId, memoryId) => {
+    getAttachedMemoryForTask: (taskId) => {
         const requestId = (0, crypto_1.randomUUID)();
         const event = {
             type: 'taskEvent',
-            action: 'attachMarktownMemoryJToTask',
+            action: 'getAttachedFromTaskMemory',
             requestId,
             taskId,
-            memoryId
-        };
-        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'attachJsonMemoryToTaskResponse');
-    },
-    attachToDoToTask: (taskId, todoId) => {
-        const requestId = (0, crypto_1.randomUUID)();
-        const event = {
-            type: 'taskEvent',
-            action: 'attachToDoToTask',
-            requestId,
-            taskId,
-            todoId
         };
-        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'attachToDoToTaskResponse');
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getAttachedFromTaskMemoryResponse');
     },
-    getAttachedTodos: (taskId) => {
+    createTaskGroup: (groupName, description) => {
         const requestId = (0, crypto_1.randomUUID)();
         const event = {
             type: 'taskEvent',
-            action: 'attachToDoToTask',
+            action: 'createTaskGroup',
             requestId,
-            taskId,
-        };
-        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'attachToDoToTaskResponse');
-    },
-    getAttachedJsonMemory: (taskId) => {
-        const requestId = (0, crypto_1.randomUUID)();
-        const event = {
-            type: 'taskEvent',
-            action: 'getAttachedJsonMemory',
-            requestId,
-            taskId,
-        };
-        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getAttachedJsonMemoryResponse');
-    },
-    getAttachedMarkdownMemory: (taskId) => {
-        const requestId = (0, crypto_1.randomUUID)();
-        const event = {
-            type: 'taskEvent',
-            action: 'getAttachedMarkdownMemory',
-            requestId,
-            taskId,
+            groupName,
+            description
         };
-        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getAttachedMarkdownMemoryResponse');
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'createTaskGroupResponse');
     }
 };
 exports.default = taskService;

package/dist/modules/user-message-utilities.d.ts

@@ -10,7 +10,7 @@ export declare const userMessageUtilities: {
      * Get the current user message object
      * @returns Current UserMessage or undefined
      */
-    getCurrent: () => any;
+    getCurrent: () => import("@codebolt/types/sdk").FlatUserMessage | undefined;
     /**
      * Get the user message text content
      * @returns Message text string
@@ -70,7 +70,7 @@ export declare const userMessageUtilities: {
      * Get processing configuration
      * @returns Processing configuration object
      */
-    getProcessingConfig: () => AgentProcessingConfig;
+    getProcessingConfig: () => import("@codebolt/types/sdk").AgentProcessingConfig;
     /**
      * Check if a processing type is enabled
      * @param type Processing type to check

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/codeboltjs",
-  "version": "4.0.2",
+  "version": "5.0.0",
   "description": "",
   "keywords": [],
   "author": "",
@@ -35,7 +35,7 @@
     "uuid": "^11.1.0",
     "ws": "^8.18.3",
     "yargs": "^17.7.2",
-    "@codebolt/types": "1.0.21"
+    "@codebolt/types": "1.0.22"
   },
   "devDependencies": {
     "@types/events": "^3.0.3",