@codebolt/agent 2.2.2 → 2.2.5

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

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdvancedLoopDetectionProcessor = void 0;
+const processor_1 = require("../../processor");
+const crypto_1 = require("crypto");
+class AdvancedLoopDetectionProcessor extends processor_1.BaseProcessor {
+    constructor(options = {}) {
+        super();
+        // Tool call tracking
+        this.lastToolCallKey = null;
+        this.toolCallRepetitionCount = 0;
+        // Content streaming tracking
+        this.streamContentHistory = '';
+        this.contentStats = new Map();
+        this.lastContentIndex = 0;
+        this.loopDetected = false;
+        this.inCodeBlock = false;
+        // Turn tracking
+        this.turnsInCurrentPrompt = 0;
+        this.lastCheckTurn = 0;
+        this.toolCallThreshold = options.toolCallThreshold || 5;
+        this.contentLoopThreshold = options.contentLoopThreshold || 10;
+        this.contentChunkSize = options.contentChunkSize || 50;
+        this.maxHistoryLength = options.maxHistoryLength || 1000;
+        this.enableLLMDetection = options.enableLLMDetection || false;
+        this.llmCheckAfterTurns = options.llmCheckAfterTurns || 30;
+        this.defaultLLMCheckInterval = options.defaultLLMCheckInterval || 3;
+        this.llmCheckInterval = this.defaultLLMCheckInterval;
+    }
+    async processInput(input) {
+        const { message, context } = input;
+        // Increment turn counter
+        this.turnsInCurrentPrompt++;
+        // Check for tool call loops in the last message
+        const lastMessage = message.messages[message.messages.length - 1];
+        if (lastMessage.tool_calls && lastMessage.tool_calls.length > 0) {
+            for (const toolCall of lastMessage.tool_calls) {
+                const isLoop = this.checkToolCallLoop({
+                    name: toolCall.function.name,
+                    args: typeof toolCall.function.arguments === 'string'
+                        ? JSON.parse(toolCall.function.arguments)
+                        : toolCall.function.arguments
+                });
+                if (isLoop) {
+                    this.loopDetected = true;
+                    return [this.createEvent('LoopDetected', {
+                            type: 'tool_call_loop',
+                            toolCall: toolCall.function.name,
+                            repetitionCount: this.toolCallRepetitionCount,
+                            threshold: this.toolCallThreshold
+                        })];
+                }
+            }
+        }
+        // Check for content loops
+        if (lastMessage.content && typeof lastMessage.content === 'string') {
+            const isContentLoop = this.checkContentLoop(lastMessage.content);
+            if (isContentLoop) {
+                this.loopDetected = true;
+                return [this.createEvent('LoopDetected', {
+                        type: 'content_loop',
+                        contentLength: this.streamContentHistory.length,
+                        threshold: this.contentLoopThreshold
+                    })];
+            }
+        }
+        // LLM-based loop detection (if enabled)
+        if (this.enableLLMDetection &&
+            this.turnsInCurrentPrompt >= this.llmCheckAfterTurns &&
+            this.turnsInCurrentPrompt - this.lastCheckTurn >= this.llmCheckInterval) {
+            this.lastCheckTurn = this.turnsInCurrentPrompt;
+            // For now, just log that LLM check would happen
+            // In a real implementation, this would call an LLM to analyze the conversation
+            console.log('[AdvancedLoopDetection] LLM-based loop check would be performed here');
+        }
+        return [this.createEvent('LoopCheckCompleted', {
+                loopDetected: this.loopDetected,
+                turnsInPrompt: this.turnsInCurrentPrompt,
+                toolCallCount: this.toolCallRepetitionCount
+            })];
+    }
+    getToolCallKey(toolCall) {
+        const argsString = JSON.stringify(toolCall.args);
+        const keyString = `${toolCall.name}:${argsString}`;
+        return (0, crypto_1.createHash)('sha256').update(keyString).digest('hex');
+    }
+    checkToolCallLoop(toolCall) {
+        const key = this.getToolCallKey(toolCall);
+        if (this.lastToolCallKey === key) {
+            this.toolCallRepetitionCount++;
+        }
+        else {
+            this.lastToolCallKey = key;
+            this.toolCallRepetitionCount = 1;
+        }
+        return this.toolCallRepetitionCount >= this.toolCallThreshold;
+    }
+    checkContentLoop(content) {
+        var _a;
+        // Different content elements can often contain repetitive syntax that is not indicative of a loop.
+        // To avoid false positives, we detect when we encounter different content types and
+        // reset tracking to avoid analyzing content that spans across different element boundaries.
+        const numFences = ((_a = content.match(/```/g)) !== null && _a !== void 0 ? _a : []).length;
+        const hasTable = /(^|\n)\s*(\|.*\||[|+-]{3,})/.test(content);
+        const hasListItem = /(^|\n)\s*[*-+]\s/.test(content) || /(^|\n)\s*\d+\.\s/.test(content);
+        const hasHeading = /(^|\n)#+\s/.test(content);
+        const hasBlockquote = /(^|\n)>\s/.test(content);
+        if (numFences || hasTable || hasListItem || hasHeading || hasBlockquote) {
+            // Reset tracking when different content elements are detected
+            this.resetContentTracking();
+        }
+        const wasInCodeBlock = this.inCodeBlock;
+        this.inCodeBlock = numFences % 2 === 0 ? this.inCodeBlock : !this.inCodeBlock;
+        if (wasInCodeBlock || this.inCodeBlock) {
+            return false;
+        }
+        this.streamContentHistory += content;
+        this.truncateAndUpdate();
+        return this.analyzeContentChunksForLoop();
+    }
+    truncateAndUpdate() {
+        if (this.streamContentHistory.length <= this.maxHistoryLength) {
+            return;
+        }
+        const truncationAmount = this.streamContentHistory.length - this.maxHistoryLength;
+        this.streamContentHistory = this.streamContentHistory.slice(truncationAmount);
+        this.lastContentIndex = Math.max(0, this.lastContentIndex - truncationAmount);
+        // Update all stored chunk indices to account for the truncation
+        for (const [hash, oldIndices] of this.contentStats.entries()) {
+            const adjustedIndices = oldIndices
+                .map((index) => index - truncationAmount)
+                .filter((index) => index >= 0);
+            if (adjustedIndices.length > 0) {
+                this.contentStats.set(hash, adjustedIndices);
+            }
+            else {
+                this.contentStats.delete(hash);
+            }
+        }
+    }
+    analyzeContentChunksForLoop() {
+        while (this.hasMoreChunksToProcess()) {
+            const currentChunk = this.streamContentHistory.substring(this.lastContentIndex, this.lastContentIndex + this.contentChunkSize);
+            const chunkHash = (0, crypto_1.createHash)('sha256').update(currentChunk).digest('hex');
+            if (this.isLoopDetectedForChunk(currentChunk, chunkHash)) {
+                return true;
+            }
+            this.lastContentIndex++;
+        }
+        return false;
+    }
+    hasMoreChunksToProcess() {
+        return this.lastContentIndex + this.contentChunkSize <= this.streamContentHistory.length;
+    }
+    isLoopDetectedForChunk(chunk, hash) {
+        const existingIndices = this.contentStats.get(hash);
+        if (!existingIndices) {
+            this.contentStats.set(hash, [this.lastContentIndex]);
+            return false;
+        }
+        if (!this.isActualContentMatch(chunk, existingIndices[0])) {
+            return false;
+        }
+        existingIndices.push(this.lastContentIndex);
+        if (existingIndices.length < this.contentLoopThreshold) {
+            return false;
+        }
+        // Analyze the most recent occurrences to see if they're clustered closely together
+        const recentIndices = existingIndices.slice(-this.contentLoopThreshold);
+        const totalDistance = recentIndices[recentIndices.length - 1] - recentIndices[0];
+        const averageDistance = totalDistance / (this.contentLoopThreshold - 1);
+        const maxAllowedDistance = this.contentChunkSize * 1.5;
+        return averageDistance <= maxAllowedDistance;
+    }
+    isActualContentMatch(currentChunk, originalIndex) {
+        const originalChunk = this.streamContentHistory.substring(originalIndex, originalIndex + this.contentChunkSize);
+        return originalChunk === currentChunk;
+    }
+    resetContentTracking(resetHistory = true) {
+        if (resetHistory) {
+            this.streamContentHistory = '';
+        }
+        this.contentStats.clear();
+        this.lastContentIndex = 0;
+    }
+    reset() {
+        this.lastToolCallKey = null;
+        this.toolCallRepetitionCount = 0;
+        this.resetContentTracking();
+        this.turnsInCurrentPrompt = 0;
+        this.llmCheckInterval = this.defaultLLMCheckInterval;
+        this.lastCheckTurn = 0;
+        this.loopDetected = false;
+        this.inCodeBlock = false;
+    }
+}
+exports.AdvancedLoopDetectionProcessor = AdvancedLoopDetectionProcessor;

package/dist/processor-pieces/postToolCall/chatCompressionProcessor.d.ts

@@ -0,0 +1,26 @@
+import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
+export interface ChatCompressionInfo {
+    originalTokenCount: number;
+    newTokenCount: number;
+    compressionRatio: number;
+    threshold: number;
+}
+export interface ChatCompressionProcessorOptions {
+    compressionThreshold?: number;
+    compressionPreserveThreshold?: number;
+    tokenLimit?: number;
+    enableCompression?: boolean;
+}
+export declare class ChatCompressionProcessor extends BaseProcessor {
+    private readonly compressionThreshold;
+    private readonly compressionPreserveThreshold;
+    private readonly tokenLimit;
+    private readonly enableCompression;
+    constructor(options?: ChatCompressionProcessorOptions);
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    private estimateTokenCount;
+    setCompressionThreshold(threshold: number): void;
+    setTokenLimit(limit: number): void;
+    enableCompressionForSession(): void;
+    disableCompressionForSession(): void;
+}

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

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatCompressionProcessor = void 0;
+const processor_1 = require("../../processor");
+const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
+class ChatCompressionProcessor extends processor_1.BaseProcessor {
+    constructor(options = {}) {
+        super(options);
+        this.compressionThreshold = options.compressionThreshold || 0.7;
+        this.compressionPreserveThreshold = options.compressionPreserveThreshold || 0.3;
+        this.tokenLimit = options.tokenLimit || 128000;
+        this.enableCompression = options.enableCompression !== false;
+    }
+    async processInput(input) {
+        try {
+            const { message, context } = input;
+            if (!this.enableCompression) {
+                return [this.createEvent('ChatCompressionDisabled', {
+                        reason: 'Compression is disabled for this session'
+                    })];
+            }
+            // Get chat history from CodeBolt
+            const chatHistory = await codeboltjs_1.default.chat.getChatHistory();
+            if (chatHistory.length === 0) {
+                return [this.createEvent('NoChatHistory', {
+                        reason: 'No chat history available for compression'
+                    })];
+            }
+            // Estimate token count (simple heuristic: 4 chars per token)
+            const estimatedTokens = this.estimateTokenCount(chatHistory);
+            const threshold = this.compressionThreshold * this.tokenLimit;
+            console.log(`[Compression] Estimated tokens: ${estimatedTokens}, threshold: ${threshold}`);
+            if (estimatedTokens < threshold) {
+                return [this.createEvent('ChatCompressionSkipped', {
+                        estimatedTokens,
+                        threshold,
+                        reason: 'Below compression threshold'
+                    })];
+            }
+            // Perform compression using CodeBolt's chatSummary
+            const compressionResult = await codeboltjs_1.default.chatSummary.summarizeAll();
+            if (compressionResult.success && compressionResult.data) {
+                const newTokenCount = this.estimateTokenCount(compressionResult.data);
+                const compressionInfo = {
+                    originalTokenCount: estimatedTokens,
+                    newTokenCount,
+                    compressionRatio: newTokenCount / estimatedTokens,
+                    threshold: this.compressionThreshold
+                };
+                // Send notification about compression
+                await codeboltjs_1.default.chat.sendNotificationEvent(`Chat compressed: ${estimatedTokens} → ${newTokenCount} tokens`, 'debug');
+                return [this.createEvent('ChatCompressed', compressionInfo)];
+            }
+            else {
+                return [this.createEvent('ChatCompressionFailed', {
+                        error: compressionResult.message || 'Unknown compression error',
+                        originalTokenCount: estimatedTokens
+                    })];
+            }
+        }
+        catch (error) {
+            console.error('Error in ChatCompressionProcessor:', error);
+            return [this.createEvent('ChatCompressionError', {
+                    error: error instanceof Error ? error.message : String(error)
+                })];
+        }
+    }
+    estimateTokenCount(data) {
+        // Simple heuristic: 4 characters per token
+        const totalContent = JSON.stringify(data);
+        return Math.ceil(totalContent.length / 4);
+    }
+    // Public methods for external control
+    setCompressionThreshold(threshold) {
+        this.compressionThreshold = Math.max(0.1, Math.min(0.9, threshold));
+    }
+    setTokenLimit(limit) {
+        this.tokenLimit = Math.max(1000, limit);
+    }
+    enableCompressionForSession() {
+        this.enableCompression = true;
+    }
+    disableCompressionForSession() {
+        this.enableCompression = false;
+    }
+}
+exports.ChatCompressionProcessor = ChatCompressionProcessor;

package/dist/processor-pieces/postToolCall/chatRecordingProcessor.d.ts

@@ -0,0 +1,81 @@
+import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
+export interface ChatRecordingProcessorOptions {
+    enableTokenTracking?: boolean;
+    exportFormat?: 'json' | 'txt' | 'csv';
+    outputDirectory?: string;
+    maxFileSize?: number;
+    enableCompression?: boolean;
+    includeMetadata?: boolean;
+    autoExport?: boolean;
+    exportInterval?: number;
+}
+export interface TokensSummary {
+    input: number;
+    output: number;
+    cached: number;
+    thoughts?: number;
+    tool?: number;
+    total: number;
+}
+export interface MessageRecord {
+    id: string;
+    timestamp: string;
+    role: string;
+    content: string;
+    metadata?: Record<string, any>;
+    tokens?: TokensSummary;
+    toolCalls?: ToolCallRecord[];
+}
+export interface ToolCallRecord {
+    id: string;
+    name: string;
+    args: Record<string, unknown>;
+    result?: any;
+    status: 'pending' | 'success' | 'error' | 'cancelled';
+    timestamp: string;
+    executionTime?: number;
+}
+export interface ConversationSession {
+    sessionId: string;
+    startTime: string;
+    endTime?: string;
+    messages: MessageRecord[];
+    totalTokens: TokensSummary;
+    toolCallCount: number;
+    metadata: Record<string, any>;
+}
+export declare class ChatRecordingProcessor extends BaseProcessor {
+    private readonly enableTokenTracking;
+    private readonly exportFormat;
+    private readonly outputDirectory;
+    private readonly maxFileSize;
+    private readonly enableCompression;
+    private readonly includeMetadata;
+    private readonly autoExport;
+    private readonly exportInterval;
+    private currentSession;
+    private messageCount;
+    private sessions;
+    constructor(options?: ChatRecordingProcessorOptions);
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    private initializeSession;
+    private createMessageRecord;
+    private extractContent;
+    private extractToolCalls;
+    private estimateTokens;
+    private updateSessionTotals;
+    private generateSessionId;
+    private generateMessageId;
+    private generateToolCallId;
+    exportSession(session: ConversationSession): Promise<string>;
+    private ensureDirectoryExists;
+    private formatAsText;
+    private formatAsCSV;
+    finalizeSession(): Promise<string | null>;
+    getCurrentSession(): ConversationSession | null;
+    getSessionStats(): {
+        currentSessionMessages: number;
+        totalSessions: number;
+        totalMessages: number;
+    };
+}