@codebolt/codeboltjs 2.2.4 → 4.0.2

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<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>;
+        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>;
         writeToFile: (relPath: string, newContent: string) => Promise<any>;
-        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>;
+        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>;
         readManyFiles: (params: {
             paths: string[];
             include?: string[];
@@ -59,7 +59,7 @@ declare class Codebolt {
             include_metadata?: boolean;
             separator_format?: string;
             notifyUser?: boolean;
-        }) => Promise<import("@codebolt/types/sdk").ReadManyFilesResponse>;
+        }) => Promise<FlatUserMessage>;
         listDirectory: (params: {
             path: string;
             ignore?: string[];
@@ -67,55 +67,55 @@ declare class Codebolt {
             detailed?: boolean;
             limit?: number;
             notifyUser?: boolean;
-        }) => Promise<import("@codebolt/types/sdk").ListDirectoryResponse>;
+        }) => Promise<FlatUserMessage>;
     };
     git: {
-        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>;
+        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>;
     };
     llm: {
-        inference: (params: import("@codebolt/types/sdk").LLMInferenceParams) => Promise<{
-            completion: import("@codebolt/types/sdk").LLMCompletion;
+        inference: (params: FlatUserMessage) => Promise<{
+            completion: FlatUserMessage;
         }>;
         getModelConfig: (modelId?: string) => Promise<{
-            config: import("@codebolt/types/sdk").LLMModelConfig | null;
+            config: FlatUserMessage | null;
             success: boolean;
             error?: string;
         }>;
     };
     browser: {
-        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>;
+        newPage: () => Promise<FlatUserMessage>;
+        getUrl: () => Promise<FlatUserMessage>;
+        goToPage: (url: string) => Promise<FlatUserMessage>;
+        screenshot: () => Promise<FlatUserMessage>;
+        getHTML: () => Promise<FlatUserMessage>;
+        getMarkdown: () => Promise<FlatUserMessage>;
         getPDF: () => void;
         pdfToText: () => void;
-        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>;
+        getContent: () => Promise<FlatUserMessage>;
+        getSnapShot: () => Promise<FlatUserMessage>;
+        getBrowserInfo: () => Promise<FlatUserMessage>;
+        extractText: () => Promise<FlatUserMessage>;
         close: () => void;
-        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>;
+        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>;
     };
     chat: {
-        getChatHistory: (threadId: string) => Promise<import("@codebolt/types/sdk").ChatMessage>;
+        getChatHistory: (threadId: string) => Promise<FlatUserMessage>;
         setRequestHandler: (handler: (request: any, response: (data: any) => void) => Promise<void> | void) => void;
         sendMessage: (message: string, payload: any) => void;
-        waitforReply: (message: string) => Promise<import("@codebolt/types/sdk").UserMessage>;
+        waitforReply: (message: string) => Promise<FlatUserMessage>;
         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<import("@codebolt/types/sdk").CommandError>;
-        sendManualInterrupt(): Promise<import("@codebolt/types/sdk").TerminalInterruptResponse>;
+        executeCommandRunUntilError: (command: string, executeInMain?: boolean) => Promise<FlatUserMessage>;
+        sendManualInterrupt(): Promise<FlatUserMessage>;
         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<import("@codebolt/types/sdk").MatchProblemResponse>;
-        getMatcherList: () => Promise<import("@codebolt/types/sdk").GetMatcherListTreeResponse>;
-        matchDetail: (matcher: string) => Promise<import("@codebolt/types/sdk").getMatchDetail>;
+        performMatch: (matcherDefinition: object, problemPatterns: any[], problems?: any[]) => Promise<FlatUserMessage>;
+        getMatcherList: () => Promise<FlatUserMessage>;
+        matchDetail: (matcher: string) => Promise<FlatUserMessage>;
     };
     crawler: {
         start: () => void;
@@ -208,102 +208,108 @@ declare class Codebolt {
         parseWarnings: (output: import("../modules/outputparsers").ParsableOutput) => string[];
     };
     project: {
-        getProjectSettings: () => Promise<import("@codebolt/types/sdk").GetProjectSettingsResponse>;
-        getProjectPath: () => Promise<import("@codebolt/types/sdk").GetProjectPathResponse>;
-        getRepoMap: (message: any) => Promise<import("@codebolt/types/sdk").GetProjectPathResponse>;
+        getProjectSettings: () => Promise<FlatUserMessage>;
+        getProjectPath: () => Promise<FlatUserMessage>;
+        getRepoMap: (message: any) => Promise<FlatUserMessage>;
         runProject: () => void;
         getEditorFileStatus: () => Promise<any>;
     };
     dbmemory: {
-        addKnowledge: (key: string, value: import("@codebolt/types/sdk").MemoryValue) => Promise<import("@codebolt/types/sdk").MemorySetResponse>;
-        getKnowledge: (key: string) => Promise<import("@codebolt/types/sdk").MemoryGetResponse>;
+        addKnowledge: (key: string, value: FlatUserMessage) => Promise<FlatUserMessage>;
+        getKnowledge: (key: string) => Promise<FlatUserMessage>;
     };
     cbstate: {
         getApplicationState: () => Promise<import("../types/commonTypes").ApplicationState>;
-        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>;
+        addToAgentState: (key: string, value: string) => Promise<FlatUserMessage>;
+        getAgentState: () => Promise<FlatUserMessage>;
+        getProjectState: () => Promise<FlatUserMessage>;
+        updateProjectState: (key: string, value: any) => Promise<FlatUserMessage>;
     };
     task: {
-        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>;
+        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>;
     };
     vectordb: {
-        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>;
+        getVector: (key: string) => Promise<FlatUserMessage>;
+        addVectorItem: (item: any) => Promise<FlatUserMessage>;
+        queryVectorItem: (key: string) => Promise<FlatUserMessage>;
+        queryVectorItems: (items: [], dbPath: string) => Promise<FlatUserMessage>;
     };
     debug: {
-        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>;
+        debug: (log: string, type: import("../modules/debug").logType) => Promise<FlatUserMessage>;
+        openDebugBrowser: (url: string, port: number) => Promise<FlatUserMessage>;
     };
     tokenizer: {
-        addToken: (key: string) => Promise<import("@codebolt/types/sdk").AddTokenResponse>;
-        getToken: (key: string) => Promise<import("@codebolt/types/sdk").GetTokenResponse>;
+        addToken: (key: string) => Promise<FlatUserMessage>;
+        getToken: (key: string) => Promise<FlatUserMessage>;
     };
     chatSummary: {
-        summarizeAll: () => Promise<import("@codebolt/types/sdk").GetSummarizeAllResponse>;
+        summarizeAll: () => Promise<FlatUserMessage>;
         summarize: (messages: {
             role: string;
             content: string;
-        }[], depth: number) => Promise<import("@codebolt/types/sdk").GetSummarizeResponse>;
+        }[], depth: number) => Promise<FlatUserMessage>;
     };
     mcp: {
-        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>;
+        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>;
         getTools: (tools: {
             toolbox: string;
             toolName: string;
-        }[]) => Promise<import("@codebolt/types/sdk").GetToolsResponse>;
-        executeTool: (toolbox: string, toolName: string, params: import("@codebolt/types/sdk").ToolParameters) => Promise<import("@codebolt/types/sdk").ExecuteToolResponse>;
+        }[]) => Promise<FlatUserMessage>;
+        executeTool: (toolbox: string, toolName: string, params: FlatUserMessage) => Promise<FlatUserMessage>;
     };
     agent: {
-        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>;
+        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>;
     };
     utils: {
-        editFileAndApplyDiff: (filePath: string, diff: string, diffIdentifier: string, prompt: string, applyModel?: string) => Promise<import("@codebolt/types/sdk").FsEditFileAndApplyDiffResponse>;
+        editFileAndApplyDiff: (filePath: string, diff: string, diffIdentifier: string, prompt: string, applyModel?: string) => Promise<FlatUserMessage>;
     };
     notify: NotificationFunctions;
     /**
      * User message utilities for accessing current user message and context
      */
     userMessage: {
-        getCurrent: () => FlatUserMessage | undefined;
+        getCurrent: () => any;
         getText: () => string;
         getMentionedMCPs: () => string[];
         getMentionedFiles: () => string[];
@@ -315,7 +321,7 @@ declare class Codebolt {
         getSelection: () => string | undefined;
         getMessageId: () => string | undefined;
         getThreadId: () => string | undefined;
-        getProcessingConfig: () => import("@codebolt/types/sdk").AgentProcessingConfig;
+        getProcessingConfig: () => AgentProcessingConfig;
         isProcessingEnabled: (type: "processMentionedMCPs" | "processRemixPrompt" | "processMentionedFiles" | "processMentionedAgents") => boolean;
         setSessionData: (key: string, value: any) => void;
         getSessionData: (key: string) => any;

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 | undefined, getFrom: FilterUsing.USE_VECTOR_DB) => Promise<FindAgentByTaskResponse>;
+    findAgent: (task: string, maxResult: number | undefined, agents: never[] | undefined, agentLocaltion: AgentLocation, 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

@@ -0,0 +1,39 @@
+export interface BaseMemoryResponse {
+    requestId: string;
+    success?: boolean;
+    message?: string;
+    error?: string;
+}
+export interface SaveMemoryResponse extends BaseMemoryResponse {
+    type: 'saveMemoryResponse';
+    memoryId?: string;
+    data?: unknown;
+}
+export interface UpdateMemoryResponse extends BaseMemoryResponse {
+    type: 'updateMemoryResponse';
+    memoryId?: string;
+    data?: unknown;
+}
+export interface DeleteMemoryResponse extends BaseMemoryResponse {
+    type: 'deleteMemoryResponse';
+}
+export interface ListMemoryResponse extends BaseMemoryResponse {
+    type: 'listMemoryResponse';
+    items?: unknown[];
+}
+export type MemoryServiceResponse = SaveMemoryResponse | UpdateMemoryResponse | DeleteMemoryResponse | ListMemoryResponse;
+declare const cbmemory: {
+    json: {
+        save: (json: any) => Promise<SaveMemoryResponse>;
+        update: (memoryId: string, json: any) => 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>;
+        delete: (memoryId: string) => Promise<DeleteMemoryResponse>;
+        list: (filters?: Record<string, unknown>) => Promise<ListMemoryResponse>;
+    };
+};
+export default cbmemory;

package/dist/modules/memory.js

@@ -0,0 +1,106 @@
+"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 crypto_1 = require("crypto");
+const cbmemory = {
+    json: {
+        save: (json) => {
+            const requestId = (0, crypto_1.randomUUID)();
+            const event = {
+                type: 'memoryEvent',
+                action: 'saveMemory',
+                requestId,
+                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,
+                format: 'json',
+                memoryId,
+                json
+            };
+            return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'updateMemoryResponse');
+        },
+        delete: (memoryId) => {
+            const requestId = (0, crypto_1.randomUUID)();
+            const event = {
+                type: 'memoryEvent',
+                action: 'deleteMemory',
+                requestId,
+                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,
+                format: 'json',
+                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,
+                format: 'markdown',
+                markdown,
+                metadata
+            };
+            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,
+                format: 'markdown',
+                memoryId,
+                markdown,
+                metadata
+            };
+            return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'updateMemoryResponse');
+        },
+        delete: (memoryId) => {
+            const requestId = (0, crypto_1.randomUUID)();
+            const event = {
+                type: 'memoryEvent',
+                action: 'deleteMemory',
+                requestId,
+                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,
+                format: 'markdown',
+                filters
+            };
+            return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'listMemoryResponse');
+        }
+    }
+};
+exports.default = cbmemory;

