@codebolt/agent 1.2.1 → 2.2.2

package/dist/unified/base/agentStep.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentStep = void 0;
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+/**
+ * Unified agent step that handles LLM interaction and tool call analysis
+ */
+class AgentStep {
+    constructor(options = {}) {
+        this.preInferenceProcessors = options.preInferenceProcessors || [];
+        this.postInferenceProcessors = options.postInferenceProcessors || [];
+        this.llmRole = options.llmRole || 'default';
+    }
+    /**
+     * Execute a single agent step
+     */
+    async executeStep(originalRequest, createdMessage) {
+        var _a;
+        try {
+            for (const preInferenceProcessor of this.preInferenceProcessors) {
+                try {
+                    // Each modifier returns a new ProcessedMessage
+                    createdMessage = await preInferenceProcessor.modify(originalRequest, createdMessage);
+                }
+                catch (error) {
+                    console.error(`[InitialPromptGenerator] Error in message modifier:`, error);
+                    // Continue with other modifiers
+                }
+            }
+            // Generate LLM response
+            const rawLLMResponse = await this.generateResponse(createdMessage.message);
+            // add llm reslponse to created message
+            let modifiedMessage = createdMessage;
+            (_a = rawLLMResponse.choices) === null || _a === void 0 ? void 0 : _a.forEach(contentBlock => {
+                modifiedMessage.message.messages.push({
+                    ...contentBlock.message,
+                    role: contentBlock.message.role
+                });
+            });
+            for (const postInferenceProcessor of this.postInferenceProcessors) {
+                try {
+                    // Each modifier returns a new ProcessedMessage
+                    modifiedMessage = await postInferenceProcessor.modify(createdMessage, rawLLMResponse, modifiedMessage);
+                }
+                catch (error) {
+                    console.error(`[InitialPromptGenerator] Error in message modifier:`, error);
+                    // Continue with other modifiers
+                }
+            }
+            const output = {
+                rawLLMResponse: rawLLMResponse,
+                nextMessage: modifiedMessage,
+                actualMessageSentToLLM: createdMessage
+            };
+            return output;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            throw new Error(`Failed to execute agent step: ${errorMessage}`);
+        }
+    }
+    async generateResponse(messageForLLM) {
+        const response = await codeboltjs_1.default.llm.inference(messageForLLM);
+        return response.completion;
+    }
+    /**
+     * Update LLM configuration
+     */
+    setLLMConfig(config) {
+        this.llmRole = config;
+    }
+    /**
+     * Get current LLM configuration
+     */
+    getLLMConfig() {
+        return this.llmRole;
+    }
+    updatePreInferenceProcessors(processors) {
+        this.preInferenceProcessors = processors;
+    }
+    ;
+    getPreInferenceProcessors() {
+        return this.preInferenceProcessors;
+    }
+    updatePostInferenceProcessors(processors) {
+        this.postInferenceProcessors = processors;
+    }
+    ;
+    getPostInferenceProcessors() {
+        return this.postInferenceProcessors;
+    }
+}
+exports.AgentStep = AgentStep;

package/dist/unified/base/create/createInitialPromptGenerators.d.ts

@@ -0,0 +1,5 @@
+import { InitialPromptGeneratorInterface } from "@codebolt/types/agent";
+/**
+ * Utility function to create a basic message processor with default settings
+ */
+export declare function createDefaultMessageProcessor(): InitialPromptGeneratorInterface;

package/dist/unified/base/create/createInitialPromptGenerators.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultMessageProcessor = createDefaultMessageProcessor;
+const initialPromptGenerator_1 = require("../initialPromptGenerator");
+/**
+ * Utility function to create a basic message processor with default settings
+ */
+function createDefaultMessageProcessor() {
+    return new initialPromptGenerator_1.InitialPromptGenerator({
+        enableLogging: true,
+        processors: [], //TODO add some default processors here
+        metaData: {
+            timestamp: new Date().toISOString(),
+            version: '1.0.0'
+        }
+    });
+}

