@codebolt/agent 1.2.1 → 2.2.3

package/dist/processor-pieces/postToolCall/toolExecutionProcessor.js

@@ -0,0 +1,207 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolExecutionProcessor = void 0;
+const processor_1 = require("../../processor");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+class ToolExecutionProcessor extends processor_1.BaseProcessor {
+    constructor(options = {}) {
+        super(options);
+        this.executedTools = new Map();
+        this.enableToolConfirmation = options.enableToolConfirmation !== false;
+        this.maxRetries = options.maxRetries || 3;
+        this.retryDelay = options.retryDelay || 1000;
+        this.enableLogging = options.enableLogging !== false;
+    }
+    async processInput(input) {
+        try {
+            const { message, context } = input;
+            // Check if message contains tool calls
+            const toolCalls = this.extractToolCalls(message);
+            if (toolCalls.length === 0) {
+                return [this.createEvent('NoToolCalls', {
+                        reason: 'No tool calls found in message'
+                    })];
+            }
+            const events = [
+                this.createEvent('ToolCallsDetected', {
+                    count: toolCalls.length,
+                    tools: toolCalls.map(tc => tc.function.name)
+                })
+            ];
+            // Process each tool call
+            for (const toolCall of toolCalls) {
+                const executionInfo = await this.processToolCall(toolCall, context);
+                if (executionInfo.needsConfirmation) {
+                    events.push(this.createEvent('ToolConfirmationRequired', executionInfo));
+                }
+                else {
+                    const result = await this.executeTool(executionInfo);
+                    events.push(this.createEvent('ToolExecuted', result));
+                }
+            }
+            // Add summary event
+            events.push(this.createEvent('ToolExecutionSummary', {
+                totalTools: toolCalls.length,
+                executedTools: Array.from(this.executedTools.values()),
+                successRate: this.calculateSuccessRate()
+            }));
+            return events;
+        }
+        catch (error) {
+            console.error('Error in ToolExecutionProcessor:', error);
+            return [this.createEvent('ToolExecutionError', {
+                    error: error instanceof Error ? error.message : String(error)
+                })];
+        }
+    }
+    extractToolCalls(message) {
+        const toolCalls = [];
+        message.messages.forEach((msg) => {
+            if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
+                toolCalls.push(...msg.tool_calls);
+            }
+        });
+        return toolCalls;
+    }
+    async processToolCall(toolCall, context) {
+        const [toolbox, toolName] = toolCall.function.name.split('--');
+        if (!toolbox || !toolName) {
+            throw new Error(`Invalid tool name format: ${toolCall.function.name}`);
+        }
+        // Parse tool arguments
+        let parameters = {};
+        try {
+            parameters = typeof toolCall.function.arguments === 'string'
+                ? JSON.parse(toolCall.function.arguments)
+                : toolCall.function.arguments;
+        }
+        catch (error) {
+            console.warn(`Failed to parse tool arguments for ${toolCall.function.name}:`, error);
+        }
+        // Check if tool needs confirmation
+        const needsConfirmation = this.shouldConfirmTool(toolCall, parameters);
+        return {
+            toolCall,
+            toolName,
+            toolbox,
+            parameters,
+            needsConfirmation
+        };
+    }
+    shouldConfirmTool(toolCall, parameters) {
+        // Check for dangerous operations
+        const dangerousOperations = [
+            'delete', 'remove', 'drop', 'destroy', 'format', 'wipe',
+            'shutdown', 'restart', 'kill', 'terminate'
+        ];
+        const toolName = toolCall.function.name.toLowerCase();
+        const hasDangerousOperation = dangerousOperations.some(op => toolName.includes(op));
+        // Check for file system operations with important paths
+        if (parameters.filePath || parameters.path) {
+            const path = (parameters.filePath || parameters.path || '').toLowerCase();
+            const importantPaths = ['/', 'c:', 'system', 'windows', 'etc', 'usr'];
+            const hasImportantPath = importantPaths.some(ip => path.includes(ip));
+            if (hasImportantPath) {
+                return true;
+            }
+        }
+        // Check for network operations
+        if (parameters.url || parameters.host || parameters.port) {
+            return true;
+        }
+        return hasDangerousOperation;
+    }
+    async executeTool(executionInfo) {
+        const startTime = Date.now();
+        const { toolCall, toolbox, toolName, parameters } = executionInfo;
+        try {
+            // Execute tool using CodeBolt's MCP
+            const { data } = await codeboltjs_1.default.mcp.executeTool(toolbox, toolName, parameters);
+            // Data comes as [failure: boolean, content: string] from CodeBolt MCP
+            let resultData;
+            let success = true;
+            if (Array.isArray(data) && data.length >= 2) {
+                const [failure, content] = data;
+                if (failure) {
+                    success = false;
+                    resultData = content; // Content is error message on failure
+                }
+                else {
+                    resultData = content; // Content is result on success
+                }
+            }
+            else {
+                // Fallback for unexpected data format
+                console.warn(`[Tool] Unexpected data format from ${toolCall.function.name}:`, data);
+                resultData = data;
+            }
+            const executionResult = {
+                toolCallId: toolCall.id,
+                result: resultData,
+                success: success,
+                executionTime: Date.now() - startTime,
+                error: success ? undefined : String(resultData)
+            };
+            // Store result
+            this.executedTools.set(toolCall.id, executionResult);
+            // Log execution if enabled
+            if (this.enableLogging) {
+                console.log(`[Tool] Successfully executed ${toolbox}--${toolName} in ${executionResult.executionTime}ms`);
+            }
+            return executionResult;
+        }
+        catch (error) {
+            const executionResult = {
+                toolCallId: toolCall.id,
+                result: null,
+                error: error instanceof Error ? error.message : String(error),
+                success: false,
+                executionTime: Date.now() - startTime
+            };
+            // Store result
+            this.executedTools.set(toolCall.id, executionResult);
+            // Log error if enabled
+            if (this.enableLogging) {
+                console.error(`[Tool] Failed to execute ${toolbox}--${toolName}:`, error);
+            }
+            return executionResult;
+        }
+    }
+    calculateSuccessRate() {
+        if (this.executedTools.size === 0)
+            return 0;
+        const successfulTools = Array.from(this.executedTools.values())
+            .filter(result => result.success).length;
+        return (successfulTools / this.executedTools.size) * 100;
+    }
+    // Public methods for external control
+    async confirmToolExecution(toolCallId, confirmed) {
+        // This method can be used to track confirmation status in the future
+        // For now, we'll just log the confirmation
+        if (this.enableLogging) {
+            console.log(`[ToolExecutor] Tool ${toolCallId} confirmation: ${confirmed}`);
+        }
+    }
+    getToolExecutionHistory() {
+        return Array.from(this.executedTools.values());
+    }
+    clearToolHistory() {
+        this.executedTools.clear();
+    }
+    setMaxRetries(maxRetries) {
+        this.maxRetries = Math.max(1, maxRetries);
+    }
+    setRetryDelay(delay) {
+        this.retryDelay = Math.max(100, delay);
+    }
+    enableLoggingForSession() {
+        this.enableLogging = true;
+    }
+    disableLoggingForSession() {
+        this.enableLogging = false;
+    }
+}
+exports.ToolExecutionProcessor = ToolExecutionProcessor;

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

