@codebolt/agent 5.0.2 → 5.0.7

package/dist/llmoutputhandler.js

@@ -0,0 +1,452 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMOutputHandler = void 0;
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const { chat, mcp, agent: codeboltAgent } = codeboltjs_1.default;
+/**
+ * Handles LLM output processing, tool execution, and completion detection.
+ * This class processes LLM responses and manages the conversation flow.
+ */
+class LLMOutputHandler {
+    /**
+     * Creates a new LLMOutputHandler instance.
+     *
+     * @param llmResponse - The LLM response object
+     * @param codebolt - Optional codebolt API instance
+     */
+    constructor(llmResponse, codebolt) {
+        /** Whether the task has been completed */
+        this.completed = false;
+        /** Tool results from execution */
+        this.toolResults = [];
+        /** Next user message to be added to conversation */
+        this.nextUserMessage = null;
+        /** Whether mcp have been executed */
+        this.mcpExecuted = false;
+        // Validate llmResponse structure
+        if (!llmResponse) {
+            throw new Error("LLM response is null or undefined");
+        }
+        if (!llmResponse.completion) {
+            throw new Error("LLM response completion is missing");
+        }
+        if (!llmResponse.completion.choices || !Array.isArray(llmResponse.completion.choices)) {
+            throw new Error("LLM response choices array is missing or invalid");
+        }
+        this.llmResponse = llmResponse;
+        this.codebolt = codebolt;
+        // Check if any message has tool_calls, if none do, mark as completed
+        let hasToolCalls = false;
+        try {
+            this.llmResponse.completion.choices.forEach((message) => {
+                var _a;
+                if (((_a = message.message) === null || _a === void 0 ? void 0 : _a.tool_calls) && message.message.tool_calls.length > 0) {
+                    hasToolCalls = true;
+                }
+            });
+        }
+        catch (error) {
+            console.error("Error checking for tool calls:", error);
+            hasToolCalls = false;
+        }
+        // If no messages have tool_calls, mark as completed
+        if (!hasToolCalls) {
+            try {
+                this.sendMessageToUser();
+            }
+            catch (error) {
+                console.error("Error sending message to user:", error);
+            }
+            this.completed = true;
+        }
+    }
+    /**
+     * Checks if the task has been completed.
+     *
+     * @returns True if the task is completed, false otherwise
+     */
+    isCompleted() {
+        return this.completed;
+    }
+    /**
+     * Gets the tool execution results.
+     *
+     * @returns Array of tool results
+     */
+    getToolResults() {
+        return [...this.toolResults];
+    }
+    /**
+     * Gets the next user message to be added to conversation.
+     *
+     * @returns The next user message or null
+     */
+    getNextUserMessage() {
+        return this.nextUserMessage;
+    }
+    /**
+     * Sends the assistant's message to the user interface.
+     *
+     * @returns Promise that resolves when the message is sent
+     */
+    async sendMessageToUser() {
+        var _a, _b;
+        if (!this.llmResponse) {
+            throw new Error("LLM response not available");
+        }
+        // Handle the response structure - it might have choices or direct content
+        let messageContent = '';
+        const completion = this.llmResponse.completion;
+        if (completion && completion.choices && completion.choices.length > 0) {
+            // OpenAI-style response with choices
+            const choice = completion.choices[0];
+            if (choice.message && choice.message.content) {
+                messageContent = choice.message.content;
+            }
+        }
+        else if (completion && completion.content) {
+            // Direct content response
+            messageContent = completion.content;
+        }
+        if (messageContent) {
+            (_b = (_a = this.codebolt) === null || _a === void 0 ? void 0 : _a.chat) === null || _b === void 0 ? void 0 : _b.sendMessage(messageContent, {});
+        }
+    }
+    /**
+     * Executes all tool calls found in the LLM response.
+     *
+     * @returns Promise that resolves when all mcp are executed
+     */
+    async runTools() {
+        var _a;
+        try {
+            // Validate llmResponse structure
+            if (!this.llmResponse || !this.llmResponse.completion) {
+                throw new Error("Invalid LLM response structure");
+            }
+            if (!this.llmResponse.completion.choices || !Array.isArray(this.llmResponse.completion.choices)) {
+                throw new Error("LLM response choices array is missing or invalid");
+            }
+            if (this.llmResponse.completion.choices.length === 0) {
+                console.warn("No choices found in LLM response");
+                return this.toolResults;
+            }
+            let toolResults = [];
+            let taskCompletedBlock;
+            let userRejectedToolUse = false;
+            console.log("Calling run tool: ", JSON.stringify(this.llmResponse.completion));
+            const contentBlock = this.llmResponse.completion.choices[0];
+            // Validate contentBlock structure
+            if (!contentBlock || !contentBlock.message) {
+                console.warn("Invalid content block structure");
+                return this.toolResults;
+            }
+            if ((_a = contentBlock.message) === null || _a === void 0 ? void 0 : _a.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);
+                                    this.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 {
+                                    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);
+                                    console.log("tool result after parsing", toolResult);
+                                    this.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.");
+                            this.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) {
+                        this.toolResults.push({
+                            role: "tool",
+                            tool_call_id: (tool === null || tool === void 0 ? void 0 : tool.id) || "unknown",
+                            content: String(error),
+                        });
+                    }
+                }
+            }
+            if (taskCompletedBlock) {
+                let taskArgs = {};
+                try {
+                    // Validate taskCompletedBlock structure
+                    if (!taskCompletedBlock.function) {
+                        throw new Error("Task completed block function is missing");
+                    }
+                    if (!taskCompletedBlock.function.name) {
+                        throw new Error("Task completed block function name is missing");
+                    }
+                    // Parse arguments safely
+                    const argumentsString = taskCompletedBlock.function.arguments || "{}";
+                    if (typeof argumentsString !== 'string') {
+                        throw new Error("Task completed block arguments must be a string");
+                    }
+                    taskArgs = JSON.parse(argumentsString);
+                }
+                catch (parseError) {
+                    const errorMessage = parseError instanceof Error ? parseError.message : 'Unknown parsing error';
+                    console.error("Failed to parse taskCompletedBlock arguments:", errorMessage);
+                    taskArgs = {};
+                }
+                let [_, result] = await this.executeTool(taskCompletedBlock.function.name, taskArgs);
+                if (result === "") {
+                    this.completed = true;
+                    result = "The user is satisfied with the result.";
+                }
+                let toolResult = this.getToolResult((taskCompletedBlock === null || taskCompletedBlock === void 0 ? void 0 : taskCompletedBlock.id) || "unknown", result);
+                this.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 = this.toolResults;
+            if (this.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.)"
+                            }]
+                    }];
+            }
+            return this.toolResults;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            console.error(`Error in runTools: ${errorMessage}`, error);
+            // Add error information to tool results for debugging
+            this.toolResults.push({
+                role: "tool",
+                tool_call_id: "error",
+                content: `Error executing mcp: ${errorMessage}`
+            });
+            return this.toolResults;
+        }
+    }
+    /**
+     * Extracts tool calls from the LLM response.
+     *
+     * @returns Array of tool calls or null if none found
+     */
+    getToolCallsFromResponse() {
+        if (!this.llmResponse)
+            return null;
+        // Check OpenAI-style response structure
+        const completion = this.llmResponse.completion;
+        if (completion && completion.choices && completion.choices.length > 0) {
+            const choice = completion.choices[0];
+            if (choice.message && choice.message.tool_calls) {
+                return choice.message.tool_calls;
+            }
+        }
+        // Check direct tool_calls property
+        if (completion && completion.tool_calls) {
+            return completion.tool_calls;
+        }
+        return null;
+    }
+    /**
+     * 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) {
+        try {
+            // Validate tool object
+            if (!tool) {
+                throw new Error("Tool object is null or undefined");
+            }
+            // Validate tool.function
+            if (!tool.function) {
+                throw new Error("Tool function is null or undefined");
+            }
+            // Validate tool.function.name
+            if (!tool.function.name || typeof tool.function.name !== 'string') {
+                throw new Error("Tool function name is missing or invalid");
+            }
+            // Validate tool.id
+            if (!tool.id || typeof tool.id !== 'string') {
+                throw new Error("Tool ID is missing or invalid");
+            }
+            // Parse tool arguments safely
+            let toolInput = {};
+            if (tool.function.arguments) {
+                try {
+                    toolInput = JSON.parse(tool.function.arguments);
+                }
+                catch (parseError) {
+                    throw new Error(`Failed to parse tool arguments: ${parseError instanceof Error ? parseError.message : 'Invalid JSON'}`);
+                }
+            }
+            return {
+                toolName: tool.function.name,
+                toolInput: toolInput,
+                toolUseId: tool.id
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            throw new Error(`Failed to extract tool details: ${errorMessage}`);
+        }
+    }
+    /**
+     * 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) {
+        var _a;
+        //codeboltmcp--readfile
+        const [toolboxName, actualToolName] = toolName.split('--');
+        console.log("Toolbox name: ", toolboxName, "Actual tool name: ", actualToolName);
+        const data = await ((_a = this.codebolt) === null || _a === void 0 ? void 0 : _a.mcp.executeTool(toolboxName, actualToolName, toolInput));
+        console.log("Tool result: ", data);
+        return data;
+    }
+    /**
+     * 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 {
+            // Validate content before parsing
+            if (typeof content !== 'string') {
+                throw new Error("Content must be a string");
+            }
+            // Only attempt to parse if content looks like JSON
+            if (content.trim().startsWith('{') || content.trim().startsWith('[')) {
+                const parsed = JSON.parse(content);
+                console.log("Parsed Content: ", parsed);
+                if (parsed && typeof parsed === 'object' && 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`;
+                    userMessage = parsed.payload.content;
+                }
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown JSON parsing error';
+            console.warn(`Failed to parse tool result content as JSON: ${errorMessage}. Using content as-is.`);
+            // Content is not valid JSON, use as-is
+        }
+        return {
+            role: "tool",
+            tool_call_id,
+            content,
+            userMessage
+        };
+    }
+    /**
+     * Checks if the response has tool calls.
+     *
+     * @returns True if the response contains tool calls
+     */
+    hasToolCalls() {
+        if (!this.llmResponse)
+            return false;
+        const toolCalls = this.getToolCallsFromResponse();
+        return toolCalls !== null && toolCalls.length > 0;
+    }
+    /**
+     * Gets the assistant's message content from the response.
+     *
+     * @returns The assistant's message content or null
+     */
+    getAssistantMessage() {
+        if (!this.llmResponse)
+            return null;
+        const completion = this.llmResponse.completion;
+        if (completion && completion.choices && completion.choices.length > 0) {
+            const choice = completion.choices[0];
+            if (choice.message && choice.message.content) {
+                return choice.message.content;
+            }
+        }
+        else if (completion && completion.content) {
+            return completion.content;
+        }
+        return null;
+    }
+    /**
+     * Resets the handler state for reuse.
+     */
+    reset() {
+        this.completed = false;
+        this.toolResults = [];
+        this.nextUserMessage = null;
+        this.mcpExecuted = false;
+    }
+}
+exports.LLMOutputHandler = LLMOutputHandler;

