@codebolt/codeboltjs 1.1.89 → 1.1.91

package/.github/workflows/publish-to-npm.yml

@@ -13,7 +13,7 @@ jobs:
         with:
           node-version: '20.x'
           registry-url: 'https://registry.npmjs.org'
-      - run: npm ci
+      - run: npm install
       - run: npm run build 
       - run: npm publish --access public
         env:

package/index.d.ts

@@ -25,7 +25,7 @@ declare class Codebolt {
         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>;
-        listFile: (folderPath: string, isRecursive?: boolean) => Promise<unknown>;
+        listFile: (folderPath: string, isRecursive?: boolean) => Promise<any>;
         listCodeDefinitionNames: (path: string) => Promise<{
             success: boolean;
             result: any;
@@ -74,6 +74,7 @@ declare class Codebolt {
     };
     chat: {
         getChatHistory: () => Promise<import("@codebolt/types").ChatMessage[]>;
+        setRequestHandler: (handler: (request: any, response: (data: any) => void) => void | Promise<void>) => void;
         onActionMessage: () => {
             [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
             addListener<K_1>(eventName: string | symbol, listener: (...args: any[]) => void): any;
@@ -91,7 +92,7 @@ declare class Codebolt {
             prependListener<K_10>(eventName: string | symbol, listener: (...args: any[]) => void): any;
             prependOnceListener<K_11>(eventName: string | symbol, listener: (...args: any[]) => void): any;
             eventNames(): (string | symbol)[];
-        } | undefined;
+        };
         sendMessage: (message: string, payload: any) => void;
         waitforReply: (message: string) => Promise<import("@codebolt/types").UserMessage>;
         processStarted: () => {
@@ -244,8 +245,10 @@ declare class Codebolt {
         getEnabledMCPS: () => Promise<any>;
     };
     AGENT: {
-        getAgent: (task: string) => 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<any>;
         startAgent: (agentId: string, task: string) => Promise<any>;
+        getAgentsList: (type?: import("./modules/agent").Agents) => Promise<any>;
+        getAgentsDetail: (agentList?: never[]) => Promise<any>;
     };
 }
 declare const _default: Codebolt;

package/index.js

@@ -64,6 +64,7 @@ class Codebolt {
         this.chatSummary = history_1.chatSummary;
         this.MCP = mcp_1.default;
         this.AGENT = agent_1.default;
+        websocket_1.default.initializeWebSocket();
         this.websocket = websocket_1.default.getWebsocket;
     }
     /**
@@ -91,4 +92,3 @@ class Codebolt {
     }
 }
 exports.default = new Codebolt();
-// module.exports = new Codebolt();

package/modules/agent.d.ts

@@ -1,15 +1,40 @@
+export declare enum AgentLocation {
+    ALL = "all",
+    LOCAL_ONLY = "local_only",
+    REMOTE_ONLY = "remote_only"
+}
+export declare enum Agents {
+    LOCAL = "local",
+    ALL = "all",
+    DOWNLOADED = "downloaded"
+}
+export declare enum FilterUsing {
+    USE_AI = "use_ai",
+    USE_VECTOR_DB = "use_vector_db",
+    USE_BOTH = "use_both"
+}
 declare const codeboltAgent: {
     /**
      * Retrieves an agent based on the specified task.
      * @param {string} task - The task for which an agent is needed.
      * @returns {Promise<AgentResponse>} A promise that resolves with the agent details.
      */
-    getAgent: (task: string) => Promise<any>;
+    findAgent: (task: string, maxResult: number | undefined, agents: never[] | undefined, agentLocaltion: AgentLocation | undefined, getFrom: FilterUsing.USE_VECTOR_DB) => Promise<any>;
     /**
      * Starts an agent for the specified task.
      * @param {string} task - The task for which the agent should be started.
      * @returns {Promise<void>} A promise that resolves when the agent has been successfully started.
      */
     startAgent: (agentId: string, task: string) => Promise<any>;
+    /**
+     * Lists all available agents.
+     * @returns {Promise<any>} A promise that resolves with the list of agents.
+     */
+    getAgentsList: (type?: Agents) => Promise<any>;
+    /**
+     * Lists all available agents.
+     * @returns {Promise<any>} A promise that resolves with the list of agents.
+     */
+    getAgentsDetail: (agentList?: never[]) => Promise<any>;
 };
 export default codeboltAgent;

package/modules/agent.js

@@ -3,23 +3,46 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterUsing = exports.Agents = exports.AgentLocation = void 0;
 const websocket_1 = __importDefault(require("./websocket"));
+var AgentLocation;
+(function (AgentLocation) {
+    AgentLocation["ALL"] = "all";
+    AgentLocation["LOCAL_ONLY"] = "local_only";
+    AgentLocation["REMOTE_ONLY"] = "remote_only";
+})(AgentLocation || (exports.AgentLocation = AgentLocation = {}));
+var Agents;
+(function (Agents) {
+    Agents["LOCAL"] = "local";
+    Agents["ALL"] = "all";
+    Agents["DOWNLOADED"] = "downloaded";
+})(Agents || (exports.Agents = Agents = {}));
+var FilterUsing;
+(function (FilterUsing) {
+    FilterUsing["USE_AI"] = "use_ai";
+    FilterUsing["USE_VECTOR_DB"] = "use_vector_db";
+    FilterUsing["USE_BOTH"] = "use_both";
+})(FilterUsing || (exports.FilterUsing = FilterUsing = {}));
 const codeboltAgent = {
     /**
      * Retrieves an agent based on the specified task.
      * @param {string} task - The task for which an agent is needed.
      * @returns {Promise<AgentResponse>} A promise that resolves with the agent details.
      */
-    getAgent: (task) => {
+    findAgent: (task, maxResult = 1, agents = [], agentLocaltion = AgentLocation.ALL, getFrom) => {
         return new Promise((resolve, reject) => {
             websocket_1.default.getWebsocket.send(JSON.stringify({
                 "type": "agentEvent",
-                "action": "getAgentByTask",
-                "task": task
+                "action": "findAgent",
+                "task": task,
+                "agents": agents, // for filter in vector db
+                "maxResult": maxResult,
+                "location": agentLocaltion,
+                "getFrom": getFrom
             }));
             websocket_1.default.getWebsocket.on('message', (data) => {
                 const response = JSON.parse(data);
-                if (response.type === "getAgentByTaskResponse") {
+                if (response.type === "findAgentByTaskResponse") {
                     resolve(response); // Resolve the Promise with the agent details
                 }
             });
@@ -45,6 +68,44 @@ const codeboltAgent = {
                 }
             });
         });
+    },
+    /**
+     * Lists all available agents.
+     * @returns {Promise<any>} A promise that resolves with the list of agents.
+     */
+    getAgentsList: (type = Agents.DOWNLOADED) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "agentEvent",
+                "action": "listAgents",
+                "agentType": type,
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "listAgentsResponse") {
+                    resolve(response); // Resolve the Promise with the list of agents
+                }
+            });
+        });
+    },
+    /**
+     * Lists all available agents.
+     * @returns {Promise<any>} A promise that resolves with the list of agents.
+     */
+    getAgentsDetail: (agentList = []) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "agentEvent",
+                "action": "agentsDetail",
+                "agentList": agentList
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "listAgentsResponse") {
+                    resolve(response); // Resolve the Promise with the list of agents
+                }
+            });
+        });
     }
 };
 exports.default = codeboltAgent;

