@codebolt/agent 5.0.1 → 5.0.6

package/dist/processor-pieces/messageModifiers/mentionedFilesModifier.js

@@ -1,207 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MentionedFilesModifier = void 0;
-const base_1 = require("../base");
-const fs = __importStar(require("node:fs/promises"));
-const path = __importStar(require("node:path"));
-const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
-/**
- * Message modifier that reads files and folders mentioned in the user message
- * Uses mentionedFiles and mentionedFolders from FlatUserMessage
- */
-class MentionedFilesModifier extends base_1.BaseMessageModifier {
-    constructor() {
-        super();
-    }
-    async modify(originalRequest, createdMessage) {
-        try {
-            const mentionedFiles = originalRequest.mentionedFiles || [];
-            const mentionedFolders = originalRequest.mentionedFolders || [];
-            const allMentionedPaths = [...mentionedFiles, ...mentionedFolders];
-            if (allMentionedPaths.length === 0) {
-                return createdMessage;
-            }
-            // Read all mentioned files and folders
-            const fileResults = [];
-            for (const mentionedPath of allMentionedPaths) {
-                try {
-                    const result = await this.resolveAndReadFile(mentionedPath);
-                    if (result) {
-                        fileResults.push(result);
-                    }
-                }
-                catch (error) {
-                    fileResults.push({
-                        path: mentionedPath,
-                        content: '',
-                        error: error instanceof Error ? error.message : 'Unknown error'
-                    });
-                }
-            }
-            if (fileResults.length === 0) {
-                return createdMessage;
-            }
-            // Add file content to the user message
-            const fileContentText = this.formatFileContent(fileResults);
-            const updatedMessages = this.updateUserMessage(createdMessage.message.messages || [], fileContentText);
-            return {
-                message: {
-                    ...createdMessage.message,
-                    messages: updatedMessages
-                },
-                metadata: {
-                    ...createdMessage.metadata,
-                    mentionedFilesAdded: true,
-                    resolvedFiles: fileResults.map(f => f.path)
-                }
-            };
-        }
-        catch (error) {
-            console.error('Error in MentionedFilesModifier:', error);
-            return createdMessage;
-        }
-    }
-    /**
-     * Resolves and reads a file, handling both files and directories
-     */
-    async resolveAndReadFile(pathName) {
-        try {
-            // pathName is already a full absolute path
-            const absolutePath = pathName;
-            // Get project path for security check and relative path display
-            let projectPath;
-            try {
-                const { projectPath: path } = await codeboltjs_1.default.project.getProjectPath();
-                projectPath = path || process.cwd();
-            }
-            catch (error) {
-                projectPath = process.cwd();
-            }
-            // Check if path is within project (basic security check)
-            const relativePath = path.relative(projectPath, absolutePath);
-            if (relativePath.startsWith('..')) {
-                throw new Error(`Path ${pathName} is outside project directory`);
-            }
-            const stats = await fs.stat(absolutePath);
-            if (stats.isDirectory()) {
-                // For directories, list contents
-                const files = await fs.readdir(absolutePath);
-                const fileList = files.join('\n');
-                return {
-                    path: relativePath || path.basename(pathName),
-                    content: `Directory contents:\n${fileList}`
-                };
-            }
-            else if (stats.isFile()) {
-                // Check file size (limit to reasonable size)
-                const maxFileSize = 1024 * 1024; // 1MB
-                if (stats.size > maxFileSize) {
-                    return {
-                        path: relativePath || path.basename(pathName),
-                        content: `File too large (${stats.size} bytes). Maximum allowed: ${maxFileSize} bytes.`
-                    };
-                }
-                // Read file content
-                const content = await fs.readFile(absolutePath, 'utf-8');
-                return {
-                    path: relativePath || path.basename(pathName),
-                    content
-                };
-            }
-        }
-        catch (error) {
-            if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
-                // File not found
-                return {
-                    path: pathName,
-                    content: '',
-                    error: `File not found: ${pathName}`
-                };
-            }
-            throw error;
-        }
-        return null;
-    }
-    /**
-     * Formats file content for inclusion in the message
-     */
-    formatFileContent(fileResults) {
-        const contentParts = [];
-        contentParts.push('\n--- Content from mentioned files ---');
-        for (const result of fileResults) {
-            if (result.error) {
-                contentParts.push(`\nError reading ${result.path}: ${result.error}`);
-            }
-            else {
-                contentParts.push(`\nContent from ${result.path}:`);
-                contentParts.push(result.content);
-            }
-        }
-        return contentParts.join('\n');
-    }
-    /**
-     * Updates the user message with file content
-     */
-    updateUserMessage(messages, fileContent) {
-        const updatedMessages = [...messages];
-        // Find the last user message and append file content
-        for (let i = updatedMessages.length - 1; i >= 0; i--) {
-            if (updatedMessages[i].role === 'user') {
-                const currentContent = updatedMessages[i].content;
-                if (Array.isArray(currentContent)) {
-                    // If content is array, add file content as new text element
-                    updatedMessages[i] = {
-                        ...updatedMessages[i],
-                        content: [...currentContent, { type: 'text', text: fileContent }]
-                    };
-                }
-                else {
-                    // If content is string, append file content
-                    updatedMessages[i] = {
-                        ...updatedMessages[i],
-                        content: (currentContent || '') + fileContent
-                    };
-                }
-                break;
-            }
-        }
-        return updatedMessages;
-    }
-}
-exports.MentionedFilesModifier = MentionedFilesModifier;

