@codebolt/agent 1.2.1 → 2.2.3

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;
+}

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

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationContinuityProcessor = void 0;
+const processorTypes_1 = require("../types/processorTypes");
+/**
+ * Processor that maintains conversation continuity by linking related messages,
+ * resolving references, and detecting context gaps in follow-up conversations.
+ */
+class ConversationContinuityProcessor extends processorTypes_1.BaseProcessor {
+    constructor(options = {}) {
+        super(options);
+        this.enableContextLinking = options.enableContextLinking !== false;
+        this.enableReferenceResolution = options.enableReferenceResolution !== false;
+        this.enableGapDetection = options.enableGapDetection !== false;
+        this.maxContextLinks = options.maxContextLinks || 5;
+        this.contextLookbackWindow = options.contextLookbackWindow || 20;
+        this.enableProactiveContext = options.enableProactiveContext !== false;
+    }
+    async processInput(input) {
+        try {
+            const { message, context } = input;
+            // Only process follow-up conversations
+            if (!(context === null || context === void 0 ? void 0 : context.followUpProcessing)) {
+                return [this.createEvent('ContinuityProcessingSkipped', {
+                        reason: 'Not a follow-up conversation processing context'
+                    })];
+            }
+            const enhancedMessage = await this.enhanceConversationContinuity(message, context);
+            const continuityInfo = this.calculateContinuityInfo(message, enhancedMessage, context);
+            return [
+                this.createEvent('ConversationContinuityProcessed', continuityInfo),
+                this.createEvent('ConversationProcessed', enhancedMessage)
+            ];
+        }
+        catch (error) {
+            console.error('Error in ConversationContinuityProcessor:', error);
+            return [this.createEvent('ConversationContinuityError', {
+                    error: error instanceof Error ? error.message : String(error),
+                    originalLength: input.message.messages.length
+                })];
+        }
+    }
+    async enhanceConversationContinuity(message, context) {
+        let enhancedMessages = [...message.messages];
+        let enhancementsAdded = 0;
+        // Add context links if enabled
+        if (this.enableContextLinking) {
+            const contextLinks = this.addContextLinks(enhancedMessages, context);
+            enhancedMessages.push(...contextLinks);
+            enhancementsAdded += contextLinks.length;
+        }
+        // Resolve references if enabled
+        if (this.enableReferenceResolution) {
+            enhancedMessages = this.resolveReferences(enhancedMessages, context);
+        }
+        // Detect and fill conversation gaps if enabled
+        if (this.enableGapDetection) {
+            const gapFillers = this.detectAndFillGaps(enhancedMessages, context);
+            enhancedMessages.push(...gapFillers);
+            enhancementsAdded += gapFillers.length;
+        }
+        // Add proactive context if enabled
+        if (this.enableProactiveContext) {
+            const proactiveContext = this.addProactiveContext(enhancedMessages, context);
+            enhancedMessages.push(...proactiveContext);
+            enhancementsAdded += proactiveContext.length;
+        }
+        return {
+            ...message,
+            messages: enhancedMessages,
+            metadata: {
+                ...message.metadata,
+                continuityEnhanced: true,
+                enhancementsAdded,
+                timestamp: new Date().toISOString()
+            }
+        };
+    }
+    addContextLinks(messages, context) {
+        const contextLinks = [];
+        const recentMessages = messages.slice(-this.contextLookbackWindow);
+        // Find messages that reference previous interactions
+        const referencingMessages = this.findReferencingMessages(recentMessages);
+        if (referencingMessages.length > 0) {
+            const linkMessage = {
+                role: 'system',
+                content: this.generateContextLinkMessage(referencingMessages, context),
+                name: 'context-link'
+            };
+            contextLinks.push(linkMessage);
+        }
+        return contextLinks.slice(0, this.maxContextLinks);
+    }
+    findReferencingMessages(messages) {
+        const referencePatterns = [
+            /\b(this|that|it|they|them)\b/i,
+            /\b(the (above|previous|last|earlier))\b/i,
+            /\b(as (mentioned|discussed|shown))\b/i,
+            /\b(from (before|earlier))\b/i,
+            /\b(the (file|code|result|output))\b/i
+        ];
+        return messages.filter(message => {
+            const content = typeof message.content === 'string'
+                ? message.content
+                : JSON.stringify(message.content);
+            return referencePatterns.some(pattern => pattern.test(content));
+        });
+    }
+    generateContextLinkMessage(referencingMessages, context) {
+        const messageCount = referencingMessages.length;
+        const toolResults = context.toolResults || [];
+        let linkMessage = `**Context Links:** Found ${messageCount} message${messageCount > 1 ? 's' : ''} with references to previous interactions.`;
+        if (toolResults.length > 0) {
+            linkMessage += ` Recent tool executions: ${toolResults.length} tool${toolResults.length > 1 ? 's' : ''} executed.`;
+        }
+        if (context.originalHistory && context.originalHistory.length > 0) {
+            linkMessage += ` Conversation history: ${context.originalHistory.length} previous messages available for reference.`;
+        }
+        return linkMessage;
+    }
+    resolveReferences(messages, context) {
+        return messages.map(message => {
+            if (message.role === 'system' || message.name === 'reference-resolution') {
+                return message;
+            }
+            const resolvedContent = this.resolveMessageReferences(message.content, context);
+            if (resolvedContent !== message.content) {
+                return {
+                    ...message,
+                    content: resolvedContent,
+                    name: message.name || 'reference-resolved'
+                };
+            }
+            return message;
+        });
+    }
+    resolveMessageReferences(content, context) {
+        if (typeof content !== 'string') {
+            return content;
+        }
+        let resolvedContent = content;
+        const toolResults = context.toolResults || [];
+        // Resolve "the file" references
+        if (/\bthe file\b/i.test(resolvedContent) && toolResults.length > 0) {
+            const fileOperations = toolResults.filter((result) => result.tool_call_id && result.tool_call_id.includes('file'));
+            if (fileOperations.length === 1) {
+                resolvedContent = resolvedContent.replace(/\bthe file\b/gi, `the file (from recent tool execution)`);
+            }
+        }
+        // Resolve "the result" references
+        if (/\bthe result\b/i.test(resolvedContent) && toolResults.length > 0) {
+            resolvedContent = resolvedContent.replace(/\bthe result\b/gi, `the result (from ${toolResults.length} recent tool execution${toolResults.length > 1 ? 's' : ''})`);
+        }
+        // Resolve "it" references in context of tool operations
+        if (/\bit\b/i.test(resolvedContent) && toolResults.length === 1) {
+            const toolResult = toolResults[0];
+            if (toolResult.tool_call_id) {
+                resolvedContent = resolvedContent.replace(/\bit\b/gi, `it (referring to the tool execution result)`);
+            }
+        }
+        return resolvedContent;
+    }
+    detectAndFillGaps(messages, context) {
+        const gapFillers = [];
+        const gaps = this.detectConversationGaps(messages, context);
+        gaps.forEach(gap => {
+            const fillerMessage = {
+                role: 'system',
+                content: this.generateGapFillerMessage(gap, context),
+                name: 'gap-filler'
+            };
+            gapFillers.push(fillerMessage);
+        });
+        return gapFillers;
+    }
+    detectConversationGaps(messages, context) {
+        const gaps = [];
+        const toolResults = context.toolResults || [];
+        // Gap: Tool results without explanation
+        const unexplainedToolResults = toolResults.filter((result) => {
+            const hasExplanation = messages.some(msg => msg.role === 'assistant' &&
+                typeof msg.content === 'string' &&
+                msg.content.includes('result'));
+            return !hasExplanation;
+        });
+        if (unexplainedToolResults.length > 0) {
+            gaps.push({
+                type: 'unexplained-tool-results',
+                description: `${unexplainedToolResults.length} tool result(s) without explanation`,
+                severity: 'medium'
+            });
+        }
+        // Gap: Missing context for references
+        const unresolvedReferences = messages.filter(msg => {
+            const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+            return /\b(this|that|it)\b/i.test(content) && msg.role === 'user';
+        });
+        if (unresolvedReferences.length > 2) {
+            gaps.push({
+                type: 'unresolved-references',
+                description: `${unresolvedReferences.length} messages with unclear references`,
+                severity: 'low'
+            });
+        }
+        // Gap: Long silence after tool execution
+        const lastToolIndex = messages.findLastIndex(msg => msg.role === 'tool');
+        const lastAssistantIndex = messages.findLastIndex(msg => msg.role === 'assistant');
+        if (lastToolIndex > lastAssistantIndex && lastToolIndex < messages.length - 1) {
+            gaps.push({
+                type: 'missing-tool-response',
+                description: 'Tool execution without assistant response',
+                severity: 'high'
+            });
+        }
+        return gaps;
+    }
+    generateGapFillerMessage(gap, context) {
+        switch (gap.type) {
+            case 'unexplained-tool-results':
+                return `**Context Note:** There are tool execution results that may need explanation or analysis. Consider reviewing the tool outputs and their implications.`;
+            case 'unresolved-references':
+                return `**Context Note:** Some messages contain references that might be unclear. Consider providing more specific context when referring to previous interactions.`;
+            case 'missing-tool-response':
+                return `**Context Note:** Recent tool execution completed but may need assistant analysis or response to continue the conversation effectively.`;
+            default:
+                return `**Context Note:** Potential conversation gap detected: ${gap.description}`;
+        }
+    }
+    addProactiveContext(messages, context) {
+        const proactiveMessages = [];
+        const toolResults = context.toolResults || [];
+        const conversationLength = messages.length;
+        // Add proactive context for complex tool interactions
+        if (toolResults.length > 3) {
+            proactiveMessages.push({
+                role: 'system',
+                content: `**Proactive Context:** Multiple tools have been executed (${toolResults.length} total). This suggests a complex task that may benefit from step-by-step progress tracking.`,
+                name: 'proactive-context'
+            });
+        }
+        // Add proactive context for long conversations
+        if (conversationLength > 25) {
+            proactiveMessages.push({
+                role: 'system',
+                content: `**Proactive Context:** This is an extended conversation (${conversationLength} messages). Consider summarizing progress or breaking down remaining objectives.`,
+                name: 'proactive-context'
+            });
+        }
+        return proactiveMessages.slice(0, 2); // Limit proactive messages
+    }
+    calculateContinuityInfo(original, enhanced, context) {
+        const originalCount = original.messages.length;
+        const enhancedCount = enhanced.messages.length;
+        const addedMessages = enhancedCount - originalCount;
+        // Count different types of enhancements
+        const contextLinks = enhanced.messages.filter(m => m.name === 'context-link').length;
+        const referenceResolutions = enhanced.messages.filter(m => m.name === 'reference-resolved').length;
+        const gapFillers = enhanced.messages.filter(m => m.name === 'gap-filler').length;
+        return {
+            contextLinksAdded: contextLinks,
+            referenceResolutionsAdded: referenceResolutions,
+            continuityEnhanced: addedMessages > 0,
+            missingContextDetected: gapFillers > 0,
+            conversationGapsFound: gapFillers
+        };
+    }
+    // Public methods for configuration
+    setContextLookbackWindow(window) {
+        this.contextLookbackWindow = Math.max(5, Math.min(50, window));
+    }
+    setMaxContextLinks(max) {
+        this.maxContextLinks = Math.max(1, Math.min(10, max));
+    }
+    enableContextLinkingForSession() {
+        this.enableContextLinking = true;
+    }
+    disableContextLinkingForSession() {
+        this.enableContextLinking = false;
+    }
+    enableReferenceResolutionForSession() {
+        this.enableReferenceResolution = true;
+    }
+    disableReferenceResolutionForSession() {
+        this.enableReferenceResolution = false;
+    }
+    enableGapDetectionForSession() {
+        this.enableGapDetection = true;
+    }
+    disableGapDetectionForSession() {
+        this.enableGapDetection = false;
+    }
+}
+exports.ConversationContinuityProcessor = ConversationContinuityProcessor;

