@codebolt/codeboltjs 4.0.2 → 4.0.3

package/dist/core/Codebolt.d.ts

@@ -35,19 +35,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 +59,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 +67,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>;
+        waitforReply: (message: string) => Promise<import("@codebolt/types/sdk").UserMessage>;
         processStarted: (onStopClicked?: (message: any) => void) => {
             stopProcess: () => void;
             cleanup: () => void;
@@ -150,8 +150,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 +174,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,52 +208,52 @@ 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>;
+        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>;
         attachJsonMemoryToTask: (taskId: string, memoryId: string) => Promise<any>;
         attachMarktownMemoryJToTask: (taskId: string, memoryId: string) => Promise<any>;
         attachToDoToTask: (taskId: string, todoId: string) => Promise<any>;
@@ -262,54 +262,74 @@ declare class Codebolt {
         getAttachedMarkdownMemory: (taskId: 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>;
+        };
+    };
     /**
      * User message utilities for accessing current user message and context
      */
     userMessage: {
-        getCurrent: () => any;
+        getCurrent: () => FlatUserMessage | undefined;
         getText: () => string;
         getMentionedMCPs: () => string[];
         getMentionedFiles: () => string[];
@@ -321,7 +341,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;

package/dist/core/Codebolt.js

@@ -25,6 +25,7 @@ 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 notificationfunctions_1 = require("../notificationfunctions");
@@ -67,6 +68,7 @@ class Codebolt {
         this.agent = agent_1.default;
         this.utils = utils_1.default;
         this.notify = notificationfunctions_1.notificationFunctions;
+        this.memory = memory_1.default;
         /**
          * User message utilities for accessing current user message and context
          */

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/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/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": "4.0.3",
   "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",