@codebolt/agent 1.2.1 → 2.2.2

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

package/dist/processor-pieces/preInferenceProcessors/chatCompressionModifier.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatCompressionModifier = exports.CompressionStatus = void 0;
+const base_1 = require("../base");
+/**
+ * Threshold for compression token count as a fraction of the model's token limit.
+ * If the chat history exceeds this threshold, it will be compressed.
+ */
+const COMPRESSION_TOKEN_THRESHOLD = 0.7;
+/**
+ * The fraction of the latest chat history to keep. A value of 0.3
+ * means that only the last 30% of the chat history will be kept after compression.
+ */
+const COMPRESSION_PRESERVE_THRESHOLD = 0.3;
+var CompressionStatus;
+(function (CompressionStatus) {
+    /** The compression was successful */
+    CompressionStatus[CompressionStatus["COMPRESSED"] = 1] = "COMPRESSED";
+    /** The compression failed due to the compression inflating the token count */
+    CompressionStatus[CompressionStatus["COMPRESSION_FAILED_INFLATED_TOKEN_COUNT"] = 2] = "COMPRESSION_FAILED_INFLATED_TOKEN_COUNT";
+    /** The compression failed due to an error counting tokens */
+    CompressionStatus[CompressionStatus["COMPRESSION_FAILED_TOKEN_COUNT_ERROR"] = 3] = "COMPRESSION_FAILED_TOKEN_COUNT_ERROR";
+    /** The compression was not necessary and no action was taken */
+    CompressionStatus[CompressionStatus["NOOP"] = 4] = "NOOP";
+})(CompressionStatus || (exports.CompressionStatus = CompressionStatus = {}));
+/**
+ * Returns the index of the content after the fraction of the total characters in the history.
+ */
+function findIndexAfterFraction(history, fraction) {
+    if (fraction <= 0 || fraction >= 1) {
+        throw new Error('Fraction must be between 0 and 1');
+    }
+    const contentLengths = history.map((content) => JSON.stringify(content).length);
+    const totalCharacters = contentLengths.reduce((sum, length) => sum + length, 0);
+    const targetCharacters = totalCharacters * fraction;
+    let charactersSoFar = 0;
+    for (let i = 0; i < contentLengths.length; i++) {
+        charactersSoFar += contentLengths[i];
+        if (charactersSoFar >= targetCharacters) {
+            return i;
+        }
+    }
+    return contentLengths.length;
+}
+function isFunctionResponse(message) {
+    // Check if message has function response content
+    if (typeof message.content === 'object' && message.content !== null) {
+        return 'functionResponse' in message.content;
+    }
+    return false;
+}
+// Mock token limit for different models (should be replaced with actual implementation)
+function tokenLimit(model) {
+    // Default token limits for common models
+    if (model.includes('gemini-pro'))
+        return 30720;
+    if (model.includes('gemini-flash'))
+        return 1048576;
+    if (model.includes('gpt-4'))
+        return 8192;
+    if (model.includes('gpt-3.5'))
+        return 4096;
+    return 8192; // Default fallback
+}
+class ChatCompressionModifier extends base_1.BasePreInferenceProcessor {
+    constructor(options = {}) {
+        super();
+        this.hasFailedCompressionAttempt = false;
+        this.options = {
+            contextPercentageThreshold: options.contextPercentageThreshold || COMPRESSION_TOKEN_THRESHOLD,
+            enableCompression: options.enableCompression !== false,
+            force: options.force || false
+        };
+    }
+    async modify(originalRequest, createdMessage) {
+        try {
+            const compressionResult = await this.tryCompressChat(createdMessage.message.messages, this.options.force || false);
+            if (compressionResult.compressionStatus === CompressionStatus.COMPRESSED) {
+                return {
+                    message: {
+                        ...createdMessage.message,
+                        messages: compressionResult.compressedMessages || createdMessage.message.messages
+                    },
+                    metadata: {
+                        ...createdMessage.metadata,
+                        chatCompressed: true,
+                        originalTokenCount: compressionResult.originalTokenCount,
+                        newTokenCount: compressionResult.newTokenCount,
+                        compressionStatus: compressionResult.compressionStatus
+                    }
+                };
+            }
+            return {
+                ...createdMessage,
+                metadata: {
+                    ...createdMessage.metadata,
+                    compressionStatus: compressionResult.compressionStatus,
+                    originalTokenCount: compressionResult.originalTokenCount,
+                    newTokenCount: compressionResult.newTokenCount
+                }
+            };
+        }
+        catch (error) {
+            console.error('Error in ChatCompressionModifier:', error);
+            this.hasFailedCompressionAttempt = true;
+            return createdMessage;
+        }
+    }
+    async tryCompressChat(messages, force = false) {
+        var _a;
+        const curatedHistory = messages;
+        // Regardless of `force`, don't do anything if the history is empty.
+        if (curatedHistory.length === 0 ||
+            (this.hasFailedCompressionAttempt && !force)) {
+            return {
+                originalTokenCount: 0,
+                newTokenCount: 0,
+                compressionStatus: CompressionStatus.NOOP,
+            };
+        }
+        // Mock model - should be replaced with actual model detection
+        const model = "gemini-pro";
+        const originalTokenCount = await this.countTokens(model, curatedHistory);
+        if (originalTokenCount === undefined) {
+            console.warn(`Could not determine token count for model ${model}.`);
+            this.hasFailedCompressionAttempt = !force && true;
+            return {
+                originalTokenCount: 0,
+                newTokenCount: 0,
+                compressionStatus: CompressionStatus.COMPRESSION_FAILED_TOKEN_COUNT_ERROR,
+            };
+        }
+        const contextPercentageThreshold = this.options.contextPercentageThreshold;
+        // Don't compress if not forced and we are under the limit.
+        if (!force) {
+            const threshold = contextPercentageThreshold !== null && contextPercentageThreshold !== void 0 ? contextPercentageThreshold : COMPRESSION_TOKEN_THRESHOLD;
+            if (originalTokenCount < threshold * tokenLimit(model)) {
+                return {
+                    originalTokenCount,
+                    newTokenCount: originalTokenCount,
+                    compressionStatus: CompressionStatus.NOOP,
+                };
+            }
+        }
+        let compressBeforeIndex = findIndexAfterFraction(curatedHistory, 1 - COMPRESSION_PRESERVE_THRESHOLD);
+        // Find the first user message after the index. This is the start of the next turn.
+        while (compressBeforeIndex < curatedHistory.length &&
+            (((_a = curatedHistory[compressBeforeIndex]) === null || _a === void 0 ? void 0 : _a.role) === 'assistant' ||
+                isFunctionResponse(curatedHistory[compressBeforeIndex]))) {
+            compressBeforeIndex++;
+        }
+        const historyToCompress = curatedHistory.slice(0, compressBeforeIndex);
+        const historyToKeep = curatedHistory.slice(compressBeforeIndex);
+        // Generate AI summary using the compression prompt
+        const summary = await this.generateCompressionSummary(historyToCompress);
+        const compressedMessages = [
+            {
+                role: 'user',
+                content: summary
+            },
+            {
+                role: 'assistant',
+                content: 'Got it. Thanks for the additional context!'
+            },
+            ...historyToKeep,
+        ];
+        const newTokenCount = await this.countTokens(model, compressedMessages);
+        if (newTokenCount === undefined) {
+            console.warn('Could not determine compressed history token count.');
+            this.hasFailedCompressionAttempt = !force && true;
+            return {
+                originalTokenCount,
+                newTokenCount: originalTokenCount,
+                compressionStatus: CompressionStatus.COMPRESSION_FAILED_TOKEN_COUNT_ERROR,
+            };
+        }
+        if (newTokenCount > originalTokenCount) {
+            this.hasFailedCompressionAttempt = !force && true;
+            return {
+                originalTokenCount,
+                newTokenCount,
+                compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT,
+            };
+        }
+        return {
+            originalTokenCount,
+            newTokenCount,
+            compressionStatus: CompressionStatus.COMPRESSED,
+            compressedMessages,
+        };
+    }
+    async countTokens(model, messages) {
+        // Mock token counting - should be replaced with actual API call
+        // Rough approximation: 4 characters per token
+        const totalCharacters = messages.reduce((sum, msg) => {
+            return sum + (typeof msg.content === 'string' ? msg.content.length : JSON.stringify(msg.content).length);
+        }, 0);
+        return Math.ceil(totalCharacters / 4);
+    }
+    async generateCompressionSummary(messages) {
+        // This should use the actual compression prompt and LLM call
+        // For now, using a simplified version similar to the original
+        const compressionPrompt = `You are tasked with creating a concise summary of a conversation history to preserve context while reducing token usage.
+
+Please analyze the conversation and create a state snapshot that captures:
+1. Key topics discussed
+2. Important decisions made
+3. Current context and progress
+4. Any ongoing tasks or issues
+
+Format your response as a clear, structured summary that maintains the essential information needed to continue the conversation effectively.`;
+        // Mock LLM call - should be replaced with actual LLM integration
+        const summaryParts = [];
+        let userQuestions = [];
+        let assistantResponses = [];
+        for (const message of messages) {
+            const content = typeof message.content === 'string' ? message.content : JSON.stringify(message.content);
+            if (message.role === 'user') {
+                if (content.length > 20) {
+                    userQuestions.push(content.substring(0, 150) + (content.length > 150 ? '...' : ''));
+                }
+            }
+            else if (message.role === 'assistant') {
+                if (content.length > 20) {
+                    assistantResponses.push(content.substring(0, 150) + (content.length > 150 ? '...' : ''));
+                }
+            }
+        }
+        summaryParts.push('<state_snapshot>');
+        summaryParts.push('This is a compressed summary of the previous conversation:');
+        summaryParts.push('');
+        if (userQuestions.length > 0) {
+            summaryParts.push('Key user requests and questions:');
+            userQuestions.slice(0, 5).forEach((q, i) => {
+                summaryParts.push(`${i + 1}. ${q}`);
+            });
+            summaryParts.push('');
+        }
+        if (assistantResponses.length > 0) {
+            summaryParts.push('Key assistant responses and actions:');
+            assistantResponses.slice(0, 5).forEach((r, i) => {
+                summaryParts.push(`${i + 1}. ${r}`);
+            });
+            summaryParts.push('');
+        }
+        summaryParts.push(`Total messages compressed: ${messages.length}`);
+        summaryParts.push('</state_snapshot>');
+        return summaryParts.join('\n');
+    }
+    resetCompressionState() {
+        this.hasFailedCompressionAttempt = false;
+    }
+}
+exports.ChatCompressionModifier = ChatCompressionModifier;
+////

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

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

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

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

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

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