package/dist/processor-pieces/preInferenceProcessors/chatCompressionModifier.d.ts

@@ -0,0 +1,35 @@
+import { ProcessedMessage } from "@codebolt/types/agent";
+import { BasePreInferenceProcessor } from "../base";
+import { FlatUserMessage, MessageObject } from "@codebolt/types/sdk";
+export declare enum CompressionStatus {
+    /** The compression was successful */
+    COMPRESSED = 1,
+    /** The compression failed due to the compression inflating the token count */
+    COMPRESSION_FAILED_INFLATED_TOKEN_COUNT = 2,
+    /** The compression failed due to an error counting tokens */
+    COMPRESSION_FAILED_TOKEN_COUNT_ERROR = 3,
+    /** The compression was not necessary and no action was taken */
+    NOOP = 4
+}
+export interface ChatCompressionInfo {
+    originalTokenCount: number;
+    newTokenCount: number;
+    compressionStatus: CompressionStatus;
+}
+export interface ChatCompressionOptions {
+    contextPercentageThreshold?: number;
+    enableCompression?: boolean;
+    force?: boolean;
+}
+export declare class ChatCompressionModifier extends BasePreInferenceProcessor {
+    private readonly options;
+    private hasFailedCompressionAttempt;
+    constructor(options?: ChatCompressionOptions);
+    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
+    tryCompressChat(messages: MessageObject[], force?: boolean): Promise<ChatCompressionInfo & {
+        compressedMessages?: MessageObject[];
+    }>;
+    private countTokens;
+    private generateCompressionSummary;
+    resetCompressionState(): void;
+}