package/dist/unified/base/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unified Base Classes Index
+ * Exports core unified framework classes
+ */
+export { InitialPromptGenerator } from './initialPromptGenerator';

package/dist/unified/base/index.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * Unified Base Classes Index
+ * Exports core unified framework classes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitialPromptGenerator = void 0;
+// Core unified framework classes
+var initialPromptGenerator_1 = require("./initialPromptGenerator");
+Object.defineProperty(exports, "InitialPromptGenerator", { enumerable: true, get: function () { return initialPromptGenerator_1.InitialPromptGenerator; } });
+// export { default as AgentStep } from './agentStep';
+// Response executor functions
+// export { createUnifiedResponseExecutor, createBasicResponseExecutor } from './responseExecutor';

package/dist/unified/base/initialPromptGenerator.d.ts

@@ -0,0 +1,48 @@
+import type { FlatUserMessage } from '@codebolt/types/sdk';
+import type { InitialPromptGeneratorInterface, MessageModifier, ProcessedMessage } from '@codebolt/types/agent';
+/**
+ * Initial prompt generator that combines message modifiers with unified processing
+ */
+export declare class InitialPromptGenerator implements InitialPromptGeneratorInterface {
+    private processors;
+    private metaData;
+    private enableLogging;
+    private baseSystemPrompt?;
+    constructor(options?: {
+        processors?: MessageModifier[];
+        baseSystemPrompt?: string;
+        metaData?: Record<string, unknown>;
+        enableLogging?: boolean;
+        templating?: boolean;
+    });
+    /**
+     * Process and modify input messages using the message modifier pattern
+     */
+    processMessage(input: FlatUserMessage): Promise<ProcessedMessage>;
+    /**
+     * Set context value
+     */
+    setMetaData(key: string, value: unknown): void;
+    /**
+     * Get context value
+     */
+    getMetaData(key: string): unknown;
+    /**
+     * Clear all context
+     */
+    clearMetaData(): void;
+    /**
+     * Get all message modifiers
+     */
+    updateProcessors(processors: MessageModifier[]): void;
+    getProcessors(): MessageModifier[];
+}
+/**
+ * Factory function to create a unified message processor with message modifiers
+ */
+export declare function createUnifiedMessageProcessor(options?: {
+    processors?: MessageModifier[];
+    baseSystemPrompt?: string;
+    metaData?: Record<string, unknown>;
+    enableLogging?: boolean;
+}): InitialPromptGeneratorInterface;