@@ -0,0 +1 @@
+export {};

package/dist/processor-pieces/postToolCallProcessors/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/processor-pieces/postToolCallProcessors/shellProcessorModifier.d.ts

@@ -0,0 +1,25 @@
+import { PostToolCallProcessorInput, PostToolCallProcessorOutput } from "@codebolt/types/agent";
+import { BasePostToolCallProcessor } from "../base";
+export interface ShellProcessorOptions {
+    enableShellExecution?: boolean;
+    maxExecutionTime?: number;
+    allowedCommands?: string[];
+    blockedCommands?: string[];
+    workingDirectory?: string;
+}
+export declare class ShellProcessorModifier extends BasePostToolCallProcessor {
+    private readonly options;
+    private readonly execAsync;
+    private readonly SHELL_TRIGGER;
+    private readonly SHELL_CLOSE;
+    private readonly ARGS_PLACEHOLDER;
+    constructor(options?: ShellProcessorOptions);
+    modify(input: PostToolCallProcessorInput): Promise<PostToolCallProcessorOutput>;
+    private processShellInToolResults;
+    private processShellInjections;
+    private extractShellInjections;
+    private validateCommand;
+    private executeCommand;
+    private escapeShellArg;
+    private escapeRegex;
+}

package/dist/processor-pieces/postToolCallProcessors/shellProcessorModifier.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShellProcessorModifier = void 0;
+const base_1 = require("../base");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+class ShellProcessorModifier extends base_1.BasePostToolCallProcessor {
+    constructor(options = {}) {
+        super();
+        this.execAsync = (0, util_1.promisify)(child_process_1.exec);
+        this.SHELL_TRIGGER = '!{';
+        this.SHELL_CLOSE = '}';
+        this.ARGS_PLACEHOLDER = '{{args}}';
+        this.options = {
+            enableShellExecution: options.enableShellExecution || false, // Disabled by default for security
+            maxExecutionTime: options.maxExecutionTime || 10000, // 10 seconds
+            allowedCommands: options.allowedCommands || ['ls', 'pwd', 'echo', 'cat', 'head', 'tail', 'grep', 'find', 'wc'],
+            blockedCommands: options.blockedCommands || ['rm', 'del', 'format', 'sudo', 'su', 'chmod', 'chown', 'kill', 'killall'],
+            workingDirectory: options.workingDirectory || process.cwd()
+        };
+    }
+    async modify(input) {
+        var _a;
+        try {
+            const { llmMessageSent, rawLLMResponseMessage, nextPrompt, toolResults } = input;
+            // Process shell commands in tool results if they exist
+            let processedNextPrompt = nextPrompt;
+            let shouldExit = false;
+            if (toolResults && toolResults.length > 0) {
+                // Look for shell-related tool results or commands in the content
+                const shellResults = toolResults.filter(result => 
+                // Check if the tool call ID suggests it's a shell command
+                (result.tool_call_id && (result.tool_call_id.includes('run_terminal_cmd') ||
+                    result.tool_call_id.includes('shell'))) ||
+                    // Check if content contains shell triggers or placeholders
+                    (result.content && typeof result.content === 'string' &&
+                        (result.content.includes(this.SHELL_TRIGGER) || result.content.includes(this.ARGS_PLACEHOLDER))));
+                if (shellResults.length > 0) {
+                    processedNextPrompt = await this.processShellInToolResults(nextPrompt, shellResults);
+                }
+            }
+            // Also process any shell injections in the next prompt messages
+            const updatedMessages = [];
+            let contentModified = false;
+            for (const message of processedNextPrompt.message.messages) {
+                if (typeof message.content === 'string') {
+                    let processedContent = message.content;
+                    // Replace {{args}} placeholders if metadata has args
+                    const args = ((_a = processedNextPrompt.metadata) === null || _a === void 0 ? void 0 : _a.args) || '';
+                    if (processedContent.includes(this.ARGS_PLACEHOLDER)) {
+                        processedContent = processedContent.replace(new RegExp(this.escapeRegex(this.ARGS_PLACEHOLDER), 'g'), args);
+                        contentModified = true;
+                    }
+                    // Process shell injections if enabled
+                    if (this.options.enableShellExecution && processedContent.includes(this.SHELL_TRIGGER)) {
+                        processedContent = await this.processShellInjections(processedContent, args);
+                        contentModified = true;
+                    }
+                    updatedMessages.push({
+                        ...message,
+                        content: processedContent
+                    });
+                }
+                else {
+                    updatedMessages.push(message);
+                }
+            }
+            if (contentModified) {
+                processedNextPrompt = {
+                    message: {
+                        ...processedNextPrompt.message,
+                        messages: updatedMessages
+                    },
+                    metadata: {
+                        ...processedNextPrompt.metadata,
+                        shellProcessed: true,
+                        argsReplaced: true
+                    }
+                };
+            }
+            return {
+                nextPrompt: processedNextPrompt,
+                shouldExit
+            };
+        }
+        catch (error) {
+            console.error('Error in ShellProcessorModifier:', error);
+            return {
+                nextPrompt: input.nextPrompt,
+                shouldExit: false
+            };
+        }
+    }
+    async processShellInToolResults(nextPrompt, shellResults) {
+        var _a;
+        // Process shell commands found in tool results
+        let processedPrompt = nextPrompt;
+        for (const result of shellResults) {
+            if (result.content && typeof result.content === 'string') {
+                const args = ((_a = processedPrompt.metadata) === null || _a === void 0 ? void 0 : _a.args) || '';
+                // Process any shell injections in the tool result content
+                if (result.content.includes(this.SHELL_TRIGGER)) {
+                    const processedContent = await this.processShellInjections(result.content, args);
+                    // Add the processed result as a system message
+                    const systemMessage = {
+                        role: 'system',
+                        content: `[Shell Tool Result]: ${processedContent}`
+                    };
+                    processedPrompt = {
+                        message: {
+                            ...processedPrompt.message,
+                            messages: [...processedPrompt.message.messages, systemMessage]
+                        },
+                        metadata: {
+                            ...processedPrompt.metadata,
+                            shellToolResultsProcessed: true
+                        }
+                    };
+                }
+            }
+        }
+        return processedPrompt;
+    }
+    async processShellInjections(content, args) {
+        let processedContent = content;
+        const injections = this.extractShellInjections(content);
+        // Process injections in reverse order to maintain correct indices
+        for (let i = injections.length - 1; i >= 0; i--) {
+            const injection = injections[i];
+            try {
+                // Replace {{args}} in the command with shell-escaped args
+                const command = injection.command.replace(new RegExp(this.escapeRegex(this.ARGS_PLACEHOLDER), 'g'), this.escapeShellArg(args));
+                // Validate and execute command
+                this.validateCommand(command);
+                const result = await this.executeCommand(command);
+                const replacement = result;
+                processedContent = processedContent.substring(0, injection.startIndex) +
+                    replacement +
+                    processedContent.substring(injection.endIndex);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                const replacement = `[Shell command error: ${errorMessage}]`;
+                processedContent = processedContent.substring(0, injection.startIndex) +
+                    replacement +
+                    processedContent.substring(injection.endIndex);
+            }
+        }
+        return processedContent;
+    }
+    extractShellInjections(content) {
+        const injections = [];
+        let searchIndex = 0;
+        while (true) {
+            const startIndex = content.indexOf(this.SHELL_TRIGGER, searchIndex);
+            if (startIndex === -1)
+                break;
+            const contentStart = startIndex + this.SHELL_TRIGGER.length;
+            const endIndex = content.indexOf(this.SHELL_CLOSE, contentStart);
+            if (endIndex === -1) {
+                // No closing brace found, skip this occurrence
+                searchIndex = contentStart;
+                continue;
+            }
+            const command = content.substring(contentStart, endIndex).trim();
+            if (command.length > 0) {
+                injections.push({
+                    startIndex,
+                    endIndex: endIndex + this.SHELL_CLOSE.length,
+                    command
+                });
+            }
+            searchIndex = endIndex + this.SHELL_CLOSE.length;
+        }
+        return injections;
+    }
+    validateCommand(command) {
+        if (!this.options.enableShellExecution) {
+            throw new Error('Shell execution is disabled');
+        }
+        // Extract the base command (first word)
+        const baseCommand = command.trim().split(/\s+/)[0];
+        // Check blocked commands
+        if (this.options.blockedCommands.some(blocked => baseCommand.includes(blocked))) {
+            throw new Error(`Command '${baseCommand}' is blocked for security reasons`);
+        }
+        // Check allowed commands (if allowlist is defined)
+        if (this.options.allowedCommands.length > 0 &&
+            !this.options.allowedCommands.some(allowed => baseCommand.includes(allowed))) {
+            throw new Error(`Command '${baseCommand}' is not in the allowed commands list`);
+        }
+        // Additional security checks
+        if (command.includes('&&') || command.includes('||') || command.includes(';') || command.includes('|')) {
+            throw new Error('Command chaining and piping are not allowed');
+        }
+    }
+    async executeCommand(command) {
+        try {
+            const { stdout, stderr } = await this.execAsync(command, {
+                cwd: this.options.workingDirectory,
+                timeout: this.options.maxExecutionTime,
+                maxBuffer: 1024 * 1024 // 1MB buffer
+            });
+            let result = stdout;
+            if (stderr) {
+                result += `\n[stderr]: ${stderr}`;
+            }
+            return result || '[Command executed successfully with no output]';
+        }
+        catch (error) {
+            if (error.killed && error.signal === 'SIGTERM') {
+                throw new Error(`Command timed out after ${this.options.maxExecutionTime}ms`);
+            }
+            throw new Error(`Command failed: ${error.message}`);
+        }
+    }
+    escapeShellArg(arg) {
+        // Basic shell escaping - in production, use a proper shell escaping library
+        return `"${arg.replace(/"/g, '\\"')}"`;
+    }
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+}
+exports.ShellProcessorModifier = ShellProcessorModifier;