package/dist/modules/task.d.ts

@@ -176,6 +176,12 @@ 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>;
 };
 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

@@ -436,6 +436,69 @@ const taskService = {
         // Note: The new API doesn't have category filtering built-in
         // This would need to be implemented as post-processing
         return taskService.getTaskList();
+    },
+    attachJsonMemoryToTask: (taskId, memoryId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'attachJsonMemoryToTask',
+            requestId,
+            taskId,
+            memoryId
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'attachJsonMemoryToTaskResponse');
+    },
+    attachMarktownMemoryJToTask: (taskId, memoryId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'attachMarktownMemoryJToTask',
+            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');
+    },
+    getAttachedTodos: (taskId) => {
+        const requestId = (0, crypto_1.randomUUID)();
+        const event = {
+            type: 'taskEvent',
+            action: 'attachToDoToTask',
+            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,
+        };
+        return websocket_1.default.messageManager.sendAndWaitForResponse(event, 'getAttachedMarkdownMemoryResponse');
     }
 };
 exports.default = taskService;

package/dist/modules/todo.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules/todo.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cbTodo = {
+    createTodos: () => {
+    },
+    getTodos: (taskId) => {
+    }
+};
+module.exports = cbTodo;

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: () => import("@codebolt/types/sdk").FlatUserMessage | undefined;
+    getCurrent: () => any;
     /**
      * 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: () => import("@codebolt/types/sdk").AgentProcessingConfig;
+    getProcessingConfig: () => 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": "2.2.4",
+  "version": "4.0.2",
   "description": "",
   "keywords": [],
   "author": "",
@@ -9,18 +9,9 @@
   "files": [
     "dist/**/*",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "package.json"
   ],
