@codebolt/codeboltjs 1.1.91 → 1.1.94

package/src/modules/toolBox.ts

@@ -22,23 +22,24 @@ import { zodToJsonSchema } from "zod-to-json-schema";
 import { z } from "zod";
 import { setTimeout as delay } from "timers/promises";
 import { readFile } from "fs/promises";
-// import { fileTypeFromBuffer } from "file-type";
-// type FileTypeModule =  typeof import('file-type');
+import { fileTypeFromBuffer } from "file-type";
 import { StrictEventEmitter } from "strict-event-emitter-types";
 import { EventEmitter } from "events";
 import Fuse from "fuse.js";
-// import { startSSEServer } from "mcp-proxy";
+import { startSSEServer } from "mcp-proxy";
 import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import parseURITemplate from "uri-templates";
+import http from "http";
+import { fetch } from "undici";
 import { loadEsm } from "load-esm";
 
 export type SSEServer = {
   close: () => Promise<void>;
 };
 
-type FastMCPEvents = {
-  connect: (event: { session: FastMCPSession }) => void;
-  disconnect: (event: { session: FastMCPSession }) => void;
+type FastMCPEvents<T extends FastMCPSessionAuth> = {
+  connect: (event: { session: FastMCPSession<T> }) => void;
+  disconnect: (event: { session: FastMCPSession<T> }) => void;
 };
 
 type FastMCPSessionEvents = {
@@ -71,6 +72,7 @@ export const imageContent = async (
       "Invalid input: Provide a valid 'url', 'path', or 'buffer'",
     );
   }
+
   const { fileTypeFromBuffer } = await loadEsm('file-type');
   const mimeType = await fileTypeFromBuffer(rawData);
   console.log(mimeType);
@@ -108,7 +110,7 @@ export class UnexpectedStateError extends FastMCPError {
 /**
  * An error that is meant to be surfaced to the user.
  */
-export class UserError extends UnexpectedStateError { }
+export class UserError extends UnexpectedStateError {}
 
 type ToolParameters = z.ZodTypeAny;
 
@@ -130,7 +132,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;
@@ -218,23 +221,23 @@ const CompletionZodSchema = z.object({
   hasMore: z.optional(z.boolean()),
 }) satisfies z.ZodType<Completion>;
 
-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,
+    context: Context<T>,
   ) => Promise<string | ContentResult | TextContent | ImageContent>;
 };
 
 type ResourceResult =
   | {
-    text: string;
-  }
+      text: string;
+    }
   | {
-    blob: string;
-  };
+      blob: string;
+    };
 
 type InputResourceTemplateArgument = Readonly<{
   name: string;
@@ -304,8 +307,8 @@ type PromptArgumentsToObject<T extends { name: string; required?: boolean }[]> =
       T[number],
       { name: K }
     >["required"] extends true
-    ? string
-    : string | undefined;
+      ? string
+      : string | undefined;
   };
 
 type InputPrompt<
@@ -337,9 +340,10 @@ type Prompt<
   name: string;
 };
 
