@codebolt/agent 2.2.2 → 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/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[];
+    };
+}

package/dist/processor-pieces/preInference/conversationCompactorProcessor.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationCompactorProcessor = void 0;
+const processorTypes_1 = require("../types/processorTypes");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+const { chatSummary } = codeboltjs_1.default;
+/**
+ * Processor that compacts long conversations to keep them within manageable limits
+ * while preserving important context and recent interactions.
+ */
+class ConversationCompactorProcessor extends processorTypes_1.BaseProcessor {
+    constructor(options = {}) {
+        super(options);
+        this.maxConversationLength = options.maxConversationLength || 50;
+        this.compactionThreshold = options.compactionThreshold || 0.8; // Compact when 80% of max length
+        this.preserveRecentMessages = options.preserveRecentMessages || 10;
+        this.preserveSystemMessages = options.preserveSystemMessages !== false;
+        this.preserveToolMessages = options.preserveToolMessages !== false;
+        this.enableSummarization = options.enableSummarization !== false;
+        this.enableSmartRemoval = options.enableSmartRemoval !== false;
+        this.compressionRatio = options.compressionRatio || 0.6; // Target 60% of original size
+    }
+    async processInput(input) {
+        try {
+            const { message, context } = input;
+            const messages = message.messages;
+            // Check if compaction is needed
+            const needsCompaction = this.shouldCompactConversation(messages);
+            if (!needsCompaction) {
+                return [this.createEvent('ConversationCompactionSkipped', {
+                        reason: 'Conversation length within limits',
+                        messageCount: messages.length,
+                        maxLength: this.maxConversationLength
+                    })];
+            }
+            // Perform compaction
+            const compactionResult = await this.compactConversation(messages, context);
+            // Update the message with compacted conversation
+            const compactedMessage = {
+                messages: compactionResult.compactedMessages,
+                metadata: {
+                    ...message.metadata,
+                    compactionInfo: compactionResult.info
+                }
+            };
+            return [
+                this.createEvent('ConversationCompacted', compactionResult.info),
+                this.createEvent('MessageModified', {
+                    originalMessageCount: messages.length,
+                    newMessageCount: compactionResult.compactedMessages.length,
+                    compactedMessage
+                })
+            ];
+        }
+        catch (error) {
+            console.error('Error in ConversationCompactorProcessor:', error);
+            return [this.createEvent('ConversationCompactionError', {
+                    error: error instanceof Error ? error.message : String(error)
+                })];
+        }
+    }
+    shouldCompactConversation(messages) {
+        const threshold = Math.floor(this.maxConversationLength * this.compactionThreshold);
+        return messages.length >= threshold;
+    }
+    async compactConversation(messages, context) {
+        const originalCount = messages.length;
+        let compactedMessages;
+        let compactionMethod;
+        // Determine the best compaction method
+        if (this.enableSummarization && originalCount > this.preserveRecentMessages * 2) {
+            compactionMethod = 'summarization';
+            compactedMessages = await this.compactWithSummarization(messages);
+        }
+        else if (this.enableSmartRemoval) {
+            compactionMethod = 'smart_removal';
+            compactedMessages = this.compactWithSmartRemoval(messages);
+        }
+        else {
+            compactionMethod = 'truncation';
+            compactedMessages = this.compactWithTruncation(messages);
+        }
+        const compactedCount = compactedMessages.length;
+        const info = {
+            originalMessageCount: originalCount,
+            compactedMessageCount: compactedCount,
+            compressionRatio: compactedCount / originalCount,
+            compactionMethod,
+            preservedMessages: compactedCount,
+            removedMessages: originalCount - compactedCount
+        };
+        return { compactedMessages, info };
+    }
+    async compactWithSummarization(messages) {
+        // Separate messages into categories
+        const systemMessages = messages.filter(m => m.role === 'system');
+        const recentMessages = messages.slice(-this.preserveRecentMessages);
+        const middleMessages = messages.slice(systemMessages.length, messages.length - this.preserveRecentMessages);
+        if (middleMessages.length === 0) {
+            return messages;
+        }
+        try {
+            // Create conversation text for summarization
+            const conversationText = middleMessages
+                .map(m => `${m.role}: ${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`)
+                .join('\n');
+            // Use codeboltjs chat summary
+            const summary = await chatSummary.summarizeConversation(conversationText, {
+                maxLength: Math.floor(middleMessages.length * this.compressionRatio),
+                preserveImportantDetails: true
+            });
+            // Create summary message
+            const summaryMessage = {
+                role: 'system',
+                content: `[Conversation Summary]: ${summary}`
+            };
+            // Combine preserved messages with summary
+            return [
+                ...systemMessages,
+                summaryMessage,
+                ...recentMessages
+            ];
+        }
+        catch (error) {
+            console.warn('Summarization failed, falling back to smart removal:', error);
+            return this.compactWithSmartRemoval(messages);
+        }
+    }
+    compactWithSmartRemoval(messages) {
+        // Always preserve system messages
+        const systemMessages = messages.filter(m => m.role === 'system');
+        const nonSystemMessages = messages.filter(m => m.role !== 'system');
+        // Always preserve recent messages
+        const recentMessages = nonSystemMessages.slice(-this.preserveRecentMessages);
+        const olderMessages = nonSystemMessages.slice(0, -this.preserveRecentMessages);
+        if (olderMessages.length === 0) {
+            return messages;
+        }
+        // Calculate target count for older messages
+        const targetTotal = Math.floor(this.maxConversationLength * this.compressionRatio);
+        const preservedCount = systemMessages.length + recentMessages.length;
+        const targetOlderCount = Math.max(0, targetTotal - preservedCount);
+        if (targetOlderCount >= olderMessages.length) {
+            return messages;
+        }
+        // Score messages by importance
+        const scoredMessages = olderMessages.map((message, index) => ({
+            message,
+            score: this.calculateMessageImportance(message, index, olderMessages.length)
+        }));
+        // Sort by score (descending) and take top messages
+        scoredMessages.sort((a, b) => b.score - a.score);
+        const selectedOlderMessages = scoredMessages
+            .slice(0, targetOlderCount)
+            .map(item => item.message);
+        // Maintain chronological order
+        const selectedIndices = new Set(selectedOlderMessages.map(msg => olderMessages.indexOf(msg)));
+        const chronologicalOlderMessages = olderMessages.filter((_, index) => selectedIndices.has(index));
+        return [
+            ...systemMessages,
+            ...chronologicalOlderMessages,
+            ...recentMessages
+        ];
+    }
+    compactWithTruncation(messages) {
+        const targetCount = Math.floor(this.maxConversationLength * this.compressionRatio);
+        if (messages.length <= targetCount) {
+            return messages;
+        }
+        // Preserve system messages and recent messages
+        const systemMessages = messages.filter(m => m.role === 'system');
+        const nonSystemMessages = messages.filter(m => m.role !== 'system');
+        const recentCount = Math.min(this.preserveRecentMessages, nonSystemMessages.length);
+        const recentMessages = nonSystemMessages.slice(-recentCount);
+        const availableForOlder = targetCount - systemMessages.length - recentMessages.length;
+        if (availableForOlder <= 0) {
+            return [...systemMessages, ...recentMessages];
+        }
+        const olderMessages = nonSystemMessages.slice(0, -recentCount);
+        const selectedOlderMessages = olderMessages.slice(-availableForOlder);
+        return [
+            ...systemMessages,
+            ...selectedOlderMessages,
+            ...recentMessages
+        ];
+    }
+    calculateMessageImportance(message, index, totalCount) {
+        let score = 0;
+        // Base score for message type
+        switch (message.role) {
+            case 'system':
+                score += 100; // Highest priority
+                break;
+            case 'assistant':
+                score += 50;
+                break;
+            case 'user':
+                score += 40;
+                break;
+            case 'tool':
+                score += this.preserveToolMessages ? 60 : 20;
+                break;
+        }
+        // Boost score for messages with tool calls
+        if (message.tool_calls && message.tool_calls.length > 0) {
+            score += 30;
+        }
+        // Boost score for longer messages (more content)
+        const contentLength = typeof message.content === 'string'
+            ? message.content.length
+            : JSON.stringify(message.content).length;
+        score += Math.min(contentLength / 100, 20); // Max 20 points for length
+        // Recency bonus (more recent = higher score)
+        const recencyBonus = (index / totalCount) * 10;
+        score += recencyBonus;
+        // Boost for messages that contain important keywords
+        const importantKeywords = [
+            'error', 'exception', 'failed', 'success', 'completed',
+            'important', 'critical', 'warning', 'note'
+        ];
+        const contentStr = typeof message.content === 'string'
+            ? message.content.toLowerCase()
+            : JSON.stringify(message.content).toLowerCase();
+        const keywordMatches = importantKeywords.filter(keyword => contentStr.includes(keyword)).length;
+        score += keywordMatches * 5;
+        return score;
+    }
+    // Public methods for configuration
+    getMaxConversationLength() {
+        return this.maxConversationLength;
+    }
+    getCompactionThreshold() {
+        return this.compactionThreshold;
+    }
+    isCompactionNeeded(messageCount) {
+        return messageCount >= Math.floor(this.maxConversationLength * this.compactionThreshold);
+    }
+    getCompressionRatio() {
+        return this.compressionRatio;
+    }
+    // Statistics and monitoring
+    getProcessorStats() {
+        const enabledFeatures = [];
+        if (this.enableSummarization)
+            enabledFeatures.push('summarization');
+        if (this.enableSmartRemoval)
+            enabledFeatures.push('smart_removal');
+        if (this.preserveSystemMessages)
+            enabledFeatures.push('preserve_system');
+        if (this.preserveToolMessages)
+            enabledFeatures.push('preserve_tools');
+        return {
+            maxLength: this.maxConversationLength,
+            threshold: this.compactionThreshold,
+            preserveRecent: this.preserveRecentMessages,
+            compressionRatio: this.compressionRatio,
+            enabledFeatures
+        };
+    }
+}
+exports.ConversationCompactorProcessor = ConversationCompactorProcessor;

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