package/dist/processor-pieces/preInference/conversationCompactorProcessor.d.ts

@@ -0,0 +1,52 @@
+import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../types/processorTypes';
+export interface ConversationCompactorInfo {
+    originalMessageCount: number;
+    compactedMessageCount: number;
+    compressionRatio: number;
+    compactionMethod: 'summarization' | 'truncation' | 'smart_removal';
+    preservedMessages: number;
+    removedMessages: number;
+}
+export interface ConversationCompactorProcessorOptions {
+    maxConversationLength?: number;
+    compactionThreshold?: number;
+    preserveRecentMessages?: number;
+    preserveSystemMessages?: boolean;
+    preserveToolMessages?: boolean;
+    enableSummarization?: boolean;
+    enableSmartRemoval?: boolean;
+    compressionRatio?: number;
+}
+/**
+ * Processor that compacts long conversations to keep them within manageable limits
+ * while preserving important context and recent interactions.
+ */
+export declare class ConversationCompactorProcessor extends BaseProcessor {
+    private readonly maxConversationLength;
+    private readonly compactionThreshold;
+    private readonly preserveRecentMessages;
+    private readonly preserveSystemMessages;
+    private readonly preserveToolMessages;
+    private readonly enableSummarization;
+    private readonly enableSmartRemoval;
+    private readonly compressionRatio;
+    constructor(options?: ConversationCompactorProcessorOptions);
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    private shouldCompactConversation;
+    private compactConversation;
+    private compactWithSummarization;
+    private compactWithSmartRemoval;
+    private compactWithTruncation;
+    private calculateMessageImportance;
+    getMaxConversationLength(): number;
+    getCompactionThreshold(): number;
+    isCompactionNeeded(messageCount: number): boolean;
+    getCompressionRatio(): number;
+    getProcessorStats(): {
+        maxLength: number;
+        threshold: number;
+        preserveRecent: number;
+        compressionRatio: number;
+        enabledFeatures: string[];
+    };
+}