-type ServerOptions = {
+type ServerOptions<T extends FastMCPSessionAuth> = {
   name: string;
   version: `${number}.${number}.${number}`;
+  authenticate?: Authenticate<T>;
 };
 
 type LoggingLevel =
@@ -353,10 +357,10 @@ type LoggingLevel =
   | "emergency";
 
 const FastMCPSessionEventEmitterBase: {
-  new(): StrictEventEmitter<EventEmitter, FastMCPSessionEvents>;
+  new (): StrictEventEmitter<EventEmitter, FastMCPSessionEvents>;
 } = EventEmitter;
 
-class FastMCPSessionEventEmitter extends FastMCPSessionEventEmitterBase { }
+class FastMCPSessionEventEmitter extends FastMCPSessionEventEmitterBase {}
 
 type SamplingResponse = {
   model: string;
@@ -365,7 +369,9 @@ type SamplingResponse = {
   content: TextContent | ImageContent;
 };
 
-export class FastMCPSession extends FastMCPSessionEventEmitter {
+type FastMCPSessionAuth = Record<string, unknown> | undefined;
+
+export class FastMCPSession<T extends FastMCPSessionAuth = FastMCPSessionAuth> extends FastMCPSessionEventEmitter {
   #capabilities: ServerCapabilities = {};
   #clientCapabilities?: ClientCapabilities;
   #loggingLevel: LoggingLevel = "info";
@@ -374,8 +380,10 @@ export class FastMCPSession extends FastMCPSessionEventEmitter {
   #resourceTemplates: ResourceTemplate[] = [];
   #roots: Root[] = [];
   #server: Server;
+  #auth: T | undefined;
 
   constructor({
+    auth,
     name,
     version,
     tools,
@@ -383,15 +391,18 @@ export class FastMCPSession extends FastMCPSessionEventEmitter {
     resourcesTemplates,
     prompts,
   }: {
+    auth?: T;
     name: string;
     version: string;
-    tools: Tool[];
+    tools: Tool<T>[];
     resources: Resource[];
     resourcesTemplates: InputResourceTemplate[];
     prompts: Prompt[];
   }) {
     super();
 
+    this.#auth = auth;
+
     if (tools.length) {
       this.#capabilities.tools = {};
     }
@@ -544,6 +555,7 @@ export class FastMCPSession extends FastMCPSessionEventEmitter {
 
     while (attempt++ < 10) {
       const capabilities = await this.#server.getClientCapabilities();
+      console.log("capabilities", capabilities);
 
       if (capabilities) {
         this.#clientCapabilities = capabilities;
@@ -555,7 +567,7 @@ export class FastMCPSession extends FastMCPSessionEventEmitter {
     }
 
     if (!this.#clientCapabilities) {
-      throw new UnexpectedStateError("Server did not connect");
+      console.warn('[warning] toolBox could not infer client capabilities')
     }
 
     if (this.#clientCapabilities?.roots) {
@@ -584,7 +596,11 @@ export class FastMCPSession extends FastMCPSessionEventEmitter {
       clearInterval(this.#pingInterval);
     }
 
-    await this.#server.close();
+    try {
+      await this.#server.close();
+    } catch (error) {
+      console.error("[MCP Error]", "could not close server", error);
+    }
   }
 
   private setupErrorHandling() {
@@ -693,7 +709,7 @@ export class FastMCPSession extends FastMCPSessionEventEmitter {
     });
   }
 
-  private setupToolHandlers(tools: Tool[]) {
+  private setupToolHandlers(tools: Tool<T>[]) {
     this.#server.setRequestHandler(ListToolsRequestSchema, async () => {
       return {
         tools: tools.map((tool) => {
@@ -790,6 +806,7 @@ export class FastMCPSession extends FastMCPSessionEventEmitter {
         const maybeStringResult = await tool.execute(args, {
           reportProgress,
           log,
+          session: this.#auth,
         });
 
         if (typeof maybeStringResult === "string") {
@@ -1003,35 +1020,39 @@ export class FastMCPSession extends FastMCPSessionEventEmitter {
 }
 
 const FastMCPEventEmitterBase: {
-  new(): StrictEventEmitter<EventEmitter, FastMCPEvents>;
+  new (): StrictEventEmitter<EventEmitter, FastMCPEvents<FastMCPSessionAuth>>;
 } = EventEmitter;
 
-class FastMCPEventEmitter extends FastMCPEventEmitterBase { }
+class FastMCPEventEmitter extends FastMCPEventEmitterBase {}
 
-export class ToolBox extends FastMCPEventEmitter {
-  #options: ServerOptions;
+type Authenticate<T> = (request: http.IncomingMessage) => Promise<T>;
+
+export class ToolBox<T extends Record<string, unknown> | undefined = undefined> extends FastMCPEventEmitter {
+  #options: ServerOptions<T>;
   #prompts: InputPrompt[] = [];
   #resources: Resource[] = [];
   #resourcesTemplates: InputResourceTemplate[] = [];
-  #sessions: FastMCPSession[] = [];
+  #sessions: FastMCPSession<T>[] = [];
   #sseServer: SSEServer | null = null;
-  #tools: Tool[] = [];
+  #tools: Tool<T>[] = [];
+  #authenticate: Authenticate<T> | undefined;
 
-  constructor(public options: ServerOptions) {
+  constructor(public options: ServerOptions<T>) {
     super();
 
     this.#options = options;
+    this.#authenticate = options.authenticate;
   }
 
-  public get sessions(): FastMCPSession[] {
+  public get sessions(): FastMCPSession<T>[] {
     return this.#sessions;
   }
 
   /**
    * Adds a tool to the server.
    */
-  public addTool<Params extends ToolParameters>(tool: Tool<Params>) {
-    this.#tools.push(tool as unknown as Tool);
+  public addTool<Params extends ToolParameters>(tool: Tool<T, Params>) {
+    this.#tools.push(tool as unknown as Tool<T>);
   }
 
   /**
@@ -1059,6 +1080,55 @@ export class ToolBox extends FastMCPEventEmitter {
     this.#prompts.push(prompt);
   }
 
+  /**
+   * Starts the server.
+   */
+  public async start(
+    options:
+      | { transportType: "stdio" }
+      | {
+          transportType: "sse";
+          sse: { endpoint: `/${string}`; port: number };
+        } = {
+      transportType: "stdio",
+    },
+  ) {
+    if (options.transportType === "stdio") {
+      const transport = new StdioServerTransport();
+
+      const session = new FastMCPSession<T>({
+        name: this.#options.name,
+        version: this.#options.version,
+        tools: this.#tools,
+        resources: this.#resources,
+        resourcesTemplates: this.#resourcesTemplates,
+        prompts: this.#prompts,
+      });
+
+      await session.connect(transport);
+
+      this.#sessions.push(session);
+
+      this.emit("connect", {
+        session,
+      });
+
+    } else if (options.transportType === "sse") {
+    
+    } else {
+      throw new Error("Invalid transport type");
+    }
+  }
+
+  /**
+   * Stops the server.
+   */
+  public async stop() {
+    if (this.#sseServer) {
+      this.#sseServer.close();
+    }
+  }
+
   /**
    * Starts the server.
    */
@@ -1074,6 +1144,7 @@ export class ToolBox extends FastMCPEventEmitter {
   ) {
     if (options.transportType === "stdio") {
       const transport = new StdioServerTransport();
+      // console.log("tools", this.#tools);
 
       const session = new FastMCPSession({
         name: this.#options.name,
@@ -1083,7 +1154,7 @@ export class ToolBox extends FastMCPEventEmitter {
         resourcesTemplates: this.#resourcesTemplates,
         prompts: this.#prompts,
       });
-      console.log("session", session);
+      // console.log("session", session);
       await session.connect(transport);
 
       this.#sessions.push(session);
@@ -1129,36 +1200,7 @@ export class ToolBox extends FastMCPEventEmitter {
     }
   }
 
-  /**
-   * Stops the server.
-   */
-  public async stop() {
-    if (this.#sseServer) {
-      this.#sseServer.close();
-    }
-  }
-
-  // public async activate() {
-
-  //   const transport = new StdioServerTransport();
+ 
 
-  //   const session = new FastMCPSession({
-  //     name: this.#options.name,
-  //     version: this.#options.version,
-  //     tools: this.#tools,
-  //     resources: this.#resources,
-  //     resourcesTemplates: this.#resourcesTemplates,
-  //     prompts: this.#prompts,
-  //   });
-
-  //   await session.connect(transport);
-
-  //   this.#sessions.push(session);
-
-  //   this.emit("connect", {
-  //     session,
-  //   });
+}
 
-  //   console.info(`server is running on stdio`);
-  // }
-}

package/src/modules/tools.ts

@@ -0,0 +1,187 @@
+import { UserMessage } from '../utils';
+import cbws from './websocket';
+const codeboltMCP = {
+    getEnabledToolBoxes: (): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "codebolttools",
+                "action": "getEnabledToolBoxes"
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "getEnabledToolBoxesResponse") {
+                        resolve(response.data);
+                    }
+                } catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            cbws.getWebsocket.on('error', (error: Error) => {
+                reject(error);
+            });
+        });
+    },
+    getLocalToolBoxes: (): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "codebolttools",
+                "action": "getLocalToolBoxes"
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "getLocalToolBoxesResponse") {
+                        resolve(response.data);
+                    }
+                } catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            cbws.getWebsocket.on('error', (error: Error) => {
+                reject(error);
+            });
+        });
+    },
+    getMentionedToolBoxes: (userMessage: UserMessage): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            resolve(userMessage.mentionedMCPs);
+        });
+    },
+    getAvailableToolBoxes: (): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "codebolttools",
+                "action": "getAvailableToolBoxes"
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "getAvailableToolBoxesResponse") {
+                        resolve(response.data);
+                    }
+                } catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            cbws.getWebsocket.on('error', (error: Error) => {
+                reject(error);
+            });
+        });
+    },
+    searchAvailableToolBoxes: (query: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "codebolttools",
+                "action": "searchAvailableToolBoxes",
+                "query": query
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "searchAvailableToolBoxesResponse") {
+                        resolve(response.data);
+                    }
+                } catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            cbws.getWebsocket.on('error', (error: Error) => {
+                reject(error);
+            });
+        });
+    },
+    listToolsFromToolBoxes: (toolBoxes: string[]): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "codebolttools",
+                "action": "listToolsFromToolBoxes",
+                "toolBoxes": toolBoxes
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "listToolsFromToolBoxesResponse") {
+                        resolve(response.data);
+                    }
+                } catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            cbws.getWebsocket.on('error', (error: Error) => {
+                reject(error);
+            });
+        });
+
+    },
+    configureToolBox: (name: string, config: any): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "codebolttools",
+                "action": "configureToolBox",
+                "mcpName": name,
+                "config": config
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "configureToolBoxResponse") {
+                        resolve(response.data);
+                    }
+                } catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            cbws.getWebsocket.on('error', (error: Error) => {
+                reject(error);
+            });
+        });
+    },
+    getTools: (tools: { toolbox: string, toolName: string }[]): Promise<any[]> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "codebolttools",
+                "action": "getTools",
+                "toolboxes": tools
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "getToolsResponse") {
+                        resolve(response.data);
+                    }
+                } catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            cbws.getWebsocket.on('error', (error: Error) => {
+                reject(error);
+            });
+        });
+    },
+    executeTool: (toolbox: string, toolName: string, params: any): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "codebolttools",
+                "action": "executeTool",
+                "toolName": `${toolbox}--${toolName}`,
+                "params": params
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                try {
+                    const response = JSON.parse(data);
+                    if (response.type === "executeToolResponse") {
+                        resolve(response.data);
+                    }
+                } catch (error) {
+                    reject(new Error("Failed to parse response"));
+                }
+            });
+            cbws.getWebsocket.on('error', (error: Error) => {
+                reject(error);
+            });
+        });
+    },
+}
+
+export default codeboltMCP;

