@codebolt/agent 5.0.7 → 5.0.9

package/dist/composablepattern/agent.js

@@ -1,598 +0,0 @@
-"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

@@ -1,67 +0,0 @@
-/**
- * @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;