@codebolt/codeboltjs 1.1.94 → 1.1.96

package/modules/tools.d.ts

@@ -1,16 +1,74 @@
 import { UserMessage } from '../utils';
+/**
+ * Object containing methods for interacting with Codebolt MCP (Model Context Protocol) tools.
+ * Provides functionality to discover, list, and execute tools.
+ */
 declare const codeboltMCP: {
+    /**
+     * Gets the list of currently enabled toolboxes.
+     *
+     * @returns Promise with the enabled toolboxes data
+     */
     getEnabledToolBoxes: () => Promise<any>;
+    /**
+     * Gets the list of locally available toolboxes.
+     *
+     * @returns Promise with the local toolboxes data
+     */
     getLocalToolBoxes: () => Promise<any>;
+    /**
+     * 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>;
+    /**
+     * Gets all available toolboxes.
+     *
+     * @returns Promise with all available toolboxes data
+     */
     getAvailableToolBoxes: () => Promise<any>;
+    /**
+     * Searches for available toolboxes matching a query.
+     *
+     * @param query - The search query string
+     * @returns Promise with matching toolboxes data
+     */
     searchAvailableToolBoxes: (query: string) => Promise<any>;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * 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[]>;
+    /**
+     * 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>;
 };
 export default codeboltMCP;

package/modules/tools.js

@@ -4,7 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const websocket_1 = __importDefault(require("./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: () => {
         return new Promise((resolve, reject) => {
             websocket_1.default.getWebsocket.send(JSON.stringify({
@@ -27,6 +36,11 @@ const codeboltMCP = {
             });
         });
     },
+    /**
+     * Gets the list of locally available toolboxes.
+     *
+     * @returns Promise with the local toolboxes data
+     */
     getLocalToolBoxes: () => {
         return new Promise((resolve, reject) => {
             websocket_1.default.getWebsocket.send(JSON.stringify({
@@ -49,11 +63,22 @@ 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) => {
         return new Promise((resolve, reject) => {
             resolve(userMessage.mentionedMCPs);
         });
     },
+    /**
+     * Gets all available toolboxes.
+     *
+     * @returns Promise with all available toolboxes data
+     */
     getAvailableToolBoxes: () => {
         return new Promise((resolve, reject) => {
             websocket_1.default.getWebsocket.send(JSON.stringify({
@@ -76,6 +101,12 @@ const codeboltMCP = {
             });
         });
     },
+    /**
+     * Searches for available toolboxes matching a query.
+     *
+     * @param query - The search query string
+     * @returns Promise with matching toolboxes data
+     */
     searchAvailableToolBoxes: (query) => {
         return new Promise((resolve, reject) => {
             websocket_1.default.getWebsocket.send(JSON.stringify({
@@ -99,6 +130,12 @@ 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) => {
         return new Promise((resolve, reject) => {
             websocket_1.default.getWebsocket.send(JSON.stringify({
@@ -122,6 +159,13 @@ 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, config) => {
         return new Promise((resolve, reject) => {
             websocket_1.default.getWebsocket.send(JSON.stringify({
@@ -146,6 +190,12 @@ 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) => {
         return new Promise((resolve, reject) => {
             websocket_1.default.getWebsocket.send(JSON.stringify({
@@ -169,6 +219,14 @@ 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, toolName, params) => {
         return new Promise((resolve, reject) => {
             websocket_1.default.getWebsocket.send(JSON.stringify({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/codeboltjs",
-  "version": "1.1.94",
+  "version": "1.1.96",
   "description": "",
   "keywords": [],
   "author": "",

package/src/modules/agent.ts

@@ -64,7 +64,7 @@ const codeboltAgent = {
             }));
             cbws.getWebsocket.on('message', (data: string) => {
                 const response = JSON.parse(data);
-                if (response.type === "taskCompletionResponse") {
+                if (response.type === "taskCompletionResponse" && response.agentId === agentId) {
                     resolve(response); // Resolve the Promise when the agent has been successfully started
                 }
             });

package/src/modules/agentlib/agent.ts

@@ -5,63 +5,121 @@ import codeboltAgent from "./../agent"
 import { SystemPrompt } from "./systemprompt";
 import { TaskInstruction } from "./taskInstruction";
 
+/**
+ * Represents a message in the conversation with roles and content.
+ */
 interface Message {
+    /** The role of the message sender: user, assistant, tool, or system */
     role: 'user' | 'assistant' | 'tool' | 'system';
+    /** The content of the message, can be an array of content blocks or a string */
     content: any[] | string;
+    /** Optional ID for tool calls */
     tool_call_id?: string;
+    /** Additional properties that might be present */
     [key: string]: any;
 }
 
+/**
+ * Represents the result from a tool execution.
+ */
 interface ToolResult {
+    /** Always 'tool' for tool execution results */
     role: 'tool';
+    /** ID that links this result to the original tool call */
     tool_call_id: string;
+    /** The content returned by the tool */
     content: any;
+    /** Optional user message to be added after tool execution */
     userMessage?: any;
 }
 
+/**
+ * Details about a tool to be executed.
+ */
 interface ToolDetails {
+    /** The name of the tool to execute */
     toolName: string;
+    /** Input parameters for the tool */
     toolInput: any;
+    /** Unique ID for this tool use instance */
     toolUseId: string;
 }
 
+/**
+ * Agent class that manages conversations with LLMs and tool executions.
+ * Handles the conversation flow, tool calls, and task completions.
+ */
 class Agent {
+    /** Available tools for the agent to use */
     private tools: any[];
-    private subAgents: any[];
+    /** Full conversation history for API calls */
     private apiConversationHistory: Message[];
+    /** Maximum number of conversation turns (0 means unlimited) */
     private maxRun: number;
+    /** System prompt that provides instructions to the model */
     private systemPrompt: SystemPrompt;
+    /** Messages from the user */
     private userMessage: Message[];
+    /** The next user message to be added to the conversation */
     private nextUserMessage:any;
 
-
-    constructor(tools: any = [], systemPrompt: SystemPrompt, maxRun: number = 0, subAgents: any[] = []) {
+    /**
+     * Creates a new Agent instance.
+     * 
+     * @param tools - The tools available to the agent
+     * @param systemPrompt - The system prompt providing instructions to the LLM
+     * @param maxRun - Maximum number of conversation turns (0 means unlimited)
+     */
+    constructor(tools: any = [], systemPrompt: SystemPrompt, maxRun: number = 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
-        })));
-       
-
 
     }
 
+    /**
+     * Runs the agent on a specific task until completion or max runs reached.
+     * 
+     * @param task - The task instruction to be executed
+     * @param successCondition - Optional function to determine if the task is successful
+     * @returns Promise with success status, error (if any), and the last assistant message
+     */
     async run(task: TaskInstruction, successCondition: () => boolean = () => true): Promise<{ success: boolean; error: string | null, message: string | null }> {
 
 
         let mentaionedMCPSTool: any[] = await task.userMessage.getMentionedMcpsTools();
+
         this.tools = [
             ...this.tools,
-            ...mentaionedMCPSTool
+            ...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;
@@ -243,6 +301,13 @@ class Agent {
         };
     }
 
+    /**
+     * Attempts to make a request to the LLM with conversation history and tools.
+     * 
+     * @param apiConversationHistory - The current conversation history
+     * @param tools - The tools available to the LLM
+     * @returns Promise with the LLM response
+     */
     private async attemptLlmRequest(apiConversationHistory: Message[], tools: Record<string, any>): Promise<any> {
 
 
@@ -268,15 +333,36 @@ class Agent {
         }
     }
 
+    /**
+     * Executes a tool with given name and input.
+     * 
+     * @param toolName - The name of the tool to execute
+     * @param toolInput - The input parameters for the tool
+     * @returns Promise with tuple [userRejected, result]
+     */
     private async executeTool(toolName: string, toolInput: any): Promise<[boolean, any]> {
         //codebolttools--readfile
         const [toolboxName, actualToolName] = toolName.split('--');
         return tools.executeTool(toolboxName, actualToolName, toolInput);
     }
+
+    /**
+     * Starts a sub-agent to handle a specific task.
+     * 
+     * @param agentName - The name of the sub-agent to start
+     * @param params - Parameters for the sub-agent
+     * @returns Promise with tuple [userRejected, result]
+     */
     private async startSubAgent(agentName: string, params: any): Promise<[boolean, any]> {
         return codeboltAgent.startAgent(agentName, params.task);
     }
 
+    /**
+     * Extracts tool details from a tool call object.
+     * 
+     * @param tool - The tool call object from the LLM response
+     * @returns ToolDetails object with name, input, and ID
+     */
     private getToolDetail(tool: any): ToolDetails {
         return {
             toolName: tool.function.name,
@@ -285,6 +371,13 @@ class Agent {
         };
     }
 
+    /**
+     * Creates a tool result object from the tool execution response.
+     * 
+     * @param tool_call_id - The ID of the tool call
+     * @param content - The content returned by the tool
+     * @returns ToolResult object
+     */
     private getToolResult(tool_call_id: string, content: string): ToolResult {
         let userMessage=undefined
         try {
@@ -306,7 +399,11 @@ class Agent {
         };
     }
 
-    // Placeholder for error fallback method
+    /**
+     * Fallback method for API requests in case of failures.
+     * 
+     * @throws Error API request fallback not implemented
+     */
     private attemptApiRequest(): any {
         throw new Error("API request fallback not implemented");
     }

package/src/modules/agentlib/taskInstruction.ts

@@ -8,37 +8,69 @@ const yaml = require('js-yaml');
 const fs = require('fs');
 const path = require('path');
 
-// ... existing imports ...
-
+/**
+ * Interface for tools that can be used within tasks.
+ * Each tool has a description and usage example.
+ */
 interface Tools {
     [key: string]: {
+        /** Description of what the tool does */
         description: string;
+        /** How to use the tool correctly */
         usage: string;
+        /** Optional example demonstrating tool usage */
         example?: string;
     };
 }
 
-
-
+/**
+ * Interface for task data structure as loaded from YAML.
+ * Contains task descriptions and expected outputs.
+ */
 interface TaskData {
     [key: string]: {
+        /** Description of what the task should accomplish */
         description: string;
+        /** Expected output format or content */
         expected_output: string;
     };
 }
 
+/**
+ * Interface for user message structure.
+ * Contains message type and text content.
+ */
 interface UserMessages {
+    /** The type of user message */
     type: string;
+    /** The text content of the message */
     text: string;
 }
 
+/**
+ * Class representing a task instruction.
+ * Handles loading task data and converting it to prompts.
+ */
 class TaskInstruction {
+    /** Available tools for the task */
     tools: Tools;
+    /** Messages from the user for this task */
     userMessages: UserMessageContent[]=[];
+    /** The user message object containing input */
     userMessage: UserMessage
+    /** Path to the YAML file with task instructions */
     filepath: string;
+    /** The section reference within the YAML file */
     refsection: string;
 
+    /**
+     * Creates a new TaskInstruction instance.
+     * 
+     * @param tools - Tools available for this task
+     * @param userMessage - User message containing task instructions
+     * @param filepath - Path to the YAML file with task data
+     * @param refsection - Section name within the YAML file
+     */
     constructor(tools: Tools = {}, userMessage: UserMessage , filepath: string = "", refsection: string = "") {
         this.tools = tools;
         this.userMessage = userMessage;
@@ -46,6 +78,13 @@ class TaskInstruction {
         this.refsection = refsection;
     }
 
+    /**
+     * Converts the task instruction to a prompt format.
+     * Loads data from YAML file and combines with user message.
+     * 
+     * @returns Promise with an array of user message content blocks
+     * @throws Error if there's an issue processing the task instruction
+     */
     async toPrompt(): Promise<UserMessages[]> {
         try {
             this.userMessages = await this.userMessage.toPrompt();

package/src/modules/agentlib/usermessage.ts

@@ -1,31 +1,79 @@
 import cbfs from "./../fs";
 import project from "./../project";
 import mcp from "./../tools";
-import { escape } from "querystring";
 
+/**
+ * Interface representing an agent that can be referenced in user messages.
+ */
+interface agent {
+    /** Short description of the agent */
+    description: string;
+    /** Title/name of the agent */
+    title: string;
+    /** Numeric ID of the agent */
+    id: number;
+    /** Agent identifier string */
+    agent_id: string;
+    /** Unique identifier for the agent */
+    unique_id: string;
+    /** Detailed description of the agent and its capabilities */
+    longDescription: string;
+}
 
+/**
+ * Interface for the user message structure.
+ */
 interface Message {
+    /** The actual text content of the user message */
     userMessage: string;
+    /** Optional list of files mentioned in the message */
     mentionedFiles?: string[];
+    /** List of MCP (Model Context Protocol) tools mentioned */
     mentionedMCPs: string[];
+    /** List of agents mentioned in the message */
+    mentionedAgents: agent[];
 }
 
+/**
+ * Interface for a single content block within a user message.
+ */
 export interface UserMessageContent {
+    /** Type of content (e.g., "text", "image") */
     type: string;
+    /** The text content */
     text: string;
 }
 
+/**
+ * Interface for file listing result.
+ */
 interface FileListResult {
+    /** Whether the listing operation was successful */
     success: boolean;
+    /** The result of the listing operation as a string */
     result: string;
 }
 
+/**
+ * Class that processes and manages user messages.
+ * Handles converting messages to prompts and extracting mentioned entities.
+ */
 class UserMessage {
+    /** The message content and metadata */
     message: Message;
+    /** Whether to override the default prompt generation */
     promptOverride: boolean;
+    /** Array of content blocks for the user message */
     userMessages: UserMessageContent[];
+    /** List of MCP tools mentioned in the message */
     mentionedMCPs: string[];
 
+    /**
+     * Creates a new UserMessage instance.
+     * 
+     * @param message - The message content and metadata
+     * @param promptOverride - Whether to override default prompt generation
+     */
     constructor(message: Message, promptOverride: boolean = false) {
         this.message = message;
         this.promptOverride = promptOverride;
@@ -33,10 +81,22 @@ class UserMessage {
         this.mentionedMCPs = message.mentionedMCPs || [];
     }
 
+    /**
+     * Gets files mentioned in the message.
+     * Currently a placeholder for implementation.
+     */
     getFiles(): void {
         // Implementation to be added
     }
 
+    /**
+     * Converts the user message to a prompt format.
+     * 
+     * @param bAttachFiles - Whether to attach file contents
+     * @param bAttachImages - Whether to attach images
+     * @param bAttachEnvironment - Whether to attach environment details
+     * @returns Promise with an array of content blocks for the prompt
+     */
     async toPrompt(
         bAttachFiles: boolean = true,
         bAttachImages: boolean = true,
@@ -70,9 +130,30 @@ class UserMessage {
         return this.userMessages;
     }
 
-    getMentionedMcps(): string[] {
-        return this.message.mentionedMCPs || [];
+    /**
+     * Gets agents mentioned in the message.
+     * 
+     * @returns Array of agent objects
+     */
+    getMentionedAgents() {
+        //TODO : get config in tool format if neede
+        return this.message.mentionedAgents || [];
+    }
+
+    /**
+     * Gets MCP tools mentioned in the message.
+     * 
+     * @returns Array of MCP tool names
+     */
+    getMentionedMcps() {
+      return this.message.mentionedMCPs || [];
     }
+
+    /**
+     * Gets MCP tools in a format suitable for the LLM.
+     * 
+     * @returns Promise with an array of MCP tools
+     */
     async getMentionedMcpsTools() {
         if (this.mentionedMCPs.length > 0) {
             let tools = await mcp.listToolsFromToolBoxes(this.mentionedMCPs)
@@ -83,6 +164,12 @@ class UserMessage {
         }
     }
 
+    /**
+     * Gets environment details for the current working directory.
+     * 
+     * @param cwd - The current working directory path
+     * @returns Promise with a string containing environment details
+     */
     private getEnvironmentDetail = async (cwd: string): Promise<string> => {
         let details = "";
         const { success, result }: FileListResult = await cbfs.listFile(cwd, true);