@codebolt/codeboltjs 2.0.13 → 2.0.15

package/dist/agentlib/agent.js

@@ -40,7 +40,7 @@ class Agent {
         let mentaionedMCPSTool = await task.userMessage.getMentionedMcpsTools();
         this.tools = [
             ...this.tools,
-            ...(mentaionedMCPSTool || []),
+            ...mentaionedMCPSTool || [],
         ];
         let mentionedAgents = await task.userMessage.getMentionedAgents();
         // Transform agents into tool format
@@ -123,9 +123,7 @@ class Agent {
                                             }
                                         }
                                         else {
-                                            console.log("Executing tool: ", toolName, toolInput);
                                             const [didUserReject, result] = await this.executeTool(toolName, toolInput);
-                                            console.log("Tool result: ", result);
                                             // toolResults.push(this.getToolResult(toolUseId, result));
                                             let toolResult = this.getToolResult(toolUseId, result);
                                             toolResults.push({
@@ -164,7 +162,7 @@ class Agent {
                                 toolResults.push({
                                     role: "tool",
                                     tool_call_id: tool.id,
-                                    content: String(error),
+                                    content: `please provide valid json string for tool.function.arguments String(error)`,
                                 });
                             }
                         }
@@ -261,12 +259,11 @@ class Agent {
      */
     async executeTool(toolName, toolInput) {
         //codebolttools--readfile
-        console.log("Executing tool: ", toolName, toolInput);
         const [toolboxName, actualToolName] = toolName.split('--');
         console.log("Toolbox name: ", toolboxName, "Actual tool name: ", actualToolName);
         const { data } = await mcp_1.default.executeTool(toolboxName, actualToolName, toolInput);
         console.log("Tool result: ", data);
-        return [false, data];
+        return data;
     }
     /**
      * Starts a sub-agent to handle a specific task.
@@ -302,7 +299,6 @@ class Agent {
         let userMessage = undefined;
         try {
             let parsed = JSON.parse(content);
-            console.log("Parsed Content: ", parsed);
             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()

package/dist/agentlib/followupquestionbuilder.d.ts

@@ -0,0 +1,75 @@
+import type { OpenAIMessage, OpenAITool, ToolResult, CodeboltAPI } from "../types/libFunctionTypes";
+/**
+ * Builds follow-up prompts for continuing conversations with tool results.
+ * Manages conversation history and summarization when conversations get too long.
+ */
+declare class FollowUpPromptBuilder {
+    /** Previous conversation messages */
+    private previousConversation;
+    /** Tool results to add to the conversation */
+    private toolResults;
+    /** Available tools for the conversation */
+    private tools;
+    /** The last LLM response, if available */
+    private llmResponse?;
+    /** Maximum conversation length before summarization */
+    private maxConversationLength;
+    /** Whether to force summarization */
+    private forceSummarization;
+    /** Codebolt API instance */
+    private codebolt?;
+    /**
+     * Creates a new FollowUpQuestionBuilder instance.
+     *
+     * @param codebolt - Optional codebolt API instance
+     */
+    constructor(codebolt?: CodeboltAPI);
+    /**
+     * Adds the previous conversation to the builder.
+     *
+     * @param previousPrompt - The previous prompt object containing messages and tools
+     * @returns The FollowUpQuestionBuilder instance for chaining
+     */
+    addPreviousConversation(previousPrompt: {
+        messages: OpenAIMessage[];
+        tools: OpenAITool[];
+        tool_choice?: string;
+    }, llmResponse: {
+        completion: any;
+    }): this;
+    addLLMResponseToConverstaion(llmResponse: {
+        completion: any;
+    }): this;
+    /**
+     * Adds tool execution results to the conversation.
+     *
+     * @param toolResults - Array of tool execution results
+     * @returns The FollowUpQuestionBuilder instance for chaining
+     */
+    addToolResult(toolResults: ToolResult[]): this;
+    /**
+     * Checks if the conversation is too long and sets up summarization with custom max length.
+     *
+     * @param maxLength - Maximum number of messages before summarization
+     * @returns The FollowUpQuestionBuilder instance for chaining
+     */
+    checkAndSummarizeConversationIfLong(maxLength: number): this;
+    /**
+     * Performs conversation summarization if needed.
+     *
+     * @returns Promise that resolves to the summarized messages
+     */
+    private performSummarization;
+    /**
+     * Builds the follow-up conversation prompt with tool results.
+     *
+     * @returns Promise that resolves to the conversation prompt object
+     */
+    build(): Promise<{
+        messages: OpenAIMessage[];
+        tools: OpenAITool[];
+        tool_choice: "auto";
+        full: boolean;
+    }>;
+}
+export { FollowUpPromptBuilder };

package/dist/agentlib/followupquestionbuilder.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FollowUpPromptBuilder = void 0;
+const history_1 = require("../modules/history");
+/**
+ * Builds follow-up prompts for continuing conversations with tool results.
+ * Manages conversation history and summarization when conversations get too long.
+ */
+class FollowUpPromptBuilder {
+    /**
+     * Creates a new FollowUpQuestionBuilder instance.
+     *
+     * @param codebolt - Optional codebolt API instance
+     */
+    constructor(codebolt) {
+        /** Previous conversation messages */
+        this.previousConversation = [];
+        /** Tool results to add to the conversation */
+        this.toolResults = [];
+        /** Available tools for the conversation */
+        this.tools = [];
+        /** Maximum conversation length before summarization */
+        this.maxConversationLength = 50;
+        /** Whether to force summarization */
+        this.forceSummarization = false;
+        this.codebolt = codebolt;
+    }
+    /**
+     * Adds the previous conversation to the builder.
+     *
+     * @param previousPrompt - The previous prompt object containing messages and tools
+     * @returns The FollowUpQuestionBuilder instance for chaining
+     */
+    addPreviousConversation(previousPrompt, llmResponse) {
+        this.previousConversation = [...previousPrompt.messages];
+        this.tools = [...previousPrompt.tools];
+        try {
+            // Resolve the response if it's a promise
+            const resolvedResponse = llmResponse;
+            if (!resolvedResponse || !resolvedResponse.completion) {
+                console.warn("Invalid LLM response provided");
+                return this;
+            }
+            const completion = resolvedResponse.completion;
+            let assistantMessage = null;
+            // Handle different response formats
+            if (completion.choices && completion.choices.length > 0) {
+                // OpenAI-style response with choices
+                const choice = completion.choices[0];
+                if (choice.message) {
+                    assistantMessage = {
+                        role: "assistant",
+                        content: choice.message.content || "",
+                        tool_calls: choice.message.tool_calls || undefined
+                    };
+                }
+            }
+            else if (completion.content) {
+                // Direct content response
+                assistantMessage = {
+                    role: "assistant",
+                    content: completion.content
+                };
+            }
+            else if (completion.message) {
+                // Message format response
+                assistantMessage = {
+                    role: "assistant",
+                    content: completion.message.content || "",
+                    tool_calls: completion.message.tool_calls || undefined
+                };
+            }
+            // Add the assistant message to conversation history
+            if (assistantMessage) {
+                this.previousConversation.push(assistantMessage);
+            }
+            else {
+                // Fallback for cases where no valid message is found
+                this.previousConversation.push({
+                    role: "assistant",
+                    content: "I apologize, but I was unable to provide a proper response."
+                });
+            }
+        }
+        catch (error) {
+            console.error("Error adding LLM response to conversation:", error);
+            // Add error message to conversation history
+            this.previousConversation.push({
+                role: "assistant",
+                content: "An error occurred while processing my response."
+            });
+        }
+        return this;
+    }
+    addLLMResponseToConverstaion(llmResponse) {
+        return this;
+    }
+    /**
+     * Adds tool execution results to the conversation.
+     *
+     * @param toolResults - Array of tool execution results
+     * @returns The FollowUpQuestionBuilder instance for chaining
+     */
+    addToolResult(toolResults) {
+        toolResults.forEach(toolResult => {
+            this.previousConversation.push(toolResult);
+        });
+        if (!toolResults.length) {
+            this.previousConversation.push({
+                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.)"
+                    }]
+            });
+        }
+        return this;
+    }
+    /**
+     * Checks if the conversation is too long and sets up summarization with custom max length.
+     *
+     * @param maxLength - Maximum number of messages before summarization
+     * @returns The FollowUpQuestionBuilder instance for chaining
+     */
+    checkAndSummarizeConversationIfLong(maxLength) {
+        this.maxConversationLength = maxLength;
+        this.forceSummarization = this.previousConversation.length > maxLength;
+        return this;
+    }
+    /**
+     * Performs conversation summarization if needed.
+     *
+     * @returns Promise that resolves to the summarized messages
+     */
+    async performSummarization() {
+        const shouldSummarize = this.forceSummarization ||
+            this.previousConversation.length > this.maxConversationLength;
+        if (!shouldSummarize) {
+            return this.previousConversation;
+        }
+        try {
+            console.log("Summarizing conversation due to length:", this.previousConversation.length);
+            // Convert OpenAI messages to the format expected by chatSummary
+            const messagesToSummarize = this.previousConversation.map(msg => ({
+                role: msg.role,
+                content: typeof msg.content === 'string' ? msg.content :
+                    Array.isArray(msg.content) ? msg.content.map(c => c.text).join(' ') :
+                        String(msg.content)
+            }));
+            // Use the chat summary service to summarize the conversation
+            const summaryResponse = await history_1.chatSummary.summarize(messagesToSummarize, Math.floor(this.maxConversationLength / 2));
+            if (summaryResponse.payload || summaryResponse.summary) {
+                const summaryText = summaryResponse.payload || summaryResponse.summary || '';
+                // Keep the system message if it exists, and replace the rest with summary
+                const systemMessage = this.previousConversation.find(msg => msg.role === 'system');
+                const summarizedMessages = [];
+                if (systemMessage) {
+                    summarizedMessages.push(systemMessage);
+                }
+                // Add the summary as a system message
+                summarizedMessages.push({
+                    role: 'system',
+                    content: `Previous conversation summary: ${summaryText}`
+                });
+                // Keep the last few messages for context
+                const recentMessages = this.previousConversation.slice(-5);
+                summarizedMessages.push(...recentMessages);
+                return summarizedMessages;
+            }
+        }
+        catch (error) {
+            console.error("Error summarizing conversation:", error);
+        }
+        // If summarization fails, just return the original conversation
+        return this.previousConversation;
+    }
+    /**
+     * Builds the follow-up conversation prompt with tool results.
+     *
+     * @returns Promise that resolves to the conversation prompt object
+     */
+    async build() {
+        // Perform summarization if needed
+        let messages = this.previousConversation;
+        return {
+            messages,
+            tools: this.tools,
+            full: true,
+            tool_choice: "auto"
+        };
+    }
+}
+exports.FollowUpPromptBuilder = FollowUpPromptBuilder;