package/dist/processor-pieces/messageModifiers/simpleMessageModifier.d.ts

@@ -1,7 +0,0 @@
-import { ProcessedMessage } from "@codebolt/types/agent";
-import { BaseMessageModifier } from "../base";
-import { FlatUserMessage } from "@codebolt/types/sdk";
-export declare class SimpleMessageModifier extends BaseMessageModifier {
-    constructor();
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage, context?: Record<string, unknown>): Promise<ProcessedMessage>;
-}

package/dist/processor-pieces/messageModifiers/simpleMessageModifier.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleMessageModifier = void 0;
-const base_1 = require("../base");
-class SimpleMessageModifier extends base_1.BaseMessageModifier {
-    constructor() {
-        super();
-    }
-    modify(originalRequest, createdMessage, context) {
-        const contextMessage = {
-            role: 'user',
-            content: "hi"
-        };
-        return Promise.resolve({
-            message: {
-                ...createdMessage.message,
-                messages: [...createdMessage.message.messages, contextMessage]
-            },
-            metadata: {
-                ...createdMessage.metadata,
-                userMessageAdded: true
-            }
-        });
-    }
-}
-exports.SimpleMessageModifier = SimpleMessageModifier;

package/dist/processor-pieces/postInference/llmOutputValidityProcessor.d.ts

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

package/dist/processor-pieces/postInference/llmOutputValidityProcessor.js

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

package/dist/processor-pieces/postInferenceProcessors/checkForNoToolCall.d.ts

@@ -1,7 +0,0 @@
-import { ProcessedMessage } from "@codebolt/types/agent";
-import { BasePostInferenceProcessor } from "../base";
-import { LLMResponse } from "@codebolt/types/sdk";
-export declare class CheckForNoToolCall extends BasePostInferenceProcessor {
-    constructor();
-    modify(llmMessageSent: ProcessedMessage, llmResponseMessage: LLMResponse, nextPrompt: ProcessedMessage): Promise<ProcessedMessage>;
-}

package/dist/processor-pieces/postInferenceProcessors/checkForNoToolCall.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CheckForNoToolCall = void 0;
-const base_1 = require("../base");
-class CheckForNoToolCall extends base_1.BasePostInferenceProcessor {
-    constructor() {
-        super();
-    }
-    modify(llmMessageSent, llmResponseMessage, nextPrompt) {
-        // Check if tool_calls exist in the LLM response
-        const hasToolCalls = llmResponseMessage.tool_calls && llmResponseMessage.tool_calls.length > 0;
-        if (!hasToolCalls) {
-            // Create a new message indicating no tool call was found
-            const noToolCallMessage = {
-                role: 'user',
-                content: 'no tool call found in request'
-            };
-            nextPrompt.message.messages.push(noToolCallMessage);
-        }
-        // If tool calls exist, return the nextPrompt unchanged
-        return Promise.resolve(nextPrompt);
-    }
-}
-exports.CheckForNoToolCall = CheckForNoToolCall;

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

@@ -1,41 +0,0 @@
-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/postToolCall/advancedLoopDetectionProcessor.js

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

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

@@ -1,90 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.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;