@codebolt/codeboltjs 2.0.7 → 2.0.11

package/dist/core/messageManager.js

@@ -60,8 +60,11 @@ class MessageManager extends events_1.EventEmitter {
     }
     /**
      * Send a message and wait for a specific response type
+     * @param message The message to send
+     * @param expectedResponseType The type of response to wait for
+     * @param timeout Optional timeout in milliseconds. If not provided or set to 0, will wait indefinitely
      */
-    sendAndWaitForResponse(message, expectedResponseType, timeout = 30000) {
+    sendAndWaitForResponse(message, expectedResponseType, timeout = 0) {
         return new Promise((resolve, reject) => {
             if (!this.websocket) {
                 reject(new Error('WebSocket is not initialized'));
@@ -72,6 +75,7 @@ class MessageManager extends events_1.EventEmitter {
             const messageWithId = { ...message, requestId };
             // Parse multiple message types separated by pipe
             const messageTypes = expectedResponseType.split('|').map(type => type.trim());
+            console.log("Message types: ", messageTypes);
             // Store the pending request
             this.pendingRequests.set(requestId, {
                 resolve,
@@ -79,22 +83,25 @@ class MessageManager extends events_1.EventEmitter {
                 messageTypes,
                 requestId
             });
-            // Set timeout
-            const timeoutId = setTimeout(() => {
-                if (this.pendingRequests.has(requestId)) {
-                    this.pendingRequests.delete(requestId);
-                    reject(new Error(`Request timeout after ${timeout}ms for message types: ${expectedResponseType}`));
-                }
-            }, timeout);
-            // Override resolve to clear timeout
-            const originalResolve = resolve;
-            const wrappedResolve = (value) => {
-                clearTimeout(timeoutId);
-                originalResolve(value);
-            };
-            // Update the stored request with wrapped resolve
-            const request = this.pendingRequests.get(requestId);
-            request.resolve = wrappedResolve;
+            // Set timeout only if a positive timeout value is provided
+            let timeoutId;
+            if (timeout > 0) {
+                timeoutId = setTimeout(() => {
+                    if (this.pendingRequests.has(requestId)) {
+                        this.pendingRequests.delete(requestId);
+                        reject(new Error(`Request timeout after ${timeout}ms for message types: ${expectedResponseType}`));
+                    }
+                }, timeout);
+                // Override resolve to clear timeout
+                const originalResolve = resolve;
+                const wrappedResolve = (value) => {
+                    clearTimeout(timeoutId);
+                    originalResolve(value);
+                };
+                // Update the stored request with wrapped resolve
+                const request = this.pendingRequests.get(requestId);
+                request.resolve = wrappedResolve;
+            }
             // Send the message
             this.websocket.send(JSON.stringify(messageWithId));
         });

package/dist/core/websocket.d.ts

@@ -5,6 +5,7 @@ import { MessageManager } from './messageManager';
  */
 declare class cbws {
     websocket: WebSocket;
+    private initialized;
     /**
      * Constructs a new cbws instance and initializes the WebSocket connection.
      */
@@ -23,10 +24,19 @@ declare class cbws {
      * @throws {Error} If the WebSocket is not open.
      */
     get getWebsocket(): WebSocket;
+    /**
+     * Waits for the WebSocket to be ready and returns it.
+     * @returns {Promise<WebSocket>} A promise that resolves with the WebSocket instance when it's ready.
+     */
+    waitForWebSocket(): Promise<WebSocket>;
     /**
      * Get the message manager instance
      */
     get messageManager(): MessageManager;
+    /**
+     * Check if the WebSocket is initialized and ready
+     */
+    get isInitialized(): boolean;
 }
 declare const _default: cbws;
 export default _default;

package/dist/core/websocket.js

@@ -15,6 +15,8 @@ class cbws {
      * Constructs a new cbws instance and initializes the WebSocket connection.
      */
     constructor() {
+        this.initialized = false;
+        console.log('[WebSocket] Initializing cbws instance');
         // this.websocket=undefined;
         // this.websocket = new WebSocket(`ws://localhost:${process.env.SOCKET_PORT}/codebolt?id=${uniqueConnectionId}${agentIdParam}${parentIdParam}${process.env.Is_Dev ? '&dev=true' : ''}`);
         // this.initializeWebSocket(initialMessage).catch(error => {
@@ -23,23 +25,29 @@ class cbws {
     }
     getUniqueConnectionId() {
         try {
+            console.log('[WebSocket] Reading unique connection ID from codeboltagent.yaml');
             let fileContents = fs_1.default.readFileSync('./codeboltagent.yaml', 'utf8');
             let data = js_yaml_1.default.load(fileContents);
-            return data.unique_connectionid;
+            const connectionId = data.unique_connectionid;
+            console.log('[WebSocket] Successfully retrieved connection ID:', connectionId);
+            return connectionId;
         }
         catch (e) {
-            console.error('Unable to locate codeboltagent.yaml file.');
+            console.error('[WebSocket] Unable to locate codeboltagent.yaml file:', e);
             return '';
         }
     }
     getInitialMessage() {
         try {
+            console.log('[WebSocket] Reading initial message from codeboltagent.yaml');
             let fileContents = fs_1.default.readFileSync('./codeboltagent.yaml', 'utf8');
             let data = js_yaml_1.default.load(fileContents);
-            return data.initial_message;
+            const initialMessage = data.initial_message;
+            console.log('[WebSocket] Successfully retrieved initial message');
+            return initialMessage;
         }
         catch (e) {
-            // console.error('Unable to locate codeboltagent.yaml file.');
+            console.warn('[WebSocket] Unable to locate codeboltagent.yaml file for initial message:', e);
             return '';
         }
     }
@@ -49,6 +57,7 @@ class cbws {
      * @returns {Promise<WebSocket>} A promise that resolves with the WebSocket instance.
      */
     async initializeWebSocket() {
+        console.log('[WebSocket] Starting WebSocket initialization');
         const uniqueConnectionId = this.getUniqueConnectionId();
         const initialMessage = this.getInitialMessage();
         const agentIdParam = process.env.agentId ? `&agentId=${process.env.agentId}` : '';
@@ -56,19 +65,49 @@ class cbws {
         const parentAgentInstanceIdParam = process.env.parentAgentInstanceId ? `&parentAgentInstanceId=${process.env.parentAgentInstanceId}` : '';
         const agentTask = process.env.agentTask ? `&agentTask=${process.env.agentTask}` : '';
         const socketPort = process.env.SOCKET_PORT || '12345';
-        this.websocket = new ws_1.default(`ws://localhost:${socketPort}/codebolt?id=${uniqueConnectionId}${agentIdParam}${parentIdParam}${parentAgentInstanceIdParam}${agentTask}${process.env.Is_Dev ? '&dev=true' : ''}`);
+        const wsUrl = `ws://localhost:${socketPort}/codebolt?id=${uniqueConnectionId}${agentIdParam}${parentIdParam}${parentAgentInstanceIdParam}${agentTask}${process.env.Is_Dev ? '&dev=true' : ''}`;
+        console.log('[WebSocket] Connecting to:', wsUrl);
+        this.websocket = new ws_1.default(wsUrl);
         return new Promise((resolve, reject) => {
+            // Set a timeout for the connection
+            const connectionTimeout = setTimeout(() => {
+                console.error('[WebSocket] Connection timeout after 10 seconds');
+                if (this.websocket) {
+                    this.websocket.terminate();
+                }
+                reject(new Error('WebSocket connection timeout after 10 seconds'));
+            }, 10000);
             this.websocket.on('error', (error) => {
+                console.error('[WebSocket] Connection error:', error);
+                clearTimeout(connectionTimeout);
                 reject(error);
             });
             this.websocket.on('open', () => {
+                console.log('[WebSocket] Connection opened successfully');
+                clearTimeout(connectionTimeout);
                 // Initialize the message manager with this websocket
+                console.log('[WebSocket] Initializing message manager');
                 messageManager_1.default.initialize(this.websocket);
+                this.initialized = true;
+                console.log('[WebSocket] WebSocket fully initialized and ready');
                 resolve(this.websocket);
             });
-            this.websocket.on('close', () => {
+            this.websocket.on('close', (code, reason) => {
+                console.log(`[WebSocket] Connection closed with code: ${code}, reason: ${reason.toString()}`);
+                clearTimeout(connectionTimeout);
                 // Clean up pending requests when connection closes
+                console.log('[WebSocket] Cleaning up message manager');
                 messageManager_1.default.cleanup();
+                this.initialized = false;
+            });
+            this.websocket.on('message', (data) => {
+                console.log('[WebSocket] Message received:', data.toString().substring(0, 100) + (data.toString().length > 100 ? '...' : ''));
+            });
+            this.websocket.on('ping', () => {
+                console.log('[WebSocket] Ping received');
+            });
+            this.websocket.on('pong', () => {
+                console.log('[WebSocket] Pong received');
             });
         });
     }
@@ -78,18 +117,63 @@ class cbws {
      * @throws {Error} If the WebSocket is not open.
      */
     get getWebsocket() {
-        if (this.websocket && !this.websocket.OPEN) {
+        if (!this.websocket) {
+            console.error('[WebSocket] WebSocket is not initialized');
+            throw new Error('WebSocket is not initialized');
+        }
+        if (this.websocket.readyState !== ws_1.default.OPEN) {
+            console.error('[WebSocket] Attempted to access WebSocket but it is not open. Ready state:', this.websocket.readyState);
             throw new Error('WebSocket is not open');
         }
-        else {
+        console.log('[WebSocket] WebSocket access - ready state:', this.websocket.readyState);
+        return this.websocket;
+    }
+    /**
+     * Waits for the WebSocket to be ready and returns it.
+     * @returns {Promise<WebSocket>} A promise that resolves with the WebSocket instance when it's ready.
+     */
+    async waitForWebSocket() {
+        if (!this.websocket) {
+            console.error('[WebSocket] WebSocket is not initialized');
+            throw new Error('WebSocket is not initialized');
+        }
+        if (this.websocket.readyState === ws_1.default.OPEN) {
+            console.log('[WebSocket] WebSocket is already open');
             return this.websocket;
         }
+        console.log('[WebSocket] Waiting for WebSocket to connect...');
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                console.error('[WebSocket] Connection timeout after 5 seconds');
+                reject(new Error('WebSocket connection timeout'));
+            }, 5000);
+            this.websocket.once('open', () => {
+                console.log('[WebSocket] WebSocket connection established while waiting');
+                clearTimeout(timeout);
+                resolve(this.websocket);
+            });
+            this.websocket.once('error', (error) => {
+                console.error('[WebSocket] WebSocket error while waiting:', error);
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
     }
     /**
      * Get the message manager instance
      */
     get messageManager() {
+        if (!this.initialized) {
+            console.log('[WebSocket] Accessing message manager (not yet initialized)');
+        }
         return messageManager_1.default;
     }
+    /**
+     * Check if the WebSocket is initialized and ready
+     */
+    get isInitialized() {
+        return this.initialized && this.websocket && this.websocket.readyState === ws_1.default.OPEN;
+    }
 }
+// console.log('[WebSocket] Creating cbws singleton instance');
 exports.default = new cbws();

package/dist/index.d.ts

@@ -1,30 +1,46 @@
 /// <reference types="node" />
 import WebSocket from 'ws';
 import { EventEmitter } from 'events';
+import type { ChatMessageFromUser, LLMResponse, UserMessage } from './types/socketMessageTypes';
+export type { Message, ToolCall, Tool, LLMInferenceParams, APIResponse, CodeboltConfig, ProgressCallback, ErrorCallback, SuccessCallback, CompletionCallback } from './types/libFunctionTypes';
 /**
  * @class Codebolt
  * @description This class provides a unified interface to interact with various modules.
  */
 declare class Codebolt {
+    websocket: WebSocket | null;
+    private isReady;
+    private readyPromise;
     /**
      * @constructor
      * @description Initializes the websocket connection.
      */
     constructor();
     /**
-     * @method waitForConnection
-     * @description Waits for the WebSocket connection to open.
-     * @returns {Promise<void>} A promise that resolves when the WebSocket connection is open.
+     * @method initializeConnection
+     * @description Initializes the WebSocket connection asynchronously.
+     * @private
      */
-    waitForConnection(): Promise<void>;
-    websocket: WebSocket | null;
+    private initializeConnection;
+    /**
+     * @method waitForReady
+     * @description Waits for the Codebolt instance to be fully initialized.
+     * @returns {Promise<void>} A promise that resolves when the instance is ready.
+     */
+    waitForReady(): Promise<void>;
+    /**
+     * @method isReady
+     * @description Checks if the Codebolt instance is ready for use.
+     * @returns {boolean} True if the instance is ready, false otherwise.
+     */
+    get ready(): boolean;
     fs: {
-        createFile: (fileName: string, source: string, filePath: string) => Promise<import("@codebolt/types").CreateFileResponse>;
-        createFolder: (folderName: string, folderPath: string) => Promise<import("@codebolt/types").CreateFolderResponse>;
-        readFile: (filePath: string) => Promise<import("@codebolt/types").ReadFileResponse>;
-        updateFile: (filename: string, filePath: string, newContent: string) => Promise<import("@codebolt/types").UpdateFileResponse>;
-        deleteFile: (filename: string, filePath: string) => Promise<import("@codebolt/types").DeleteFileResponse>;
-        deleteFolder: (foldername: string, folderpath: string) => Promise<import("@codebolt/types").DeleteFolderResponse>;
+        createFile: (fileName: string, source: string, filePath: string) => Promise<import("./types/socketMessageTypes").CreateFileResponse>;
+        createFolder: (folderName: string, folderPath: string) => Promise<import("./types/socketMessageTypes").CreateFolderResponse>;
+        readFile: (filePath: string) => Promise<import("./types/socketMessageTypes").ReadFileResponse>;
+        updateFile: (filename: string, filePath: string, newContent: string) => Promise<import("./types/socketMessageTypes").UpdateFileResponse>;
+        deleteFile: (filename: string, filePath: string) => Promise<import("./types/socketMessageTypes").DeleteFileResponse>;
+        deleteFolder: (foldername: string, folderpath: string) => Promise<import("./types/socketMessageTypes").DeleteFolderResponse>;
         listFile: (folderPath: string, isRecursive?: boolean) => Promise<any>;
         listCodeDefinitionNames: (path: string) => Promise<{
             success: boolean;
@@ -49,45 +65,45 @@ declare class Codebolt {
         }>;
     };
     git: {
-        init: (path: string) => Promise<any>;
-        pull: () => Promise<any>;
-        push: () => Promise<any>;
-        status: () => Promise<any>;
-        addAll: () => Promise<any>;
-        commit: (message: string) => Promise<any>;
-        checkout: (branch: string) => Promise<any>;
-        branch: (branch: string) => Promise<any>;
-        logs: (path: string) => Promise<any>;
-        diff: (commitHash: string) => Promise<any>;
+        init: (path: string) => Promise<import("./types/socketMessageTypes").GitInitResponse>;
+        pull: () => Promise<import("./types/socketMessageTypes").GitPullResponse>;
+        push: () => Promise<import("./types/socketMessageTypes").GitPushResponse>;
+        status: () => Promise<import("./types/socketMessageTypes").GitStatusResponse>;
+        addAll: () => Promise<import("./types/socketMessageTypes").AddResponse>;
+        commit: (message: string) => Promise<import("./types/socketMessageTypes").GitCommitResponse>;
+        checkout: (branch: string) => Promise<import("./types/socketMessageTypes").GitCheckoutResponse>;
+        branch: (branch: string) => Promise<import("./types/socketMessageTypes").GitBranchResponse>;
+        logs: (path: string) => Promise<import("./types/socketMessageTypes").GitLogsResponse>;
+        diff: (commitHash: string) => Promise<import("./types/socketMessageTypes").GitDiffResponse>;
     };
     llm: {
-        inference: (message: string, llmrole: string) => Promise<import("@codebolt/types").LLMResponse>;
+        inference: (message: string, llmrole: string) => Promise<LLMResponse>;
     };
     browser: {
-        newPage: () => Promise<any>;
-        getUrl: () => Promise<import("@codebolt/types").UrlResponse>;
-        goToPage: (url: string) => Promise<import("@codebolt/types").GoToPageResponse>;
-        screenshot: () => Promise<any>;
-        getHTML: () => Promise<import("@codebolt/types").HtmlReceived>;
-        getMarkdown: () => Promise<import("@codebolt/types").GetMarkdownResponse>;
+        newPage: () => Promise<import("./types/socketMessageTypes").BrowserActionResponseData>;
+        getUrl: () => Promise<import("./types/socketMessageTypes").UrlResponse>;
+        goToPage: (url: string) => Promise<import("./types/socketMessageTypes").GoToPageResponse>;
+        screenshot: () => Promise<import("./types/socketMessageTypes").BrowserScreenshotResponse>;
+        getHTML: () => Promise<import("./types/socketMessageTypes").HtmlReceived>;
+        getMarkdown: () => Promise<import("./types/socketMessageTypes").GetMarkdownResponse>;
         getPDF: () => void;
         pdfToText: () => void;
-        getContent: () => Promise<import("@codebolt/types").GetContentResponse>;
-        getSnapShot: () => Promise<any>;
-        getBrowserInfo: () => Promise<any>;
-        extractText: () => Promise<import("@codebolt/types").ExtractTextResponse>;
+        getContent: () => Promise<import("./types/socketMessageTypes").GetContentResponse>;
+        getSnapShot: () => Promise<import("./types/socketMessageTypes").BrowserSnapshotResponse>;
+        getBrowserInfo: () => Promise<import("./types/socketMessageTypes").BrowserInfoResponse>;
+        extractText: () => Promise<import("./types/socketMessageTypes").ExtractTextResponse>;
         close: () => void;
-        scroll: (direction: string, pixels: string) => Promise<any>;
-        type: (elementid: string, text: string) => Promise<any>;
-        click: (elementid: string) => Promise<any>;
-        enter: () => Promise<any>;
-        search: (elementid: string, query: string) => Promise<any>;
+        scroll: (direction: string, pixels: string) => Promise<import("./types/socketMessageTypes").BrowserActionResponseData>;
+        type: (elementid: string, text: string) => Promise<import("./types/socketMessageTypes").BrowserActionResponseData>;
+        click: (elementid: string) => Promise<import("./types/socketMessageTypes").BrowserActionResponseData>;
+        enter: () => Promise<import("./types/socketMessageTypes").BrowserActionResponseData>;
+        search: (elementid: string, query: string) => Promise<import("./types/socketMessageTypes").BrowserActionResponseData>;
     };
     chat: {
-        getChatHistory: () => Promise<import("@codebolt/types").ChatMessage[]>;
+        getChatHistory: () => Promise<import("./types/socketMessageTypes").ChatMessage[]>;
         setRequestHandler: (handler: (request: any, response: (data: any) => void) => void | Promise<void>) => void;
         sendMessage: (message: string, payload: any) => void;
-        waitforReply: (message: string) => Promise<import("@codebolt/types").UserMessage>;
+        waitforReply: (message: string) => Promise<UserMessage>;
         processStarted: (onStopClicked?: ((message: any) => void) | undefined) => {
             stopProcess: () => void;
             cleanup: () => void;
@@ -99,7 +115,7 @@ declare class Codebolt {
         processFinished: () => void;
         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;
+        sendNotificationEvent: (notificationMessage: string, type: "browser" | "terminal" | "git" | "debug" | "planner" | "editor" | "preview") => void;
     };
     terminal: {
         eventEmitter: {
@@ -122,8 +138,8 @@ declare class Codebolt {
             eventNames(): (string | symbol)[];
         };
         executeCommand: (command: string, returnEmptyStringOnSuccess?: boolean) => Promise<any>;
-        executeCommandRunUntilError: (command: string, executeInMain?: boolean) => Promise<import("@codebolt/types").CommandError>;
-        sendManualInterrupt(): Promise<import("@codebolt/types").TerminalInterruptResponse>;
+        executeCommandRunUntilError: (command: string, executeInMain?: boolean) => Promise<import("./types/socketMessageTypes").CommandError>;
+        sendManualInterrupt(): Promise<import("./types/socketMessageTypes").TerminalInterruptResponse>;
         executeCommandWithStream(command: string, executeInMain?: boolean): {
             cleanup?: (() => void) | undefined;
             [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
@@ -145,11 +161,11 @@ declare class Codebolt {
         };
     };
     codeutils: {
-        getJsTree: (filePath?: string | undefined) => Promise<import("./modules/codeutils").JSTreeResponse>;
+        getJsTree: (filePath?: string | undefined) => Promise<import("./types/InternalTypes").JSTreeResponse>;
         getAllFilesAsMarkDown: () => Promise<string>;
-        performMatch: (matcherDefinition: object, problemPatterns: any[], problems?: any[]) => Promise<import("@codebolt/types").MatchProblemResponse>;
-        getMatcherList: () => Promise<import("@codebolt/types").GetMatcherListTreeResponse>;
-        matchDetail: (matcher: string) => Promise<import("@codebolt/types").getMatchDetail>;
+        performMatch: (matcherDefinition: object, problemPatterns: any[], problems?: any[]) => Promise<import("./types/socketMessageTypes").MatchProblemResponse>;
+        getMatcherList: () => Promise<import("./types/socketMessageTypes").GetMatcherListTreeResponse>;
+        matchDetail: (matcher: string) => Promise<import("./types/socketMessageTypes").getMatchDetail>;
     };
     crawler: {
         start: () => void;
@@ -183,7 +199,7 @@ declare class Codebolt {
             class: string;
             location: string;
         }[]>;
-        getAstTreeInFile: (file: string, className?: string | undefined) => Promise<import("./modules/codeparsers").ASTNode | {
+        getAstTreeInFile: (file: string, className?: string | undefined) => Promise<import("./types/commonTypes").ASTNode | {
             error: string;
         }>;
     };
@@ -198,11 +214,7 @@ declare class Codebolt {
             parsed?: any;
         };
         parseCSV: (csvString: string) => {
-            success: boolean; /**
-             * @method waitForConnection
-             * @description Waits for the WebSocket connection to open.
-             * @returns {Promise<void>} A promise that resolves when the WebSocket connection is open.
-             */
+            success: boolean;
             parsed?: any[] | undefined;
             error?: Error | undefined;
         };
@@ -215,23 +227,19 @@ declare class Codebolt {
     };
     project: {
         getProjectSettings: () => Promise<any>;
-        getProjectPath: () => Promise<import("@codebolt/types").GetProjectPathResponse>;
-        getRepoMap: (message: any) => Promise<import("@codebolt/types").GetProjectPathResponse>;
-        runProject: () => void; /**
-         * @method waitForConnection
-         * @description Waits for the WebSocket connection to open.
-         * @returns {Promise<void>} A promise that resolves when the WebSocket connection is open.
-         */
+        getProjectPath: () => Promise<import("./types/socketMessageTypes").GetProjectPathResponse>;
+        getRepoMap: (message: any) => Promise<import("./types/socketMessageTypes").GetProjectPathResponse>;
+        runProject: () => void;
         getEditorFileStatus: () => Promise<any>;
     };
     dbmemory: {
-        addKnowledge: (key: string, value: any) => Promise<import("@codebolt/types").MemorySetResponse>;
-        getKnowledge: (key: string) => Promise<import("@codebolt/types").MemoryGetResponse>;
+        addKnowledge: (key: string, value: any) => Promise<import("./types/socketMessageTypes").MemorySetResponse>;
+        getKnowledge: (key: string) => Promise<import("./types/socketMessageTypes").MemoryGetResponse>;
     };
     cbstate: {
-        getApplicationState: () => Promise<import("@codebolt/types").ApplicationState>;
-        addToAgentState: (key: string, value: string) => Promise<import("@codebolt/types").AddToAgentStateResponse>;
-        getAgentState: () => Promise<import("@codebolt/types").GetAgentStateResponse>;
+        getApplicationState: () => Promise<import("./types/commonTypes").ApplicationState>;
+        addToAgentState: (key: string, value: string) => Promise<import("./types/socketMessageTypes").AddToAgentStateResponse>;
+        getAgentState: () => Promise<import("./types/socketMessageTypes").GetAgentStateResponse>;
         getProjectState: () => Promise<any>;
         updateProjectState: (key: string, value: any) => Promise<any>;
     };
@@ -241,60 +249,54 @@ declare class Codebolt {
         updateTask: (task: string) => Promise<any>;
     };
     vectordb: {
-        getVector: (key: string) => Promise<import("@codebolt/types").GetVectorResponse>;
-        addVectorItem: (item: any) => Promise<import("@codebolt/types").AddVectorItemResponse>;
-        queryVectorItem: (key: string) => Promise<import("@codebolt/types").QueryVectorItemResponse>;
-        queryVectorItems: (items: [], dbPath: string) => Promise<import("@codebolt/types").QueryVectorItemResponse>;
+        getVector: (key: string) => Promise<import("./types/socketMessageTypes").GetVectorResponse>;
+        addVectorItem: (item: any) => Promise<import("./types/socketMessageTypes").AddVectorItemResponse>;
+        queryVectorItem: (key: string) => Promise<import("./types/socketMessageTypes").QueryVectorItemResponse>;
+        queryVectorItems: (items: [], dbPath: string) => Promise<import("./types/socketMessageTypes").QueryVectorItemResponse>;
     };
     debug: {
-        debug: (log: string, type: import("./modules/debug").logType) => Promise<import("@codebolt/types").DebugAddLogResponse>;
-        openDebugBrowser: (url: string, port: number) => Promise<import("@codebolt/types").OpenDebugBrowserResponse>;
+        debug: (log: string, type: import("./modules/debug").logType) => Promise<import("./types/socketMessageTypes").DebugAddLogResponse>;
+        openDebugBrowser: (url: string, port: number) => Promise<import("./types/socketMessageTypes").OpenDebugBrowserResponse>;
     };
     tokenizer: {
-        addToken: (key: string) => Promise<import("@codebolt/types").AddTokenResponse>;
-        getToken: (key: string) => Promise<import("@codebolt/types").GetTokenResponse>;
+        addToken: (key: string) => Promise<import("./types/socketMessageTypes").AddTokenResponse>;
+        getToken: (key: string) => Promise<import("./types/socketMessageTypes").GetTokenResponse>;
     };
     chatSummary: {
-        summarizeAll: () => Promise<{
-            role: string;
-            content: string;
-        }[]>;
+        summarizeAll: () => Promise<import("./types/socketMessageTypes").GetSummarizeAllResponse>;
         summarize: (messages: {
             role: string;
             content: string;
-        }[], depth: number) => Promise<{
-            role: string;
-            content: string;
-        }[]>;
+        }[], depth: number) => Promise<import("./types/socketMessageTypes").GetSummarizeResponse>;
     };
-    tools: {
-        getEnabledToolBoxes: () => Promise<any>;
-        getLocalToolBoxes: () => Promise<any>;
-        getMentionedToolBoxes: (userMessage: import("./utils").UserMessage) => Promise<any>;
-        searchAvailableToolBoxes: (query: string) => Promise<any>;
-        listToolsFromToolBoxes: (toolBoxes: string[]) => Promise<any>;
-        configureToolBox: (name: string, config: any) => Promise<any>;
+    mcp: {
+        getEnabledMCPServers: () => Promise<import("./types/socketMessageTypes").GetEnabledToolBoxesResponse>;
+        getLocalMCPServers: () => Promise<import("./types/socketMessageTypes").GetLocalToolBoxesResponse>;
+        getMentionedMCPServers: (userMessage: import("./utils").UserMessage) => Promise<import("./types/socketMessageTypes").GetAvailableToolBoxesResponse>;
+        searchAvailableMCPServers: (query: string) => Promise<import("./types/socketMessageTypes").SearchAvailableToolBoxesResponse>;
+        listMcpFromServers: (toolBoxes: string[]) => Promise<import("./types/socketMessageTypes").ListToolsFromToolBoxesResponse>;
+        configureMCPServer: (name: string, config: any) => Promise<import("./types/socketMessageTypes").ConfigureToolBoxResponse>;
         getTools: (tools: {
             toolbox: string;
             toolName: string;
-        }[]) => Promise<any[]>;
-        executeTool: (toolbox: string, toolName: string, params: any) => Promise<any>;
+        }[]) => Promise<import("./types/socketMessageTypes").GetToolsResponse>;
+        executeTool: (toolbox: string, toolName: string, params: any) => Promise<import("./types/socketMessageTypes").ExecuteToolResponse>;
     };
     agent: {
-        findAgent: (task: string, maxResult: number | undefined, agents: never[] | undefined, agentLocaltion: import("./modules/agent").AgentLocation | undefined, getFrom: import("./modules/agent").FilterUsing.USE_VECTOR_DB) => Promise<any>;
-        startAgent: (agentId: string, task: string) => Promise<any>;
-        getAgentsList: (type?: import("./modules/agent").Agents) => Promise<any>;
-        getAgentsDetail: (agentList?: never[]) => Promise<any>;
+        findAgent: (task: string, maxResult: number | undefined, agents: never[] | undefined, agentLocaltion: import("./modules/agent").AgentLocation | undefined, getFrom: import("./modules/agent").FilterUsing.USE_VECTOR_DB) => Promise<import("./types/socketMessageTypes").FindAgentByTaskResponse>;
+        startAgent: (agentId: string, task: string) => Promise<import("./types/socketMessageTypes").TaskCompletionResponse>;
+        getAgentsList: (type?: import("./modules/agent").Agents) => Promise<import("./types/socketMessageTypes").ListAgentsResponse>;
+        getAgentsDetail: (agentList?: never[]) => Promise<import("./types/socketMessageTypes").AgentsDetailResponse>;
     };
     utils: {
-        editFileAndApplyDiff: (filePath: string, diff: string, diffIdentifier: string, prompt: string, applyModel?: string | undefined) => Promise<any>;
+        editFileAndApplyDiff: (filePath: string, diff: string, diffIdentifier: string, prompt: string, applyModel?: string | undefined) => Promise<import("./types/socketMessageTypes").FsEditFileAndApplyDiffResponse>;
     };
     /**
      * Sets up a listener for incoming messages with a direct handler function.
      * @param {Function} handler - The handler function to call when a message is received.
      * @returns {void}
      */
-    onMessage(handler: (userMessage: any) => void | Promise<void> | any | Promise<any>): void;
+    onMessage(handler: (userMessage: ChatMessageFromUser) => void | Promise<void> | any | Promise<any>): void;
 }
 declare const codebolt: Codebolt;
 export default codebolt;