package/dist/agentlib/llmoutputhandler.d.ts

@@ -0,0 +1,102 @@
+import type { OpenAIMessage, ToolResult, CodeboltAPI } from "../types/libFunctionTypes";
+/**
+ * Handles LLM output processing, tool execution, and completion detection.
+ * This class processes LLM responses and manages the conversation flow.
+ */
+declare class LLMOutputHandler {
+    /** The LLM response to process */
+    private llmResponse;
+    /** Whether the task has been completed */
+    private completed;
+    /** Tool results from execution */
+    private toolResults;
+    /** Next user message to be added to conversation */
+    private nextUserMessage;
+    /** Codebolt API instance */
+    private codebolt?;
+    /** Whether tools have been executed */
+    private toolsExecuted;
+    /**
+     * Creates a new LLMOutputHandler instance.
+     *
+     * @param llmResponse - The LLM response object
+     * @param codebolt - Optional codebolt API instance
+     */
+    constructor(llmResponse: any, codebolt?: CodeboltAPI);
+    /**
+     * Checks if the task has been completed.
+     *
+     * @returns True if the task is completed, false otherwise
+     */
+    isCompleted(): boolean;
+    /**
+     * Gets the tool execution results.
+     *
+     * @returns Array of tool results
+     */
+    getToolResults(): ToolResult[];
+    /**
+     * Gets the next user message to be added to conversation.
+     *
+     * @returns The next user message or null
+     */
+    getNextUserMessage(): OpenAIMessage | null;
+    /**
+     * Sends the assistant's message to the user interface.
+     *
+     * @returns Promise that resolves when the message is sent
+     */
+    sendMessageToUser(): Promise<void>;
+    /**
+     * Executes all tool calls found in the LLM response.
+     *
+     * @returns Promise that resolves when all tools are executed
+     */
+    runTools(): Promise<ToolResult[]>;
+    /**
+     * Extracts tool calls from the LLM response.
+     *
+     * @returns Array of tool calls or null if none found
+     */
+    private getToolCallsFromResponse;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Checks if the response has tool calls.
+     *
+     * @returns True if the response contains tool calls
+     */
+    hasToolCalls(): boolean;
+    /**
+     * Gets the assistant's message content from the response.
+     *
+     * @returns The assistant's message content or null
+     */
+    getAssistantMessage(): string | null;
+    /**
+     * Resets the handler state for reuse.
+     */
+    reset(): void;
+}
+export { LLMOutputHandler };