@codebolt/codeboltjs 1.1.95 → 1.1.97

package/src/modules/tools.ts

@@ -1,6 +1,16 @@
 import { UserMessage } from '../utils';
 import cbws from './websocket';
+
+/**
+ * Object containing methods for interacting with Codebolt MCP (Model Context Protocol) tools.
+ * Provides functionality to discover, list, and execute tools.
+ */
 const codeboltMCP = {
+    /**
+     * Gets the list of currently enabled toolboxes.
+     * 
+     * @returns Promise with the enabled toolboxes data
+     */
     getEnabledToolBoxes: (): Promise<any> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
@@ -22,6 +32,12 @@ const codeboltMCP = {
             });
         });
     },
+
+    /**
+     * Gets the list of locally available toolboxes.
+     * 
+     * @returns Promise with the local toolboxes data
+     */
     getLocalToolBoxes: (): Promise<any> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
@@ -43,11 +59,24 @@ const codeboltMCP = {
             });
         });
     },
+
+    /**
+     * Gets toolboxes mentioned in a user message.
+     * 
+     * @param userMessage - The user message to extract mentions from
+     * @returns Promise with the mentioned toolboxes
+     */
     getMentionedToolBoxes: (userMessage: UserMessage): Promise<any> => {
         return new Promise((resolve, reject) => {
             resolve(userMessage.mentionedMCPs);
         });
     },
+
+    /**
+     * Gets all available toolboxes.
+     * 
+     * @returns Promise with all available toolboxes data
+     */
     getAvailableToolBoxes: (): Promise<any> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
@@ -69,6 +98,13 @@ const codeboltMCP = {
             });
         });
     },
+
+    /**
+     * Searches for available toolboxes matching a query.
+     * 
+     * @param query - The search query string
+     * @returns Promise with matching toolboxes data
+     */
     searchAvailableToolBoxes: (query: string): Promise<any> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
@@ -91,6 +127,13 @@ const codeboltMCP = {
             });
         });
     },
+
+    /**
+     * Lists all tools from the specified toolboxes.
+     * 
+     * @param toolBoxes - Array of toolbox names to list tools from
+     * @returns Promise with tools from the specified toolboxes
+     */
     listToolsFromToolBoxes: (toolBoxes: string[]): Promise<any> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
@@ -114,6 +157,14 @@ const codeboltMCP = {
         });
 
     },
+
+    /**
+     * Configures a specific toolbox with provided configuration.
+     * 
+     * @param name - The name of the toolbox to configure
+     * @param config - Configuration object for the toolbox
+     * @returns Promise with the configuration result
+     */
     configureToolBox: (name: string, config: any): Promise<any> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
@@ -137,6 +188,13 @@ const codeboltMCP = {
             });
         });
     },
+
+    /**
+     * Gets detailed information about specific tools.
+     * 
+     * @param tools - Array of toolbox and tool name pairs
+     * @returns Promise with detailed information about the tools
+     */
     getTools: (tools: { toolbox: string, toolName: string }[]): Promise<any[]> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({
@@ -159,6 +217,15 @@ const codeboltMCP = {
             });
         });
     },
