@codebolt/codeboltjs 2.0.12 → 2.0.15

package/dist/agentlib/promptbuilder.d.ts

@@ -1,11 +1,11 @@
 import { UserMessage as CLIUserMessage } from "../types/socketMessageTypes";
-import type { OpenAIMessage, OpenAITool, ConversationEntry, CodeboltAPI } from "../types/libFunctionTypes";
+import type { OpenAIMessage, OpenAITool, ConversationEntry, CodeboltAPI, ToolResult } from "../types/libFunctionTypes";
 import type { MCPTool, Agent, InitialUserMessage } from "../types/commonTypes";
 /**
  * PromptBuilder class for constructing prompts using a fluent interface.
  * Allows chaining methods to build complex prompts from user messages.
  */
-declare class PromptBuilder {
+declare class InitialPromptBuilder {
     /** The main message text */
     private message;
     /** List of mentioned files */
@@ -30,6 +30,11 @@ declare class PromptBuilder {
     private fileContents;
     /** Codebolt API instance */
     private codebolt?;
+    private shouldLoadMCPTools;
+    private mcpAdditionalServers;
+    private shouldLoadAgentTools;
+    private shouldLoadEnvironmentDetails;
+    private shouldLoadAll;
     /**
      * Creates a new PromptBuilder instance.
      *
@@ -45,33 +50,47 @@ declare class PromptBuilder {
      */
     setCodeboltAPI(codebolt: CodeboltAPI): 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
      */
-    addMCPTools(additionalServers?: string[]): Promise<this>;
+    addMCPTools(additionalServers?: string[]): this;
     /**
-     * Automatically converts mentioned agents to OpenAI tool format and adds them.
+     * Marks mentioned agents to be converted to OpenAI tool format during build.
      *
      * @returns The PromptBuilder instance for chaining
      */
     addAgentTools(): this;
     /**
-     * Automatically loads file contents for mentioned files and adds environment details.
+     * Marks environment details to be loaded during build.
      *
      * @returns The PromptBuilder instance for chaining
      */
-    addEnvironmentDetails(): Promise<this>;
+    addEnvironmentDetails(): this;
     /**
-     * Convenience method to automatically add all tools and environment details.
+     * 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?: string[]): Promise<this>;
+    addAllAutomatic(additionalServers?: string[]): this;
+    /**
+     * Loads MCP tools from the codebolt API.
+     * Internal method called during build.
+     */
+    private loadMCPTools;
+    /**
+     * Converts mentioned agents to OpenAI tool format.
+     * Internal method called during build.
+     */
+    private loadAgentTools;
+    /**
+     * Loads file contents and environment details from the codebolt API.
+     * Internal method called during build.
+     */
+    private loadEnvironmentDetails;
     /**
      * Adds system prompt from a YAML file.
      *
@@ -128,7 +147,7 @@ declare class PromptBuilder {
      */
     addTools(tools: OpenAITool[]): 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
      */
@@ -170,6 +189,101 @@ declare class PromptBuilder {
      * @returns Array of conversation entries
      */
     getConversationHistory(): ConversationEntry[];
+    /**
+     * 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++;
+     *     }
+     * }
+     * ```
+     */
+    addLLMResponse(llmResponse: Promise<{
+        completion: any;
+    }> | {
+        completion: any;
+    }): Promise<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: ToolResult[]): 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: string | Array<{
+        type: string;
+        text: string;
+    }>): 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(): this;
     /**
      * Adds a custom text section to the prompt.
      *
@@ -193,12 +307,18 @@ declare class PromptBuilder {
      */
     addContext(context: string): 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(): string;
+    build(): Promise<{
+        messages: OpenAIMessage[];
+        tools: OpenAITool[];
+        full: boolean;
+        max_tokens: number;
+        tool_choice: "auto";
+    }>;
     /**
      * Gets the current prompt parts without building the final string.
      * Useful for debugging or inspection.
@@ -215,14 +335,48 @@ declare class PromptBuilder {
     reset(): 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(): {
+    buildInferenceParams(): Promise<{
         full: boolean;
         messages: OpenAIMessage[];
         tools: OpenAITool[];
         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
+     */
+    buildDefaultInferenceParams(): {
+        full: boolean;
+        messages: string[];
+        tools: never[];
+        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(): boolean;
+    /**
+     * 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(): number;
+    /**
+     * 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?: number): boolean;
 }
-export { PromptBuilder, MCPTool, Agent, InitialUserMessage, OpenAIMessage, OpenAITool, ConversationEntry, CodeboltAPI };
+export { InitialPromptBuilder, MCPTool, Agent, InitialUserMessage, OpenAIMessage, OpenAITool, ConversationEntry, CodeboltAPI };