@codebolt/codeboltjs 1.1.92 → 1.1.95

package/index.d.ts

@@ -237,14 +237,21 @@ declare class Codebolt {
             content: string;
         }[]>;
     };
-    MCP: {
-        executeTool: (toolName: string, params: any, mcpServer?: string | undefined) => Promise<any>;
-        getMcpTools: (tools: string[]) => Promise<any>;
-        getAllMCPTools: (mpcName: string) => Promise<any>;
-        getMCPTool: (name: string) => Promise<any>;
-        getEnabledMCPS: () => Promise<any>;
-    };
-    AGENT: {
+    tools: {
+        getEnabledToolBoxes: () => Promise<any>;
+        getLocalToolBoxes: () => Promise<any>;
+        getMentionedToolBoxes: (userMessage: import("./utils").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>;
+    };
+    agent: {
         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>;

package/index.js

@@ -27,7 +27,7 @@ const debug_1 = __importDefault(require("./modules/debug"));
 const tokenizer_1 = __importDefault(require("./modules/tokenizer"));
 const ws_1 = __importDefault(require("ws"));
 const history_1 = require("./modules/history");
-const mcp_1 = __importDefault(require("./modules/mcp"));
+const tools_1 = __importDefault(require("./modules/tools"));
 const agent_1 = __importDefault(require("./modules/agent"));
 /**
  * @class Codebolt
@@ -62,8 +62,8 @@ class Codebolt {
         this.debug = debug_1.default;
         this.tokenizer = tokenizer_1.default;
         this.chatSummary = history_1.chatSummary;
-        this.MCP = mcp_1.default;
-        this.AGENT = agent_1.default;
+        this.tools = tools_1.default;
+        this.agent = agent_1.default;
         websocket_1.default.initializeWebSocket();
         this.websocket = websocket_1.default.getWebsocket;
     }

package/modules/agentlib/agent.d.ts

@@ -2,12 +2,12 @@ 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[]);
+    private nextUserMessage;
+    constructor(tools: any, systemPrompt: SystemPrompt, maxRun?: number);
     run(task: TaskInstruction, successCondition?: () => boolean): Promise<{
         success: boolean;
         error: string | null;

package/modules/agentlib/agent.js

@@ -5,32 +5,46 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
 const chat_1 = __importDefault(require("./../chat"));
-const mcp_1 = __importDefault(require("./../mcp"));
+const tools_1 = __importDefault(require("./../tools"));
 const llm_1 = __importDefault(require("./../llm"));
 const agent_1 = __importDefault(require("./../agent"));
 class Agent {
-    constructor(tools = [], systemPrompt, maxRun = 0, subAgents = []) {
+    constructor(tools = [], systemPrompt, maxRun = 0) {
         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
+            ...mentaionedMCPSTool,
         ];
+        let mentionedAgents = await task.userMessage.getMentionedAgents();
+        // Transform agents into tool format
+        const agentTools = mentionedAgents.map(agent => {
+            return {
+                type: "function",
+                function: {
+                    name: `subagent--${agent.unique_id}`,
+                    description: agent.longDescription || agent.description,
+                    parameters: {
+                        type: "object",
+                        properties: {
+                            task: {
+                                type: "string",
+                                description: "The task to be executed by the tool."
+                            }
+                        },
+                        required: ["task"]
+                    }
+                }
+            };
+        });
+        this.tools = this.tools.concat(agentTools);
         let completed = false;
         let userMessages = await task.toPrompt();
         this.apiConversationHistory.push({ role: "user", content: userMessages });
@@ -75,7 +89,18 @@ class Agent {
                                         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));
+                                        let toolResult = this.getToolResult(toolUseId, result);
+                                        toolResults.push({
+                                            role: "tool",
+                                            tool_call_id: toolResult.tool_call_id,
+                                            content: toolResult.content,
+                                        });
+                                        if (toolResult.userMessage) {
+                                            this.nextUserMessage = {
+                                                role: "user",
+                                                content: toolResult.userMessage
+                                            };
+                                        }
                                         if (didUserReject) {
                                             userRejectedToolUse = true;
                                         }
@@ -84,7 +109,19 @@ class Agent {
                                         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));
+                                        // toolResults.push(this.getToolResult(toolUseId, result));
+                                        let toolResult = this.getToolResult(toolUseId, result);
+                                        toolResults.push({
+                                            role: "tool",
+                                            tool_call_id: toolResult.tool_call_id,
+                                            content: toolResult.content,
+                                        });
+                                        if (toolResult.userMessage) {
+                                            this.nextUserMessage = {
+                                                role: "user",
+                                                content: toolResult.userMessage
+                                            };
+                                        }
                                         if (didUserReject) {
                                             userRejectedToolUse = true;
                                         }
@@ -92,7 +129,18 @@ class Agent {
                                 }
                             }
                             else {
-                                toolResults.push(this.getToolResult(toolUseId, "Skipping tool execution due to previous tool user rejection."));
+                                let toolResult = this.getToolResult(toolUseId, "Skipping tool execution due to previous tool user rejection.");
+                                toolResults.push({
+                                    role: "tool",
+                                    tool_call_id: toolResult.tool_call_id,
+                                    content: toolResult.content,
+                                });
+                                if (toolResult.userMessage) {
+                                    this.nextUserMessage = {
+                                        role: "user",
+                                        content: toolResult.userMessage
+                                    };
+                                }
                             }
                         }
                     }
@@ -102,9 +150,23 @@ class Agent {
                             completed = true;
                             result = "The user is satisfied with the result.";
                         }
-                        toolResults.push(this.getToolResult(taskCompletedBlock.id, result));
+                        let toolResult = this.getToolResult(taskCompletedBlock.id, result);
+                        toolResults.push({
+                            role: "tool",
+                            tool_call_id: toolResult.tool_call_id,
+                            content: toolResult.content,
+                        });
+                        if (toolResult.userMessage) {
+                            this.nextUserMessage = {
+                                role: "user",
+                                content: toolResult.userMessage
+                            };
+                        }
                     }
                     this.apiConversationHistory.push(...toolResults);
+                    if (this.nextUserMessage) {
+                        this.apiConversationHistory.push(this.nextUserMessage);
+                    }
                     let nextUserMessage = toolResults;
                     if (toolResults.length === 0) {
                         nextUserMessage = [{
@@ -160,7 +222,9 @@ class Agent {
         }
     }
     async executeTool(toolName, toolInput) {
-        return mcp_1.default.executeTool(toolName, toolInput);
+        //codebolttools--readfile
+        const [toolboxName, actualToolName] = toolName.split('--');
+        return tools_1.default.executeTool(toolboxName, actualToolName, toolInput);
     }
     async startSubAgent(agentName, params) {
         return agent_1.default.startAgent(agentName, params.task);
@@ -173,10 +237,22 @@ class Agent {
         };
     }
     getToolResult(tool_call_id, content) {
+        let userMessage = undefined;
+        try {
+            let parsed = JSON.parse(content);
+            if (parsed.payload && parsed.payload.content) {
+                content = `The browser action has been executed. The  screenshot have been captured for your analysis. The tool response is provided in the next user message`;
+                // this.apiConversationHistory.push()
+                userMessage = parsed.payload.content;
+            }
+        }
+        catch (error) {
+        }
         return {
             role: "tool",
             tool_call_id,
             content,
+            userMessage
         };
     }
     // Placeholder for error fallback method

package/modules/agentlib/usermessage.d.ts

@@ -1,7 +1,16 @@
+interface agent {
+    description: string;
+    title: string;
+    id: number;
+    agent_id: string;
+    unique_id: string;
+    longDescription: string;
+}
 interface Message {
     userMessage: string;
     mentionedFiles?: string[];
     mentionedMCPs: string[];
+    mentionedAgents: agent[];
 }
 export interface UserMessageContent {
     type: string;
@@ -11,10 +20,11 @@ declare class UserMessage {
     message: Message;
     promptOverride: boolean;
     userMessages: UserMessageContent[];
-    mentaionedMCPS: string[];
+    mentionedMCPs: string[];
     constructor(message: Message, promptOverride?: boolean);
     getFiles(): void;
     toPrompt(bAttachFiles?: boolean, bAttachImages?: boolean, bAttachEnvironment?: boolean): Promise<UserMessageContent[]>;
+    getMentionedAgents(): agent[];
     getMentionedMcps(): string[];
     getMentionedMcpsTools(): Promise<any>;
     private getEnvironmentDetail;

package/modules/agentlib/usermessage.js

@@ -6,7 +6,7 @@ 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"));
+const tools_1 = __importDefault(require("./../tools"));
 class UserMessage {
     constructor(message, promptOverride = false) {
         this.getEnvironmentDetail = async (cwd) => {
@@ -21,7 +21,7 @@ class UserMessage {
         this.message = message;
         this.promptOverride = promptOverride;
         this.userMessages = [];
-        this.mentaionedMCPS = message.mentionedMCPs || [];
+        this.mentionedMCPs = message.mentionedMCPs || [];
     }
     getFiles() {
         // Implementation to be added
@@ -54,12 +54,16 @@ class UserMessage {
         }
         return this.userMessages;
     }
+    getMentionedAgents() {
+        //TODO : get config in tool format if neede
+        return this.message.mentionedAgents || [];
+    }
     getMentionedMcps() {
         return this.message.mentionedMCPs || [];
     }
     async getMentionedMcpsTools() {
-        if (this.mentaionedMCPS.length > 0) {
-            let tools = await mcp_1.default.getMcpTools(this.mentaionedMCPS);
+        if (this.mentionedMCPs.length > 0) {
+            let tools = await tools_1.default.listToolsFromToolBoxes(this.mentionedMCPs);
             return tools;
         }
         else {

package/modules/mcp.d.ts

@@ -4,5 +4,6 @@ declare const codeboltMCP: {
     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

@@ -120,5 +120,29 @@ const codeboltMCP = {
             });
         });
     },
+    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

@@ -0,0 +1,262 @@
+/// <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 {};