@codebolt/codeboltjs 2.0.3 → 2.0.4

package/src/modules/agent.ts

@@ -1,120 +0,0 @@
-import { GetAgentStateResponse } from '@codebolt/types';
-import cbws from './websocket';
-
-
-export enum AgentLocation {
-    ALL = 'all',
-    LOCAL_ONLY = 'local_only',
-    REMOTE_ONLY = 'remote_only',
-}
-
-
-export enum Agents {
-    LOCAL = 'local',
-    ALL = 'all',
-    DOWNLOADED = 'downloaded',
-}
-
-export enum FilterUsing {
-    USE_AI = 'use_ai',
-    USE_VECTOR_DB = 'use_vector_db',
-    USE_BOTH = 'use_both',
-}
-
-
-
-const codeboltAgent = {
-    /**
-     * Retrieves an agent based on the specified task.
-     * @param {string} task - The task for which an agent is needed.
-     * @returns {Promise<AgentResponse>} A promise that resolves with the agent details.
-     */
-    findAgent: (task: string, maxResult = 1, agents = [], agentLocaltion: AgentLocation = AgentLocation.ALL, getFrom: FilterUsing.USE_VECTOR_DB): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "agentEvent",
-                "action": "findAgent",
-                "task": task,
-                "agents": agents,// for filter in vector db
-                "maxResult": maxResult,
-                "location": agentLocaltion,
-                "getFrom": getFrom
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                const response = JSON.parse(data);
-                if (response.type === "findAgentByTaskResponse") {
-                    resolve(response); // Resolve the Promise with the agent details
-                }
-            });
-        });
-    },
-
-    /**
-     * Starts an agent for the specified task.
-     * @param {string} task - The task for which the agent should be started.
-     * @returns {Promise<void>} A promise that resolves when the agent has been successfully started.
-     */
-    startAgent: (agentId: string, task: string): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "agentEvent",
-                "action": "startAgent",
-                "agentId": agentId,
-                "task": task
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                const response = JSON.parse(data);
-                if (response.type === "taskCompletionResponse" && response.agentId === agentId) {
-                    resolve(response); // Resolve the Promise when the agent has been successfully started
-                }
-            });
-        });
-    },
-
-    /**
-     * Lists all available agents.
-     * @returns {Promise<any>} A promise that resolves with the list of agents.
-     */
-    getAgentsList: (type: Agents = Agents.DOWNLOADED): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "agentEvent",
-                "action": "listAgents",
-                "agentType": type,
-
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                const response = JSON.parse(data);
-                if (response.type === "listAgentsResponse") {
-                    resolve(response); // Resolve the Promise with the list of agents
-                }
-            });
-        });
-    },
-    /**
-     * Lists all available agents.
-     * @returns {Promise<any>} A promise that resolves with the list of agents.
-     */
-    getAgentsDetail: (agentList = []): Promise<any> => {
-        return new Promise((resolve, reject) => {
-            cbws.getWebsocket.send(JSON.stringify({
-                "type": "agentEvent",
-                "action": "agentsDetail",
-                "agentList": agentList
-            }));
-            cbws.getWebsocket.on('message', (data: string) => {
-                const response = JSON.parse(data);
-                if (response.type === "listAgentsResponse") {
-                    resolve(response); // Resolve the Promise with the list of agents
-                }
-            });
-        });
-    }
-}
-
-
-export default codeboltAgent;
-
-
-
-

package/src/modules/agentlib/agent.ts

