@codebolt/codeboltjs 5.0.1 → 5.0.3

package/dist/core/Codebolt.d.ts

@@ -13,6 +13,7 @@ declare class Codebolt {
     private readyHandlers;
     private messageQueue;
     private messageResolvers;
+    private lastUserMessage;
     /**
      * @constructor
      * @description Initializes the websocket connection.
@@ -82,6 +83,7 @@ declare class Codebolt {
         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>;
+        clone: (url: string, path?: string) => Promise<import("@codebolt/types/sdk").GitCloneResponse>;
     };
     llm: {
         inference: (params: import("@codebolt/types/sdk").LLMInferenceParams) => Promise<{
@@ -93,25 +95,77 @@ declare class Codebolt {
             error?: string;
         }>;
     };
+    mail: {
+        registerAgent: (params: import("@codebolt/types/sdk").IRegisterAgentParams) => Promise<import("@codebolt/types/sdk").IRegisterAgentResponse>;
+        listAgents: () => Promise<import("../modules/mail").IListAgentsResponse>;
+        getAgent: (params: import("../modules/mail").IGetAgentParams) => Promise<import("../modules/mail").IGetAgentResponse>;
+        createThread: (params: import("../modules/mail").ICreateThreadParams) => Promise<import("../modules/mail").ICreateThreadResponse>;
+        findOrCreateThread: (params: import("../modules/mail").IFindOrCreateThreadParams) => Promise<import("../modules/mail").IFindOrCreateThreadResponse>;
+        listThreads: (params?: import("../modules/mail").IListThreadsParams) => Promise<import("../modules/mail").IListThreadsResponse>;
+        getThread: (params: import("../modules/mail").IGetThreadParams) => Promise<import("../modules/mail").IGetThreadResponse>;
+        updateThreadStatus: (params: import("../modules/mail").IUpdateThreadStatusParams) => Promise<import("../modules/mail").IUpdateThreadStatusResponse>;
+        archiveThread: (params: import("../modules/mail").IArchiveThreadParams) => Promise<import("../modules/mail").IArchiveThreadResponse>;
+        fetchInbox: (params: import("@codebolt/types/sdk").IFetchInboxParams) => Promise<import("@codebolt/types/sdk").IFetchInboxResponse>;
+        sendMessage: (params: import("@codebolt/types/sdk").ISendMessageParams) => Promise<import("@codebolt/types/sdk").ISendMessageResponse>;
+        replyMessage: (params: import("@codebolt/types/sdk").IReplyMessageParams) => Promise<import("@codebolt/types/sdk").IReplyMessageResponse>;
+        getMessage: (params: import("../modules/mail").IGetMessageParams) => Promise<import("../modules/mail").IGetMessageResponse>;
+        getMessages: (params: import("../modules/mail").IGetMessagesParams) => Promise<import("../modules/mail").IGetMessagesResponse>;
+        markRead: (params: import("@codebolt/types/sdk").IMarkReadParams) => Promise<import("@codebolt/types/sdk").IMarkReadResponse>;
+        acknowledge: (params: import("@codebolt/types/sdk").IAcknowledgeParams) => Promise<import("@codebolt/types/sdk").IAcknowledgeResponse>;
+        search: (params: import("@codebolt/types/sdk").ISearchParams) => Promise<import("@codebolt/types/sdk").ISearchResponse>;
+        summarizeThread: (params: import("@codebolt/types/sdk").ISummarizeThreadParams) => Promise<import("@codebolt/types/sdk").ISummarizeThreadResponse>;
+        reserveFiles: (params: import("@codebolt/types/sdk").IReserveFilesParams) => Promise<import("@codebolt/types/sdk").IReserveFilesResponse>;
+        releaseFiles: (params: import("@codebolt/types/sdk").IReleaseFilesParams) => Promise<import("@codebolt/types/sdk").IReleaseFilesResponse>;
+        forceReserveFiles: (params: import("@codebolt/types/sdk").IForceReserveFilesParams) => Promise<import("@codebolt/types/sdk").IForceReserveFilesResponse>;
+        listReservations: (params: import("@codebolt/types/sdk").IListReservationsParams) => Promise<import("@codebolt/types/sdk").IListReservationsResponse>;
+        checkConflicts: (params: import("@codebolt/types/sdk").ICheckConflictsParams) => Promise<import("@codebolt/types/sdk").ICheckConflictsResponse>;
+    };
+    groupFeedback: {
+        create: (params: import("..").ICreateFeedbackParams) => Promise<import("..").ICreateFeedbackResponse>;
+        get: (params: import("..").IGetFeedbackParams) => Promise<import("..").IGetFeedbackResponse>;
+        list: (params?: import("..").IListFeedbacksParams) => Promise<import("..").IListFeedbacksResponse>;
+        respond: (params: import("..").IRespondParams) => Promise<import("..").IRespondResponse>;
+        reply: (params: import("..").IReplyParams) => Promise<import("..").IReplyResponse>;
+        updateSummary: (params: import("..").IUpdateSummaryParams) => Promise<import("..").IUpdateSummaryResponse>;
+        updateStatus: (params: import("..").IUpdateStatusParams) => Promise<import("..").IUpdateStatusResponse>;
+    };
+    agentDeliberation: {
+        create: (params: import("..").ICreateDeliberationParams) => Promise<import("..").ICreateDeliberationResponse>;
+        get: (params: import("..").IGetDeliberationParams) => Promise<import("..").IGetDeliberationResponse>;
+        list: (params?: import("..").IListDeliberationsParams) => Promise<import("..").IListDeliberationsResponse>;
+        update: (params: import("..").IUpdateDeliberationParams) => Promise<import("..").IUpdateDeliberationResponse>;
+        respond: (params: import("..").IDeliberationRespondParams) => Promise<import("..").IDeliberationRespondResponse>;
+        vote: (params: import("..").IVoteParams) => Promise<import("..").IVoteResponse>;
+        getWinner: (params: import("..").IGetWinnerParams) => Promise<import("..").IGetWinnerResponse>;
+        summary: (params: import("../types/agentDeliberation").ISummaryParams) => Promise<import("../types/agentDeliberation").ISummaryResponse>;
+    };
     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>;
-        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>;
-        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>;
+        newPage: (options?: import("..").BrowserInstanceOptions) => Promise<import("@codebolt/types/sdk").BrowserActionResponseData>;
+        getUrl: (options?: import("..").BrowserOperationOptions) => Promise<import("@codebolt/types/sdk").UrlResponse>;
+        goToPage: (url: string, options?: import("..").BrowserOperationOptions) => Promise<import("@codebolt/types/sdk").GoToPageResponse>;
+        screenshot: (options?: import("..").BrowserScreenshotOptions) => Promise<import("@codebolt/types/sdk").BrowserScreenshotResponse>;
+        getHTML: (options?: import("..").BrowserOperationOptions) => Promise<import("@codebolt/types/sdk").HtmlReceived>;
+        getMarkdown: (options?: import("..").BrowserOperationOptions) => Promise<import("@codebolt/types/sdk").GetMarkdownResponse>;
+        getPDF: (options?: import("..").BrowserOperationOptions) => Promise<void>;
+        pdfToText: (options?: import("..").BrowserOperationOptions) => Promise<void>;
+        getContent: (options?: import("..").BrowserOperationOptions) => Promise<import("@codebolt/types/sdk").GetContentResponse>;
+        getSnapShot: (options?: import("..").BrowserOperationOptions) => Promise<import("@codebolt/types/sdk").BrowserSnapshotResponse>;
+        getBrowserInfo: (options?: import("..").BrowserOperationOptions) => Promise<import("@codebolt/types/sdk").BrowserInfoResponse>;
+        extractText: (options?: import("..").BrowserOperationOptions) => Promise<import("@codebolt/types/sdk").ExtractTextResponse>;
+        close: (options?: import("..").BrowserOperationOptions) => Promise<void>;
+        scroll: (direction: string, pixels: string, options?: import("..").BrowserOperationOptions) => Promise<import("@codebolt/types/sdk").BrowserActionResponseData>;
+        type: (elementid: string, text: string, options?: import("..").BrowserOperationOptions) => Promise<import("@codebolt/types/sdk").BrowserActionResponseData>;
+        click: (elementid: string, options?: import("..").BrowserOperationOptions) => Promise<import("@codebolt/types/sdk").BrowserActionResponseData>;
+        enter: (options?: import("..").BrowserOperationOptions) => Promise<import("@codebolt/types/sdk").BrowserActionResponseData>;
+        search: (elementid: string, query: string, options?: import("..").BrowserOperationOptions) => Promise<import("@codebolt/types/sdk").BrowserActionResponseData>;
+        listBrowserInstances: () => Promise<import("..").BrowserInstanceInfo[]>;
+        getBrowserInstance: (instanceId: string) => Promise<import("..").BrowserInstanceInfo | null>;
+        setActiveBrowserInstance: (instanceId: string) => Promise<boolean>;
+        openNewBrowserInstance: (options?: import("..").BrowserInstanceOptions) => Promise<{
+            instanceId: string;
+        }>;
+        closeBrowserInstance: (instanceId: string) => Promise<boolean>;
+        executeOnInstance: (instanceId: string, operation: string, params: any) => Promise<any>;
     };
     chat: {
         getChatHistory: (threadId: string) => Promise<import("@codebolt/types/sdk").ChatMessage>;
@@ -130,6 +184,8 @@ declare class Codebolt {
         sendConfirmationRequest: (confirmationMessage: string, buttons?: string[], withFeedback?: boolean) => Promise<string>;
         askQuestion: (question: string, buttons?: string[], withFeedback?: boolean) => Promise<string>;
         sendNotificationEvent: (notificationMessage: string, type: "debug" | "git" | "planner" | "browser" | "editor" | "terminal" | "preview") => void;
+        checkForSteeringMessage: () => any;
+        onSteeringMessageReceived: () => Promise<any>;
     };
     terminal: {
         eventEmitter: {
@@ -153,6 +209,7 @@ declare class Codebolt {
         };
         executeCommand: (command: string, returnEmptyStringOnSuccess?: boolean) => Promise<any>;
         executeCommandRunUntilError: (command: string, executeInMain?: boolean) => Promise<import("@codebolt/types/sdk").CommandError>;
+        executeCommandRunUntilInterrupt: (command: string, executeInMain?: boolean) => Promise<import("@codebolt/types/sdk").CommandError>;
         sendManualInterrupt(): Promise<import("@codebolt/types/sdk").TerminalInterruptResponse>;
         executeCommandWithStream(command: string, executeInMain?: boolean): {
             cleanup?: () => void;
@@ -228,37 +285,29 @@ declare class Codebolt {
         updateProjectState: (key: string, value: any) => Promise<import("@codebolt/types/sdk").UpdateProjectStateResponse>;
     };
     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>;
-        attachMemoryToTask: (taskId: string, memoryId: string) => Promise<any>;
-        getAttachedMemoryForTask: (taskId: string) => Promise<any>;
-        createTaskGroup: (groupName: string, description: string) => Promise<any>;
+        createTask: (options: import("@codebolt/types/agent-to-app-ws-schema").CreateTaskOptions) => Promise<import("@codebolt/types/app-to-agent-ws-schema").CreateTaskResponse>;
+        updateTask: (taskId: string, updates: import("@codebolt/types/agent-to-app-ws-schema").UpdateTaskOptions) => Promise<import("@codebolt/types/app-to-agent-ws-schema").UpdateTaskResponse>;
+        deleteTask: (taskId: string) => Promise<import("@codebolt/types/app-to-agent-ws-schema").DeleteTaskResponse>;
+        getTaskList: (options?: import("@codebolt/types/agent-to-app-ws-schema").GetTaskListOptions) => Promise<import("@codebolt/types/app-to-agent-ws-schema").ListTasksResponse>;
+        getTaskDetail: (options: import("@codebolt/types/agent-to-app-ws-schema").GetTaskDetailOptions) => Promise<import("@codebolt/types/app-to-agent-ws-schema").GetTaskResponse>;
+        assignAgentToTask: (taskId: string, agentId: string) => Promise<import("@codebolt/types/app-to-agent-ws-schema").UpdateTaskResponse>;
+        executeTaskWithAgent: (taskId: string, agentId: string) => Promise<import("@codebolt/types/app-to-agent-ws-schema").StartTaskWithAgentResponse>;
+        getTaskStatus: (taskId: string) => Promise<string | undefined>;
+        getTaskSummary: (taskId: string) => Promise<string | undefined>;
+    };
+    thread: {
+        createThread: (options: any) => Promise<import("@codebolt/types/app-to-agent-ws-schema").CreateThreadResponse>;
+        createAndStartThread: (options: import("@codebolt/types/agent-to-app-ws-schema").CreateAndStartThreadOptions) => Promise<import("@codebolt/types/app-to-agent-ws-schema").StartThreadResponse>;
+        createThreadInBackground: (options: import("@codebolt/types/agent-to-app-ws-schema").CreateAndStartThreadOptions) => Promise<import("@codebolt/types/app-to-agent-ws-schema").ThreadAgentStartedResponse | import("@codebolt/types/app-to-agent-ws-schema").ThreadAgentStartFailedResponse>;
+        getThreadList: (options?: import("@codebolt/types/agent-to-app-ws-schema").GetThreadListOptions) => Promise<import("@codebolt/types/app-to-agent-ws-schema").ListThreadsResponse>;
+        getThreadDetail: (options: import("@codebolt/types/agent-to-app-ws-schema").GetThreadDetailOptions) => Promise<import("@codebolt/types/app-to-agent-ws-schema").GetThreadResponse>;
+        startThread: (threadId: string) => Promise<import("@codebolt/types/app-to-agent-ws-schema").StartThreadResponse>;
+        updateThread: (threadId: string, updates: import("@codebolt/types/agent-to-app-ws-schema").UpdateThreadOptions) => Promise<import("@codebolt/types/app-to-agent-ws-schema").UpdateThreadResponse>;
+        deleteThread: (threadId: string) => Promise<import("@codebolt/types/app-to-agent-ws-schema").DeleteThreadResponse>;
+        updateThreadStatus: (threadId: string, status: string) => Promise<import("@codebolt/types/app-to-agent-ws-schema").UpdateThreadStatusResponse>;
+        getThreadMessages: (options: import("@codebolt/types/agent-to-app-ws-schema").GetThreadMessagesOptions) => Promise<import("@codebolt/types/app-to-agent-ws-schema").GetThreadMessagesResponse>;
+        getThreadFileChanges: (threadId: string) => Promise<any>;
+        getThreadFileChangesSummary: (threadId: string) => Promise<any>;
     };
     vectordb: {
         getVector: (key: string) => Promise<import("@codebolt/types/sdk").GetVectorResponse>;
@@ -288,17 +337,22 @@ declare class Codebolt {
         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: {
+        getTools: (toolRequests: {
             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>;
+        getMcpTools: (mcpNames?: string[]) => Promise<import("@codebolt/types/sdk").GetMcpToolsResponse>;
+        getMcpList: () => Promise<import("@codebolt/types/sdk").GetMcpListResponse>;
+        getAllMcpTools: () => Promise<import("@codebolt/types/sdk").GetAllMCPToolsResponse>;
+        getEnabledMcps: () => Promise<import("@codebolt/types/sdk").GetEnabledMCPSResponse>;
+        configureMcpTool: (mcpName: string, toolName: string, config: Record<string, unknown>) => Promise<import("@codebolt/types/sdk").ConfigureMCPToolResponse>;
     };
     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>;
+        getAgentsDetail: (agentList?: string[]) => Promise<import("@codebolt/types/sdk").AgentsDetailResponse>;
     };
     utils: {
         editFileAndApplyDiff: (filePath: string, diff: string, diffIdentifier: string, prompt: string, applyModel?: string) => Promise<import("@codebolt/types/sdk").FsEditFileAndApplyDiffResponse>;
@@ -344,9 +398,505 @@ declare class Codebolt {
             taskType?: string;
             [key: string]: any;
         }) => Promise<any>;
+        addGroupToActionPlan: (planId: string, group: {
+            type: "parallelGroup" | "loopGroup" | "ifGroup" | "waitUntilGroup";
+            name?: string;
+            groupItems?: Record<string, any[]>;
+            loopTasks?: any[];
+            ifTasks?: any[];
+            waitTasks?: any[];
+            [key: string]: any;
+        }) => Promise<any>;
         startTaskStep: (planId: string, taskId: string) => Promise<any>;
         startTaskStepWithListener: (planId: string, taskId: string, onResponse: (response: any) => void) => () => void;
     };
+    todo: {
+        addTodo: (params: {
+            title: string;
+            priority?: "high" | "medium" | "low";
+            tags?: string[];
+        }) => Promise<import("@codebolt/types/sdk").AddTodoResponse>;
+        updateTodo: (params: {
+            id: string;
+            title?: string;
+            status?: "pending" | "processing" | "completed" | "cancelled";
+            priority?: "high" | "medium" | "low";
+            tags?: string[];
+        }) => Promise<import("@codebolt/types/sdk").UpdateTodoResponse>;
+        getTodoList: (params?: any) => Promise<import("@codebolt/types/sdk").GetTodoListResponse>;
+        getAllIncompleteTodos: () => Promise<import("@codebolt/types/sdk").GetAllIncompleteTodosResponse>;
+        exportTodos: (params?: {
+            format?: "json" | "markdown";
+            listId?: string;
+            status?: string[];
+        }) => Promise<import("@codebolt/types/sdk").ExportTodosResponse>;
+        importTodos: (params: {
+            data: string;
+            format?: "json" | "markdown";
+            mergeStrategy?: "replace" | "merge";
+            listId?: string;
+        }) => Promise<import("@codebolt/types/sdk").ImportTodosResponse>;
+    };
+    sideExecution: {
+        startWithActionBlock: (actionBlockPath: string, params?: Record<string, any>, timeout?: number) => Promise<import("@codebolt/types/sdk").StartSideExecutionResponse>;
+        startWithCode: (inlineCode: string, params?: Record<string, any>, timeout?: number) => Promise<import("@codebolt/types/sdk").StartSideExecutionResponse>;
+        stop: (sideExecutionId: string) => Promise<import("@codebolt/types/sdk").StopSideExecutionResponse>;
+        listActionBlocks: (projectPath?: string) => Promise<import("@codebolt/types/sdk").ListActionBlocksResponse>;
+        getStatus: (sideExecutionId: string) => Promise<import("@codebolt/types/sdk").GetSideExecutionStatusResponse>;
+    };
+    capability: {
+        listCapabilities: (filter?: import("@codebolt/types/sdk").CapabilityFilter) => Promise<import("@codebolt/types/sdk").ListCapabilitiesResponse>;
+        listCapabilitiesByType: (capabilityType: import("@codebolt/types/sdk").CapabilityType) => Promise<import("@codebolt/types/sdk").ListCapabilitiesResponse>;
+        listSkills: () => Promise<import("@codebolt/types/sdk").ListCapabilitiesResponse>;
+        listPowers: () => Promise<import("@codebolt/types/sdk").ListCapabilitiesResponse>;
+        listTalents: () => Promise<import("@codebolt/types/sdk").ListCapabilitiesResponse>;
+        getCapabilityDetail: (capabilityName: string, capabilityType?: import("@codebolt/types/sdk").CapabilityType) => Promise<import("@codebolt/types/sdk").GetCapabilityDetailResponse>;
+        listExecutors: () => Promise<import("@codebolt/types/sdk").ListExecutorsResponse>;
+        startCapability: (capabilityName: string, capabilityType: import("@codebolt/types/sdk").CapabilityType, params?: Record<string, any>, timeout?: number) => Promise<import("@codebolt/types/sdk").StartCapabilityResponse>;
+        startSkill: (skillName: string, params?: Record<string, any>, timeout?: number) => Promise<import("@codebolt/types/sdk").StartCapabilityResponse>;
+        startPower: (powerName: string, params?: Record<string, any>, timeout?: number) => Promise<import("@codebolt/types/sdk").StartCapabilityResponse>;
+        startTalent: (talentName: string, params?: Record<string, any>, timeout?: number) => Promise<import("@codebolt/types/sdk").StartCapabilityResponse>;
+        stopCapability: (executionId: string) => Promise<import("@codebolt/types/sdk").StopCapabilityResponse>;
+        getExecutionStatus: (executionId: string) => Promise<import("@codebolt/types/sdk").GetExecutionStatusResponse>;
+        getCapabilitiesByTag: (tag: string) => Promise<import("@codebolt/types/sdk").ListCapabilitiesResponse>;
+        getCapabilitiesByAuthor: (author: string) => Promise<import("@codebolt/types/sdk").ListCapabilitiesResponse>;
+    };
+    job: {
+        createJob: (groupId: string, data: import("..").CreateJobData) => Promise<import("..").JobCreateResponse>;
+        getJob: (jobId: string) => Promise<import("..").JobShowResponse>;
+        updateJob: (jobId: string, data: import("..").UpdateJobData) => Promise<import("..").JobUpdateResponse>;
+        deleteJob: (jobId: string) => Promise<import("..").JobDeleteResponse>;
+        deleteJobs: (jobIds: string[]) => Promise<import("..").JobDeleteBulkResponse>;
+        listJobs: (filters?: import("..").JobListFilters) => Promise<import("..").JobListResponse>;
+        createJobGroup: (data: import("..").CreateJobGroupData) => Promise<import("..").JobGroupCreateResponse>;
+        addDependency: (jobId: string, targetId: string, type?: import("..").DependencyType) => Promise<import("..").JobDependencyResponse>;
+        removeDependency: (jobId: string, targetId: string) => Promise<import("..").JobDependencyResponse>;
+        getReadyJobs: (filters?: import("..").JobListFilters) => Promise<import("..").JobReadyBlockedResponse>;
+        getBlockedJobs: (filters?: import("..").JobListFilters) => Promise<import("..").JobReadyBlockedResponse>;
+        addLabel: (label: string) => Promise<import("..").JobLabelsResponse>;
+        removeLabel: (label: string) => Promise<import("..").JobLabelsResponse>;
+        listLabels: () => Promise<import("..").JobLabelsResponse>;
+        getPheromoneTypes: () => Promise<import("..").JobPheromoneTypesResponse>;
+        addPheromoneType: (data: import("..").AddPheromoneTypeData) => Promise<import("..").JobPheromoneTypeResponse>;
+        removePheromoneType: (name: string) => Promise<import("..").JobPheromoneTypeResponse>;
+        depositPheromone: (jobId: string, deposit: import("..").DepositPheromoneData) => Promise<import("..").JobPheromoneDepositResponse>;
+        removePheromone: (jobId: string, type: string, depositedBy?: string) => Promise<import("..").JobPheromoneRemoveResponse>;
+        getPheromones: (jobId: string) => Promise<import("..").JobPheromoneListResponse>;
+        getPheromonesAggregated: (jobId: string) => Promise<import("..").JobPheromoneAggregatedResponse>;
+        listJobsByPheromone: (type: string, minIntensity?: number) => Promise<import("..").JobPheromoneSearchResponse>;
+        getPheromonesWithDecay: (jobId: string) => Promise<import("..").JobPheromoneListResponse>;
+        getPheromonesAggregatedWithDecay: (jobId: string) => Promise<import("..").JobPheromoneAggregatedResponse>;
+        addSplitProposal: (jobId: string, proposal: import("..").AddSplitProposalData) => Promise<import("..").JobSplitProposeResponse>;
+        deleteSplitProposal: (jobId: string, proposalId: string) => Promise<import("..").JobSplitDeleteResponse>;
+        acceptSplitProposal: (jobId: string, proposalId: string) => Promise<import("..").JobSplitAcceptResponse>;
+        lockJob: (jobId: string, agentId: string, agentName?: string) => Promise<import("..").JobLockAcquireResponse>;
+        unlockJob: (jobId: string, agentId: string) => Promise<import("..").JobLockReleaseResponse>;
+        isJobLocked: (jobId: string) => Promise<import("..").JobLockCheckResponse>;
+        addUnlockRequest: (jobId: string, request: import("..").AddUnlockRequestData) => Promise<import("..").JobUnlockRequestAddResponse>;
+        approveUnlockRequest: (jobId: string, unlockRequestId: string, respondedBy: string) => Promise<import("..").JobUnlockRequestApproveResponse>;
+        rejectUnlockRequest: (jobId: string, unlockRequestId: string, respondedBy: string) => Promise<import("..").JobUnlockRequestRejectResponse>;
+        deleteUnlockRequest: (jobId: string, unlockRequestId: string) => Promise<import("..").JobUnlockRequestDeleteResponse>;
+        addBid: (jobId: string, bid: import("..").AddBidData) => Promise<import("..").JobBidAddResponse>;
+        withdrawBid: (jobId: string, bidId: string) => Promise<import("..").JobBidWithdrawResponse>;
+        acceptBid: (jobId: string, bidId: string) => Promise<import("..").JobBidAcceptResponse>;
+        listBids: (jobId: string) => Promise<import("..").JobBidListResponse>;
+        addBlocker: (jobId: string, blocker: import("..").AddBlockerData) => Promise<import("..").JobBlockerAddResponse>;
+        removeBlocker: (jobId: string, blockerId: string) => Promise<import("..").JobBlockerRemoveResponse>;
+        resolveBlocker: (jobId: string, blockerId: string, resolvedBy: string) => Promise<import("..").JobBlockerResolveResponse>;
+    };
+    autoTesting: {
+        createSuite: (params: import("..").ICreateSuiteParams) => Promise<import("..").ICreateSuiteResponse>;
+        getSuite: (params: import("..").IGetSuiteParams) => Promise<import("..").IGetSuiteResponse>;
+        listSuites: (_params?: import("..").IListSuitesParams) => Promise<import("..").IListSuitesResponse>;
+        updateSuite: (params: import("..").IUpdateSuiteParams) => Promise<import("..").IUpdateSuiteResponse>;
+        deleteSuite: (params: import("..").IDeleteSuiteParams) => Promise<import("..").IDeleteSuiteResponse>;
+        addCaseToSuite: (params: import("..").IAddCaseToSuiteParams) => Promise<import("..").IAddCaseToSuiteResponse>;
+        removeCaseFromSuite: (params: import("..").IRemoveCaseFromSuiteParams) => Promise<import("..").IRemoveCaseFromSuiteResponse>;
+        createCase: (params: import("..").ICreateCaseParams) => Promise<import("..").ICreateCaseResponse>;
+        getCase: (params: import("..").IGetCaseParams) => Promise<import("..").IGetCaseResponse>;
+        listCases: (_params?: import("..").IListCasesParams) => Promise<import("..").IListCasesResponse>;
+        updateCase: (params: import("..").IUpdateCaseParams) => Promise<import("..").IUpdateCaseResponse>;
+        deleteCase: (params: import("..").IDeleteCaseParams) => Promise<import("..").IDeleteCaseResponse>;
+        createRun: (params: import("..").ICreateRunParams) => Promise<import("..").ICreateRunResponse>;
+        getRun: (params: import("..").IGetRunParams) => Promise<import("..").IGetRunResponse>;
+        listRuns: (params?: import("..").IListRunsParams) => Promise<import("..").IListRunsResponse>;
+        updateRunStatus: (params: import("..").IUpdateRunStatusParams) => Promise<import("..").IUpdateRunStatusResponse>;
+        updateRunCaseStatus: (params: import("..").IUpdateRunCaseParams) => Promise<import("..").IUpdateRunCaseResponse>;
+        updateRunStepStatus: (params: import("..").IUpdateRunStepParams) => Promise<import("..").IUpdateRunStepResponse>;
+    };
+    actionBlock: {
+        list: (filter?: import("../modules/actionBlock").ActionBlockFilter) => Promise<import("../modules/actionBlock").ListActionBlocksResponse>;
+        getDetail: (actionBlockName: string) => Promise<import("../modules/actionBlock").GetActionBlockDetailResponse>;
+        start: (actionBlockName: string, params?: Record<string, any>) => Promise<import("../modules/actionBlock").StartActionBlockResponse>;
+    };
+    requirementPlan: {
+        create: (fileName: string) => Promise<import("../modules/requirementPlan").RequirementPlanCreateResponse>;
+        get: (filePath: string) => Promise<import("../modules/requirementPlan").RequirementPlanGetResponse>;
+        update: (filePath: string, content: string | import("../modules/requirementPlan").RequirementPlanDocument) => Promise<import("../modules/requirementPlan").RequirementPlanUpdateResponse>;
+        list: () => Promise<import("../modules/requirementPlan").RequirementPlanListResponse>;
+        addSection: (filePath: string, section: Omit<import("../modules/requirementPlan").RequirementPlanSection, "id" | "order">, afterIndex?: number) => Promise<import("../modules/requirementPlan").RequirementPlanSectionResponse>;
+        updateSection: (filePath: string, sectionId: string, updates: Partial<import("../modules/requirementPlan").RequirementPlanSection>) => Promise<import("../modules/requirementPlan").RequirementPlanSectionResponse>;
+        removeSection: (filePath: string, sectionId: string) => Promise<import("../modules/requirementPlan").RequirementPlanSectionResponse>;
+        reorderSections: (filePath: string, sectionIds: string[]) => Promise<import("../modules/requirementPlan").RequirementPlanSectionResponse>;
+        review: (filePath: string) => Promise<import("../modules/requirementPlan").RequirementPlanReviewResponse>;
+    };
+    swarm: {
+        createSwarm: (data: import("../types/swarm").CreateSwarmRequest) => Promise<import("../types/swarm").CreateSwarmResponse>;
+        listSwarms: () => Promise<import("../types/swarm").ListSwarmsResponse>;
+        getSwarm: (swarmId: string) => Promise<import("../types/swarm").GetSwarmResponse>;
+        getSwarmAgents: (swarmId: string) => Promise<import("../types/swarm").GetSwarmAgentsResponse>;
+        registerAgent: (swarmId: string, data: import("../types/swarm").AgentRegistration) => Promise<import("../types/swarm").RegisterAgentResponse>;
+        unregisterAgent: (swarmId: string, agentId: string) => Promise<import("../types/swarm").UnregisterAgentResponse>;
+        createTeam: (swarmId: string, data: import("../types/swarm").CreateTeamRequest) => Promise<import("../types/swarm").CreateTeamResponse>;
+        listTeams: (swarmId: string) => Promise<import("../types/swarm").ListTeamsResponse>;
+        getTeam: (swarmId: string, teamId: string) => Promise<import("../types/swarm").GetTeamResponse>;
+        joinTeam: (swarmId: string, teamId: string, agentId: string) => Promise<import("../types/swarm").JoinTeamResponse>;
+        leaveTeam: (swarmId: string, teamId: string, agentId: string) => Promise<import("../types/swarm").LeaveTeamResponse>;
+        deleteTeam: (swarmId: string, teamId: string) => Promise<import("../types/swarm").DeleteTeamResponse>;
+        createRole: (swarmId: string, data: import("../types/swarm").CreateRoleRequest) => Promise<import("../types/swarm").CreateRoleResponse>;
+        listRoles: (swarmId: string) => Promise<import("../types/swarm").ListRolesResponse>;
+        getRole: (swarmId: string, roleId: string) => Promise<import("../types/swarm").GetRoleResponse>;
+        assignRole: (swarmId: string, roleId: string, agentId: string) => Promise<import("../types/swarm").AssignRoleResponse>;
+        unassignRole: (swarmId: string, roleId: string, agentId: string) => Promise<import("../types/swarm").UnassignRoleResponse>;
+        getAgentsByRole: (swarmId: string, roleId: string) => Promise<import("../types/swarm").GetAgentsByRoleResponse>;
+        deleteRole: (swarmId: string, roleId: string) => Promise<import("../types/swarm").DeleteRoleResponse>;
+        createVacancy: (swarmId: string, data: import("../types/swarm").CreateVacancyRequest) => Promise<import("../types/swarm").CreateVacancyResponse>;
+        listVacancies: (swarmId: string) => Promise<import("../types/swarm").ListVacanciesResponse>;
+        applyForVacancy: (swarmId: string, vacancyId: string, agentId: string, message?: string) => Promise<import("../types/swarm").ApplyForVacancyResponse>;
+        closeVacancy: (swarmId: string, vacancyId: string, reason: string) => Promise<import("../types/swarm").CloseVacancyResponse>;
+        updateAgentStatus: (swarmId: string, agentId: string, data: import("../types/swarm").AgentStatusUpdate) => Promise<import("../types/swarm").UpdateStatusResponse>;
+        getSwarmStatusSummary: (swarmId: string) => Promise<import("../types/swarm").GetStatusSummaryResponse>;
+        getDefaultJobGroup: (swarmId: string) => Promise<import("../types/swarm").GetDefaultJobGroupResponse>;
+    };
+    calendar: {
+        createEvent: (params: import("../modules/calendar").ICreateEventParams) => Promise<import("../modules/calendar").ICreateEventResponse>;
+        updateEvent: (params: import("../modules/calendar").IUpdateEventParams) => Promise<import("../modules/calendar").IUpdateEventResponse>;
+        deleteEvent: (params: import("../modules/calendar").IDeleteEventParams) => Promise<import("../modules/calendar").IDeleteEventResponse>;
+        getEvent: (params: import("../modules/calendar").IGetEventParams) => Promise<import("../modules/calendar").IGetEventResponse>;
+        listEvents: (params?: import("../modules/calendar").IListEventsParams) => Promise<import("../modules/calendar").IListEventsResponse>;
+        getEventsInRange: (params: import("../modules/calendar").IGetEventsInRangeParams) => Promise<import("../modules/calendar").IGetEventsInRangeResponse>;
+        getUpcomingEvents: (params?: import("../modules/calendar").IGetUpcomingEventsParams) => Promise<import("../modules/calendar").IGetUpcomingEventsResponse>;
+        getTriggeredEvents: (params?: import("../modules/calendar").IGetTriggeredEventsParams) => Promise<import("../modules/calendar").IGetTriggeredEventsResponse>;
+        markEventComplete: (params: import("../modules/calendar").IMarkEventCompleteParams) => Promise<import("../modules/calendar").IMarkEventCompleteResponse>;
+        markEventsComplete: (params: import("../modules/calendar").IMarkEventsCompleteParams) => Promise<import("../modules/calendar").IMarkEventsCompleteResponse>;
+        getTriggeredEventsAndMarkComplete: () => Promise<import("../modules/calendar").IGetTriggeredEventsAndMarkCompleteResponse>;
+        rsvp: (params: import("../modules/calendar").IRSVPParams) => Promise<import("../modules/calendar").IRSVPResponse>;
+        getStatus: () => Promise<import("../modules/calendar").IGetStatusResponse>;
+    };
+    episodicMemory: {
+        createMemory: (params: import("../modules/episodicMemory").ICreateMemoryParams) => Promise<import("../modules/episodicMemory").ICreateMemoryResponse>;
+        listMemories: () => Promise<import("../modules/episodicMemory").IListMemoriesResponse>;
+        getMemory: (params: import("../modules/episodicMemory").IGetMemoryParams) => Promise<import("../modules/episodicMemory").IGetMemoryResponse>;
+        appendEvent: (params: import("../modules/episodicMemory").IAppendEventParams) => Promise<import("../modules/episodicMemory").IAppendEventResponse>;
+        queryEvents: (params: import("../modules/episodicMemory").IQueryEventsParams) => Promise<import("../modules/episodicMemory").IQueryEventsResponse>;
+        getEventTypes: (params: import("../modules/episodicMemory").IGetEventTypesParams) => Promise<import("../modules/episodicMemory").IGetEventTypesResponse>;
+        getTags: (params: import("../modules/episodicMemory").IGetTagsParams) => Promise<import("../modules/episodicMemory").IGetTagsResponse>;
+        getAgents: (params: import("../modules/episodicMemory").IGetAgentsParams) => Promise<import("../modules/episodicMemory").IGetAgentsResponse>;
+        archiveMemory: (params: import("../modules/episodicMemory").IArchiveMemoryParams) => Promise<import("../modules/episodicMemory").IArchiveMemoryResponse>;
+        unarchiveMemory: (params: import("../modules/episodicMemory").IUnarchiveMemoryParams) => Promise<import("../modules/episodicMemory").IUnarchiveMemoryResponse>;
+        updateTitle: (params: import("../modules/episodicMemory").IUpdateTitleParams) => Promise<import("../modules/episodicMemory").IUpdateTitleResponse>;
+    };
+    roadmap: {
+        getRoadmap: (projectPath?: string) => Promise<import("..").RoadmapGetResponse>;
+        getPhases: (projectPath?: string) => Promise<import("..").RoadmapPhasesResponse>;
+        createPhase: (data: import("..").CreatePhaseData, projectPath?: string) => Promise<import("..").RoadmapPhaseResponse>;
+        updatePhase: (phaseId: string, data: import("..").UpdatePhaseData, projectPath?: string) => Promise<import("..").RoadmapPhaseResponse>;
+        deletePhase: (phaseId: string, projectPath?: string) => Promise<import("..").RoadmapDeleteResponse>;
+        getFeatures: (phaseId: string, projectPath?: string) => Promise<import("..").RoadmapFeaturesResponse>;
+        getAllFeatures: (projectPath?: string) => Promise<import("..").RoadmapFeaturesResponse>;
+        createFeature: (phaseId: string, data: import("..").CreateFeatureData, projectPath?: string) => Promise<import("..").RoadmapFeatureResponse>;
+        updateFeature: (featureId: string, data: import("..").UpdateFeatureData, projectPath?: string) => Promise<import("..").RoadmapFeatureResponse>;
+        deleteFeature: (featureId: string, projectPath?: string) => Promise<import("..").RoadmapDeleteResponse>;
+        moveFeature: (featureId: string, data: import("..").MoveFeatureData, projectPath?: string) => Promise<import("..").RoadmapFeatureResponse>;
+        getIdeas: (projectPath?: string) => Promise<import("..").RoadmapIdeasResponse>;
+        createIdea: (data: import("..").CreateIdeaData, projectPath?: string) => Promise<import("..").RoadmapIdeaResponse>;
+        updateIdea: (ideaId: string, data: import("..").UpdateIdeaData, projectPath?: string) => Promise<import("..").RoadmapIdeaResponse>;
+        deleteIdea: (ideaId: string, projectPath?: string) => Promise<import("..").RoadmapDeleteResponse>;
+        reviewIdea: (ideaId: string, data: import("..").ReviewIdeaData, projectPath?: string) => Promise<import("..").RoadmapIdeaResponse>;
+        moveIdeaToRoadmap: (ideaId: string, data: import("..").MoveIdeaToRoadmapData, projectPath?: string) => Promise<import("..").RoadmapMoveToRoadmapResponse>;
+    };
+    codemap: {
+        list: (projectPath?: string) => Promise<import("..").CodemapListResponse>;
+        get: (codemapId: string, projectPath?: string) => Promise<import("..").CodemapGetResponse>;
+        create: (data: import("..").CreateCodemapData, projectPath?: string) => Promise<import("..").CodemapCreateResponse>;
+        save: (codemapId: string, codemap: import("..").Codemap, projectPath?: string) => Promise<import("..").CodemapSaveResponse>;
+        setStatus: (codemapId: string, status: import("..").CodemapStatus, error?: string, projectPath?: string) => Promise<import("..").CodemapUpdateResponse>;
+        update: (codemapId: string, data: import("..").UpdateCodemapData, projectPath?: string) => Promise<import("..").CodemapUpdateResponse>;
+        delete: (codemapId: string, projectPath?: string) => Promise<import("..").CodemapDeleteResponse>;
+    };
+    projectStructure: {
+        getMetadata: (workspacePath?: string) => Promise<import("..").ProjectStructureMetadataResponse>;
+        updateMetadata: (updates: Record<string, any>, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+        getPackages: (workspacePath?: string) => Promise<import("..").ProjectStructurePackagesResponse>;
+        getPackage: (packageId: string, workspacePath?: string) => Promise<import("..").ProjectStructurePackageResponse>;
+        createPackage: (data: import("..").CreatePackageData, workspacePath?: string) => Promise<import("..").ProjectStructurePackageResponse>;
+        updatePackage: (packageId: string, updates: import("..").UpdatePackageData, workspacePath?: string) => Promise<import("..").ProjectStructurePackageResponse>;
+        deletePackage: (packageId: string, workspacePath?: string) => Promise<import("..").ProjectStructureDeleteResponse>;
+        addRoute: (packageId: string, route: Omit<import("..").ApiRoute, "id">, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+        updateRoute: (packageId: string, routeId: string, updates: Partial<import("..").ApiRoute>, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+        deleteRoute: (packageId: string, routeId: string, workspacePath?: string) => Promise<import("..").ProjectStructureDeleteResponse>;
+        addTable: (packageId: string, table: Omit<import("..").DatabaseTable, "id">, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+        updateTable: (packageId: string, tableId: string, updates: Partial<import("..").DatabaseTable>, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+        deleteTable: (packageId: string, tableId: string, workspacePath?: string) => Promise<import("..").ProjectStructureDeleteResponse>;
+        addDependency: (packageId: string, dependency: Omit<import("..").Dependency, "id">, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+        updateDependency: (packageId: string, dependencyId: string, updates: Partial<import("..").Dependency>, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+        deleteDependency: (packageId: string, dependencyId: string, workspacePath?: string) => Promise<import("..").ProjectStructureDeleteResponse>;
+        addCommand: (packageId: string, command: Omit<import("..").RunCommand, "id">, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+        updateCommand: (packageId: string, commandId: string, updates: Partial<import("..").RunCommand>, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+        deleteCommand: (packageId: string, commandId: string, workspacePath?: string) => Promise<import("..").ProjectStructureDeleteResponse>;
+        addUiRoute: (packageId: string, route: Omit<import("..").UiRoute, "id">, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+        updateUiRoute: (packageId: string, routeId: string, updates: Partial<import("..").UiRoute>, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+        deleteUiRoute: (packageId: string, routeId: string, workspacePath?: string) => Promise<import("..").ProjectStructureDeleteResponse>;
+        addDeployment: (packageId: string, config: Omit<import("..").DeploymentConfig, "id">, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+        updateDeployment: (packageId: string, configId: string, updates: Partial<import("..").DeploymentConfig>, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+        deleteDeployment: (packageId: string, configId: string, workspacePath?: string) => Promise<import("..").ProjectStructureDeleteResponse>;
+        updateGit: (gitInfo: import("..").GitInfo, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+        updateDesignGuidelines: (packageId: string, guidelines: import("..").DesignGuidelines, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+        updateFrontendFramework: (packageId: string, framework: import("..").FrameworkInfo, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+        updateSection: (packageId: string, section: string, sectionData: any, workspacePath?: string) => Promise<import("..").ProjectStructureUpdateResponse>;
+    };
+    codebaseSearch: {
+        search: (query: string, targetDirectories?: string[]) => Promise<import("..").CodebaseSearchResponse>;
+        searchMcpTool: (query: string, tags?: string[]) => Promise<import("..").McpToolSearchResponse>;
+    };
+    fileUpdateIntent: {
+        create: (data: import("..").CreateFileUpdateIntentRequest, claimedBy: string, claimedByName?: string) => Promise<{
+            intent?: import("..").FileUpdateIntent;
+            overlap?: import("..").IntentOverlapResult;
+        }>;
+        update: (id: string, data: import("..").UpdateFileUpdateIntentRequest) => Promise<import("..").FileUpdateIntent>;
+        get: (id: string) => Promise<import("..").FileUpdateIntent>;
+        list: (filters?: import("..").FileUpdateIntentFilters) => Promise<import("..").FileUpdateIntent[]>;
+        complete: (id: string, closedBy: string) => Promise<import("..").FileUpdateIntent>;
+        cancel: (id: string, cancelledBy: string) => Promise<import("..").FileUpdateIntent>;
+        checkOverlap: (environmentId: string, filePaths: string[], priority?: number) => Promise<import("..").IntentOverlapResult>;
+        getBlockedFiles: (environmentId: string) => Promise<{
+            blockedFiles: string[];
+        }>;
+        getByAgent: (agentId: string) => Promise<import("..").FileUpdateIntent[]>;
+        getFilesWithIntents: (environmentId: string) => Promise<import("../types/fileUpdateIntent").FileWithIntent[]>;
+        delete: (id: string) => Promise<{
+            success: boolean;
+        }>;
+    };
+    projectStructureUpdateRequest: {
+        create: (data: import("../types/projectStructureUpdateRequest").CreateUpdateRequestData, workspacePath?: string) => Promise<import("../types/projectStructureUpdateRequest").UpdateRequestResponse>;
+        get: (id: string, workspacePath?: string) => Promise<import("../types/projectStructureUpdateRequest").UpdateRequestResponse>;
+        list: (filters?: import("../types/projectStructureUpdateRequest").UpdateRequestFilters, workspacePath?: string) => Promise<import("../types/projectStructureUpdateRequest").UpdateRequestListResponse>;
+        update: (id: string, updates: import("../types/projectStructureUpdateRequest").UpdateUpdateRequestData, workspacePath?: string) => Promise<import("../types/projectStructureUpdateRequest").UpdateRequestResponse>;
+        delete: (id: string, workspacePath?: string) => Promise<import("../types/projectStructureUpdateRequest").UpdateRequestResponse>;
+        submit: (id: string, workspacePath?: string) => Promise<import("../types/projectStructureUpdateRequest").UpdateRequestResponse>;
+        startWork: (id: string, workspacePath?: string) => Promise<import("../types/projectStructureUpdateRequest").UpdateRequestResponse>;
+        complete: (id: string, workspacePath?: string) => Promise<import("../types/projectStructureUpdateRequest").UpdateRequestResponse>;
+        merge: (id: string, workspacePath?: string) => Promise<import("../types/projectStructureUpdateRequest").UpdateRequestResponse>;
+        addDispute: (id: string, data: import("../types/projectStructureUpdateRequest").CreateDisputeData, workspacePath?: string) => Promise<import("../types/projectStructureUpdateRequest").UpdateRequestResponse>;
+        resolveDispute: (id: string, disputeId: string, resolutionSummary?: string, workspacePath?: string) => Promise<import("../types/projectStructureUpdateRequest").UpdateRequestResponse>;
+        addComment: (id: string, disputeId: string, data: import("../types/projectStructureUpdateRequest").AddCommentData, workspacePath?: string) => Promise<import("../types/projectStructureUpdateRequest").UpdateRequestResponse>;
+        watch: (id: string, data: import("../types/projectStructureUpdateRequest").AddWatcherData, workspacePath?: string) => Promise<import("../types/projectStructureUpdateRequest").UpdateRequestResponse>;
+        unwatch: (id: string, watcherId: string, workspacePath?: string) => Promise<import("../types/projectStructureUpdateRequest").UpdateRequestResponse>;
+    };
+    reviewMergeRequest: {
+        list: (filters?: import("..").ReviewMergeRequestFilters) => Promise<{
+            requests: import("..").ReviewMergeRequest[];
+            totalCount: number;
+        }>;
+        get: (id: string) => Promise<{
+            request: import("..").ReviewMergeRequest;
+        }>;
+        create: (data: import("..").CreateReviewMergeRequest) => Promise<{
+            request: import("..").ReviewMergeRequest;
+        }>;
+        update: (id: string, data: import("..").UpdateReviewMergeRequest) => Promise<{
+            request: import("..").ReviewMergeRequest;
+        }>;
+        delete: (id: string) => Promise<{
+            deleted: boolean;
+        }>;
+        addReview: (id: string, feedback: import("..").AddReviewFeedback) => Promise<{
+            request: import("..").ReviewMergeRequest;
+        }>;
+        updateStatus: (id: string, status: import("..").ReviewRequestStatus) => Promise<{
+            request: import("..").ReviewMergeRequest;
+        }>;
+        merge: (id: string, mergedBy: string) => Promise<{
+            result: import("..").MergeResult;
+        }>;
+        addLinkedJob: (id: string, jobId: string) => Promise<{
+            request: import("..").ReviewMergeRequest;
+        }>;
+        removeLinkedJob: (id: string, jobId: string) => Promise<{
+            request: import("..").ReviewMergeRequest;
+        }>;
+        pending: () => Promise<{
+            requests: import("..").ReviewMergeRequest[];
+            totalCount: number;
+        }>;
+        readyToMerge: () => Promise<{
+            requests: import("..").ReviewMergeRequest[];
+            totalCount: number;
+        }>;
+        byAgent: (agentId: string) => Promise<{
+            requests: import("..").ReviewMergeRequest[];
+            totalCount: number;
+        }>;
+        bySwarm: (swarmId: string) => Promise<{
+            requests: import("..").ReviewMergeRequest[];
+            totalCount: number;
+        }>;
+        statistics: () => Promise<{
+            statistics: any;
+        }>;
+    };
+    kvStore: {
+        createInstance: (name: string, description?: string) => Promise<import("..").KVInstanceResponse>;
+        getInstance: (instanceId: string) => Promise<import("..").KVInstanceResponse>;
+        listInstances: () => Promise<import("..").KVInstanceListResponse>;
+        updateInstance: (instanceId: string, updates: import("..").UpdateKVInstanceParams) => Promise<import("..").KVInstanceResponse>;
+        deleteInstance: (instanceId: string) => Promise<import("..").KVDeleteResponse>;
+        get: (instanceId: string, namespace: string, key: string) => Promise<import("..").KVGetResponse>;
+        set: (instanceId: string, namespace: string, key: string, value: any, autoCreateInstance?: boolean) => Promise<import("..").KVSetResponse>;
+        delete: (instanceId: string, namespace: string, key: string) => Promise<import("..").KVDeleteResponse>;
+        deleteNamespace: (instanceId: string, namespace: string) => Promise<import("..").KVDeleteNamespaceResponse>;
+        query: (query: import("..").KVQueryDSL) => Promise<import("..").KVQueryResponse>;
+        getNamespaces: (instanceId: string) => Promise<import("..").KVNamespacesResponse>;
+        getRecordCount: (instanceId: string, namespace?: string) => Promise<import("..").KVRecordCountResponse>;
+    };
+    persistentMemory: {
+        create: (config: import("..").CreatePersistentMemoryParams) => Promise<import("..").PersistentMemoryResponse>;
+        get: (memoryId: string) => Promise<import("..").PersistentMemoryResponse>;
+        list: (filters?: import("..").ListPersistentMemoryParams) => Promise<import("..").PersistentMemoryListResponse>;
+        update: (memoryId: string, updates: import("..").UpdatePersistentMemoryParams) => Promise<import("..").PersistentMemoryResponse>;
+        delete: (memoryId: string) => Promise<import("..").PersistentMemoryResponse>;
+        executeRetrieval: (memoryId: string, intent: import("..").PipelineExecutionIntent) => Promise<import("..").PersistentMemoryExecuteResponse>;
+        validate: (memory: import("..").CreatePersistentMemoryParams) => Promise<import("..").PersistentMemoryValidateResponse>;
+        getStepSpecs: () => Promise<import("..").PersistentMemoryStepSpecsResponse>;
+    };
+    eventLog: {
+        createInstance: (name: string, description?: string) => Promise<import("..").EventLogInstanceResponse>;
+        getInstance: (instanceId: string) => Promise<import("..").EventLogInstanceResponse>;
+        listInstances: () => Promise<import("..").EventLogInstanceListResponse>;
+        updateInstance: (instanceId: string, updates: import("..").UpdateEventLogInstanceParams) => Promise<import("..").EventLogInstanceResponse>;
+        deleteInstance: (instanceId: string) => Promise<import("..").EventLogInstanceResponse>;
+        appendEvent: (params: import("..").AppendEventParams) => Promise<import("..").EventLogAppendResponse>;
+        appendEvents: (params: import("..").AppendEventsParams) => Promise<import("..").EventLogAppendMultipleResponse>;
+        queryEvents: (query: import("..").EventLogDSL) => Promise<import("..").EventLogQueryResponse>;
+        getInstanceStats: (instanceId: string) => Promise<import("..").EventLogStatsResponse>;
+    };
+    knowledgeGraph: {
+        createInstanceTemplate: (config: import("..").CreateKGInstanceTemplateParams) => Promise<import("..").KGInstanceTemplateResponse>;
+        getInstanceTemplate: (templateId: string) => Promise<import("..").KGInstanceTemplateResponse>;
+        listInstanceTemplates: () => Promise<import("..").KGInstanceTemplateListResponse>;
+        updateInstanceTemplate: (templateId: string, updates: Partial<import("..").CreateKGInstanceTemplateParams>) => Promise<import("..").KGInstanceTemplateResponse>;
+        deleteInstanceTemplate: (templateId: string) => Promise<import("..").KGDeleteResponse>;
+        createInstance: (config: import("..").CreateKGInstanceParams) => Promise<import("..").KGInstanceResponse>;
+        getInstance: (instanceId: string) => Promise<import("..").KGInstanceResponse>;
+        listInstances: (templateId?: string) => Promise<import("..").KGInstanceListResponse>;
+        deleteInstance: (instanceId: string) => Promise<import("..").KGDeleteResponse>;
+        addMemoryRecord: (instanceId: string, record: import("..").CreateKGMemoryRecordParams) => Promise<import("..").KGMemoryRecordResponse>;
+        addMemoryRecords: (instanceId: string, records: import("..").CreateKGMemoryRecordParams[]) => Promise<import("..").KGMemoryRecordListResponse>;
+        getMemoryRecord: (instanceId: string, recordId: string) => Promise<import("..").KGMemoryRecordResponse>;
+        listMemoryRecords: (instanceId: string, filters?: import("..").ListKGMemoryRecordsParams) => Promise<import("..").KGMemoryRecordListResponse>;
+        updateMemoryRecord: (instanceId: string, recordId: string, updates: Partial<import("..").CreateKGMemoryRecordParams>) => Promise<import("..").KGMemoryRecordResponse>;
+        deleteMemoryRecord: (instanceId: string, recordId: string) => Promise<import("..").KGDeleteResponse>;
+        addEdge: (instanceId: string, edge: import("..").CreateKGEdgeParams) => Promise<import("..").KGEdgeResponse>;
+        addEdges: (instanceId: string, edges: import("..").CreateKGEdgeParams[]) => Promise<import("..").KGEdgeListResponse>;
+        listEdges: (instanceId: string, filters?: import("..").ListKGEdgesParams) => Promise<import("..").KGEdgeListResponse>;
+        deleteEdge: (instanceId: string, edgeId: string) => Promise<import("..").KGDeleteResponse>;
+        createViewTemplate: (config: import("..").CreateKGViewTemplateParams) => Promise<import("..").KGViewTemplateResponse>;
+        getViewTemplate: (templateId: string) => Promise<import("..").KGViewTemplateResponse>;
+        listViewTemplates: (applicableTemplateId?: string) => Promise<import("..").KGViewTemplateListResponse>;
+        updateViewTemplate: (templateId: string, updates: Partial<import("..").CreateKGViewTemplateParams>) => Promise<import("..").KGViewTemplateResponse>;
+        deleteViewTemplate: (templateId: string) => Promise<import("..").KGDeleteResponse>;
+        createView: (config: import("..").CreateKGViewParams) => Promise<import("..").KGViewResponse>;
+        listViews: (instanceId: string) => Promise<import("..").KGViewListResponse>;
+        executeView: (viewId: string) => Promise<import("..").KGViewExecuteResponse>;
+        deleteView: (viewId: string) => Promise<import("..").KGDeleteResponse>;
+    };
+    hook: {
+        initialize: (projectPath: string) => Promise<import("..").HookInitializeResponse>;
+        create: (config: import("..").HookConfig) => Promise<import("..").HookResponse>;
+        update: (hookId: string, config: Partial<import("..").HookConfig>) => Promise<import("..").HookResponse>;
+        delete: (hookId: string) => Promise<import("..").HookDeleteResponse>;
+        list: () => Promise<import("..").HookListResponse>;
+        get: (hookId: string) => Promise<import("..").HookResponse>;
+        enable: (hookId: string) => Promise<import("..").HookResponse>;
+        disable: (hookId: string) => Promise<import("..").HookResponse>;
+    };
+    memoryIngestion: {
+        create: (config: import("..").CreateIngestionPipelineParams) => Promise<import("..").IngestionPipelineResponse>;
+        get: (pipelineId: string) => Promise<import("..").IngestionPipelineResponse>;
+        list: (filters?: import("..").ListIngestionPipelineParams) => Promise<import("..").IngestionPipelineListResponse>;
+        update: (pipelineId: string, updates: import("..").UpdateIngestionPipelineParams) => Promise<import("..").IngestionPipelineResponse>;
+        delete: (pipelineId: string) => Promise<import("..").IngestionPipelineResponse>;
+        execute: (params: import("..").ExecuteIngestionParams) => Promise<import("..").IngestionExecuteResponse>;
+        validate: (pipeline: import("..").CreateIngestionPipelineParams) => Promise<import("..").IngestionValidateResponse>;
+        getProcessorSpecs: () => Promise<import("..").IngestionProcessorSpecsResponse>;
+        activate: (pipelineId: string) => Promise<import("..").IngestionPipelineResponse>;
+        disable: (pipelineId: string) => Promise<import("..").IngestionPipelineResponse>;
+        duplicate: (pipelineId: string, newId?: string, newLabel?: string) => Promise<import("..").IngestionPipelineResponse>;
+    };
+    contextAssembly: {
+        getContext: (request: import("..").ContextAssemblyRequest) => Promise<import("..").ContextAssemblyResponse>;
+        validate: (request: import("..").ContextAssemblyRequest) => Promise<import("..").ContextValidateResponse>;
+        listMemoryTypes: () => Promise<import("..").MemoryTypesResponse>;
+        evaluateRules: (request: import("..").ContextAssemblyRequest, ruleEngineIds?: string[]) => Promise<import("..").RuleEvaluationResponse>;
+        getRequiredVariables: (memoryNames: string[]) => Promise<import("..").RequiredVariablesResponse>;
+    };
+    contextRuleEngine: {
+        create: (config: import("..").CreateContextRuleEngineParams) => Promise<import("..").ContextRuleEngineResponse>;
+        get: (id: string) => Promise<import("..").ContextRuleEngineResponse>;
+        list: () => Promise<import("..").ContextRuleEngineListResponse>;
+        update: (id: string, updates: import("..").UpdateContextRuleEngineParams) => Promise<import("..").ContextRuleEngineResponse>;
+        delete: (id: string) => Promise<import("..").ContextRuleEngineDeleteResponse>;
+        evaluate: (params: import("..").EvaluateRulesParams) => Promise<import("..").EvaluateRulesResponse>;
+        getPossibleVariables: () => Promise<import("..").PossibleVariablesResponse>;
+    };
+    agentPortfolio: {
+        getPortfolio: (agentId: string) => Promise<import("@codebolt/types/sdk").GetPortfolioResponse>;
+        getConversations: (agentId: string, limit?: number, offset?: number) => Promise<import("@codebolt/types/sdk").GetConversationsResponse>;
+        addTestimonial: (toAgentId: string, content: string, projectId?: string) => Promise<import("@codebolt/types/sdk").AddTestimonialResponse>;
+        updateTestimonial: (testimonialId: string, content: string) => Promise<import("@codebolt/types/sdk").UpdateTestimonialResponse>;
+        deleteTestimonial: (testimonialId: string) => Promise<import("@codebolt/types/sdk").DeleteTestimonialResponse>;
+        addKarma: (toAgentId: string, amount: number, reason?: string) => Promise<import("@codebolt/types/sdk").AddKarmaResponse>;
+        getKarmaHistory: (agentId: string, limit?: number) => Promise<import("@codebolt/types/sdk").GetKarmaHistoryResponse>;
+        addAppreciation: (toAgentId: string, message: string) => Promise<import("@codebolt/types/sdk").AddAppreciationResponse>;
+        addTalent: (name: string, description?: string) => Promise<import("@codebolt/types/sdk").AddTalentResponse>;
+        endorseTalent: (talentId: string) => Promise<import("@codebolt/types/sdk").EndorseTalentResponse>;
+        getTalents: (agentId?: string) => Promise<import("@codebolt/types/sdk").GetTalentsResponse>;
+        getRanking: (limit?: number, sortBy?: "karma" | "testimonials" | "endorsements") => Promise<import("@codebolt/types/sdk").GetRankingResponse>;
+        getPortfoliosByProject: (projectId: string) => Promise<import("@codebolt/types/sdk").GetPortfoliosByProjectResponse>;
+        updateProfile: (agentId: string, profile: {
+            displayName?: string;
+            bio?: string;
+            specialties?: string[];
+            avatarUrl?: string;
+            location?: string;
+            website?: string;
+        }) => Promise<import("@codebolt/types/sdk").UpdateProfileResponse>;
+    };
+    orchestrator: {
+        listOrchestrators: () => Promise<import("../modules/orchestrator").OrchestratorResponse>;
+        getOrchestrator: (orchestratorId: string) => Promise<import("../modules/orchestrator").OrchestratorResponse>;
+        getOrchestratorSettings: (orchestratorId: string) => Promise<import("../modules/orchestrator").OrchestratorResponse>;
+        createOrchestrator: (data: import("../modules/orchestrator").CreateOrchestratorParams) => Promise<import("../modules/orchestrator").OrchestratorResponse>;
+        updateOrchestrator: (orchestratorId: string, data: import("../modules/orchestrator").UpdateOrchestratorParams) => Promise<import("../modules/orchestrator").OrchestratorResponse>;
+        updateOrchestratorSettings: (orchestratorId: string, settings: import("../modules/orchestrator").UpdateOrchestratorSettingsParams) => Promise<import("../modules/orchestrator").OrchestratorResponse>;
+        deleteOrchestrator: (orchestratorId: string) => Promise<import("../modules/orchestrator").OrchestratorResponse>;
+        updateOrchestratorStatus: (orchestratorId: string, status: "idle" | "running" | "paused") => Promise<import("../modules/orchestrator").OrchestratorResponse>;
+        updateCodeboltJs: () => Promise<import("../modules/orchestrator").OrchestratorResponse>;
+    };
+    backgroundChildThreads: {
+        addRunningAgent: (threadId: string, data: any, groupId?: string) => void;
+        getRunningAgentCount: () => number;
+        checkForBackgroundAgentCompletion: () => any[] | null;
+        onBackgroundAgentCompletion: () => Promise<any>;
+        checkForBackgroundGroupedAgentCompletion: () => any;
+        onBackgroundGroupedAgentCompletion: () => Promise<any>;
+        waitForAnyExternalEvent: () => Promise<{
+            type: string;
+            data: any;
+        }>;
+    };
     /**
      * User message utilities for accessing current user message and context
      */
@@ -380,10 +930,16 @@ declare class Codebolt {
      */
     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
+     * Gets the current or next incoming message.
+     * Priority order:
+     * 1. Returns the current message being processed (if called during message handling)
+     * 2. Returns a queued message (if any are waiting)
+     * 3. Waits for the next message to arrive
+     *
+     * This allows getMessage() to work both during active message processing
+     * and when waiting for new messages in a loop.
+     *
+     * @returns {Promise<FlatUserMessage>} A promise that resolves with the message
      */
     getMessage(): Promise<FlatUserMessage>;
     /**
@@ -405,7 +961,23 @@ declare class Codebolt {
      * @param {Function} handler - The handler function to call when a message is received.
      * @returns {void}
      */
-    onMessage(handler: (userMessage: FlatUserMessage) => void | Promise<void> | any | Promise<any>): void;
+    onMessage(handler: (userMessage: FlatUserMessage, additionalVariable?: Record<string, string | undefined>) => void | Promise<void> | any | Promise<any>): void;
+    /**
+     * Sets up a listener for ActionBlock invocation events.
+     * This is called when a Side Execution ActionBlock is invoked by a parent agent.
+     * @param {Function} handler - The handler function to call when ActionBlock is invoked.
+     *   - params: The parameters passed to the ActionBlock
+     *   - threadContext: The thread context from the parent agent
+     *   - metadata: Additional metadata (sideExecutionId, threadId, parentAgentId, etc.)
+     * @returns {void}
+     */
+    onActionBlockInvocation(handler: (threadContext: any, metadata: {
+        sideExecutionId: string;
+        threadId: string;
+        parentAgentId: string;
+        parentAgentInstanceId: string;
+        timestamp: string;
+    }) => void | Promise<void> | any | Promise<any>): void;
     onRawMessage(handler: (userMessage: RawMessageForAgent) => void | Promise<void> | any | Promise<any>): void;
     /**
      * Sets up a listener for provider start events.
@@ -431,6 +1003,60 @@ declare class Codebolt {
      * @returns {void}
      */
     onGetDiffFiles(handler: () => void | Promise<void> | any | Promise<any>): void;
+    /**
+     * Sets up a listener for read file events.
+     * @param {Function} handler - The handler function to call when read file is requested.
+     * @returns {void}
+     */
+    onReadFile(handler: (path: string) => void | Promise<void> | any | Promise<any>): void;
+    /**
+     * Sets up a listener for write file events.
+     * @param {Function} handler - The handler function to call when write file is requested.
+     * @returns {void}
+     */
+    onWriteFile(handler: (path: string, content: string) => void | Promise<void> | any | Promise<any>): void;
+    /**
+     * Sets up a listener for delete file events.
+     * @param {Function} handler - The handler function to call when delete file is requested.
+     * @returns {void}
+     */
+    onDeleteFile(handler: (path: string) => void | Promise<void> | any | Promise<any>): void;
+    /**
+     * Sets up a listener for delete folder events.
+     * @param {Function} handler - The handler function to call when delete folder is requested.
+     * @returns {void}
+     */
+    onDeleteFolder(handler: (path: string) => void | Promise<void> | any | Promise<any>): void;
+    /**
+     * Sets up a listener for rename item events.
+     * @param {Function} handler - The handler function to call when rename item is requested.
+     * @returns {void}
+     */
+    onRenameItem(handler: (oldPath: string, newPath: string) => void | Promise<void> | any | Promise<any>): void;
+    /**
+     * Sets up a listener for create folder events.
+     * @param {Function} handler - The handler function to call when create folder is requested.
+     * @returns {void}
+     */
+    onCreateFolder(handler: (path: string) => void | Promise<void> | any | Promise<any>): void;
+    /**
+     * Sets up a listener for copy file events.
+     * @param {Function} handler - The handler function to call when copy file is requested.
+     * @returns {void}
+     */
+    onCopyFile(handler: (sourcePath: string, destinationPath: string) => void | Promise<void> | any | Promise<any>): void;
+    /**
+     * Sets up a listener for copy folder events.
+     * @param {Function} handler - The handler function to call when copy folder is requested.
+     * @returns {void}
+     */
+    onCopyFolder(handler: (sourcePath: string, destinationPath: string) => void | Promise<void> | any | Promise<any>): void;
+    /**
+     * Sets up a listener for get full project events.
+     * @param {Function} handler - The handler function to call when get full project is requested.
+     * @returns {void}
+     */
+    onGetFullProject(handler: () => void | Promise<void> | any | Promise<any>): void;
     /**
      * Sets up a listener for close signal events.
      * @param {Function} handler - The handler function to call when close signal is received.
@@ -449,5 +1075,99 @@ declare class Codebolt {
      * @returns {void}
      */
     onCreatePullRequestRequest(handler: () => void | Promise<void> | any | Promise<any>): void;
+    /**
+     * Sets up a listener for merge as patch events.
+     * @param {Function} handler - The handler function to call when merge as patch is requested.
+     * @returns {void}
+     */
+    onMergeAsPatch(handler: () => void | Promise<void> | any | Promise<any>): void;
+    /**
+     * Sets up a listener for send PR events.
+     * @param {Function} handler - The handler function to call when send PR is requested.
+     * @returns {void}
+     */
+    onSendPR(handler: () => void | Promise<void> | any | Promise<any>): void;
+    /**
+     * Sets up a listener for get tree children events.
+     * @param {Function} handler - The handler function to call when tree children are requested.
+     * @returns {void}
+     */
+    onGetTreeChildren(handler: (path: string) => void | Promise<void> | any | Promise<any>): void;
+    /**
+     * Sends a provider heartbeat to the main application.
+     * Should be called periodically by providers to indicate they are alive.
+     * @param {object} heartbeatData - The heartbeat data to send
+     * @param {string} heartbeatData.providerId - The provider ID
+     * @param {string} heartbeatData.status - The provider health status ('healthy', 'degraded', 'error')
+     * @param {string[]} heartbeatData.connectedEnvironments - Array of connected environment IDs
+     * @param {Record<string, any>} [heartbeatData.metadata] - Optional metadata
+     * @returns {void}
+     */
+    sendProviderHeartbeat(heartbeatData: {
+        providerId: string;
+        status: 'healthy' | 'degraded' | 'error';
+        connectedEnvironments: string[];
+        uptime?: number;
+        metadata?: Record<string, any>;
+    }): void;
+    /**
+     * Sends an environment heartbeat request to the remote executor.
+     * @param {object} heartbeatData - The heartbeat data to send
+     * @param {string} heartbeatData.environmentId - The environment ID
+     * @param {string} heartbeatData.providerId - The provider ID
+     * @returns {void}
+     */
+    sendEnvironmentHeartbeat(heartbeatData: {
+        environmentId: string;
+        providerId: string;
+    }): void;
+    /**
+     * Sets up a listener for provider heartbeat requests from the main application.
+     * Providers should respond with their current health status.
+     * @param {Function} handler - The handler function to call when heartbeat is requested
+     * @returns {void}
+     */
+    onProviderHeartbeatRequest(handler: (request: {
+        providerId: string;
+        timestamp: string;
+    }) => void | Promise<void> | {
+        status: 'healthy' | 'degraded' | 'error';
+        connectedEnvironments: string[];
+    } | Promise<{
+        status: 'healthy' | 'degraded' | 'error';
+        connectedEnvironments: string[];
+    }>): void;
+    /**
+     * Sets up a listener for environment heartbeat requests.
+     * Environment executors should respond with their current status.
+     * @param {Function} handler - The handler function to call when heartbeat is requested
+     * @returns {void}
+     */
+    onEnvironmentHeartbeatRequest(handler: (request: {
+        environmentId: string;
+        providerId: string;
+        timestamp: string;
+    }) => void | Promise<void> | {
+        status: 'active' | 'degraded' | 'unreachable';
+        remoteExecutorStatus: 'running' | 'stopped' | 'starting' | 'error' | 'restarting';
+    } | Promise<{
+        status: 'active' | 'degraded' | 'unreachable';
+        remoteExecutorStatus: 'running' | 'stopped' | 'starting' | 'error' | 'restarting';
+    }>): void;
+    /**
+     * Sets up a listener for environment restart requests from the main application.
+     * @param {Function} handler - The handler function to restart the environment/remote executor
+     * @returns {void}
+     */
+    onEnvironmentRestartRequest(handler: (request: {
+        environmentId: string;
+        providerId: string;
+    }) => void | Promise<void> | {
+        success: boolean;
+        message?: string;
+    } | Promise<{
+        success: boolean;
+        message?: string;
+    }>): void;
 }
 export default Codebolt;