@codebolt/agent 1.1.0 → 2.2.2

package/dist/composablepattern/agent.js

@@ -0,0 +1,598 @@
+"use strict";
+/**
+ * @fileoverview Main ComposableAgent implementation
+ * @description Core agent class that provides a composable API for creating and running agents
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComposableAgent = void 0;
+exports.createAgent = createAgent;
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+// Use all relevant CodeBolt APIs
+const { chat, llm, mcp, fs } = codeboltjs_1.default;
+const tool_1 = require("./tool");
+// Import codeboltjs for accessing user message
+// The user message is now automatically saved by codeboltjs.onMessage()
+/**
+ * Main ComposableAgent class that provides a simple, composable API for creating agents
+ */
+class ComposableAgent {
+    constructor(config) {
+        this.conversation = [];
+        this.config = {
+            maxTurns: 10,
+            ...config
+        };
+        // Merge user tools with default tools
+        this.tools = {
+            ...(0, tool_1.createDefaultTools)(),
+            ...(config.tools || {})
+        };
+        this.memory = config.memory;
+        // Initialize conversation with system message
+        this.conversation = [
+            {
+                role: 'system',
+                content: config.instructions,
+                timestamp: new Date().toISOString()
+            }
+        ];
+    }
+    /**
+     * Run the agent using globally saved user context from codeboltjs
+     * This is the main method to use within codebolt.onMessage()
+     *
+     * @param options - Execution options
+     * @returns Promise<ExecutionResult>
+     */
+    async run(options = {}) {
+        var _a;
+        // Get user message from codeboltjs (automatically saved by onMessage)
+        const userMessage = (_a = codeboltjs_1.default.userMessage) === null || _a === void 0 ? void 0 : _a.getCurrent();
+        if (!userMessage) {
+            throw new Error('No user message found. Make sure this is called within codebolt.onMessage()');
+        }
+        // Convert to CodeBoltMessage format
+        const codeboltMessage = {
+            userMessage: userMessage.userMessage,
+            mentionedFiles: [
+                ...(userMessage.mentionedFiles || []),
+                ...(userMessage.mentionedFullPaths || [])
+            ],
+            mentionedMCPs: userMessage.mentionedMCPs || [],
+            mentionedAgents: userMessage.mentionedAgents || [],
+            remixPrompt: userMessage.remixPrompt
+        };
+        return this.executeMessage(codeboltMessage, options);
+    }
+    /**
+     * Execute a task with the agent using a simple string message
+     *
+     * @param message - User message to process
+     * @param options - Execution options
+     * @returns Promise<ExecutionResult>
+     */
+    async execute(message, options = {}) {
+        // Convert string to CodeBoltMessage format
+        const codeboltMessage = {
+            userMessage: message,
+            mentionedFiles: [],
+            mentionedMCPs: [],
+            mentionedAgents: []
+        };
+        return this.executeMessage(codeboltMessage, options);
+    }
+    /**
+     * Execute a task with the agent using CodeBolt Message format
+     *
+     * @param message - CodeBolt message with enhanced features
+     * @param options - Execution options
+     * @returns Promise<ExecutionResult>
+     */
+    async executeMessage(message, options = {}) {
+        var _a, _b;
+        const { stream = false, callback } = options;
+        try {
+            // Process the CodeBolt message and enhance the agent
+            await this.processCodeBoltMessage(message);
+            // Create user message for conversation
+            let messageContent = message.userMessage;
+            // Add file content if processing enabled
+            if (((_a = this.config.processing) === null || _a === void 0 ? void 0 : _a.processMentionedFiles) && ((_b = message.mentionedFiles) === null || _b === void 0 ? void 0 : _b.length)) {
+                const fileContents = await this.processFiles(message.mentionedFiles);
+                if (fileContents.length > 0) {
+                    messageContent += '\n\nReferenced files:\n' + fileContents.join('\n\n');
+                }
+            }
+            const userMessage = {
+                role: 'user',
+                content: messageContent,
+                timestamp: new Date().toISOString()
+            };
+            this.addMessage(userMessage);
+            let turnCount = 0;
+            let completed = false;
+            let lastAssistantMessage = '';
+            while (!completed && turnCount < (this.config.maxTurns || 10)) {
+                turnCount++;
+                if (stream && callback) {
+                    await callback({
+                        type: 'text',
+                        content: `\n--- Turn ${turnCount} ---\n`
+                    });
+                }
+                // Make LLM request
+                const response = await this.makeLLMRequest();
+                if (!response || !response.choices || response.choices.length === 0) {
+                    throw new Error('No response from LLM');
+                }
+                const choice = response.choices[0];
+                const assistantMessage = choice.message;
+                if (!assistantMessage) {
+                    throw new Error('No message in LLM response');
+                }
+                // Add assistant message to conversation
+                this.addMessage(assistantMessage);
+                // Store content for return
+                if (assistantMessage.content) {
+                    lastAssistantMessage = Array.isArray(assistantMessage.content)
+                        ? assistantMessage.content.map((c) => c.text || '').join('')
+                        : assistantMessage.content;
+                }
+                // Send message to chat if it has content
+                if (lastAssistantMessage && !stream) {
+                    await chat.sendMessage(lastAssistantMessage, {});
+                }
+                if (stream && callback && lastAssistantMessage) {
+                    await callback({
+                        type: 'text',
+                        content: lastAssistantMessage
+                    });
+                }
+                // Handle tool calls
+                if (assistantMessage.tool_calls && assistantMessage.tool_calls.length > 0) {
+                    const toolResults = [];
+                    for (const toolCall of assistantMessage.tool_calls) {
+                        if (stream && callback) {
+                            await callback({
+                                type: 'tool_call',
+                                content: `Calling tool: ${toolCall.function.name}`,
+                                tool_call: toolCall
+                            });
+                        }
+                        const result = await this.executeToolCall(toolCall);
+                        toolResults.push(result);
+                        if (stream && callback) {
+                            await callback({
+                                type: 'tool_result',
+                                content: result.content,
+                                tool_call: toolCall
+                            });
+                        }
+                        // Check if task was completed
+                        if (toolCall.function.name === 'attempt_completion') {
+                            completed = true;
+                        }
+                    }
+                    // Add tool results to conversation
+                    toolResults.forEach(result => this.addMessage(result));
+                }
+                else {
+                    // No tool calls, assume we need to continue or complete
+                    const continueMessage = {
+                        role: 'user',
+                        content: 'If you have completed the task, use the attempt_completion tool. If you need more information, use the ask_followup_question tool. Otherwise, continue with the next step.',
+                        timestamp: new Date().toISOString()
+                    };
+                    this.addMessage(continueMessage);
+                }
+            }
+            // Save conversation to memory if configured
+            if (this.memory) {
+                await this.saveConversation();
+            }
+            return {
+                success: completed || turnCount >= (this.config.maxTurns || 10),
+                message: lastAssistantMessage,
+                conversation: [...this.conversation],
+                metadata: {
+                    turnCount,
+                    completed,
+                    toolsUsed: this.getUsedTools()
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                conversation: [...this.conversation]
+            };
+        }
+    }
+    /**
+     * Add a message to the conversation
+     *
+     * @param message - Message to add
+     */
+    addMessage(message) {
+        this.conversation.push({
+            ...message,
+            timestamp: message.timestamp || new Date().toISOString()
+        });
+    }
+    /**
+     * Get conversation history
+     *
+     * @returns Array of messages
+     */
+    getConversation() {
+        return [...this.conversation];
+    }
+    /**
+     * Clear conversation history (keeps system message)
+     */
+    clearConversation() {
+        const systemMessage = this.conversation.find(msg => msg.role === 'system');
+        this.conversation = systemMessage ? [systemMessage] : [];
+    }
+    /**
+     * Save conversation to memory
+     */
+    async saveConversation() {
+        if (!this.memory)
+            return;
+        await this.memory.saveMessages(this.conversation);
+    }
+    /**
+     * Load conversation from memory
+     */
+    async loadConversation() {
+        if (!this.memory)
+            return;
+        const messages = await this.memory.loadMessages();
+        if (messages.length > 0) {
+            this.conversation = messages;
+        }
+    }
+    /**
+     * Make a request to the LLM
+     *
+     * @returns LLM response
+     */
+    async makeLLMRequest() {
+        try {
+            // Prepare messages for API
+            const apiMessages = this.conversation.map(msg => ({
+                role: msg.role,
+                content: msg.content,
+                tool_calls: msg.tool_calls,
+                tool_call_id: msg.tool_call_id
+            }));
+            // Prepare tools for API
+            const openAITools = (0, tool_1.toolsToOpenAIFunctions)(this.tools);
+            const createParams = {
+                full: true,
+                messages: apiMessages,
+                tools: openAITools,
+                tool_choice: 'auto',
+                llmrole: this.config.model // Use model name as llmrole for CodeBolt inference
+            };
+            // Use CodeBolt's LLM inference API - no custom logic needed
+            const { completion } = await llm.inference(createParams);
+            return completion;
+        }
+        catch (error) {
+            console.error('LLM request failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Execute a tool call
+     *
+     * @param toolCall - Tool call to execute
+     * @returns Tool result message
+     */
+    async executeToolCall(toolCall) {
+        try {
+            const toolName = toolCall.function.name;
+            // Parse arguments
+            let args;
+            try {
+                args = JSON.parse(toolCall.function.arguments);
+            }
+            catch (error) {
+                return {
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    content: `Error: Invalid tool arguments: ${toolCall.function.arguments}`,
+                    timestamp: new Date().toISOString()
+                };
+            }
+            // Check if this is a custom tool first
+            if (this.tools[toolName]) {
+                const result = await (0, tool_1.executeTool)(this.tools[toolName], args, this);
+                return {
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    content: result.success
+                        ? JSON.stringify(result.result)
+                        : `Error: ${result.error}`,
+                    timestamp: new Date().toISOString()
+                };
+            }
+            // Try to execute as MCP tool using CodeBolt API
+            try {
+                // Parse toolbox--toolName format or guess structure
+                let toolbox, actualToolName;
+                if (toolName.includes('--')) {
+                    [toolbox, actualToolName] = toolName.split('--');
+                }
+                else if (toolName.includes('_')) {
+                    // Handle tool_name format
+                    const parts = toolName.split('_');
+                    toolbox = parts[0];
+                    actualToolName = parts.slice(1).join('_');
+                }
+                else {
+                    // Assume single word tools belong to 'codebolt' toolbox
+                    toolbox = 'codebolt';
+                    actualToolName = toolName;
+                }
+                const mcpResult = await mcp.executeTool(toolbox, actualToolName, args);
+                return {
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    content: JSON.stringify(mcpResult.data || mcpResult),
+                    timestamp: new Date().toISOString()
+                };
+            }
+            catch (mcpError) {
+                // If MCP execution fails, return error
+                return {
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    content: `Error: Tool '${toolName}' not found in custom tools or MCP toolboxes. ${mcpError.message}`,
+                    timestamp: new Date().toISOString()
+                };
+            }
+        }
+        catch (error) {
+            return {
+                role: 'tool',
+                tool_call_id: toolCall.id,
+                content: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+    /**
+     * Get list of tools that were used in the conversation
+     *
+     * @returns Array of tool names
+     */
+    getUsedTools() {
+        const usedTools = new Set();
+        for (const message of this.conversation) {
+            if (message.tool_calls) {
+                for (const toolCall of message.tool_calls) {
+                    usedTools.add(toolCall.function.name);
+                }
+            }
+        }
+        return Array.from(usedTools);
+    }
+    /**
+     * Get available tools
+     *
+     * @returns Record of available tools
+     */
+    getTools() {
+        return { ...this.tools };
+    }
+    /**
+     * Add a tool to the agent
+     *
+     * @param name - Tool name
+     * @param tool - Tool instance
+     */
+    addTool(name, tool) {
+        this.tools[name] = tool;
+    }
+    /**
+     * Remove a tool from the agent
+     *
+     * @param name - Tool name
+     */
+    removeTool(name) {
+        delete this.tools[name];
+    }
+    /**
+     * Get execution context for tools
+     *
+     * @returns ExecutionContext
+     */
+    getExecutionContext() {
+        return {
+            messages: [...this.conversation],
+            tools: { ...this.tools },
+            config: { ...this.config }
+        };
+    }
+    /**
+     * Process CodeBolt message and enhance agent capabilities
+     *
+     * @param message - CodeBolt message to process
+     */
+    async processCodeBoltMessage(message) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const processing = this.config.processing || {};
+        const userConfig = ((_a = codeboltjs_1.default.userMessage) === null || _a === void 0 ? void 0 : _a.getProcessingConfig()) || {};
+        // Merge agent config with global user config from codeboltjs
+        const shouldProcessMCPs = (_c = (_b = processing.processMentionedMCPs) !== null && _b !== void 0 ? _b : userConfig.processMentionedMCPs) !== null && _c !== void 0 ? _c : false;
+        const shouldProcessRemix = (_e = (_d = processing.processRemixPrompt) !== null && _d !== void 0 ? _d : userConfig.processRemixPrompt) !== null && _e !== void 0 ? _e : false;
+        const shouldProcessAgents = (_g = (_f = processing.processMentionedAgents) !== null && _f !== void 0 ? _f : userConfig.processMentionedAgents) !== null && _g !== void 0 ? _g : false;
+        // Process remix prompt to enhance system instructions
+        if (shouldProcessRemix && message.remixPrompt) {
+            await this.processRemixPrompt(message.remixPrompt);
+        }
+        // Process mentioned MCPs and add as tools
+        if (shouldProcessMCPs && message.mentionedMCPs.length > 0) {
+            await this.processMCPs(message.mentionedMCPs);
+        }
+        // Process mentioned agents and add as sub-agent tools
+        if (shouldProcessAgents && message.mentionedAgents.length > 0) {
+            await this.processAgents(message.mentionedAgents);
+        }
+    }
+    /**
+     * Process remix prompt and enhance system instructions
+     *
+     * @param remixPrompt - Additional instructions to add to system prompt
+     */
+    async processRemixPrompt(remixPrompt) {
+        // Find the system message and enhance it
+        const systemMessageIndex = this.conversation.findIndex(msg => msg.role === 'system');
+        if (systemMessageIndex !== -1) {
+            const currentSystemMessage = this.conversation[systemMessageIndex];
+            const enhancedContent = `${currentSystemMessage.content}\n\n--- Enhanced Instructions ---\n${remixPrompt}`;
+            this.conversation[systemMessageIndex] = {
+                ...currentSystemMessage,
+                content: enhancedContent,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+    /**
+     * Process mentioned MCP tools and add them to available tools
+     *
+     * @param mentionedMCPs - List of MCP tools to process
+     */
+    async processMCPs(mentionedMCPs) {
+        const processing = this.config.processing || {};
+        for (const mcp of mentionedMCPs) {
+            try {
+                let tool = null;
+                // Use custom processor if provided
+                if (processing.mcpToolProcessor) {
+                    tool = await processing.mcpToolProcessor(mcp.toolbox, mcp.toolName);
+                }
+                else {
+                    // Default MCP processing - create a generic tool
+                    tool = this.createMCPTool(mcp.toolbox, mcp.toolName);
+                }
+                if (tool) {
+                    this.tools[`${mcp.toolbox}--${mcp.toolName}`] = tool;
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to process MCP tool ${mcp.toolbox}--${mcp.toolName}:`, error);
+            }
+        }
+    }
+    /**
+     * Create a generic MCP tool wrapper
+     *
+     * @param toolbox - MCP toolbox name
+     * @param toolName - MCP tool name
+     * @returns Tool instance
+     */
+    createMCPTool(toolbox, toolName) {
+        return {
+            id: `${toolbox}--${toolName}`,
+            description: `MCP tool ${toolName} from ${toolbox} toolbox`,
+            inputSchema: require('zod').record(require('zod').any()),
+            outputSchema: require('zod').any(),
+            validateInput: (input) => input,
+            validateOutput: (output) => output,
+            execute: async ({ context }) => {
+                // Use CodeBolt's MCP system to execute the tool
+                const { mcp } = codeboltjs_1.default;
+                const result = await mcp.executeTool(toolbox, toolName, context);
+                return result.data || result;
+            }
+        };
+    }
+    /**
+     * Process mentioned agents and add them as sub-agent tools
+     *
+     * @param mentionedAgents - List of agents to process
+     */
+    async processAgents(mentionedAgents) {
+        for (const agent of mentionedAgents) {
+            try {
+                const agentTool = this.createSubAgentTool(agent);
+                this.tools[`subagent--${agent.unique_id || agent.id}`] = agentTool;
+            }
+            catch (error) {
+                console.warn(`Failed to process sub-agent ${agent.unique_id || agent.id}:`, error);
+            }
+        }
+    }
+    /**
+     * Create a sub-agent tool wrapper
+     *
+     * @param agent - Agent information
+     * @returns Tool instance
+     */
+    createSubAgentTool(agent) {
+        return {
+            id: `subagent--${agent.unique_id || agent.id}`,
+            description: agent.longDescription || agent.description || `Sub-agent: ${agent.name}`,
+            inputSchema: require('zod').object({
+                task: require('zod').string().describe('The task to be executed by the sub-agent')
+            }),
+            outputSchema: require('zod').string(),
+            validateInput: (input) => input,
+            validateOutput: (output) => output,
+            execute: async ({ context }) => {
+                // Use CodeBolt's agent system to execute the sub-agent
+                const { agent: codeboltAgent } = codeboltjs_1.default;
+                const result = await codeboltAgent.startAgent(agent.unique_id || agent.id, context.task);
+                return result;
+            }
+        };
+    }
+    /**
+     * Process mentioned files and return their contents
+     *
+     * @param mentionedFiles - List of file paths
+     * @returns Array of file contents with headers
+     */
+    async processFiles(mentionedFiles) {
+        const processing = this.config.processing || {};
+        const fileContents = [];
+        for (const filePath of mentionedFiles) {
+            try {
+                let content;
+                if (processing.fileContentProcessor) {
+                    content = await processing.fileContentProcessor(filePath);
+                }
+                else {
+                    // Default file processing using CodeBolt's filesystem
+                    const { fs } = codeboltjs_1.default;
+                    const result = await fs.readFile(filePath);
+                    content = result.data || '';
+                }
+                fileContents.push(`--- File: ${filePath} ---\n${content}`);
+            }
+            catch (error) {
+                console.warn(`Failed to read file ${filePath}:`, error);
+                fileContents.push(`--- File: ${filePath} ---\n[Error reading file: ${error}]`);
+            }
+        }
+        return fileContents;
+    }
+}
+exports.ComposableAgent = ComposableAgent;
+/**
+ * Create a new ComposableAgent instance
+ *
+ * @param config - Agent configuration
+ * @returns ComposableAgent instance
+ */
+function createAgent(config) {
+    return new ComposableAgent(config);
+}

package/dist/composablepattern/codebolt-storage.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @fileoverview CodeBolt Backend Storage Provider for Composable Agent Pattern
+ * @description Uses CodeBolt's state and memory functions instead of SQLite for storage
+ */
+import type { StorageProvider } from './types';
+/**
+ * Storage provider that uses CodeBolt's agent state backend
+ * Data is persisted in the CodeBolt application's agent state
+ */
+export declare class CodeBoltAgentStore implements StorageProvider {
+    private prefix;
+    constructor(prefix?: string);
+    private getFullKey;
+    get(key: string): Promise<any>;
+    set(key: string, value: any): Promise<void>;
+    delete(key: string): Promise<void>;
+    keys(): Promise<string[]>;
+    clear(): Promise<void>;
+}
+/**
+ * Storage provider that uses CodeBolt's in-memory database (dbmemory)
+ * Data is persisted in the CodeBolt application's memory database
+ */
+export declare class CodeBoltMemoryStore implements StorageProvider {
+    private prefix;
+    constructor(prefix?: string);
+    private getFullKey;
+    get(key: string): Promise<any>;
+    set(key: string, value: any): Promise<void>;
+    delete(key: string): Promise<void>;
+    keys(): Promise<string[]>;
+    clear(): Promise<void>;
+    /**
+     * Override set to maintain key index
+     */
+    setWithIndex(key: string, value: any): Promise<void>;
+}
+/**
+ * Storage provider that uses CodeBolt's project state backend
+ * Data is persisted in the CodeBolt application's project state
+ */
+export declare class CodeBoltProjectStore implements StorageProvider {
+    private prefix;
+    constructor(prefix?: string);
+    private getFullKey;
+    get(key: string): Promise<any>;
+    set(key: string, value: any): Promise<void>;
+    delete(key: string): Promise<void>;
+    keys(): Promise<string[]>;
+    clear(): Promise<void>;
+}
+/**
+ * Configuration for CodeBolt storage providers
+ */
+export interface CodeBoltStoreConfig {
+    /** Storage type to use */
+    type: 'agent' | 'memory' | 'project';
+    /** Prefix for storage keys to avoid conflicts */
+    prefix?: string;
+}
+/**
+ * Factory function to create appropriate CodeBolt storage provider
+ *
+ * @param config - Storage configuration
+ * @returns StorageProvider instance
+ */
+export declare function createCodeBoltStore(config: CodeBoltStoreConfig): StorageProvider;