@codebolt/agent 1.2.1 → 2.2.3

package/dist/processor-pieces/preToolCall/toolValidationProcessor.js

@@ -0,0 +1,391 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolValidationProcessor = void 0;
+const processor_1 = require("../../processor");
+/**
+ * Processor that validates tool calls before execution, checking parameters,
+ * security constraints, and tool availability.
+ */
+class ToolValidationProcessor extends processor_1.BaseProcessor {
+    constructor(options = {}) {
+        super(options);
+        this.enableParameterValidation = options.enableParameterValidation !== false;
+        this.enableSecurityValidation = options.enableSecurityValidation !== false;
+        this.enableTypeValidation = options.enableTypeValidation !== false;
+        this.strictMode = options.strictMode || false;
+        this.allowedTools = new Set(options.allowedTools || []);
+        this.blockedTools = new Set(options.blockedTools || []);
+        this.maxParameterSize = options.maxParameterSize || 1024 * 1024; // 1MB
+        this.enableLogging = options.enableLogging !== false;
+    }
+    async processInput(input) {
+        var _a;
+        try {
+            const { message, context } = input;
+            // Check if this is a pre-tool call processing
+            if (!(context === null || context === void 0 ? void 0 : context.preToolCallProcessing)) {
+                return [this.createEvent('ToolValidationSkipped', {
+                        reason: 'Not a pre-tool call processing context'
+                    })];
+            }
+            const toolName = context.toolName;
+            const toolInput = context.toolInput;
+            const toolUseId = context.toolUseId;
+            // Perform validation
+            const validationResult = await this.validateTool(toolName, toolInput, context);
+            if (!validationResult.isValid) {
+                // Tool validation failed - intercept and return error
+                const errorMessage = this.formatValidationErrors(validationResult);
+                return [
+                    this.createEvent('ToolValidationFailed', validationResult),
+                    this.createEvent('ToolIntercepted', {
+                        result: errorMessage,
+                        toolName,
+                        userRejected: false,
+                        validationFailed: true
+                    })
+                ];
+            }
+            // Validation passed
+            return [
+                this.createEvent('ToolValidationPassed', validationResult)
+            ];
+        }
+        catch (error) {
+            console.error('Error in ToolValidationProcessor:', error);
+            return [this.createEvent('ToolValidationError', {
+                    error: error instanceof Error ? error.message : String(error),
+                    toolName: (_a = input.context) === null || _a === void 0 ? void 0 : _a.toolName
+                })];
+        }
+    }
+    async validateTool(toolName, toolInput, context) {
+        const validationResult = {
+            toolName,
+            isValid: true,
+            validationErrors: [],
+            validationWarnings: [],
+            parameterValidation: {
+                required: [],
+                missing: [],
+                invalid: []
+            },
+            securityChecks: {
+                passed: true,
+                issues: []
+            }
+        };
+        // Tool availability validation
+        if (!this.validateToolAvailability(toolName, validationResult)) {
+            validationResult.isValid = false;
+        }
+        // Parameter validation
+        if (this.enableParameterValidation) {
+            if (!this.validateParameters(toolName, toolInput, validationResult)) {
+                validationResult.isValid = false;
+            }
+        }
+        // Security validation
+        if (this.enableSecurityValidation) {
+            if (!this.validateSecurity(toolName, toolInput, validationResult)) {
+                validationResult.isValid = false;
+            }
+        }
+        // Type validation
+        if (this.enableTypeValidation) {
+            if (!this.validateTypes(toolName, toolInput, validationResult)) {
+                validationResult.isValid = false;
+            }
+        }
+        // Size validation
+        if (!this.validateSize(toolInput, validationResult)) {
+            validationResult.isValid = false;
+        }
+        return validationResult;
+    }
+    validateToolAvailability(toolName, result) {
+        let isValid = true;
+        // Check if tool is explicitly blocked
+        if (this.blockedTools.has(toolName)) {
+            result.validationErrors.push(`Tool '${toolName}' is blocked and cannot be executed`);
+            isValid = false;
+        }
+        // Check if tool is in allowed list (if allowlist is configured)
+        if (this.allowedTools.size > 0 && !this.allowedTools.has(toolName)) {
+            result.validationErrors.push(`Tool '${toolName}' is not in the allowed tools list`);
+            isValid = false;
+        }
+        // Check for dangerous tool patterns
+        const dangerousPatterns = [
+            /^(rm|del|delete)$/i,
+            /^(format|fdisk)$/i,
+            /^(sudo|su)$/i,
+            /^(chmod|chown).*777/i,
+            /eval|exec|system/i
+        ];
+        if (dangerousPatterns.some(pattern => pattern.test(toolName))) {
+            result.validationWarnings.push(`Tool '${toolName}' matches potentially dangerous pattern`);
+            if (this.strictMode) {
+                result.validationErrors.push(`Tool '${toolName}' is considered dangerous in strict mode`);
+                isValid = false;
+            }
+        }
+        return isValid;
+    }
+    validateParameters(toolName, toolInput, result) {
+        let isValid = true;
+        // Get expected parameters for known tools
+        const expectedParams = this.getExpectedParameters(toolName);
+        if (expectedParams) {
+            result.parameterValidation.required = expectedParams.required || [];
+            // Check required parameters
+            for (const requiredParam of expectedParams.required || []) {
+                if (!toolInput || !(requiredParam in toolInput)) {
+                    result.parameterValidation.missing.push(requiredParam);
+                    result.validationErrors.push(`Required parameter '${requiredParam}' is missing for tool '${toolName}'`);
+                    isValid = false;
+                }
+            }
+            // Check parameter types
+            if (expectedParams.types && toolInput) {
+                for (const [paramName, expectedType] of Object.entries(expectedParams.types)) {
+                    if (paramName in toolInput) {
+                        const actualType = typeof toolInput[paramName];
+                        if (actualType !== expectedType) {
+                            result.parameterValidation.invalid.push(paramName);
+                            result.validationErrors.push(`Parameter '${paramName}' should be of type '${expectedType}' but got '${actualType}'`);
+                            isValid = false;
+                        }
+                    }
+                }
+            }
+            // Check for unexpected parameters in strict mode
+            if (this.strictMode && expectedParams.allowed && toolInput) {
+                for (const paramName of Object.keys(toolInput)) {
+                    if (!expectedParams.allowed.includes(paramName)) {
+                        result.validationWarnings.push(`Unexpected parameter '${paramName}' for tool '${toolName}'`);
+                    }
+                }
+            }
+        }
+        return isValid;
+    }
+    validateSecurity(toolName, toolInput, result) {
+        let isValid = true;
+        // Check for injection patterns in parameters
+        if (toolInput && typeof toolInput === 'object') {
+            for (const [key, value] of Object.entries(toolInput)) {
+                if (typeof value === 'string') {
+                    // SQL injection patterns
+                    const sqlInjectionPatterns = [
+                        /('|\\'|;|\\;|--|\s*or\s+|union\s+select)/i,
+                        /(drop\s+table|delete\s+from|insert\s+into)/i
+                    ];
+                    // Command injection patterns
+                    const commandInjectionPatterns = [
+                        /[;&|`$(){}[\]]/,
+                        /(rm\s+-rf)|(sudo\s+)|(chmod\s+)/i
+                    ];
+                    // Path traversal patterns
+                    const pathTraversalPatterns = [
+                        /\.\.\//,
+                        /\.\.\\/, // fixed: properly closed regex for Windows path traversal
+                        /%2[eE]%2[eE]%2[fF]/i
+                    ];
+                    const allPatterns = [
+                        ...sqlInjectionPatterns,
+                        ...commandInjectionPatterns,
+                        ...pathTraversalPatterns
+                    ];
+                    for (const pattern of allPatterns) {
+                        if (pattern.test(value)) {
+                            result.securityChecks.issues.push(`Potential security issue in parameter '${key}': suspicious pattern detected`);
+                            result.securityChecks.passed = false;
+                            if (this.strictMode) {
+                                result.validationErrors.push(`Security validation failed for parameter '${key}' in tool '${toolName}'`);
+                                isValid = false;
+                            }
+                            else {
+                                result.validationWarnings.push(`Security warning for parameter '${key}' in tool '${toolName}'`);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Check for sensitive file operations
+        if (toolName.includes('file') || toolName.includes('read') || toolName.includes('write')) {
+            const sensitiveFiles = [
+                '/etc/passwd',
+                '/etc/shadow',
+                '~/.ssh/',
+                '.env',
+                'config.json',
+                'secrets.json'
+            ];
+            const filePath = (toolInput === null || toolInput === void 0 ? void 0 : toolInput.filePath) || (toolInput === null || toolInput === void 0 ? void 0 : toolInput.path) || (toolInput === null || toolInput === void 0 ? void 0 : toolInput.file);
+            if (typeof filePath === 'string') {
+                for (const sensitiveFile of sensitiveFiles) {
+                    if (filePath.includes(sensitiveFile)) {
+                        result.securityChecks.issues.push(`Attempt to access sensitive file: ${filePath}`);
+                        result.securityChecks.passed = false;
+                        if (this.strictMode) {
+                            result.validationErrors.push(`Access to sensitive file '${filePath}' is not allowed`);
+                            isValid = false;
+                        }
+                        else {
+                            result.validationWarnings.push(`Warning: accessing potentially sensitive file '${filePath}'`);
+                        }
+                    }
+                }
+            }
+        }
+        return isValid;
+    }
+    validateTypes(toolName, toolInput, result) {
+        let isValid = true;
+        if (toolInput === null || toolInput === undefined) {
+            if (this.strictMode) {
+                result.validationErrors.push(`Tool input cannot be null or undefined for '${toolName}'`);
+                isValid = false;
+            }
+            return isValid;
+        }
+        // Validate input is serializable
+        try {
+            JSON.stringify(toolInput);
+        }
+        catch (error) {
+            result.validationErrors.push(`Tool input for '${toolName}' is not serializable`);
+            isValid = false;
+        }
+        // Check for circular references
+        if (typeof toolInput === 'object' && this.hasCircularReference(toolInput)) {
+            result.validationErrors.push(`Tool input for '${toolName}' contains circular references`);
+            isValid = false;
+        }
+        return isValid;
+    }
+    validateSize(toolInput, result) {
+        try {
+            const serialized = JSON.stringify(toolInput);
+            const size = new Blob([serialized]).size;
+            if (size > this.maxParameterSize) {
+                result.validationErrors.push(`Tool input size (${size} bytes) exceeds maximum allowed size (${this.maxParameterSize} bytes)`);
+                return false;
+            }
+        }
+        catch (error) {
+            result.validationWarnings.push('Could not determine tool input size');
+        }
+        return true;
+    }
+    getExpectedParameters(toolName) {
+        // Define expected parameters for common tools
+        const toolSchemas = {
+            'file_read': {
+                required: ['filePath'],
+                types: { filePath: 'string' },
+                allowed: ['filePath', 'encoding']
+            },
+            'file_write': {
+                required: ['filePath', 'content'],
+                types: { filePath: 'string', content: 'string' },
+                allowed: ['filePath', 'content', 'encoding', 'append']
+            },
+            'execute_command': {
+                required: ['command'],
+                types: { command: 'string' },
+                allowed: ['command', 'args', 'cwd', 'timeout']
+            },
+            'http_request': {
+                required: ['url'],
+                types: { url: 'string' },
+                allowed: ['url', 'method', 'headers', 'body', 'timeout']
+            },
+            'database_query': {
+                required: ['query'],
+                types: { query: 'string' },
+                allowed: ['query', 'parameters', 'database']
+            }
+        };
+        return toolSchemas[toolName] || null;
+    }
+    hasCircularReference(obj, seen = new WeakSet()) {
+        if (obj === null || typeof obj !== 'object') {
+            return false;
+        }
+        if (seen.has(obj)) {
+            return true;
+        }
+        seen.add(obj);
+        for (const value of Object.values(obj)) {
+            if (this.hasCircularReference(value, seen)) {
+                return true;
+            }
+        }
+        seen.delete(obj);
+        return false;
+    }
+    formatValidationErrors(result) {
+        const errors = result.validationErrors;
+        const warnings = result.validationWarnings;
+        let message = `Tool validation failed for '${result.toolName}':\n`;
+        if (errors.length > 0) {
+            message += '\nErrors:\n' + errors.map(error => `- ${error}`).join('\n');
+        }
+        if (warnings.length > 0) {
+            message += '\nWarnings:\n' + warnings.map(warning => `- ${warning}`).join('\n');
+        }
+        if (result.parameterValidation.missing.length > 0) {
+            message += `\nMissing required parameters: ${result.parameterValidation.missing.join(', ')}`;
+        }
+        if (result.securityChecks.issues.length > 0) {
+            message += '\nSecurity issues:\n' + result.securityChecks.issues.map(issue => `- ${issue}`).join('\n');
+        }
+        return message;
+    }
+    // Public methods for configuration
+    addAllowedTool(toolName) {
+        this.allowedTools.add(toolName);
+        if (this.enableLogging) {
+            console.log(`[ToolValidation] Added allowed tool: ${toolName}`);
+        }
+    }
+    removeAllowedTool(toolName) {
+        const removed = this.allowedTools.delete(toolName);
+        if (removed && this.enableLogging) {
+            console.log(`[ToolValidation] Removed allowed tool: ${toolName}`);
+        }
+        return removed;
+    }
+    addBlockedTool(toolName) {
+        this.blockedTools.add(toolName);
+        if (this.enableLogging) {
+            console.log(`[ToolValidation] Added blocked tool: ${toolName}`);
+        }
+    }
+    removeBlockedTool(toolName) {
+        const removed = this.blockedTools.delete(toolName);
+        if (removed && this.enableLogging) {
+            console.log(`[ToolValidation] Removed blocked tool: ${toolName}`);
+        }
+        return removed;
+    }
+    getAllowedTools() {
+        return Array.from(this.allowedTools);
+    }
+    getBlockedTools() {
+        return Array.from(this.blockedTools);
+    }
+    isToolAllowed(toolName) {
+        if (this.blockedTools.has(toolName)) {
+            return false;
+        }
+        if (this.allowedTools.size > 0) {
+            return this.allowedTools.has(toolName);
+        }
+        return true;
+    }
+}
+exports.ToolValidationProcessor = ToolValidationProcessor;

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

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

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

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

package/dist/processor-pieces/processors/advancedLoopDetectionProcessor.d.ts

@@ -0,0 +1,41 @@
+import { BaseProcessor, ProcessorInput, ProcessorOutput } from '../../processor';
+export interface AdvancedLoopDetectionProcessorOptions {
+    toolCallThreshold?: number;
+    contentLoopThreshold?: number;
+    contentChunkSize?: number;
+    maxHistoryLength?: number;
+    enableLLMDetection?: boolean;
+    llmCheckAfterTurns?: number;
+    defaultLLMCheckInterval?: number;
+}
+export declare class AdvancedLoopDetectionProcessor extends BaseProcessor {
+    private readonly toolCallThreshold;
+    private readonly contentLoopThreshold;
+    private readonly contentChunkSize;
+    private readonly maxHistoryLength;
+    private readonly enableLLMDetection;
+    private readonly llmCheckAfterTurns;
+    private readonly defaultLLMCheckInterval;
+    private lastToolCallKey;
+    private toolCallRepetitionCount;
+    private streamContentHistory;
+    private contentStats;
+    private lastContentIndex;
+    private loopDetected;
+    private inCodeBlock;
+    private turnsInCurrentPrompt;
+    private llmCheckInterval;
+    private lastCheckTurn;
+    constructor(options?: AdvancedLoopDetectionProcessorOptions);
+    processInput(input: ProcessorInput): Promise<ProcessorOutput[]>;
+    private getToolCallKey;
+    private checkToolCallLoop;
+    private checkContentLoop;
+    private truncateAndUpdate;
+    private analyzeContentChunksForLoop;
+    private hasMoreChunksToProcess;
+    private isLoopDetectedForChunk;
+    private isActualContentMatch;
+    private resetContentTracking;
+    reset(): void;
+}

package/dist/processor-pieces/processors/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/processors/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;
+}