@@ -0,0 +1,49 @@
+import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../types/processorTypes';
+export interface ConversationContinuityInfo {
+    contextLinksAdded: number;
+    referenceResolutionsAdded: number;
+    continuityEnhanced: boolean;
+    missingContextDetected: boolean;
+    conversationGapsFound: number;
+}
+export interface ConversationContinuityProcessorOptions {
+    enableContextLinking?: boolean;
+    enableReferenceResolution?: boolean;
+    enableGapDetection?: boolean;
+    maxContextLinks?: number;
+    contextLookbackWindow?: number;
+    enableProactiveContext?: boolean;
+}
+/**
+ * Processor that maintains conversation continuity by linking related messages,
+ * resolving references, and detecting context gaps in follow-up conversations.
+ */
+export declare class ConversationContinuityProcessor extends BaseProcessor {
+    private readonly enableContextLinking;
+    private readonly enableReferenceResolution;
+    private readonly enableGapDetection;
+    private readonly maxContextLinks;
+    private readonly contextLookbackWindow;
+    private readonly enableProactiveContext;
+    constructor(options?: ConversationContinuityProcessorOptions);
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    private enhanceConversationContinuity;
+    private addContextLinks;
+    private findReferencingMessages;
+    private generateContextLinkMessage;
+    private resolveReferences;
+    private resolveMessageReferences;
+    private detectAndFillGaps;
+    private detectConversationGaps;
+    private generateGapFillerMessage;
+    private addProactiveContext;
+    private calculateContinuityInfo;
+    setContextLookbackWindow(window: number): void;
+    setMaxContextLinks(max: number): void;
+    enableContextLinkingForSession(): void;
+    disableContextLinkingForSession(): void;
+    enableReferenceResolutionForSession(): void;
+    disableReferenceResolutionForSession(): void;
+    enableGapDetectionForSession(): void;
+    disableGapDetectionForSession(): void;
+}