@codebolt/codeboltjs 1.1.89 → 1.1.91

package/modules/websocket.d.ts

@@ -15,7 +15,7 @@ declare class cbws {
      * when the WebSocket connection is successfully opened.
      * @returns {Promise<WebSocket>} A promise that resolves with the WebSocket instance.
      */
-    private initializeWebSocket;
+    initializeWebSocket(): Promise<WebSocket>;
     /**
      * Getter for the WebSocket instance. Throws an error if the WebSocket is not open.
      * @returns {WebSocket} The WebSocket instance.

package/modules/websocket.js

@@ -14,14 +14,11 @@ class cbws {
      * Constructs a new cbws instance and initializes the WebSocket connection.
      */
     constructor() {
-        const uniqueConnectionId = this.getUniqueConnectionId();
-        const initialMessage = this.getInitialMessage();
-        const agentIdParam = process.env.agentId ? `&agentId=${process.env.agentId}` : '';
-        const parentIdParam = process.env.parentId ? `&parentId=${process.env.parentId}` : '';
-        this.websocket = new ws_1.default(`ws://localhost:${process.env.SOCKET_PORT}/codebolt?id=${uniqueConnectionId}${agentIdParam}${parentIdParam}${process.env.Is_Dev ? '&dev=true' : ''}`);
-        this.initializeWebSocket(initialMessage).catch(error => {
-            console.error("WebSocket connection failed:", error);
-        });
+        // 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 => {
+        //     console.error("WebSocket connection failed:", error);
+        // });
     }
     getUniqueConnectionId() {
         try {
@@ -41,7 +38,7 @@ class cbws {
             return data.initial_message;
         }
         catch (e) {
-            console.error('Unable to locate codeboltagent.yaml file.');
+            // console.error('Unable to locate codeboltagent.yaml file.');
             return '';
         }
     }
@@ -50,7 +47,12 @@ class cbws {
      * when the WebSocket connection is successfully opened.
      * @returns {Promise<WebSocket>} A promise that resolves with the WebSocket instance.
      */
-    async initializeWebSocket(initialMessage) {
+    async initializeWebSocket() {
+        const uniqueConnectionId = this.getUniqueConnectionId();
+        const initialMessage = this.getInitialMessage();
+        const agentIdParam = process.env.agentId ? `&agentId=${process.env.agentId}` : '';
+        const parentIdParam = process.env.parentId ? `&parentId=${process.env.parentId}` : '';
+        this.websocket = new ws_1.default(`ws://localhost:${process.env.SOCKET_PORT}/codebolt?id=${uniqueConnectionId}${agentIdParam}${parentIdParam}${process.env.Is_Dev ? '&dev=true' : ''}`);
         return new Promise((resolve, reject) => {
             this.websocket.on('error', (error) => {
                 console.log('WebSocket error:', error);
@@ -78,7 +80,7 @@ class cbws {
      * @throws {Error} If the WebSocket is not open.
      */
     get getWebsocket() {
-        if (!this.websocket.OPEN) {
+        if (this.websocket && !this.websocket.OPEN) {
             throw new Error('WebSocket is not open');
         }
         else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/codeboltjs",
-  "version": "1.1.89",
+  "version": "1.1.91",
   "description": "",
   "keywords": [],
   "author": "",
@@ -20,28 +20,52 @@
   "homepage": "https://codeboltai.github.io",
   "dependencies": {
     "@codebolt/types": "^1.0.10",
+    "@modelcontextprotocol/sdk": "^1.4.1",
+    "execa": "^9.5.2",
+    "file-type": "^19.6.0",
+    "fuse.js": "^7.0.0",
     "js-yaml": "^4.1.0",
+    "load-esm": "^1.0.1",
+    "mcp-proxy": "^2.4.0",
+    "strict-event-emitter-types": "^2.0.0",
+    "timers": "^0.1.1",
     "tree-sitter": "^0.21.1",
     "tree-sitter-javascript": "^0.23.1",
     "tree-sitter-typescript": "^0.23.2",
     "typedoc-plugin-missing-exports": "^2.2.0",
-    "ws": "^8.17.0"
+    "uri-templates": "^0.2.0",
+    "ws": "^8.17.0",
+    "yargs": "^17.7.2",
+    "zod": "^3.24.1",
+    "zod-to-json-schema": "^3.24.1"
   },
   "devDependencies": {
     "@types/events": "^3.0.3",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.14.2",
+    "@types/uri-templates": "^0.1.34",
     "@types/ws": "^8.5.10",
     "jest": "^29.7.0",
     "jest-serial-runner": "^1.2.1",
     "ts-loader": "^9.5.1",
     "typedoc": "^0.25.13",
-    "typedoc-plugin-markdown": "^4.0.1",
+    "typedoc-plugin-markdown": "^3.15.0",
+    "typedoc-plugin-missing-exports": "^2.2.0",
     "typescript": "^5.4.5",
     "webpack": "^5.91.0",
     "webpack-cli": "^5.1.4"
   },
   "jest": {
     "testTimeout": 50000
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./utils": {
+      "types": "./utils.d.ts",
+      "default": "./utils.js"
+    }
   }
-}
+}

package/src/index.ts

@@ -28,6 +28,7 @@ import cbagent from './modules/agent';
 
 
 
+
 /**
  * @class Codebolt
  * @description This class provides a unified interface to interact with various modules.
@@ -39,8 +40,9 @@ class Codebolt  { // Extend EventEmitter
      * @description Initializes the websocket connection.
      */
     constructor() {
-
+        cbws.initializeWebSocket()
         this.websocket = cbws.getWebsocket;
+         
     }
     
     /**
@@ -96,8 +98,10 @@ class Codebolt  { // Extend EventEmitter
     chatSummary=chatSummary;
     MCP = codeboltMCP;
     AGENT = cbagent;
+  
 }
 
 export default new Codebolt();
 
-// module.exports = new Codebolt();
+
+

package/src/modules/agent.ts

@@ -1,22 +1,48 @@
 import { GetAgentStateResponse } from '@codebolt/types';
 import cbws from './websocket';
 
+
+export enum AgentLocation {
+    ALL = 'all',
+    LOCAL_ONLY = 'local_only',
+    REMOTE_ONLY = 'remote_only',
+}
+
+
+export enum Agents {
+    LOCAL = 'local',
+    ALL = 'all',
+    DOWNLOADED = 'downloaded',
+}
+
+export enum FilterUsing {
+    USE_AI = 'use_ai',
+    USE_VECTOR_DB = 'use_vector_db',
+    USE_BOTH = 'use_both',
+}
+
+
+
 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 = 1, agents = [], agentLocaltion: AgentLocation = AgentLocation.ALL, getFrom: FilterUsing.USE_VECTOR_DB): Promise<any> => {
         return new Promise((resolve, reject) => {
             cbws.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
             }));
             cbws.getWebsocket.on('message', (data: string) => {
                 const response = JSON.parse(data);
-                if (response.type === "getAgentByTaskResponse") {
+                if (response.type === "findAgentByTaskResponse") {
                     resolve(response); // Resolve the Promise with the agent details
                 }
             });
@@ -43,6 +69,46 @@ const codeboltAgent = {
                 }
             });
         });
+    },
+
+    /**
+     * Lists all available agents.
+     * @returns {Promise<any>} A promise that resolves with the list of agents.
+     */
+    getAgentsList: (type: Agents = Agents.DOWNLOADED): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "agentEvent",
+                "action": "listAgents",
+                "agentType": type,
+
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                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 = []): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "agentEvent",
+                "action": "agentsDetail",
+                "agentList": agentList
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "listAgentsResponse") {
+                    resolve(response); // Resolve the Promise with the list of agents
+                }
+            });
+        });
     }
 }
 

package/src/modules/agentlib/agent.ts

@@ -0,0 +1,243 @@
+import chatlib from "./../chat"
+import mcp from "./../mcp"
+import llm from "./../llm"
+import codeboltAgent from "./../agent"
+import { SystemPrompt } from "./systemprompt";
+import { TaskInstruction } from "./taskInstruction";
+
+interface Message {
+    role: 'user' | 'assistant' | 'tool' | 'system';
+    content: any[] | string;
+    tool_call_id?: string;
+    [key: string]: any;
+}
+
+interface ToolResult {
+    role: 'tool';
+    tool_call_id: string;
+    content: any;
+}
+
+interface ToolDetails {
+    toolName: string;
+    toolInput: any;
+    toolUseId: string;
+}
+
+class Agent {
+    private tools: any[];
+    private subAgents: any[];
+    private apiConversationHistory: Message[];
+    private maxRun: number;
+    private systemPrompt: SystemPrompt;
+    private userMessage: Message[];
+
+
+    constructor(tools: any = [], systemPrompt: SystemPrompt, maxRun: number = 0, subAgents: any[] = []) {
+        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: TaskInstruction, successCondition: () => boolean = () => true): Promise<{ success: boolean; error: string | null, message: string | null }> {
+
+
+        let mentaionedMCPSTool: any[] = 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 chatlib.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: ToolResult[] = [];
+                    let taskCompletedBlock: any;
+                    let userRejectedToolUse = false;
+                    const contentBlock = response.choices[0];
+
+                    if (contentBlock.message?.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 codeboltAgent.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: Message[] = 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: this.apiConversationHistory
+                .filter(msg => msg.role === 'assistant')
+                .pop()?.content as string || ''
+        };
+    }
+
+    private async attemptLlmRequest(apiConversationHistory: Message[], tools: Record<string, any>): Promise<any> {
+
+
+        try {
+            let systemPrompt = await this.systemPrompt.toPromptText();
+            const aiMessages: Message[] = [
+                { role: "system", content: systemPrompt },
+                ...apiConversationHistory,
+            ];
+
+            const createParams = {
+                full: true,
+                messages: aiMessages,
+                tools: tools,
+                tool_choice: "auto",
+            };
+            //@ts-ignore
+            const { completion } = await llm.inference(createParams);
+            return completion;
+        } catch (error) {
+            console.log(error);
+            return this.attemptApiRequest();
+        }
+    }
+
+    private async executeTool(toolName: string, toolInput: any): Promise<[boolean, any]> {
+        return mcp.executeTool(toolName, toolInput);
+    }
+    private async startSubAgent(agentName: string, params: any): Promise<[boolean, any]> {
+        return codeboltAgent.startAgent(agentName, params.task);
+    }
+
+    private getToolDetail(tool: any): ToolDetails {
+        return {
+            toolName: tool.function.name,
+            toolInput: JSON.parse(tool.function.arguments || "{}"),
+            toolUseId: tool.id
+        };
+    }
+
+    private getToolResult(tool_call_id: string, content: any): ToolResult {
+        return {
+            role: "tool",
+            tool_call_id,
+            content,
+        };
+    }
+
+    // Placeholder for error fallback method
+    private attemptApiRequest(): any {
+        throw new Error("API request fallback not implemented");
+    }
+}
+
+export { Agent };