package/dist/unified/base/initialPromptGenerator.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitialPromptGenerator = void 0;
+exports.createUnifiedMessageProcessor = createUnifiedMessageProcessor;
+const types_1 = require("../types/types");
+/**
+ * Initial prompt generator that combines message modifiers with unified processing
+ */
+class InitialPromptGenerator {
+    constructor(options = {}) {
+        this.processors = [];
+        this.metaData = {};
+        this.processors = options.processors || [];
+        this.metaData = options.metaData || {};
+        this.enableLogging = options.enableLogging !== false;
+        this.baseSystemPrompt = options.baseSystemPrompt;
+    }
+    /**
+     * Process and modify input messages using the message modifier pattern
+     */
+    async processMessage(input) {
+        try {
+            if (this.enableLogging) {
+                console.log('[InitialPromptGenerator] Processing message:', input);
+            }
+            // Create initial ProcessedMessage from FlatUserMessage
+            const content = input.userMessage;
+            // Create messages array, starting with system message if baseSystemPrompt is defined
+            const messages = [];
+            let createdMessage = {
+                message: {
+                    messages: messages,
+                    tools: []
+                },
+                metadata: {
+                    timestamp: new Date().toISOString(),
+                    messageId: input.messageId,
+                    threadId: input.threadId
+                }
+            };
+            // Apply all message modifiers in sequence
+            // Each modifier receives the original request (FlatUserMessage) and the current processed message
+            for (const messageModifier of this.processors) {
+                try {
+                    // Each modifier returns a new ProcessedMessage
+                    createdMessage = await messageModifier.modify(input, createdMessage);
+                }
+                catch (error) {
+                    console.error(`[InitialPromptGenerator] Error in message modifier:`, error);
+                    // Continue with other modifiers
+                }
+            }
+            createdMessage.message.messages.push({
+                role: 'assistant',
+                content: "Got it. Thanks for the context!"
+            });
+            createdMessage.message.messages.push({
+                role: 'user',
+                content: content.trim()
+            });
+            if (this.enableLogging) {
+                console.log('[InitialPromptGenerator] Processing completed:', {
+                    messageCount: createdMessage.message.messages.length,
+                    metadata: createdMessage.metadata
+                });
+            }
+            if (this.baseSystemPrompt !== undefined) {
+                const hasSystem = createdMessage.message.messages.some(msg => msg.role === 'system');
+                if (!hasSystem) {
+                    createdMessage.message.messages.unshift({
+                        role: 'system',
+                        content: this.baseSystemPrompt
+                    });
+                }
+            }
+            return createdMessage;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            throw new types_1.UnifiedMessageProcessingError(`Failed to process message: ${errorMessage}`);
+        }
+    }
+    /**
+     * Set context value
+     */
+    setMetaData(key, value) {
+        this.metaData[key] = value;
+    }
+    /**
+     * Get context value
+     */
+    getMetaData(key) {
+        return this.metaData[key];
+    }
+    /**
+     * Clear all context
+     */
+    clearMetaData() {
+        this.metaData = {};
+    }
+    /**
+     * Get all message modifiers
+     */
+    updateProcessors(processors) {
+        this.processors = processors;
+    }
+    ;
+    getProcessors() {
+        return this.processors;
+    }
+}
+exports.InitialPromptGenerator = InitialPromptGenerator;
+/**
+ * Factory function to create a unified message processor with message modifiers
+ */
+function createUnifiedMessageProcessor(options = {}) {
+    return new InitialPromptGenerator(options);
+}

package/dist/unified/base/responseExecutor.d.ts