+
+    /**
+     * Executes a specific tool with provided parameters.
+     * 
+     * @param toolbox - The name of the toolbox containing the tool
+     * @param toolName - The name of the tool to execute
+     * @param params - Parameters to pass to the tool
+     * @returns Promise with the execution result
+     */
     executeTool: (toolbox: string, toolName: string, params: any): Promise<any> => {
         return new Promise((resolve, reject) => {
             cbws.getWebsocket.send(JSON.stringify({

package/src/modules/websocket.ts

@@ -59,12 +59,10 @@ class cbws {
 
         return new Promise((resolve, reject) => {
             this.websocket.on('error', (error: Error) => {
-                console.log('WebSocket error:', error);
                 reject(error);
             });
 
             this.websocket.on('open', () => {
-                console.log('WebSocket connected');
                 // if (this.websocket) {
                 //     this.websocket.send(JSON.stringify({
                 //         "type": "sendMessage",
@@ -76,7 +74,6 @@ class cbws {
 
             this.websocket.on('message', (data: WebSocket.Data) => {
                 // Handle incoming WebSocket messages here.
-                // console.log('WebSocket message received:', data);
             });
         });
     }

package/modules/mcp.d.ts

@@ -1,9 +0,0 @@
-declare const codeboltMCP: {
-    executeTool: (toolName: string, params: any, mcpServer?: string) => Promise<any>;
-    getMcpTools: (tools: string[]) => Promise<any>;
-    getAllMCPTools: (mpcName: string) => Promise<any>;
-    getMCPTool: (name: string) => Promise<any>;
-    getEnabledMCPS: () => Promise<any>;
-    configureMCPTool: (name: string, config: any) => Promise<any>;
-};
-export default codeboltMCP;

package/modules/mcp.js

@@ -1,148 +0,0 @@
-"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 = {
-    executeTool: (toolName, params, mcpServer) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "mcpEvent",
-                "action": "executeTool",
-                "toolName": 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);
-            });
-        });
-    },
-    getMcpTools: (tools) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "mcpEvent",
-                "action": "getMcpTools",
-                "tools": tools
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getMcpToolsResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('error', (error) => {
-                reject(error);
-            });
-        });
-    },
-    getAllMCPTools: (mpcName) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "mcpEvent",
-                "action": "getAllMCPTools",
-                "mpcName": mpcName
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getAllMCPToolsResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('error', (error) => {
-                reject(error);
-            });
-        });
-    },
-    getMCPTool: (name) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "mcpEvent",
-                "action": "getMCPTool",
-                "mcpName": name
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getMCPToolResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('error', (error) => {
-                reject(error);
-            });
-        });
-    },
-    getEnabledMCPS: () => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "mcpEvent",
-                "action": "getEnabledMCPS"
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getEnabledMCPSResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('error', (error) => {
-                reject(error);
-            });
-        });
-    },
-    configureMCPTool: (name, config) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "mcpEvent",
-                "action": "configureMCPTool",
-                "mcpName": name,
-                "config": config
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "configureMCPToolResponse") {
-                        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/modules/toolBox.bkp.d.ts

@@ -1,262 +0,0 @@
-/// <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";
-export type SSEServer = {
-    close: () => Promise<void>;
-};
-type FastMCPEvents = {
-    connect: (event: {
-        session: FastMCPSession;
-    }) => void;
-    disconnect: (event: {
-        session: FastMCPSession;
-    }) => void;
-};
-type FastMCPSessionEvents = {
-    rootsChanged: (event: {
-        roots: Root[];
-    }) => void;
-    error: (event: {
-        error: Error;
-    }) => void;
-};
-/**
- * Generates an image content object from a URL, file path, or buffer.
- */
-export declare const imageContent: (input: {
-    url: string;
-} | {
-    path: string;
-} | {
-    buffer: Buffer;
-}) => Promise<ImageContent>;
-declare abstract class FastMCPError extends Error {
-    constructor(message?: string);
-}
-type Extra = unknown;
-type Extras = Record<string, Extra>;
-export declare class UnexpectedStateError extends FastMCPError {
-    extras?: Extras;
-    constructor(message: string, extras?: Extras);
-}
-/**
- * An error that is meant to be surfaced to the user.
- */
-export declare class UserError extends UnexpectedStateError {
-}
-type ToolParameters = z.ZodTypeAny;
-type Literal = boolean | null | number | string | undefined;
-type SerializableValue = Literal | SerializableValue[] | {
-    [key: string]: SerializableValue;
-};
-type Progress = {
-    /**
-     * The progress thus far. This should increase every time progress is made, even if the total is unknown.
-     */
-    progress: number;
-    /**
-     * Total number of items to process (or total progress required), if known.
-     */
-    total?: number;
-};
-type Context = {
-    reportProgress: (progress: Progress) => Promise<void>;
-    log: {
-        debug: (message: string, data?: SerializableValue) => void;
-        error: (message: string, data?: SerializableValue) => void;
-        info: (message: string, data?: SerializableValue) => void;
-        warn: (message: string, data?: SerializableValue) => void;
-    };
-};
-type TextContent = {
-    type: "text";
-    text: string;
-};
-type ImageContent = {
-    type: "image";
-    data: string;
-    mimeType: string;
-};
-type Content = TextContent | ImageContent;
-type ContentResult = {
-    content: Content[];
-    isError?: boolean;
-};
-type Completion = {
-    values: string[];
-    total?: number;
-    hasMore?: boolean;
-};
-type Tool<Params extends ToolParameters = ToolParameters> = {
-    name: string;
-    description?: string;
-    parameters?: Params;
-    execute: (args: z.infer<Params>, context: Context) => Promise<string | ContentResult | TextContent | ImageContent>;
-};
-type ResourceResult = {
-    text: string;
-} | {
-    blob: string;
-};
-type InputResourceTemplateArgument = Readonly<{
-    name: string;
-    description?: string;
-    complete?: ArgumentValueCompleter;
-}>;
-type ResourceTemplateArgument = Readonly<{
-    name: string;
-    description?: string;
-    complete?: ArgumentValueCompleter;
-}>;
-type ResourceTemplateArgumentsToObject<T extends {
-    name: string;
-}[]> = {
-    [K in T[number]["name"]]: string;
-};
-type InputResourceTemplate<Arguments extends ResourceTemplateArgument[] = ResourceTemplateArgument[]> = {
-    uriTemplate: string;
-    name: string;
-    description?: string;
-    mimeType?: string;
-    arguments: Arguments;
-    load: (args: ResourceTemplateArgumentsToObject<Arguments>) => Promise<ResourceResult>;
-};
-type Resource = {
-    uri: string;
-    name: string;
-    description?: string;
-    mimeType?: string;
-    load: () => Promise<ResourceResult | ResourceResult[]>;
-    complete?: (name: string, value: string) => Promise<Completion>;
-};
-type ArgumentValueCompleter = (value: string) => Promise<Completion>;
-type InputPromptArgument = Readonly<{
-    name: string;
-    description?: string;
-    required?: boolean;
-    complete?: ArgumentValueCompleter;
-    enum?: string[];
-}>;
-type PromptArgumentsToObject<T extends {
-    name: string;
-    required?: boolean;
-}[]> = {
-    [K in T[number]["name"]]: Extract<T[number], {
-        name: K;
-    }>["required"] extends true ? string : string | undefined;
-};
-type InputPrompt<Arguments extends InputPromptArgument[] = InputPromptArgument[], Args = PromptArgumentsToObject<Arguments>> = {
-    name: string;
-    description?: string;
-    arguments?: InputPromptArgument[];
-    load: (args: Args) => Promise<string>;
-};
-type PromptArgument = Readonly<{
-    name: string;
-    description?: string;
-    required?: boolean;
-    complete?: ArgumentValueCompleter;
-    enum?: string[];
-}>;
-type Prompt<Arguments extends PromptArgument[] = PromptArgument[], Args = PromptArgumentsToObject<Arguments>> = {
-    arguments?: PromptArgument[];
-    complete?: (name: string, value: string) => Promise<Completion>;
-    description?: string;
-    load: (args: Args) => Promise<string>;
-    name: string;
-};
-type ServerOptions = {
-    name: string;
-    version: `${number}.${number}.${number}`;
-};
-type LoggingLevel = "debug" | "info" | "notice" | "warning" | "error" | "critical" | "alert" | "emergency";
-declare const FastMCPSessionEventEmitterBase: {
-    new (): StrictEventEmitter<EventEmitter, FastMCPSessionEvents>;
-};
-declare class FastMCPSessionEventEmitter extends FastMCPSessionEventEmitterBase {
-}
-type SamplingResponse = {
-    model: string;
-    stopReason?: "endTurn" | "stopSequence" | "maxTokens" | string;
-    role: "user" | "assistant";
-    content: TextContent | ImageContent;
-};
-export declare class FastMCPSession extends FastMCPSessionEventEmitter {
-    #private;
-    constructor({ name, version, tools, resources, resourcesTemplates, prompts, }: {
-        name: string;
-        version: string;
-        tools: Tool[];
-        resources: Resource[];
-        resourcesTemplates: InputResourceTemplate[];
-        prompts: Prompt[];
-    });
-    private addResource;
-    private addResourceTemplate;
-    private addPrompt;
-    get clientCapabilities(): ClientCapabilities | null;
-    get server(): Server;
-    requestSampling(message: z.infer<typeof CreateMessageRequestSchema>["params"]): Promise<SamplingResponse>;
-    connect(transport: Transport): Promise<void>;
-    get roots(): Root[];
-    close(): Promise<void>;
-    private setupErrorHandling;
-    get loggingLevel(): LoggingLevel;
-    private setupCompleteHandlers;
-    private setupRootsHandlers;
-    private setupLoggingHandlers;
-    private setupToolHandlers;
-    private setupResourceHandlers;
-    private setupResourceTemplateHandlers;
-    private setupPromptHandlers;
-}
-declare const FastMCPEventEmitterBase: {
-    new (): StrictEventEmitter<EventEmitter, FastMCPEvents>;
-};
-declare class FastMCPEventEmitter extends FastMCPEventEmitterBase {
-}
-export declare class ToolBox extends FastMCPEventEmitter {
-    #private;
-    options: ServerOptions;
-    constructor(options: ServerOptions);
-    get sessions(): FastMCPSession[];
-    /**
-     * Adds a tool to the server.
-     */
-    addTool<Params extends ToolParameters>(tool: Tool<Params>): void;
-    /**
-     * Adds a resource to the server.
-     */
-    addResource(resource: Resource): void;
-    /**
-     * Adds a resource template to the server.
-     */
-    addResourceTemplate<const Args extends InputResourceTemplateArgument[]>(resource: InputResourceTemplate<Args>): void;
-    /**
-     * Adds a prompt to the server.
-     */
-    addPrompt<const Args extends InputPromptArgument[]>(prompt: InputPrompt<Args>): void;
-    /**
-     * Starts the server.
-     */
-    activate(options?: {
-        transportType: "stdio";
-    } | {
-        transportType: "sse";
-        sse: {
-            endpoint: `/${string}`;
-            port: number;
-        };
-    }): Promise<void>;
-    /**
-     * Stops the server.
-     */
-    stop(): Promise<void>;
-}
-export {};