@codebolt/agent 5.0.2 → 5.0.7

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

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

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

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

@@ -1,49 +0,0 @@
-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;
-}