@@ -0,0 +1,36 @@
+import { AgentResponseExecutor, PostToolCallProcessor, PreToolCallProcessor, ResponseInput, ResponseOutput } from '@codebolt/types/agent';
+export declare class ResponseExecutor implements AgentResponseExecutor {
+    private preToolCalProcessors;
+    private postToolCallProcessors;
+    private completed;
+    constructor(options: {
+        preToolCalProcessors: PreToolCallProcessor[];
+        postToolCallProcessors: PostToolCallProcessor[];
+    });
+    executeResponse(input: ResponseInput): Promise<ResponseOutput>;
+    /**
+   * Extract tool details from tool call
+   */
+    private getToolDetail;
+    private executeTools;
+    /**
+     * 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 parseToolResult;
+    setPreToolCallProcessors(processors: PreToolCallProcessor[]): void;
+    setPostToolCallProcessors(processors: PostToolCallProcessor[]): void;
+    getPreToolCallProcessors(): PreToolCallProcessor[];
+    getPostToolCallProcessors(): PostToolCallProcessor[];
+}

package/dist/unified/base/responseExecutor.js

@@ -0,0 +1,283 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseExecutor = void 0;
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+class ResponseExecutor {
+    constructor(options) {
+        this.preToolCalProcessors = [];
+        this.postToolCallProcessors = [];
+        this.completed = false;
+        this.preToolCalProcessors = options.preToolCalProcessors;
+        this.postToolCallProcessors = options.postToolCallProcessors;
+    }
+    async executeResponse(input) {
+        let nextMessage = input.nextMessage;
+        for (const preToolCallProcessor of this.preToolCalProcessors) {
+            try {
+                // TODO: Extract required properties from input for PreToolCallProcessorInput
+                let { nextPrompt, shouldExit } = await preToolCallProcessor.modify({ llmMessageSent: input.actualMessageSentToLLM, rawLLMResponseMessage: input.rawLLMOutput, nextPrompt: input.nextMessage });
+                nextMessage = nextPrompt;
+                if (shouldExit) {
+                    this.completed = true;
+                    Promise.resolve({
+                        nextPrompt,
+                        completed: this.completed
+                    });
+                }
+            }
+            catch (error) {
+                console.error(`[InitialPromptGenerator] Error in message modifier:`, error);
+                // Continue with other modifiers
+            }
+        }
+        //ToolCall here
+        let toolResults = await this.executeTools(input.rawLLMOutput);
+        // INSERT_YOUR_CODE
+        if (nextMessage && toolResults && toolResults.length > 0 && nextMessage && nextMessage.message && Array.isArray(nextMessage.message.messages)) {
+            for (const toolResult of toolResults) {
+                const messageObject = {
+                    role: toolResult.role,
+                    content: typeof toolResult.content === 'string' ? toolResult.content : JSON.stringify(toolResult.content),
+                    tool_call_id: toolResult.tool_call_id
+                };
+                nextMessage.message.messages.push(messageObject);
+            }
+        }
+        else {
+            // this.completed=true;
+            nextMessage.message.messages.push({
+                role: "user",
+                content: [{
+                        type: "text",
+                        text: "If you have completed the user's task, use the attempt_completion tool. 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.)"
+                    }]
+            });
+        }
+        for (const postToolCallProcessor of this.postToolCallProcessors) {
+            try {
+                // TODO: Extract required properties from input for PreToolCallProcessorInput
+                let { nextPrompt, shouldExit } = await postToolCallProcessor.modify({
+                    llmMessageSent: input.actualMessageSentToLLM,
+                    rawLLMResponseMessage: input.rawLLMOutput,
+                    nextPrompt: input.nextMessage,
+                    toolResults: []
+                });
+                if (shouldExit) {
+                    this.completed = true;
+                    Promise.resolve({
+                        nextPrompt,
+                        completed: this.completed
+                    });
+                }
+            }
+            catch (error) {
+                console.error(`[InitialPromptGenerator] Error in message modifier:`, error);
+                // Continue with other modifiers
+            }
+        }
+        return {
+            completed: this.completed,
+            nextMessage: nextMessage,
+            toolResults: toolResults
+        };
+    }
+    /**
+   * Extract tool details from tool call
+   */
+    getToolDetail(tool) {
+        let toolInput = {};
+        if (tool.function.arguments) {
+            try {
+                toolInput = JSON.parse(tool.function.arguments);
+            }
+            catch (parseError) {
+                throw new Error(`Failed to parse tool arguments: ${parseError}`);
+            }
+        }
+        return {
+            toolName: tool.function.name,
+            toolInput: toolInput,
+            toolUseId: tool.id
+        };
+    }
+    async executeTools(llmResponse) {
+        var _a, _b;
+        try {
+            let fallBackMessages = [];
+            for (const contentBlock of llmResponse.choices || []) {
+                if (contentBlock.message) {
+                    if (contentBlock.message.content != null) {
+                        await codeboltjs_1.default.chat.sendMessage(contentBlock.message.content, {});
+                    }
+                }
+            }
+            try {
+                let toolResults = [];
+                let taskCompletedBlock;
+                let userRejectedToolUse = false;
+                const contentBlock = (_a = llmResponse.choices) === null || _a === void 0 ? void 0 : _a[0];
+                if (contentBlock && ((_b = contentBlock.message) === null || _b === void 0 ? void 0 : _b.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;
+                                    this.completed = true;
+                                }
+                                else {
+                                    let [serverName] = toolName.replace('--', ':').split(':');
+                                    if (serverName == 'subagent') {
+                                        const agentResponse = await codeboltjs_1.default.agent.startAgent(toolName.replace("subagent--", ''), toolInput.task);
+                                        const [didUserReject, result] = [false, "tool result is successful"];
+                                        let toolResult = this.parseToolResult(toolUseId, result);
+                                        toolResults.push({
+                                            role: "tool",
+                                            tool_call_id: toolResult.tool_call_id,
+                                            content: toolResult.content,
+                                        });
+                                        if (toolResult.userMessage) {
+                                            fallBackMessages.push({
+                                                role: "user",
+                                                content: toolResult.userMessage.toString()
+                                            });
+                                        }
+                                        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.parseToolResult(toolUseId, result));
+                                        let toolResult = this.parseToolResult(toolUseId, result);
+                                        toolResults.push({
+                                            role: "tool",
+                                            tool_call_id: toolResult.tool_call_id,
+                                            content: toolResult.content,
+                                        });
+                                        if (toolResult.userMessage) {
+                                            fallBackMessages.push({
+                                                role: "user",
+                                                content: toolResult.userMessage.toString()
+                                            });
+                                        }
+                                        if (didUserReject) {
+                                            userRejectedToolUse = true;
+                                        }
+                                    }
+                                }
+                            }
+                            else {
+                                let toolResult = this.parseToolResult(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) {
+                                    fallBackMessages.push({
+                                        role: "user",
+                                        content: toolResult.userMessage.toString()
+                                    });
+                                }
+                            }
+                        }
+                        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 === "") {
+                        // this.completed = true;
+                        result = "The user is satisfied with the result.";
+                    }
+                    let toolResult = this.parseToolResult(taskCompletedBlock.id, result);
+                    toolResults.push({
+                        role: "tool",
+                        tool_call_id: toolResult.tool_call_id,
+                        content: toolResult.content,
+                    });
+                    if (toolResult.userMessage) {
+                        fallBackMessages.push({
+                            role: "user",
+                            content: toolResult.userMessage.toString()
+                        });
+                    }
+                }
+                return toolResults;
+            }
+            catch (error) {
+            }
+        }
+        catch (error) {
+        }
+        return [];
+    }
+    /**
+     * 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) {
+        //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 codeboltjs_1.default.mcp.executeTool(toolboxName, actualToolName, toolInput);
+        console.log("Tool result: ", data);
+        return [false, 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
+     */
+    parseToolResult(tool_call_id, content) {
+        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()
+                userMessage = parsed.payload.content;
+            }
+        }
+        catch (error) {
+        }
+        return {
+            role: "tool",
+            tool_call_id,
+            content,
+            userMessage
+        };
+    }
+    setPreToolCallProcessors(processors) {
+        this.preToolCalProcessors = processors;
+    }
+    setPostToolCallProcessors(processors) {
+        this.postToolCallProcessors = processors;
+    }
+    getPreToolCallProcessors() {
+        return this.preToolCalProcessors;
+    }
+    getPostToolCallProcessors() {
+        return this.postToolCallProcessors;
+    }
+}
+exports.ResponseExecutor = ResponseExecutor;