@@ -1,417 +0,0 @@
-import chatlib from "./../chat"
-import tools from "./../tools"
-import llm from "./../llm"
-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[];
-    /** 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;
-
-    /**
-     * 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;
-
-    }
-
-    /**
-     * 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,
-
-        ]
-        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 });
-        let runcomplete = 0;
-        while (!completed && (runcomplete <= this.maxRun || this.maxRun === 0)) {
-            try {
-                runcomplete++;
-                const response = await this.attemptLlmRequest(this.apiConversationHistory, this.tools);
-                let isMessagePresentinReply = false;
-
-                for (const contentBlock of response.choices) {
-                    if (contentBlock.message) {
-                        isMessagePresentinReply = true;
-                        this.apiConversationHistory.push(contentBlock.message);
-
-                        if (contentBlock.message.content != null) {
-                            await chatlib.sendMessage(contentBlock.message.content, {});
-                        }
-                    }
-                }
-
-                if (!isMessagePresentinReply) {
-                    this.apiConversationHistory.push({
-                        role: "assistant",
-                        content: [{ type: "text", text: "Failure: I did not provide a response." }],
-                    });
-                }
-
-                try {
-                    let toolResults: ToolResult[] = [];
-                    let taskCompletedBlock: any;
-                    let userRejectedToolUse = false;
-                    const contentBlock = response.choices[0];
-
-                    if (contentBlock.message?.tool_calls) {
-                        for (const tool of contentBlock.message.tool_calls) {
-                            try {
-                                const { toolInput, toolName, toolUseId } = this.getToolDetail(tool);
-
-                                if (!userRejectedToolUse) {
-                                    if (toolName.includes("attempt_completion")) {
-                                        taskCompletedBlock = tool;
-                                    } else {
-
-                                        let [serverName] = toolName.replace('--', ':').split(':');
-
-
-                                        if (serverName == 'subagent') {
-
-                                            const agentResponse = await codeboltAgent.startAgent(toolName.replace("subagent--", ''), toolInput.task);
-                                            const [didUserReject, result] = [false, "tool result is successful"];
-                                            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;
-                                            }
-
-                                        }
-                                        else {
-                                            const [didUserReject, result] = await this.executeTool(toolName, toolInput);
-                                            // 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;
-                                            }
-                                        }
-
-                                    }
-                                } else {
-                                    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
-                                        }
-                                    }
-
-                                }
-                            } catch (error) {
-                              
-                                toolResults.push({
-                                    role: "tool",
-                                    tool_call_id: tool.id,
-                                    content: String(error),
-
-                                });
-
-                            }
-                        }
-                    }
-
-                    if (taskCompletedBlock) {
-                        let [_, result] = await this.executeTool(
-                            taskCompletedBlock.function.name,
-                            JSON.parse(taskCompletedBlock.function.arguments || "{}")
-                        );
-
-                        if (result === "") {
-                            completed = true;
-                            result = "The user is satisfied with the 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: Message[] = toolResults;
-
-                    if (toolResults.length === 0) {
-                        nextUserMessage = [{
-                            role: "user",
-                            content: [{
-                                type: "text",
-                                text: "If you have completed the user's task, use the attempt_completion tool. If you require additional information from the user, use the ask_followup_question tool. Otherwise, if you have not completed the task and do not need additional information, then proceed with the next step of the task. (This is an automated message, so do not respond to it conversationally.)"
-                            }]
-                        }];
-
-                        if (nextUserMessage) {
-                            this.apiConversationHistory.push(nextUserMessage[0]);
-                        }
-                    }
-                } catch (error) {
-                    console.error("Error in agent tool call:", error);
-                    return { success: false, error: error instanceof Error ? error.message : String(error), message: null };
-                }
-            } catch (error) {
-                console.error("Error in agent tool call:", error);
-                return { success: false, error: error instanceof Error ? error.message : String(error), message: null };
-            }
-        }
-
-        return {
-            success: completed,
-            error: null,
-            message: this.apiConversationHistory
-                .filter(msg => msg.role === 'assistant')
-                .pop()?.content as string || ''
-        };
-    }
-
-    /**
-     * 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> {
-
-
-        try {
-            let systemPrompt = await this.systemPrompt.toPromptText();
-            const aiMessages: Message[] = [
-                { role: "system", content: systemPrompt },
-                ...apiConversationHistory,
-            ];
-
-            const createParams = {
-                full: true,
-                messages: aiMessages,
-                tools: tools,
-                tool_choice: "auto",
-            };
-            //@ts-ignore
-            const { completion } = await llm.inference(createParams);
-            return completion;
-        } catch (error) {
-            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]
-     */
-    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,
-            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
-     */
-    private getToolResult(tool_call_id: string, content: string): ToolResult {
-        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
-        };
-    }
-
-    /**
-     * 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");
-    }
-}
-
-export { Agent };

package/src/modules/agentlib/systemprompt.ts

@@ -1,55 +0,0 @@
-import yaml from 'js-yaml';
-import fs from 'fs';
-import path from 'path';
-
-interface PromptData {
-    [key: string]: {
-        prompt: string;
-    };
-}
-
-/**
- * SystemPrompt class for loading and managing system prompts from YAML files
- */
-class SystemPrompt {
-    private filepath: string;
-    private key: string;
-
-    /**
-     * Creates a SystemPrompt instance
-     * @param {string} filepath - Path to the YAML file containing prompts
-     * @param {string} key - Key identifier for the specific prompt
-     */
-    constructor(filepath: string = "", key: string = "") {
-        this.filepath = filepath;
-        this.key = key;
-    }
-
-    /**
-     * Loads and returns the prompt text
-     * @returns {string} The prompt text
-     * @throws {Error} If file cannot be read or parsed
-     */
-    toPromptText(): string {
-        try {
-            const absolutePath = path.resolve(this.filepath);
-            const fileContents = fs.readFileSync(absolutePath, 'utf8');
-            const data = yaml.load(fileContents) as PromptData;
-
-            if (!data || typeof data !== 'object') {
-                throw new Error('Invalid YAML structure');
-            }
-
-            if (!data[this.key]?.prompt) {
-                throw new Error(`Prompt not found for key: ${this.key}`);
-            }
-
-            return data[this.key].prompt;
-        } catch (error) {
-            console.error(`SystemPrompt Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            throw error; // Re-throw to allow caller handling
-        }
-    }
-}
-
-export { SystemPrompt };

package/src/modules/agentlib/taskInstruction.ts

@@ -1,105 +0,0 @@
-import { UserMessage, UserMessageContent } from "./usermessage";
-
-/**
- * Encapsulates task instructions and their related metadata.
- * Handles loading and processing of task instructions from YAML files.
- */
-const yaml = require('js-yaml');
-const fs = require('fs');
-const path = require('path');
-
-/**
- * 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;
-        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(): Promise<UserMessages[]> {
-        try {
-            this.userMessages = await this.userMessage.toPrompt();
-            const fileContents = fs.readFileSync(path.resolve(this.filepath), 'utf8');
-            const data = yaml.load(fileContents) as TaskData;
-            const task = data[this.refsection];
-            this.userMessages.push({
-                type: "text",
-                text: `Task Description: ${task.description}\nExpected Output: ${task.expected_output}`
-            });
-            return this.userMessages;
-        } catch (error) {
-            console.error(`Error processing task instruction: ${error}`);
-            throw error;
-        }
-    }
-}
-export { TaskInstruction };