@codebolt/codeboltjs 2.0.12 → 2.0.15

package/dist/agentlib/promptbuilder.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromptBuilder = void 0;
+exports.InitialPromptBuilder = void 0;
 const systemprompt_1 = require("./systemprompt");
 const js_yaml_1 = __importDefault(require("js-yaml"));
 const fs_1 = __importDefault(require("fs"));
@@ -13,7 +13,7 @@ const path_1 = __importDefault(require("path"));
  * PromptBuilder class for constructing prompts using a fluent interface.
  * Allows chaining methods to build complex prompts from user messages.
  */
-class PromptBuilder {
+class InitialPromptBuilder {
     /**
      * Creates a new PromptBuilder instance.
      *
@@ -34,10 +34,16 @@ class PromptBuilder {
         this.environmentDetails = "";
         /** File contents cache */
         this.fileContents = new Map();
+        // Flags for what needs to be loaded during build
+        this.shouldLoadMCPTools = false;
+        this.mcpAdditionalServers = ["codebolt"];
+        this.shouldLoadAgentTools = false;
+        this.shouldLoadEnvironmentDetails = false;
+        this.shouldLoadAll = false;
         // Handle both InitialUserMessage and CLIUserMessage types
         if ('message' in userMessage && typeof userMessage.message === 'object') {
             // This is a CLIUserMessage with nested message structure
-            this.message = userMessage.message.userMessage || ((_a = userMessage.data) === null || _a === void 0 ? void 0 : _a.text) || "";
+            this.message = userMessage.message.userMessage || ((_a = userMessage.data) === null || _a === void 0 ? void 0 : _a.text.trim()) || "";
             this.mentionedFiles = userMessage.message.mentionedFiles || [];
             // Convert string array to MCPTool array for CLIUserMessage
             this.mentionedMCPs = (userMessage.message.mentionedMCPs || []).map((name) => ({ name }));
@@ -64,20 +70,58 @@ class PromptBuilder {
         return this;
     }
     /**
-     * Automatically loads and adds MCP tools from the mentioned MCPs in the user message.
-     * Also loads default codebolt tools.
+     * Marks MCP tools to be loaded during build from the mentioned MCPs and additional servers.
      *
      * @param additionalServers - Additional MCP servers to load tools from
      * @returns The PromptBuilder instance for chaining
      */
-    async addMCPTools(additionalServers = ["codebolt"]) {
+    addMCPTools(additionalServers = ["codebolt"]) {
+        this.shouldLoadMCPTools = true;
+        this.mcpAdditionalServers = additionalServers;
+        return this;
+    }
+    /**
+     * Marks mentioned agents to be converted to OpenAI tool format during build.
+     *
+     * @returns The PromptBuilder instance for chaining
+     */
+    addAgentTools() {
+        this.shouldLoadAgentTools = true;
+        return this;
+    }
+    /**
+     * Marks environment details to be loaded during build.
+     *
+     * @returns The PromptBuilder instance for chaining
+     */
+    addEnvironmentDetails() {
+        this.shouldLoadEnvironmentDetails = true;
+        return this;
+    }
+    /**
+     * Convenience method to mark all tools and environment details to be loaded during build.
+     * Equivalent to calling addMCPTools(), addAgentTools(), and addEnvironmentDetails().
+     *
+     * @param additionalServers - Additional MCP servers to load tools from
+     * @returns The PromptBuilder instance for chaining
+     */
+    addAllAutomatic(additionalServers = ["codebolt"]) {
+        this.shouldLoadAll = true;
+        this.mcpAdditionalServers = additionalServers;
+        return this;
+    }
+    /**
+     * Loads MCP tools from the codebolt API.
+     * Internal method called during build.
+     */
+    async loadMCPTools() {
         if (!this.codebolt) {
             console.warn("Codebolt API not available. Cannot load MCP tools automatically.");
-            return this;
+            return;
         }
         try {
             // Get default tools from specified servers
-            const { data: defaultTools } = await this.codebolt.mcp.listMcpFromServers(additionalServers);
+            const { data: defaultTools } = await this.codebolt.mcp.listMcpFromServers(this.mcpAdditionalServers);
             this.tools = [...this.tools, ...defaultTools];
             // Get tools from mentioned MCPs
             if (this.mentionedMCPs && this.mentionedMCPs.length > 0) {
@@ -88,14 +132,12 @@ class PromptBuilder {
         catch (error) {
             console.error(`Error loading MCP tools: ${error}`);
         }
-        return this;
     }
     /**
-     * Automatically converts mentioned agents to OpenAI tool format and adds them.
-     *
-     * @returns The PromptBuilder instance for chaining
+     * Converts mentioned agents to OpenAI tool format.
+     * Internal method called during build.
      */
-    addAgentTools() {
+    loadAgentTools() {
         if (this.mentionedAgents && this.mentionedAgents.length > 0) {
             const agentTools = this.mentionedAgents.map(agent => ({
                 type: "function",
@@ -116,17 +158,15 @@ class PromptBuilder {
             }));
             this.tools = [...this.tools, ...agentTools];
         }
-        return this;
     }
     /**
-     * Automatically loads file contents for mentioned files and adds environment details.
-     *
-     * @returns The PromptBuilder instance for chaining
+     * Loads file contents and environment details from the codebolt API.
+     * Internal method called during build.
      */
-    async addEnvironmentDetails() {
+    async loadEnvironmentDetails() {
         if (!this.codebolt) {
             console.warn("Codebolt API not available. Cannot load environment details automatically.");
-            return this;
+            return;
         }
         try {
             // Load mentioned file contents
@@ -154,20 +194,6 @@ class PromptBuilder {
         catch (error) {
             console.error(`Error loading environment details: ${error}`);
         }
-        return this;
-    }
-    /**
-     * Convenience method to automatically add all tools and environment details.
-     * Equivalent to calling addMCPTools(), addAgentTools(), and addEnvironmentDetails().
-     *
-     * @param additionalServers - Additional MCP servers to load tools from
-     * @returns The PromptBuilder instance for chaining
-     */
-    async addAllAutomatic(additionalServers = ["codebolt"]) {
-        await this.addMCPTools(additionalServers);
-        this.addAgentTools();
-        await this.addEnvironmentDetails();
-        return this;
     }
     /**
      * Adds system prompt from a YAML file.
@@ -185,7 +211,7 @@ class PromptBuilder {
             if (exampleFilePath) {
                 try {
                     const example = fs_1.default.readFileSync(path_1.default.resolve(exampleFilePath), 'utf8');
-                    this.systemPromptText += `\n\n<example_agent>\n\n${example}\n</example_agent>`;
+                    this.systemPromptText += `\n\n<example_agent>\n\`\`\`\n${example}\n\`\`\`\n</example_agent>`;
                 }
                 catch (error) {
                     console.error(`Error loading example file: ${error}`);
@@ -297,7 +323,7 @@ class PromptBuilder {
         return this;
     }
     /**
-     * Builds the user message content with files and environment details.
+     * Builds the user message content with files (without environment details).
      *
      * @returns Array of content blocks
      */
@@ -314,13 +340,13 @@ class PromptBuilder {
                 finalPrompt += `File Name: ${file}, File Path: ${file}, Filedata: ${fileData}`;
             }
         }
-        // Add environment details
-        if (this.environmentDetails) {
-            finalPrompt += this.environmentDetails;
-        }
         const content = [
             { type: "text", text: finalPrompt }
         ];
+        // Add environment details
+        if (this.environmentDetails) {
+            content.push({ type: "text", text: this.environmentDetails });
+        }
         // Add task instruction if available
         if (this.taskInstructionText) {
             content.push({
@@ -398,6 +424,178 @@ class PromptBuilder {
     getConversationHistory() {
         return [...this.conversationHistory];
     }
+    /**
+     * Adds an LLM response to the conversation history.
+     * This method processes the LLM response and adds the assistant's message to the conversation.
+     * It handles both resolved responses and promises that resolve to responses.
+     *
+     * @param llmResponse - The LLM response (can be a promise or resolved response)
+     * @returns The PromptBuilder instance for chaining
+     *
+     * @example
+     * ```typescript
+     * // Example of using addLLMResponse in an agent workflow loop
+     * import { PromptBuilder } from './promptbuilder';
+     * import llm from '../modules/llm';
+     *
+     * async function agentWorkflowWithLLMResponse(userMessage: any, codebolt: CodeboltAPI) {
+     *     // Step 1: Build initial prompt
+     *     const promptBuilder = new PromptBuilder(userMessage, codebolt);
+     *     let currentPrompt = await promptBuilder
+     *         .addMCPTools()
+     *         .addAgentTools()
+     *         .addEnvironmentDetails()
+     *         .buildInferenceParams();
+     *
+     *     let completed = false;
+     *     let maxTurns = 20;
+     *     let turn = 0;
+     *
+     *     // Step 2: Main conversation loop (similar to agent.ts while loop)
+     *     while (!completed && turn < maxTurns) {
+     *         // Get LLM response
+     *         const llmResponse = llm.inference(currentPrompt);
+     *
+     *         // Add LLM response to conversation history
+     *         await promptBuilder.addLLMResponse(llmResponse);
+     *
+     *         // Process the response using LLMOutputHandler
+     *         const outputHandler = new LLMOutputHandler(llmResponse, codebolt);
+     *         await outputHandler.sendMessageToUser();
+     *
+     *         // Check if task is completed
+     *         if (outputHandler.isCompleted()) {
+     *             completed = true;
+     *             break;
+     *         }
+     *
+     *         // Execute tools and get results
+     *         const toolResults = await outputHandler.runTools();
+     *
+     *         // Add tool results to conversation
+     *         if (toolResults.length > 0) {
+     *             promptBuilder.addToolResults(toolResults);
+     *         } else {
+     *             // Add default continuation message when no tools executed
+     *             promptBuilder.addDefaultContinuationMessage();
+     *         }
+     *
+     *         // Build next prompt for the loop
+     *         currentPrompt = await promptBuilder.buildInferenceParams();
+     *         turn++;
+     *     }
+     * }
+     * ```
+     */
+    async addLLMResponse(llmResponse) {
+        try {
+            // Resolve the response if it's a promise
+            const resolvedResponse = await Promise.resolve(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.conversationHistory.push(assistantMessage);
+            }
+            else {
+                // Fallback for cases where no valid message is found
+                this.conversationHistory.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.conversationHistory.push({
+                role: "assistant",
+                content: "An error occurred while processing my response."
+            });
+        }
+        return this;
+    }
+    /**
+     * Adds tool results to the conversation history.
+     * This method is typically used after executing tools from an LLM response.
+     *
+     * @param toolResults - Array of tool results to add to the conversation
+     * @returns The PromptBuilder instance for chaining
+     */
+    addToolResults(toolResults) {
+        if (toolResults && toolResults.length > 0) {
+            // Add each tool result as a separate message
+            toolResults.forEach(toolResult => {
+                this.conversationHistory.push({
+                    role: "tool",
+                    content: toolResult.content,
+                    tool_call_id: toolResult.tool_call_id
+                });
+            });
+        }
+        return this;
+    }
+    /**
+     * Adds a user message to the conversation history.
+     * Useful for adding follow-up questions or additional context during the conversation.
+     *
+     * @param message - The user message to add
+     * @returns The PromptBuilder instance for chaining
+     */
+    addUserMessage(message) {
+        const userMessage = {
+            role: "user",
+            content: message
+        };
+        this.conversationHistory.push(userMessage);
+        return this;
+    }
+    /**
+     * Adds a default continuation message when no tools were executed.
+     * This is used in the agent workflow to prompt the LLM to either complete the task
+     * or ask for more information.
+     *
+     * @returns The PromptBuilder instance for chaining
+     */
+    addDefaultContinuationMessage() {
+        const defaultMessage = "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.)";
+        this.addUserMessage([{
+                type: "text",
+                text: defaultMessage
+            }]);
+        return this;
+    }
     /**
      * Adds a custom text section to the prompt.
      *
@@ -431,19 +629,44 @@ class PromptBuilder {
      * @returns The PromptBuilder instance for chaining
      */
     addContext(context) {
-        if (context.trim()) {
-            this.promptParts.push(`[Context]\n${context}`);
-        }
+        const userMessage = {
+            role: "user",
+            content: context
+        };
+        this.conversationHistory.push(userMessage);
         return this;
     }
     /**
-     * Builds and returns the final prompt string.
-     * Joins all prompt parts with double newlines.
+     * Builds and returns the OpenAI message format with tools.
+     * This method performs all async operations that were marked during setup.
      *
-     * @returns The complete prompt string
+     * @returns Object with messages, tools, and other LLM parameters
      */
-    build() {
-        return this.promptParts.join("\n\n");
+    async build() {
+        // Perform all async operations based on what was requested
+        if (this.shouldLoadAll) {
+            await this.loadMCPTools();
+            this.loadAgentTools();
+            await this.loadEnvironmentDetails();
+        }
+        else {
+            if (this.shouldLoadMCPTools) {
+                await this.loadMCPTools();
+            }
+            if (this.shouldLoadAgentTools) {
+                this.loadAgentTools();
+            }
+            if (this.shouldLoadEnvironmentDetails) {
+                await this.loadEnvironmentDetails();
+            }
+        }
+        return {
+            messages: this.buildOpenAIMessages(),
+            tools: this.getTools(),
+            full: true,
+            max_tokens: 8192,
+            tool_choice: "auto",
+        };
     }
     /**
      * Gets the current prompt parts without building the final string.
@@ -468,14 +691,38 @@ class PromptBuilder {
         this.tools = [];
         this.environmentDetails = "";
         this.fileContents.clear();
+        // Reset async loading flags
+        this.shouldLoadMCPTools = false;
+        this.shouldLoadAgentTools = false;
+        this.shouldLoadEnvironmentDetails = false;
+        this.shouldLoadAll = false;
+        this.mcpAdditionalServers = ["codebolt"];
         return this;
     }
     /**
      * Creates an LLM inference parameters object in the format expected by the sample code.
+     * This method performs all async operations that were marked during setup.
      *
      * @returns Object with messages, tools, and other LLM parameters
      */
-    buildInferenceParams() {
+    async buildInferenceParams() {
+        // Perform all async operations based on what was requested
+        if (this.shouldLoadAll) {
+            await this.loadMCPTools();
+            this.loadAgentTools();
+            await this.loadEnvironmentDetails();
+        }
+        else {
+            if (this.shouldLoadMCPTools) {
+                await this.loadMCPTools();
+            }
+            if (this.shouldLoadAgentTools) {
+                this.loadAgentTools();
+            }
+            if (this.shouldLoadEnvironmentDetails) {
+                await this.loadEnvironmentDetails();
+            }
+        }
         return {
             full: true,
             messages: this.buildOpenAIMessages(),
@@ -483,5 +730,76 @@ class PromptBuilder {
             tool_choice: "auto",
         };
     }
+    /**
+     * Creates a minimal LLM inference parameters object with only the user message.
+     * This is useful for simple completions or when no tools/context are needed.
+     *
+     * @returns Object with messages (user only), no tools, and default tool_choice
+     */
+    //TODO: implement this
+    buildDefaultInferenceParams() {
+        return {
+            full: false,
+            messages: [this.message],
+            tools: [],
+            tool_choice: "auto",
+        };
+    }
+    /**
+     * Checks if the last LLM response indicates task completion.
+     * This method examines the conversation history for completion signals.
+     *
+     * @returns Boolean indicating if the task appears to be completed
+     */
+    isTaskCompleted() {
+        if (this.conversationHistory.length === 0) {
+            return false;
+        }
+        // Get the last assistant message
+        const lastAssistantMessage = this.conversationHistory
+            .slice()
+            .reverse()
+            .find(msg => msg.role === 'assistant');
+        if (!lastAssistantMessage) {
+            return false;
+        }
+        // Check if the message has tool calls with completion tools
+        if (lastAssistantMessage.tool_calls) {
+            const hasCompletionTool = lastAssistantMessage.tool_calls.some(toolCall => toolCall.function && toolCall.function.name.includes('attempt_completion'));
+            if (hasCompletionTool) {
+                return true;
+            }
+        }
+        // Check for completion keywords in the message content
+        const content = typeof lastAssistantMessage.content === 'string'
+            ? lastAssistantMessage.content
+            : '';
+        const completionKeywords = [
+            'task completed',
+            'task is completed',
+            'successfully completed',
+            'finished the task',
+            'task has been completed'
+        ];
+        return completionKeywords.some(keyword => content.toLowerCase().includes(keyword.toLowerCase()));
+    }
+    /**
+     * Gets the current conversation length (number of messages).
+     * Useful for determining when to summarize the conversation.
+     *
+     * @returns Number of messages in the conversation history
+     */
+    getConversationLength() {
+        return this.conversationHistory.length;
+    }
+    /**
+     * Checks if the conversation should be summarized based on length.
+     *
+     * @param maxLength - Maximum conversation length before summarization (default: 50)
+     * @returns Boolean indicating if summarization is needed
+     */
+    shouldSummarizeConversation(maxLength = 50) {
+        return this.getConversationLength() > maxLength;
+    }
 }
-exports.PromptBuilder = PromptBuilder;
+exports.InitialPromptBuilder = InitialPromptBuilder;

package/dist/agentlib/systemprompt.js

@@ -26,7 +26,6 @@ class SystemPrompt {
      * @throws {Error} If file cannot be read or parsed
      */
     toPromptText() {
-        var _a;
         try {
             const absolutePath = path_1.default.resolve(this.filepath);
             const fileContents = fs_1.default.readFileSync(absolutePath, 'utf8');
@@ -34,10 +33,11 @@ class SystemPrompt {
             if (!data || typeof data !== 'object') {
                 throw new Error('Invalid YAML structure');
             }
-            if (!((_a = data[this.key]) === null || _a === void 0 ? void 0 : _a.prompt)) {
+            if (!data[this.key]) {
                 throw new Error(`Prompt not found for key: ${this.key}`);
             }
-            return data[this.key].prompt;
+            const promptData = data[this.key];
+            return typeof promptData === 'string' ? promptData : promptData.prompt;
         }
         catch (error) {
             console.error(`SystemPrompt Error: ${error instanceof Error ? error.message : 'Unknown error'}`);

package/dist/agentlib/usermessage.d.ts

@@ -37,7 +37,7 @@ declare class UserMessage {
      * @param bAttachEnvironment - Whether to attach environment details
      * @returns Promise with an array of content blocks for the prompt
      */
-    toPrompt(bAttachFiles?: boolean, bAttachImages?: boolean, bAttachEnvironment?: boolean): Promise<UserMessageContent[]>;
+    toPrompt(bAttachFiles?: boolean, bAttachImages?: boolean, bAttachEnvironment?: boolean, supportRemix?: boolean): Promise<UserMessageContent[]>;
     /**
      * Gets agents mentioned in the message.
      *

package/dist/agentlib/usermessage.js

@@ -55,7 +55,7 @@ class UserMessage {
      * @param bAttachEnvironment - Whether to attach environment details
      * @returns Promise with an array of content blocks for the prompt
      */
-    async toPrompt(bAttachFiles = true, bAttachImages = true, bAttachEnvironment = true) {
+    async toPrompt(bAttachFiles = true, bAttachImages = true, bAttachEnvironment = true, supportRemix = true) {
         var _a;
         if (bAttachFiles) {
             if (this.promptOverride) {
@@ -83,6 +83,10 @@ class UserMessage {
                 this.userMessages.push({ type: "text", text: environmentDetail });
             }
         }
+        if (supportRemix) {
+            if (this.message.remixPrompt)
+                this.userMessages.push({ type: "text", text: this.message.remixPrompt });
+        }
         return this.userMessages;
     }
     /**