@codebolt/codeboltjs 1.1.91 → 1.1.94

package/modules/toolBox.d.ts

@@ -1,21 +1,23 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { ClientCapabilities, CreateMessageRequestSchema, Root } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { StrictEventEmitter } from "strict-event-emitter-types";
 import { EventEmitter } from "events";
 import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import http from "http";
 export type SSEServer = {
     close: () => Promise<void>;
 };
-type FastMCPEvents = {
+type FastMCPEvents<T extends FastMCPSessionAuth> = {
     connect: (event: {
-        session: FastMCPSession;
+        session: FastMCPSession<T>;
     }) => void;
     disconnect: (event: {
-        session: FastMCPSession;
+        session: FastMCPSession<T>;
     }) => void;
 };
 type FastMCPSessionEvents = {
@@ -65,7 +67,8 @@ type Progress = {
      */
     total?: number;
 };
-type Context = {
+type Context<T extends FastMCPSessionAuth> = {
+    session: T | undefined;
     reportProgress: (progress: Progress) => Promise<void>;
     log: {
         debug: (message: string, data?: SerializableValue) => void;
@@ -93,11 +96,11 @@ type Completion = {
     total?: number;
     hasMore?: boolean;
 };
-type Tool<Params extends ToolParameters = ToolParameters> = {
+type Tool<T extends FastMCPSessionAuth, Params extends ToolParameters = ToolParameters> = {
     name: string;
     description?: string;
     parameters?: Params;
-    execute: (args: z.infer<Params>, context: Context) => Promise<string | ContentResult | TextContent | ImageContent>;
+    execute: (args: z.infer<Params>, context: Context<T>) => Promise<string | ContentResult | TextContent | ImageContent>;
 };
 type ResourceResult = {
     text: string;
@@ -171,9 +174,10 @@ type Prompt<Arguments extends PromptArgument[] = PromptArgument[], Args = Prompt
     load: (args: Args) => Promise<string>;
     name: string;
 };
-type ServerOptions = {
+type ServerOptions<T extends FastMCPSessionAuth> = {
     name: string;
     version: `${number}.${number}.${number}`;
+    authenticate?: Authenticate<T>;
 };
 type LoggingLevel = "debug" | "info" | "notice" | "warning" | "error" | "critical" | "alert" | "emergency";
 declare const FastMCPSessionEventEmitterBase: {
@@ -187,12 +191,14 @@ type SamplingResponse = {
     role: "user" | "assistant";
     content: TextContent | ImageContent;
 };
-export declare class FastMCPSession extends FastMCPSessionEventEmitter {
+type FastMCPSessionAuth = Record<string, unknown> | undefined;
+export declare class FastMCPSession<T extends FastMCPSessionAuth = FastMCPSessionAuth> extends FastMCPSessionEventEmitter {
     #private;
-    constructor({ name, version, tools, resources, resourcesTemplates, prompts, }: {
+    constructor({ auth, name, version, tools, resources, resourcesTemplates, prompts, }: {
+        auth?: T;
         name: string;
         version: string;
-        tools: Tool[];
+        tools: Tool<T>[];
         resources: Resource[];
         resourcesTemplates: InputResourceTemplate[];
         prompts: Prompt[];
@@ -217,19 +223,20 @@ export declare class FastMCPSession extends FastMCPSessionEventEmitter {
     private setupPromptHandlers;
 }
 declare const FastMCPEventEmitterBase: {
-    new (): StrictEventEmitter<EventEmitter, FastMCPEvents>;
+    new (): StrictEventEmitter<EventEmitter, FastMCPEvents<FastMCPSessionAuth>>;
 };
 declare class FastMCPEventEmitter extends FastMCPEventEmitterBase {
 }
-export declare class ToolBox extends FastMCPEventEmitter {
+type Authenticate<T> = (request: http.IncomingMessage) => Promise<T>;
+export declare class ToolBox<T extends Record<string, unknown> | undefined = undefined> extends FastMCPEventEmitter {
     #private;
-    options: ServerOptions;
-    constructor(options: ServerOptions);
-    get sessions(): FastMCPSession[];
+    options: ServerOptions<T>;
+    constructor(options: ServerOptions<T>);
+    get sessions(): FastMCPSession<T>[];
     /**
      * Adds a tool to the server.
      */
-    addTool<Params extends ToolParameters>(tool: Tool<Params>): void;
+    addTool<Params extends ToolParameters>(tool: Tool<T, Params>): void;
     /**
      * Adds a resource to the server.
      */
@@ -245,7 +252,7 @@ export declare class ToolBox extends FastMCPEventEmitter {
     /**
      * Starts the server.
      */
-    activate(options?: {
+    start(options?: {
         transportType: "stdio";
     } | {
         transportType: "sse";
@@ -258,5 +265,17 @@ export declare class ToolBox extends FastMCPEventEmitter {
      * Stops the server.
      */
     stop(): Promise<void>;
+    /**
+     * Starts the server.
+     */
+    activate(options?: {
+        transportType: "stdio";
+    } | {
+        transportType: "sse";
+        sse: {
+            endpoint: `/${string}`;
+            port: number;
+        };
+    }): Promise<void>;
 }
 export {};

package/modules/toolBox.js

@@ -1,19 +1,19 @@
 "use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _FastMCPSession_capabilities, _FastMCPSession_clientCapabilities, _FastMCPSession_loggingLevel, _FastMCPSession_prompts, _FastMCPSession_resources, _FastMCPSession_resourceTemplates, _FastMCPSession_roots, _FastMCPSession_server, _FastMCPSession_pingInterval, _ToolBox_options, _ToolBox_prompts, _ToolBox_resources, _ToolBox_resourcesTemplates, _ToolBox_sessions, _ToolBox_sseServer, _ToolBox_tools;
+var _FastMCPSession_capabilities, _FastMCPSession_clientCapabilities, _FastMCPSession_loggingLevel, _FastMCPSession_prompts, _FastMCPSession_resources, _FastMCPSession_resourceTemplates, _FastMCPSession_roots, _FastMCPSession_server, _FastMCPSession_auth, _FastMCPSession_pingInterval, _ToolBox_options, _ToolBox_prompts, _ToolBox_resources, _ToolBox_resourcesTemplates, _ToolBox_sessions, _ToolBox_sseServer, _ToolBox_tools, _ToolBox_authenticate;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToolBox = exports.FastMCPSession = exports.UserError = exports.UnexpectedStateError = exports.imageContent = void 0;
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
@@ -26,6 +26,7 @@ const promises_2 = require("fs/promises");
 const events_1 = require("events");
 const fuse_js_1 = __importDefault(require("fuse.js"));
 const uri_templates_1 = __importDefault(require("uri-templates"));
+const undici_1 = require("undici");
 const load_esm_1 = require("load-esm");
 /**
  * Generates an image content object from a URL, file path, or buffer.
@@ -34,7 +35,7 @@ const imageContent = async (input) => {
     var _a;
     let rawData;
     if ("url" in input) {
-        const response = await fetch(input.url);
+        const response = await (0, undici_1.fetch)(input.url);
         if (!response.ok) {
             throw new Error(`Failed to fetch image from URL: ${response.statusText}`);
         }
@@ -133,7 +134,7 @@ const FastMCPSessionEventEmitterBase = events_1.EventEmitter;
 class FastMCPSessionEventEmitter extends FastMCPSessionEventEmitterBase {
 }
 class FastMCPSession extends FastMCPSessionEventEmitter {
-    constructor({ name, version, tools, resources, resourcesTemplates, prompts, }) {
+    constructor({ auth, name, version, tools, resources, resourcesTemplates, prompts, }) {
         super();
         _FastMCPSession_capabilities.set(this, {});
         _FastMCPSession_clientCapabilities.set(this, void 0);
@@ -143,7 +144,9 @@ class FastMCPSession extends FastMCPSessionEventEmitter {
         _FastMCPSession_resourceTemplates.set(this, []);
         _FastMCPSession_roots.set(this, []);
         _FastMCPSession_server.set(this, void 0);
+        _FastMCPSession_auth.set(this, void 0);
         _FastMCPSession_pingInterval.set(this, null);
+        __classPrivateFieldSet(this, _FastMCPSession_auth, auth, "f");
         if (tools.length) {
             __classPrivateFieldGet(this, _FastMCPSession_capabilities, "f").tools = {};
         }
@@ -259,6 +262,7 @@ class FastMCPSession extends FastMCPSessionEventEmitter {
         let attempt = 0;
         while (attempt++ < 10) {
             const capabilities = await __classPrivateFieldGet(this, _FastMCPSession_server, "f").getClientCapabilities();
+            console.log("capabilities", capabilities);
             if (capabilities) {
                 __classPrivateFieldSet(this, _FastMCPSession_clientCapabilities, capabilities, "f");
                 break;
@@ -266,7 +270,7 @@ class FastMCPSession extends FastMCPSessionEventEmitter {
             await (0, promises_1.setTimeout)(100);
         }
         if (!__classPrivateFieldGet(this, _FastMCPSession_clientCapabilities, "f")) {
-            throw new UnexpectedStateError("Server did not connect");
+            console.warn('[warning] toolBox could not infer client capabilities');
         }
         if ((_a = __classPrivateFieldGet(this, _FastMCPSession_clientCapabilities, "f")) === null || _a === void 0 ? void 0 : _a.roots) {
             const roots = await __classPrivateFieldGet(this, _FastMCPSession_server, "f").listRoots();
@@ -290,7 +294,12 @@ class FastMCPSession extends FastMCPSessionEventEmitter {
         if (__classPrivateFieldGet(this, _FastMCPSession_pingInterval, "f")) {
             clearInterval(__classPrivateFieldGet(this, _FastMCPSession_pingInterval, "f"));
         }
-        await __classPrivateFieldGet(this, _FastMCPSession_server, "f").close();
+        try {
+            await __classPrivateFieldGet(this, _FastMCPSession_server, "f").close();
+        }
+        catch (error) {
+            console.error("[MCP Error]", "could not close server", error);
+        }
     }
     setupErrorHandling() {
         __classPrivateFieldGet(this, _FastMCPSession_server, "f").onerror = (error) => {
@@ -441,6 +450,7 @@ class FastMCPSession extends FastMCPSessionEventEmitter {
                 const maybeStringResult = await tool.execute(args, {
                     reportProgress,
                     log,
+                    session: __classPrivateFieldGet(this, _FastMCPSession_auth, "f"),
                 });
                 if (typeof maybeStringResult === "string") {
                     result = ContentResultZodSchema.parse({
@@ -605,7 +615,7 @@ class FastMCPSession extends FastMCPSessionEventEmitter {
     }
 }
 exports.FastMCPSession = FastMCPSession;
-_FastMCPSession_capabilities = new WeakMap(), _FastMCPSession_clientCapabilities = new WeakMap(), _FastMCPSession_loggingLevel = new WeakMap(), _FastMCPSession_prompts = new WeakMap(), _FastMCPSession_resources = new WeakMap(), _FastMCPSession_resourceTemplates = new WeakMap(), _FastMCPSession_roots = new WeakMap(), _FastMCPSession_server = new WeakMap(), _FastMCPSession_pingInterval = new WeakMap();
+_FastMCPSession_capabilities = new WeakMap(), _FastMCPSession_clientCapabilities = new WeakMap(), _FastMCPSession_loggingLevel = new WeakMap(), _FastMCPSession_prompts = new WeakMap(), _FastMCPSession_resources = new WeakMap(), _FastMCPSession_resourceTemplates = new WeakMap(), _FastMCPSession_roots = new WeakMap(), _FastMCPSession_server = new WeakMap(), _FastMCPSession_auth = new WeakMap(), _FastMCPSession_pingInterval = new WeakMap();
 const FastMCPEventEmitterBase = events_1.EventEmitter;
 class FastMCPEventEmitter extends FastMCPEventEmitterBase {
 }
@@ -620,7 +630,9 @@ class ToolBox extends FastMCPEventEmitter {
         _ToolBox_sessions.set(this, []);
         _ToolBox_sseServer.set(this, null);
         _ToolBox_tools.set(this, []);
+        _ToolBox_authenticate.set(this, void 0);
         __classPrivateFieldSet(this, _ToolBox_options, options, "f");
+        __classPrivateFieldSet(this, _ToolBox_authenticate, options.authenticate, "f");
     }
     get sessions() {
         return __classPrivateFieldGet(this, _ToolBox_sessions, "f");
@@ -649,6 +661,42 @@ class ToolBox extends FastMCPEventEmitter {
     addPrompt(prompt) {
         __classPrivateFieldGet(this, _ToolBox_prompts, "f").push(prompt);
     }
+    /**
+     * Starts the server.
+     */
+    async start(options = {
+        transportType: "stdio",
+    }) {
+        if (options.transportType === "stdio") {
+            const transport = new stdio_js_1.StdioServerTransport();
+            const session = new FastMCPSession({
+                name: __classPrivateFieldGet(this, _ToolBox_options, "f").name,
+                version: __classPrivateFieldGet(this, _ToolBox_options, "f").version,
+                tools: __classPrivateFieldGet(this, _ToolBox_tools, "f"),
+                resources: __classPrivateFieldGet(this, _ToolBox_resources, "f"),
+                resourcesTemplates: __classPrivateFieldGet(this, _ToolBox_resourcesTemplates, "f"),
+                prompts: __classPrivateFieldGet(this, _ToolBox_prompts, "f"),
+            });
+            await session.connect(transport);
+            __classPrivateFieldGet(this, _ToolBox_sessions, "f").push(session);
+            this.emit("connect", {
+                session,
+            });
+        }
+        else if (options.transportType === "sse") {
+        }
+        else {
+            throw new Error("Invalid transport type");
+        }
+    }
+    /**
+     * Stops the server.
+     */
+    async stop() {
+        if (__classPrivateFieldGet(this, _ToolBox_sseServer, "f")) {
+            __classPrivateFieldGet(this, _ToolBox_sseServer, "f").close();
+        }
+    }
     /**
      * Starts the server.
      */
@@ -657,6 +705,7 @@ class ToolBox extends FastMCPEventEmitter {
     }) {
         if (options.transportType === "stdio") {
             const transport = new stdio_js_1.StdioServerTransport();
+            // console.log("tools", this.#tools);
             const session = new FastMCPSession({
                 name: __classPrivateFieldGet(this, _ToolBox_options, "f").name,
                 version: __classPrivateFieldGet(this, _ToolBox_options, "f").version,
@@ -665,7 +714,7 @@ class ToolBox extends FastMCPEventEmitter {
                 resourcesTemplates: __classPrivateFieldGet(this, _ToolBox_resourcesTemplates, "f"),
                 prompts: __classPrivateFieldGet(this, _ToolBox_prompts, "f"),
             });
-            console.log("session", session);
+            // console.log("session", session);
             await session.connect(transport);
             __classPrivateFieldGet(this, _ToolBox_sessions, "f").push(session);
             this.emit("connect", {
@@ -707,14 +756,6 @@ class ToolBox extends FastMCPEventEmitter {
             throw new Error("Invalid transport type");
         }
     }
-    /**
-     * Stops the server.
-     */
-    async stop() {
-        if (__classPrivateFieldGet(this, _ToolBox_sseServer, "f")) {
-            __classPrivateFieldGet(this, _ToolBox_sseServer, "f").close();
-        }
-    }
 }
 exports.ToolBox = ToolBox;
-_ToolBox_options = new WeakMap(), _ToolBox_prompts = new WeakMap(), _ToolBox_resources = new WeakMap(), _ToolBox_resourcesTemplates = new WeakMap(), _ToolBox_sessions = new WeakMap(), _ToolBox_sseServer = new WeakMap(), _ToolBox_tools = new WeakMap();
+_ToolBox_options = new WeakMap(), _ToolBox_prompts = new WeakMap(), _ToolBox_resources = new WeakMap(), _ToolBox_resourcesTemplates = new WeakMap(), _ToolBox_sessions = new WeakMap(), _ToolBox_sseServer = new WeakMap(), _ToolBox_tools = new WeakMap(), _ToolBox_authenticate = new WeakMap();

package/modules/tools.d.ts

@@ -0,0 +1,16 @@
+import { UserMessage } from '../utils';
+declare const codeboltMCP: {
+    getEnabledToolBoxes: () => Promise<any>;
+    getLocalToolBoxes: () => Promise<any>;
+    getMentionedToolBoxes: (userMessage: UserMessage) => Promise<any>;
+    getAvailableToolBoxes: () => Promise<any>;
+    searchAvailableToolBoxes: (query: string) => Promise<any>;
+    listToolsFromToolBoxes: (toolBoxes: string[]) => Promise<any>;
+    configureToolBox: (name: string, config: any) => Promise<any>;
+    getTools: (tools: {
+        toolbox: string;
+        toolName: string;
+    }[]) => Promise<any[]>;
+    executeTool: (toolbox: string, toolName: string, params: any) => Promise<any>;
+};
+export default codeboltMCP;

package/modules/tools.js

@@ -0,0 +1,197 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const websocket_1 = __importDefault(require("./websocket"));
+const codeboltMCP = {
+    getEnabledToolBoxes: () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "codebolttools",
+                "action": "getEnabledToolBoxes"
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "getEnabledToolBoxesResponse") {
+                        resolve(response.data);
+                    }
+                }
+                catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            websocket_1.default.getWebsocket.on('error', (error) => {
+                reject(error);
+            });
+        });
+    },
+    getLocalToolBoxes: () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "codebolttools",
+                "action": "getLocalToolBoxes"
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "getLocalToolBoxesResponse") {
+                        resolve(response.data);
+                    }
+                }
+                catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            websocket_1.default.getWebsocket.on('error', (error) => {
+                reject(error);
+            });
+        });
+    },
+    getMentionedToolBoxes: (userMessage) => {
+        return new Promise((resolve, reject) => {
+            resolve(userMessage.mentionedMCPs);
+        });
+    },
+    getAvailableToolBoxes: () => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "codebolttools",
+                "action": "getAvailableToolBoxes"
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "getAvailableToolBoxesResponse") {
+                        resolve(response.data);
+                    }
+                }
+                catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            websocket_1.default.getWebsocket.on('error', (error) => {
+                reject(error);
+            });
+        });
+    },
+    searchAvailableToolBoxes: (query) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "codebolttools",
+                "action": "searchAvailableToolBoxes",
+                "query": query
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "searchAvailableToolBoxesResponse") {
+                        resolve(response.data);
+                    }
+                }
+                catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            websocket_1.default.getWebsocket.on('error', (error) => {
+                reject(error);
+            });
+        });
+    },
+    listToolsFromToolBoxes: (toolBoxes) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "codebolttools",
+                "action": "listToolsFromToolBoxes",
+                "toolBoxes": toolBoxes
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "listToolsFromToolBoxesResponse") {
+                        resolve(response.data);
+                    }
+                }
+                catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            websocket_1.default.getWebsocket.on('error', (error) => {
+                reject(error);
+            });
+        });
+    },
+    configureToolBox: (name, config) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "codebolttools",
+                "action": "configureToolBox",
+                "mcpName": name,
+                "config": config
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "configureToolBoxResponse") {
+                        resolve(response.data);
+                    }
+                }
+                catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            websocket_1.default.getWebsocket.on('error', (error) => {
+                reject(error);
+            });
+        });
+    },
+    getTools: (tools) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "codebolttools",
+                "action": "getTools",
+                "toolboxes": tools
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "getToolsResponse") {
+                        resolve(response.data);
+                    }
+                }
+                catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            websocket_1.default.getWebsocket.on('error', (error) => {
+                reject(error);
+            });
+        });
+    },
+    executeTool: (toolbox, toolName, params) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "codebolttools",
+                "action": "executeTool",
+                "toolName": `${toolbox}--${toolName}`,
+                "params": params
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "executeToolResponse") {
+                        resolve(response.data);
+                    }
+                }
+                catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            websocket_1.default.getWebsocket.on('error', (error) => {
+                reject(error);
+            });
+        });
+    },
+};
+exports.default = codeboltMCP;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/codeboltjs",
-  "version": "1.1.91",
+  "version": "1.1.94",
   "description": "",
   "keywords": [],
   "author": "",
@@ -33,6 +33,7 @@
     "tree-sitter-javascript": "^0.23.1",
     "tree-sitter-typescript": "^0.23.2",
     "typedoc-plugin-missing-exports": "^2.2.0",
+    "undici": "^7.4.0",
     "uri-templates": "^0.2.0",
     "ws": "^8.17.0",
     "yargs": "^17.7.2",
@@ -68,4 +69,4 @@
       "default": "./utils.js"
     }
   }
-}
+}

package/src/index.ts

@@ -23,7 +23,7 @@ import tokenizer from './modules/tokenizer'
 import WebSocket from 'ws';
 import { EventEmitter } from 'events';
 import {chatSummary} from './modules/history'
-import codeboltMCP from './modules/mcp';
+import codeboltTools from './modules/tools';
 import cbagent from './modules/agent';
 
 
@@ -96,8 +96,8 @@ class Codebolt  { // Extend EventEmitter
     debug = debug;
     tokenizer = tokenizer;
     chatSummary=chatSummary;
-    MCP = codeboltMCP;
-    AGENT = cbagent;
+    tools = codeboltTools;
+    agent = cbagent;
   
 }