changes

Author: rawatSingh2022

modules/agent.js

@@ -63,7 +63,7 @@ const codeboltAgent = {
             }));
             websocket_1.default.getWebsocket.on('message', (data) => {
                 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
                 }
             });

modules/agentlib/agent.d.ts

@@ -1,23 +1,86 @@
 import { SystemPrompt } from "./systemprompt";
 import { TaskInstruction } from "./taskInstruction";
+/**
+ * Agent class that manages conversations with LLMs and tool executions.
+ * Handles the conversation flow, tool calls, and task completions.
+ */
 declare class Agent {
+    /** Available tools for the agent to use */
     private tools;
+    /** Full conversation history for API calls */
     private apiConversationHistory;
+    /** Maximum number of conversation turns (0 means unlimited) */
     private maxRun;
+    /** System prompt that provides instructions to the model */
     private systemPrompt;
+    /** Messages from the user */
     private userMessage;
+    /** The next user message to be added to the conversation */
     private nextUserMessage;
+    /**
+     * 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);
+    /**
+     * 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
+     */
     run(task: TaskInstruction, successCondition?: () => boolean): Promise<{
         success: boolean;
         error: string | null;
         message: string | null;
     }>;
+    /**
+     * 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 attemptLlmRequest;
+    /**
+     * 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 executeTool;
+    /**
+     * 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 startSubAgent;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Fallback method for API requests in case of failures.
+     *
+     * @throws Error API request fallback not implemented
+     */
     private attemptApiRequest;
 }
 export { Agent };

modules/agentlib/agent.js

@@ -8,14 +8,32 @@ const chat_1 = __importDefault(require("./../chat"));
 const tools_1 = __importDefault(require("./../tools"));
 const llm_1 = __importDefault(require("./../llm"));
 const agent_1 = __importDefault(require("./../agent"));
+/**
+ * Agent class that manages conversations with LLMs and tool executions.
+ * Handles the conversation flow, tool calls, and task completions.
+ */
 class Agent {
+    /**
+     * 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 = [], systemPrompt, maxRun = 0) {
         this.tools = tools;
         this.userMessage = [];
         this.apiConversationHistory = [];
         this.maxRun = maxRun;
         this.systemPrompt = systemPrompt;
     }
+    /**
+     * 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, successCondition = () => true) {
         var _a, _b;
         let mentaionedMCPSTool = await task.userMessage.getMentionedMcpsTools();
@@ -199,6 +217,13 @@ class Agent {
                 .pop()) === null || _b === void 0 ? void 0 : _b.content) || ''
         };
     }
+    /**
+     * 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
+     */
     async attemptLlmRequest(apiConversationHistory, tools) {
         try {
             let systemPrompt = await this.systemPrompt.toPromptText();
@@ -221,21 +246,48 @@ class Agent {
             return this.attemptApiRequest();
         }
     }
+    /**
+     * 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]
+     */
     async executeTool(toolName, toolInput) {
         //codebolttools--readfile
         const [toolboxName, actualToolName] = toolName.split('--');
         return tools_1.default.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]
+     */
     async startSubAgent(agentName, params) {
         return agent_1.default.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
+     */
     getToolDetail(tool) {
         return {
             toolName: tool.function.name,
             toolInput: JSON.parse(tool.function.arguments || "{}"),
             toolUseId: tool.id
         };
     }
+    /**
+     * 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
+     */
     getToolResult(tool_call_id, content) {
         let userMessage = undefined;
         try {
@@ -255,7 +307,11 @@ class Agent {
             userMessage
         };
     }
-    // Placeholder for error fallback method
+    /**
+     * Fallback method for API requests in case of failures.
+     *
+     * @throws Error API request fallback not implemented
+     */
     attemptApiRequest() {
         throw new Error("API request fallback not implemented");
     }

modules/agentlib/taskInstruction.d.ts

@@ -1,22 +1,59 @@
 import { UserMessage, UserMessageContent } from "./usermessage";
+/**
+ * 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 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.
+ */
 declare 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 | undefined, userMessage: UserMessage, filepath?: string, refsection?: string);
+    /**
+     * 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
+     */
     toPrompt(): Promise<UserMessages[]>;
 }
 export { TaskInstruction };

modules/agentlib/taskInstruction.js

@@ -8,14 +8,34 @@ exports.TaskInstruction = void 0;
 const yaml = require('js-yaml');
 const fs = require('fs');
 const path = require('path');
+/**
+ * Class representing a task instruction.
+ * Handles loading task data and converting it to prompts.
+ */
 class TaskInstruction {
+    /**
+     * 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 = {}, userMessage, filepath = "", refsection = "") {
+        /** Messages from the user for this task */
         this.userMessages = [];
         this.tools = tools;
         this.userMessage = userMessage;
         this.filepath = filepath;
         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() {
         try {
             this.userMessages = await this.userMessage.toPrompt();