-  "scripts": {
-    "build": "tsc && node script/copy-wasm.js",
-    "build:webpack": "webpack",
-    "build:all": "npm run build && npm run build:webpack",
-    "build:docs": "typedoc --plugin typedoc-plugin-missing-exports",
-    "build:jsondocs": "typedoc --plugin typedoc-plugin-missing-exports --json out.json --pretty",
-    "test": "echo \"Integration tests require WebSocket server - skipping for release\" && exit 0",
-    "clean": "powershell -Command \"Remove-Item -Path 'dist' -Recurse -Force -ErrorAction SilentlyContinue; Remove-Item -Path 'build' -Recurse -Force -ErrorAction SilentlyContinue\"",
-    "lint": "eslint src/**/*.ts && tsc --noEmit"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/codeboltai/codeboltjs.git",
@@ -32,7 +23,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@codebolt/types": "workspace:*",
     "@types/uuid": "^10.0.0",
     "buffer": "^6.0.3",
     "execa": "^9.5.2",
@@ -44,7 +34,8 @@
     "util": "^0.12.5",
     "uuid": "^11.1.0",
     "ws": "^8.18.3",
-    "yargs": "^17.7.2"
+    "yargs": "^17.7.2",
+    "@codebolt/types": "1.0.21"
   },
   "devDependencies": {
     "@types/events": "^3.0.3",
@@ -70,5 +61,15 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     }
+  },
+  "scripts": {
+    "build": "tsc && node script/copy-wasm.js",
+    "build:webpack": "webpack",
+    "build:all": "npm run build && npm run build:webpack",
+    "build:docs": "typedoc --plugin typedoc-plugin-missing-exports",
+    "build:jsondocs": "typedoc --plugin typedoc-plugin-missing-exports --json out.json --pretty",
+    "test": "echo \"Integration tests require WebSocket server - skipping for release\" && exit 0",
+    "clean": "powershell -Command \"Remove-Item -Path 'dist' -Recurse -Force -ErrorAction SilentlyContinue; Remove-Item -Path 'build' -Recurse -Force -ErrorAction SilentlyContinue\"",
+    "lint": "eslint src/**/*.ts && tsc --noEmit"
   }
-}
+}