package/src/modules/mcp.ts

@@ -1,117 +0,0 @@
-import cbws from './websocket';
-const codeboltMCP = {
-
-    executeTool: ( toolName: string, params: any,mcpServer?: string,): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "mcpEvent",
-                "action": "executeTool",
-                "toolName": toolName,
-                "params": params
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "executeToolResponse") {
-                        resolve(response.data);
-                    } 
-                } catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            cbws.getWebsocket.on('error', (error: Error) => {
-                reject(error);
-            });
-        });
-    },
-    getMcpTools: (tools: string[]): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "mcpEvent",
-                "action": "getMcpTools",
-                "tools": tools
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getMcpToolsResponse") {
-                        resolve(response.data);
-                    } 
-                } catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            cbws.getWebsocket.on('error', (error: Error) => {
-                reject(error);
-            });
-        });
-
-    },
-    getAllMCPTools: (mpcName: string): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "mcpEvent",
-                "action": "getAllMCPTools",
-                "mpcName": mpcName
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getAllMCPToolsResponse") {
-                        resolve(response.data);
-                    } 
-                } catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            cbws.getWebsocket.on('error', (error: Error) => {
-                reject(error);
-            });
-        });
-    },
-    getMCPTool: (name: string): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "mcpEvent",
-                "action": "getMCPTool",
-                "mcpName": name
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getMCPToolResponse") {
-                        resolve(response.data);
-                    } 
-                } catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            cbws.getWebsocket.on('error', (error: Error) => {
-                reject(error);
-            });
-        });
-    },
-    getEnabledMCPS: (): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "mcpEvent",
-                "action": "getEnabledMCPS"
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getEnabledMCPSResponse") {
-                        resolve(response.data);
-                    } 
-                } catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            cbws.getWebsocket.on('error', (error: Error) => {
-                reject(error);
-            });
-        });
-    },
-}
-
-export default codeboltMCP;