package/modules/agentlib/agent.d.ts

@@ -0,0 +1,23 @@
+import { SystemPrompt } from "./systemprompt";
+import { TaskInstruction } from "./taskInstruction";
+declare class Agent {
+    private tools;
+    private subAgents;
+    private apiConversationHistory;
+    private maxRun;
+    private systemPrompt;
+    private userMessage;
+    constructor(tools: any, systemPrompt: SystemPrompt, maxRun?: number, subAgents?: any[]);
+    run(task: TaskInstruction, successCondition?: () => boolean): Promise<{
+        success: boolean;
+        error: string | null;
+        message: string | null;
+    }>;
+    private attemptLlmRequest;
+    private executeTool;
+    private startSubAgent;
+    private getToolDetail;
+    private getToolResult;
+    private attemptApiRequest;
+}
+export { Agent };

package/modules/agentlib/agent.js

@@ -0,0 +1,187 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Agent = void 0;
+const chat_1 = __importDefault(require("./../chat"));
+const mcp_1 = __importDefault(require("./../mcp"));
+const llm_1 = __importDefault(require("./../llm"));
+const agent_1 = __importDefault(require("./../agent"));
+class Agent {
+    constructor(tools = [], systemPrompt, maxRun = 0, subAgents = []) {
+        this.tools = tools;
+        this.userMessage = [];
+        this.apiConversationHistory = [];
+        this.maxRun = maxRun;
+        this.systemPrompt = systemPrompt;
+        this.subAgents = subAgents;
+        this.subAgents = subAgents.map(subagent => {
+            subagent.function.name = `subagent--${subagent.function.name}`;
+            return subagent;
+        });
+        this.tools = this.tools.concat(subAgents.map(subagent => ({
+            ...subagent
+        })));
+    }
+    async run(task, successCondition = () => true) {
+        var _a, _b;
+        let mentaionedMCPSTool = await task.userMessage.getMentionedMcpsTools();
+        this.tools = [
+            ...this.tools,
+            ...mentaionedMCPSTool
+        ];
+        let completed = false;
+        let userMessages = await task.toPrompt();
+        this.apiConversationHistory.push({ role: "user", content: userMessages });
+        let runcomplete = 0;
+        while (!completed && (runcomplete <= this.maxRun || this.maxRun === 0)) {
+            try {
+                runcomplete++;
+                const response = await this.attemptLlmRequest(this.apiConversationHistory, this.tools);
+                let isMessagePresentinReply = false;
+                for (const contentBlock of response.choices) {
+                    if (contentBlock.message) {
+                        isMessagePresentinReply = true;
+                        this.apiConversationHistory.push(contentBlock.message);
+                        if (contentBlock.message.content != null) {
+                            await chat_1.default.sendMessage(contentBlock.message.content, {});
+                        }
+                    }
+                }
+                if (!isMessagePresentinReply) {
+                    this.apiConversationHistory.push({
+                        role: "assistant",
+                        content: [{ type: "text", text: "Failure: I did not provide a response." }],
+                    });
+                }
+                try {
+                    let toolResults = [];
+                    let taskCompletedBlock;
+                    let userRejectedToolUse = false;
+                    const contentBlock = response.choices[0];
+                    if ((_a = contentBlock.message) === null || _a === void 0 ? void 0 : _a.tool_calls) {
+                        for (const tool of contentBlock.message.tool_calls) {
+                            const { toolInput, toolName, toolUseId } = this.getToolDetail(tool);
+                            if (!userRejectedToolUse) {
+                                if (toolName.includes("attempt_completion")) {
+                                    taskCompletedBlock = tool;
+                                }
+                                else {
+                                    let [serverName] = toolName.replace('--', ':').split(':');
+                                    if (serverName == 'subagent') {
+                                        console.log("calling agent with params", toolName, toolInput);
+                                        const agentResponse = await agent_1.default.startAgent(toolName.replace("subagent--", ''), toolInput.task);
+                                        console.log("got sub agent resonse  result", agentResponse);
+                                        const [didUserReject, result] = [false, "tool result is successful"];
+                                        console.log("got sub agent resonse  result", didUserReject, result);
+                                        toolResults.push(this.getToolResult(toolUseId, result));
+                                        if (didUserReject) {
+                                            userRejectedToolUse = true;
+                                        }
+                                    }
+                                    else {
+                                        console.log("calling tool with params", toolName, toolInput);
+                                        const [didUserReject, result] = await this.executeTool(toolName, toolInput);
+                                        console.log("tool result", result);
+                                        toolResults.push(this.getToolResult(toolUseId, result));
+                                        if (didUserReject) {
+                                            userRejectedToolUse = true;
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                toolResults.push(this.getToolResult(toolUseId, "Skipping tool execution due to previous tool user rejection."));
+                            }
+                        }
+                    }
+                    if (taskCompletedBlock) {
+                        let [_, result] = await this.executeTool(taskCompletedBlock.function.name, JSON.parse(taskCompletedBlock.function.arguments || "{}"));
+                        if (result === "") {
+                            completed = true;
+                            result = "The user is satisfied with the result.";
+                        }
+                        toolResults.push(this.getToolResult(taskCompletedBlock.id, result));
+                    }
+                    this.apiConversationHistory.push(...toolResults);
+                    let nextUserMessage = toolResults;
+                    if (toolResults.length === 0) {
+                        nextUserMessage = [{
+                                role: "user",
+                                content: [{
+                                        type: "text",
+                                        text: "If you have completed the user's task, use the attempt_completion tool. If you require additional information from the user, use the ask_followup_question tool. Otherwise, if you have not completed the task and do not need additional information, then proceed with the next step of the task. (This is an automated message, so do not respond to it conversationally.)"
+                                    }]
+                            }];
+                        if (nextUserMessage) {
+                            this.apiConversationHistory.push(nextUserMessage[0]);
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error("Error in agent tool call:", error);
+                    return { success: false, error: error instanceof Error ? error.message : String(error), message: null };
+                }
+            }
+            catch (error) {
+                console.error("Error in agent tool call:", error);
+                return { success: false, error: error instanceof Error ? error.message : String(error), message: null };
+            }
+        }
+        return {
+            success: completed,
+            error: null,
+            message: ((_b = this.apiConversationHistory
+                .filter(msg => msg.role === 'assistant')
+                .pop()) === null || _b === void 0 ? void 0 : _b.content) || ''
+        };
+    }
+    async attemptLlmRequest(apiConversationHistory, tools) {
+        try {
+            let systemPrompt = await this.systemPrompt.toPromptText();
+            const aiMessages = [
+                { role: "system", content: systemPrompt },
+                ...apiConversationHistory,
+            ];
+            const createParams = {
+                full: true,
+                messages: aiMessages,
+                tools: tools,
+                tool_choice: "auto",
+            };
+            //@ts-ignore
+            const { completion } = await llm_1.default.inference(createParams);
+            return completion;
+        }
+        catch (error) {
+            console.log(error);
+            return this.attemptApiRequest();
+        }
+    }
+    async executeTool(toolName, toolInput) {
+        return mcp_1.default.executeTool(toolName, toolInput);
+    }
+    async startSubAgent(agentName, params) {
+        return agent_1.default.startAgent(agentName, params.task);
+    }
+    getToolDetail(tool) {
+        return {
+            toolName: tool.function.name,
+            toolInput: JSON.parse(tool.function.arguments || "{}"),
+            toolUseId: tool.id
+        };
+    }
+    getToolResult(tool_call_id, content) {
+        return {
+            role: "tool",
+            tool_call_id,
+            content,
+        };
+    }
+    // Placeholder for error fallback method
+    attemptApiRequest() {
+        throw new Error("API request fallback not implemented");
+    }
+}
+exports.Agent = Agent;

package/modules/agentlib/systemprompt.d.ts

@@ -0,0 +1,20 @@
+/**
+ * SystemPrompt class for loading and managing system prompts from YAML files
+ */
+declare class SystemPrompt {
+    private filepath;
+    private key;
+    /**
+     * Creates a SystemPrompt instance
+     * @param {string} filepath - Path to the YAML file containing prompts
+     * @param {string} key - Key identifier for the specific prompt
+     */
+    constructor(filepath?: string, key?: string);
+    /**
+     * Loads and returns the prompt text
+     * @returns {string} The prompt text
+     * @throws {Error} If file cannot be read or parsed
+     */
+    toPromptText(): string;
+}
+export { SystemPrompt };

package/modules/agentlib/systemprompt.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemPrompt = void 0;
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * SystemPrompt class for loading and managing system prompts from YAML files
+ */
+class SystemPrompt {
+    /**
+     * Creates a SystemPrompt instance
+     * @param {string} filepath - Path to the YAML file containing prompts
+     * @param {string} key - Key identifier for the specific prompt
+     */
+    constructor(filepath = "", key = "") {
+        this.filepath = filepath;
+        this.key = key;
+    }
+    /**
+     * Loads and returns the prompt text
+     * @returns {string} The prompt text
+     * @throws {Error} If file cannot be read or parsed
+     */
+    toPromptText() {
+        var _a;
+        try {
+            const absolutePath = path_1.default.resolve(this.filepath);
+            const fileContents = fs_1.default.readFileSync(absolutePath, 'utf8');
+            const data = js_yaml_1.default.load(fileContents);
+            if (!data || typeof data !== 'object') {
+                throw new Error('Invalid YAML structure');
+            }
+            if (!((_a = data[this.key]) === null || _a === void 0 ? void 0 : _a.prompt)) {
+                throw new Error(`Prompt not found for key: ${this.key}`);
+            }
+            return data[this.key].prompt;
+        }
+        catch (error) {
+            console.error(`SystemPrompt Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw error; // Re-throw to allow caller handling
+        }
+    }
+}
+exports.SystemPrompt = SystemPrompt;

package/modules/agentlib/taskInstruction.d.ts

@@ -0,0 +1,22 @@
+import { UserMessage, UserMessageContent } from "./usermessage";
+interface Tools {
+    [key: string]: {
+        description: string;
+        usage: string;
+        example?: string;
+    };
+}
+interface UserMessages {
+    type: string;
+    text: string;
+}
+declare class TaskInstruction {
+    tools: Tools;
+    userMessages: UserMessageContent[];
+    userMessage: UserMessage;
+    filepath: string;
+    refsection: string;
+    constructor(tools: Tools | undefined, userMessage: UserMessage, filepath?: string, refsection?: string);
+    toPrompt(): Promise<UserMessages[]>;
+}
+export { TaskInstruction };

package/modules/agentlib/taskInstruction.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskInstruction = void 0;
+/**
+ * Encapsulates task instructions and their related metadata.
+ * Handles loading and processing of task instructions from YAML files.
+ */
+const yaml = require('js-yaml');
+const fs = require('fs');
+const path = require('path');
+class TaskInstruction {
+    constructor(tools = {}, userMessage, filepath = "", refsection = "") {
+        this.userMessages = [];
+        this.tools = tools;
+        this.userMessage = userMessage;
+        this.filepath = filepath;
+        this.refsection = refsection;
+    }
+    async toPrompt() {
+        try {
+            this.userMessages = await this.userMessage.toPrompt();
+            const fileContents = fs.readFileSync(path.resolve(this.filepath), 'utf8');
+            const data = yaml.load(fileContents);
+            const task = data[this.refsection];
+            this.userMessages.push({
+                type: "text",
+                text: `Task Description: ${task.description}\nExpected Output: ${task.expected_output}`
+            });
+            return this.userMessages;
+        }
+        catch (error) {
+            console.error(`Error processing task instruction: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.TaskInstruction = TaskInstruction;

package/modules/agentlib/usermessage.d.ts

@@ -0,0 +1,22 @@
+interface Message {
+    userMessage: string;
+    mentionedFiles?: string[];
+    mentionedMCPs: string[];
+}
+export interface UserMessageContent {
+    type: string;
+    text: string;
+}
+declare class UserMessage {
+    message: Message;
+    promptOverride: boolean;
+    userMessages: UserMessageContent[];
+    mentaionedMCPS: string[];
+    constructor(message: Message, promptOverride?: boolean);
+    getFiles(): void;
+    toPrompt(bAttachFiles?: boolean, bAttachImages?: boolean, bAttachEnvironment?: boolean): Promise<UserMessageContent[]>;
+    getMentionedMcps(): string[];
+    getMentionedMcpsTools(): Promise<any>;
+    private getEnvironmentDetail;
+}
+export { UserMessage };

package/modules/agentlib/usermessage.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserMessage = void 0;
+const fs_1 = __importDefault(require("./../fs"));
+const project_1 = __importDefault(require("./../project"));
+const mcp_1 = __importDefault(require("./../mcp"));
+class UserMessage {
+    constructor(message, promptOverride = false) {
+        this.getEnvironmentDetail = async (cwd) => {
+            let details = "";
+            const { success, result } = await fs_1.default.listFile(cwd, true);
+            details += `\n\n# Current Working Directory (${cwd}) Files\n${result}
+            ? "\n(Note: Only top-level contents shown for Desktop by default. Use list_files to explore further if necessary.)"
+            : ""
+            }`;
+            return `<environment_details>\n${details.trim()}\n</environment_details>`;
+        };
+        this.message = message;
+        this.promptOverride = promptOverride;
+        this.userMessages = [];
+        this.mentaionedMCPS = message.mentionedMCPs;
+    }
+    getFiles() {
+        // Implementation to be added
+    }
+    async toPrompt(bAttachFiles = true, bAttachImages = true, bAttachEnvironment = true) {
+        var _a;
+        if (bAttachFiles) {
+            if (this.promptOverride) {
+                // Use a rendering engine
+            }
+            else {
+                let finalPrompt = `
+                    The user has sent the following query:
+                    ${this.message.userMessage}.
+                `;
+                if ((_a = this.message.mentionedFiles) === null || _a === void 0 ? void 0 : _a.length) {
+                    finalPrompt += `The Attached files are:`;
+                    for (const file of this.message.mentionedFiles) {
+                        let filedata = await fs_1.default.readFile(file);
+                        finalPrompt += `File Name: ${file}, File Path: ${file}, Filedata: ${filedata}`;
+                    }
+                }
+                this.userMessages.push({ type: "text", text: finalPrompt });
+            }
+        }
+        if (bAttachEnvironment) {
+            let { projectPath } = await project_1.default.getProjectPath();
+            const environmentDetail = await this.getEnvironmentDetail(projectPath);
+            this.userMessages.push({ type: "text", text: environmentDetail });
+        }
+        return this.userMessages;
+    }
+    getMentionedMcps() {
+        return this.message.mentionedMCPs || [];
+    }
+    async getMentionedMcpsTools() {
+        if (this.mentaionedMCPS.length > 0) {
+            let tools = await mcp_1.default.getMcpTools(this.mentaionedMCPS);
+            return tools;
+        }
+        else {
+            return [];
+        }
+    }
+}
+exports.UserMessage = UserMessage;

package/modules/chat.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
 import { ChatMessage, UserMessage } from '@codebolt/types';
+type RequestHandler = (request: any, response: (data: any) => void) => Promise<void> | void;
 /**
  * CustomEventEmitter class that extends the Node.js EventEmitter class.
  */
@@ -15,11 +16,20 @@ declare const cbchat: {
      * @returns {Promise<ChatMessage[]>} A promise that resolves with an array of ChatMessage objects representing the chat history.
      */
     getChatHistory: () => Promise<ChatMessage[]>;
+    /**
+     * Sets a global request handler for all incoming messages
+     * @param handler The async handler function
+     */
+    setRequestHandler: (handler: RequestHandler) => void;
     /**
      * Sets up a listener for incoming WebSocket messages and emits a custom event when a message is received.
      * @returns {EventEmitter} The event emitter used for emitting custom events.
      */
-    onActionMessage: () => CustomEventEmitter | undefined;
+    /**
+ * Sets up a listener for incoming WebSocket messages and emits a custom event when a message is received.
+ * @returns {EventEmitter} The event emitter used for emitting custom events.
+ */
+    onActionMessage: () => CustomEventEmitter;
     /**
      * Sends a message through the WebSocket connection.
      * @param {string} message - The message to be sent.