package/dist/unified/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Unified Agent Framework
+ *
+ * This module provides a unified approach to agent development that combines:
+ * - Message modification using the processor pattern
+ * - Agent step execution with LLM integration
+ * - Response execution with tool handling and conversation management
+ *
+ * The framework is designed to be modular, extensible, and easy to use.
+ */
+export type { UnifiedAgentConfig, UnifiedMessageOutput, UnifiedStepInput, UnifiedStepOutput, UnifiedResponseInput, UnifiedResponseOutput, UnifiedAgentInput, UnifiedAgentOutput, UnifiedMessageModifier, UnifiedResponseExecutor, UnifiedAgentEvent, UnifiedAgentEventHandler, UnifiedAgentEventType } from './types/types';
+export { UnifiedAgentError, UnifiedMessageProcessingError, UnifiedStepExecutionError, UnifiedResponseExecutionError, UnifiedToolExecutionError } from './types/types';
+export { createDefaultMessageProcessor } from './base/create/createInitialPromptGenerators';
+export { InitialPromptGenerator } from './base/initialPromptGenerator';
+export { AgentStep } from './base/agentStep';
+export { ResponseExecutor } from './base/responseExecutor';
+export { type OpenAIMessage, type OpenAITool, type ToolResult, type CodeboltAPI, type AgentExecutionResult, type StreamChunk, type StreamCallback } from './types/libTypes';
+export { type LLMConfig } from './types/libTypes';