package/dist/processor/types/interfaces.d.ts

@@ -1,75 +1,52 @@
-import type { FlatUserMessage } from '@codebolt/types';
 export interface ToolCall {
-    /** Unique identifier for this tool call */
     id: string;
-    /** The type of tool call */
-    type: 'function';
-    /** Function call details */
     function: {
-        /** Name of the function to call */
         name: string;
-        /** Arguments for the function call as JSON string */
-        arguments: string;
+        arguments: string | Record<string, any>;
     };
 }
 export interface Message {
-    /** Role of the message sender */
-    role: 'system' | 'user' | 'assistant' | 'tool';
-    /** Content of the message */
-    content: string | Array<{
-        type: string;
-        text: string;
-    }>;
-    /** Optional name for the message sender */
+    role: 'user' | 'assistant' | 'tool' | 'system';
+    content: string | any[];
     name?: string;
-    /** Tool call ID for tool messages */
+    tool_calls?: ToolCall[];
     tool_call_id?: string;
-    /** Tool calls for assistant messages */
-    tool_calls?: Array<{
-        id: string;
-        type: 'function';
-        function: {
-            name: string;
-            arguments: string;
-        };
-    }>;
+    [key: string]: any;
 }
 export interface ProcessedMessage {
-    /** Array of messages in OpenAI format */
     messages: Message[];
-    /** Optional metadata about the processing */
-    metadata?: Record<string, unknown>;
+    metadata?: Record<string, any>;
 }
 export interface ProcessorInput {
     message: ProcessedMessage;
-    context?: Record<string, unknown>;
+    context?: Record<string, any>;
 }
 export interface ProcessorOutput {
     type: string;
-    value?: unknown;
+    value?: any;
 }
 export interface Processor {
     processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
-    setContext(key: string, value: unknown): void;
-    getContext(key: string): unknown;
+    setContext(key: string, value: any): void;
+    getContext(key: string): any;
     clearContext(): void;
 }
 export interface MessageModifierInput {
-    originalRequest: FlatUserMessage;
+    originalRequest: any;
     createdMessage: ProcessedMessage;
-    context?: Record<string, unknown>;
+    context?: Record<string, any>;
 }
 export interface MessageModifier {
     modify(input: MessageModifierInput): Promise<ProcessedMessage>;
-    setContext(key: string, value: unknown): void;
-    getContext(key: string): unknown;
+    setContext(key: string, value: any): void;
+    getContext(key: string): any;
     clearContext(): void;
 }
 export interface Tool {
     name: string;
     description: string;
-    parameters: Record<string, unknown>;
-    execute(params: unknown, abortSignal?: AbortSignal): Promise<unknown>;
+    parameters: Record<string, any>;
+    execute(params: any, abortSignal?: AbortSignal): Promise<any>;
 }
 export interface ToolList {
     getTool(name: string): Tool | undefined;
@@ -80,13 +57,13 @@ export interface ToolList {
 export interface AgentStepInput {
     message: ProcessedMessage;
     tools: Tool[];
-    context?: Record<string, unknown>;
+    context?: Record<string, any>;
 }
 export interface AgentStepOutput {
     response: ProcessedMessage;
     toolCalls?: Array<{
         tool: string;
-        parameters: unknown;
+        parameters: any;
     }>;
     finished: boolean;
 }
@@ -98,15 +75,15 @@ export interface IAgentStep {
 export interface ToolExecutionInput {
     toolCalls: Array<{
         tool: string;
-        parameters: unknown;
+        parameters: any;
     }>;
     tools: ToolList;
-    context?: Record<string, unknown>;
+    context?: Record<string, any>;
 }
 export interface ToolExecutionOutput {
     results: Array<{
         tool: string;
-        result: unknown;
+        result: any;
         error?: string;
     }>;
     success: boolean;

package/dist/processor-pieces/index.d.ts

@@ -1 +1,4 @@
 export * from './messageModifiers';
+export * from './pretoolCallProcessors';
+export * from './postToolCallProcessors';
+export * from './preInferenceProcessors';

package/dist/processor-pieces/index.js

@@ -57,3 +57,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 //     FileCopyTool 
 // } from './tools/fileTools';
 __exportStar(require("./messageModifiers"), exports);
+__exportStar(require("./pretoolCallProcessors"), exports);
+__exportStar(require("./postToolCallProcessors"), exports);
+__exportStar(require("./preInferenceProcessors"), exports);

package/dist/processor-pieces/messageModifiers/addToolsListMessageModifier.d.ts

@@ -1,28 +1,19 @@
-import { ProcessedMessage } from "@codebolt/types/agent";
-import { BaseMessageModifier } from "../base";
-import { FlatUserMessage, Tool } from "@codebolt/types/sdk";
-export interface ToolList {
-    getAllTools(): Tool[];
-    addTool?(tool: Tool): void;
-    removeTool?(toolName: string): void;
-    getTool?(toolName: string): Tool | undefined;
-    getToolNames?(): string[];
-}
+import { BaseMessageModifier, MessageModifierInput, ProcessedMessage, ToolList } from '../../processor';
 export interface AddToolsListMessageModifierOptions {
-    toolsList?: ToolList;
+    toolsList: ToolList;
     addToolsLocation?: 'InsidePrompt' | 'Tool' | 'SystemMessage';
     giveToolExamples?: boolean;
     maxToolExamples?: number;
     includeToolDescriptions?: boolean;
 }
 export declare class AddToolsListMessageModifier extends BaseMessageModifier {
-    private readonly toolsList?;
+    private readonly toolsList;
     private readonly addToolsLocation;
     private readonly giveToolExamples;
     private readonly maxToolExamples;
     private readonly includeToolDescriptions;
-    constructor(options?: AddToolsListMessageModifierOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    constructor(options: AddToolsListMessageModifierOptions);
+    modify(input: MessageModifierInput): Promise<ProcessedMessage>;
     private addToolsInsidePrompt;
     private addToolsAsSystemMessage;
     private addToolsAsToolCalls;