@codebolt/agent 5.0.2 → 5.0.7

package/dist/processor-pieces/additionalModifiers/shellProcessorModifier.js

@@ -1,169 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ShellProcessorModifier = void 0;
-const base_1 = require("../base");
-const child_process_1 = require("child_process");
-const util_1 = require("util");
-class ShellProcessorModifier extends base_1.BaseMessageModifier {
-    constructor(options = {}) {
-        super();
-        this.execAsync = (0, util_1.promisify)(child_process_1.exec);
-        this.SHELL_TRIGGER = '!{';
-        this.SHELL_CLOSE = '}';
-        this.ARGS_PLACEHOLDER = '{{args}}';
-        this.options = {
-            enableShellExecution: options.enableShellExecution || false, // Disabled by default for security
-            maxExecutionTime: options.maxExecutionTime || 10000, // 10 seconds
-            allowedCommands: options.allowedCommands || ['ls', 'pwd', 'echo', 'cat', 'head', 'tail', 'grep', 'find', 'wc'],
-            blockedCommands: options.blockedCommands || ['rm', 'del', 'format', 'sudo', 'su', 'chmod', 'chown', 'kill', 'killall'],
-            workingDirectory: options.workingDirectory || process.cwd()
-        };
-    }
-    async modify(originalRequest, createdMessage) {
-        var _a;
-        try {
-            // Get the user message content to process
-            const userMessage = createdMessage.message.messages.find(msg => msg.role === 'user');
-            if (!userMessage || typeof userMessage.content !== 'string') {
-                return createdMessage;
-            }
-            const content = userMessage.content;
-            const args = ((_a = createdMessage.metadata) === null || _a === void 0 ? void 0 : _a.args) || '';
-            // First, replace {{args}} placeholders
-            let processedContent = content.replace(new RegExp(this.escapeRegex(this.ARGS_PLACEHOLDER), 'g'), args);
-            // Then process shell injections if enabled
-            if (this.options.enableShellExecution && processedContent.includes(this.SHELL_TRIGGER)) {
-                processedContent = await this.processShellInjections(processedContent, args);
-            }
-            // If content was modified, update the message
-            if (processedContent !== content) {
-                const updatedMessages = createdMessage.message.messages.map(msg => {
-                    if (msg.role === 'user' && typeof msg.content === 'string' && msg.content === content) {
-                        return {
-                            ...msg,
-                            content: processedContent
-                        };
-                    }
-                    return msg;
-                });
-                return Promise.resolve({
-                    message: {
-                        ...createdMessage.message,
-                        messages: updatedMessages
-                    },
-                    metadata: {
-                        ...createdMessage.metadata,
-                        shellProcessed: true,
-                        argsReplaced: content.includes(this.ARGS_PLACEHOLDER)
-                    }
-                });
-            }
-            return createdMessage;
-        }
-        catch (error) {
-            console.error('Error in ShellProcessorModifier:', error);
-            return createdMessage;
-        }
-    }
-    async processShellInjections(content, args) {
-        let processedContent = content;
-        const injections = this.extractShellInjections(content);
-        // Process injections in reverse order to maintain correct indices
-        for (let i = injections.length - 1; i >= 0; i--) {
-            const injection = injections[i];
-            try {
-                // Replace {{args}} in the command with shell-escaped args
-                const command = injection.command.replace(new RegExp(this.escapeRegex(this.ARGS_PLACEHOLDER), 'g'), this.escapeShellArg(args));
-                // Validate and execute command
-                this.validateCommand(command);
-                const result = await this.executeCommand(command);
-                const replacement = result;
-                processedContent = processedContent.substring(0, injection.startIndex) +
-                    replacement +
-                    processedContent.substring(injection.endIndex);
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-                const replacement = `[Shell command error: ${errorMessage}]`;
-                processedContent = processedContent.substring(0, injection.startIndex) +
-                    replacement +
-                    processedContent.substring(injection.endIndex);
-            }
-        }
-        return processedContent;
-    }
-    extractShellInjections(content) {
-        const injections = [];
-        let searchIndex = 0;
-        while (true) {
-            const startIndex = content.indexOf(this.SHELL_TRIGGER, searchIndex);
-            if (startIndex === -1)
-                break;
-            const contentStart = startIndex + this.SHELL_TRIGGER.length;
-            const endIndex = content.indexOf(this.SHELL_CLOSE, contentStart);
-            if (endIndex === -1) {
-                // No closing brace found, skip this occurrence
-                searchIndex = contentStart;
-                continue;
-            }
-            const command = content.substring(contentStart, endIndex).trim();
-            if (command.length > 0) {
-                injections.push({
-                    startIndex,
-                    endIndex: endIndex + this.SHELL_CLOSE.length,
-                    command
-                });
-            }
-            searchIndex = endIndex + this.SHELL_CLOSE.length;
-        }
-        return injections;
-    }
-    validateCommand(command) {
-        if (!this.options.enableShellExecution) {
-            throw new Error('Shell execution is disabled');
-        }
-        // Extract the base command (first word)
-        const baseCommand = command.trim().split(/\s+/)[0];
-        // Check blocked commands
-        if (this.options.blockedCommands.some(blocked => baseCommand.includes(blocked))) {
-            throw new Error(`Command '${baseCommand}' is blocked for security reasons`);
-        }
-        // Check allowed commands (if allowlist is defined)
-        if (this.options.allowedCommands.length > 0 &&
-            !this.options.allowedCommands.some(allowed => baseCommand.includes(allowed))) {
-            throw new Error(`Command '${baseCommand}' is not in the allowed commands list`);
-        }
-        // Additional security checks
-        if (command.includes('&&') || command.includes('||') || command.includes(';') || command.includes('|')) {
-            throw new Error('Command chaining and piping are not allowed');
-        }
-    }
-    async executeCommand(command) {
-        try {
-            const { stdout, stderr } = await this.execAsync(command, {
-                cwd: this.options.workingDirectory,
-                timeout: this.options.maxExecutionTime,
-                maxBuffer: 1024 * 1024 // 1MB buffer
-            });
-            let result = stdout;
-            if (stderr) {
-                result += `\n[stderr]: ${stderr}`;
-            }
-            return result || '[Command executed successfully with no output]';
-        }
-        catch (error) {
-            if (error.killed && error.signal === 'SIGTERM') {
-                throw new Error(`Command timed out after ${this.options.maxExecutionTime}ms`);
-            }
-            throw new Error(`Command failed: ${error.message}`);
-        }
-    }
-    escapeShellArg(arg) {
-        // Basic shell escaping - in production, use a proper shell escaping library
-        return `"${arg.replace(/"/g, '\\"')}"`;
-    }
-    escapeRegex(str) {
-        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    }
-}
-exports.ShellProcessorModifier = ShellProcessorModifier;

package/dist/processor-pieces/additionalModifiers/toolInjectionModifier.d.ts

@@ -1,20 +0,0 @@
-import { ProcessedMessage } from "@codebolt/types/agent";
-import { BaseMessageModifier } from "../base";
-import { FlatUserMessage } from "@codebolt/types/sdk";
-export interface ToolInjectionOptions {
-    toolsLocation?: 'Tool' | 'SystemMessage' | 'InsidePrompt';
-    includeToolDescriptions?: boolean;
-    maxToolsInMessage?: number;
-    giveToolExamples?: boolean;
-    maxToolExamples?: number;
-}
-export declare class ToolInjectionModifier extends BaseMessageModifier {
-    private readonly options;
-    constructor(options?: ToolInjectionOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
-    private addToolsInsidePrompt;
-    private addToolsAsSystemMessage;
-    private addToolsAsToolCalls;
-    private generateToolsInfo;
-    private generateToolExample;
-}

package/dist/processor-pieces/additionalModifiers/toolInjectionModifier.js

@@ -1,152 +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.ToolInjectionModifier = void 0;
-const base_1 = require("../base");
-const codeboltjs_1 = __importDefault(require("@codebolt/codeboltjs"));
-class ToolInjectionModifier extends base_1.BaseMessageModifier {
-    constructor(options = {}) {
-        super();
-        this.options = {
-            toolsLocation: options.toolsLocation || 'Tool',
-            includeToolDescriptions: options.includeToolDescriptions !== false,
-            maxToolsInMessage: options.maxToolsInMessage || 20,
-            giveToolExamples: options.giveToolExamples || false,
-            maxToolExamples: options.maxToolExamples || 2
-        };
-    }
-    async modify(originalRequest, createdMessage) {
-        try {
-            const toolsResponse = await codeboltjs_1.default.mcp.listMcpFromServers(['codebolt']);
-            const tools = (toolsResponse === null || toolsResponse === void 0 ? void 0 : toolsResponse.data) || [];
-            if (tools.length === 0) {
-                return createdMessage;
-            }
-            switch (this.options.toolsLocation) {
-                case 'InsidePrompt':
-                    //@ts-ignore
-                    return this.addToolsInsidePrompt(createdMessage, tools);
-                //@ts-ignore
-                case 'SystemMessage':
-                    //@ts-ignore
-                    return this.addToolsAsSystemMessage(createdMessage, tools);
-                case 'Tool':
-                    //@ts-ignore
-                    return this.addToolsAsToolCalls(createdMessage, tools);
-                default:
-                    //@ts-ignore
-                    return this.addToolsAsToolCalls(createdMessage, tools);
-            }
-        }
-        catch (error) {
-            console.error('Error in ToolInjectionModifier:', error);
-            return createdMessage;
-        }
-    }
-    addToolsInsidePrompt(createdMessage, tools) {
-        const toolsInfo = this.generateToolsInfo(tools);
-        // Modify the last user message to include tools information
-        const modifiedMessages = createdMessage.message.messages.map((message, index) => {
-            if (message.role === 'user' && index === createdMessage.message.messages.length - 1) {
-                return {
-                    ...message,
-                    content: `${message.content}\n\n--- Available Tools ---\n${toolsInfo}`
-                };
-            }
-            return message;
-        });
-        return {
-            message: {
-                ...createdMessage.message,
-                messages: modifiedMessages
-            },
-            metadata: {
-                ...createdMessage.metadata,
-                toolsInjected: true,
-                toolsLocation: 'InsidePrompt',
-                toolsCount: tools.length
-            }
-        };
-    }
-    addToolsAsSystemMessage(createdMessage, tools) {
-        const toolsInfo = this.generateToolsInfo(tools);
-        const toolsMessage = {
-            role: 'system',
-            content: `Available Tools:\n${toolsInfo}`
-        };
-        return {
-            message: {
-                ...createdMessage.message,
-                messages: [toolsMessage, ...createdMessage.message.messages]
-            },
-            metadata: {
-                ...createdMessage.metadata,
-                toolsInjected: true,
-                toolsLocation: 'SystemMessage',
-                toolsCount: tools.length
-            }
-        };
-    }
-    addToolsAsToolCalls(createdMessage, tools) {
-        return {
-            message: {
-                ...createdMessage.message,
-                tools,
-                tool_choice: 'auto'
-            },
-            metadata: {
-                ...createdMessage.metadata,
-                toolsInjected: true,
-                toolsLocation: 'Tool',
-                toolsCount: tools.length
-            }
-        };
-    }
-    generateToolsInfo(tools) {
-        const toolsInfo = [];
-        tools.slice(0, this.options.maxToolsInMessage).forEach((tool, index) => {
-            let toolInfo = `${index + 1}. **${tool.function.name}**`;
-            if (this.options.includeToolDescriptions && tool.function.description) {
-                toolInfo += `\n   Description: ${tool.function.description}`;
-            }
-            if (tool.function.parameters) {
-                const params = typeof tool.function.parameters === 'object'
-                    ? Object.keys(tool.function.parameters).join(', ')
-                    : String(tool.function.parameters);
-                toolInfo += `\n   Parameters: ${params}`;
-            }
-            if (this.options.giveToolExamples && index < this.options.maxToolExamples) {
-                const example = this.generateToolExample(tool);
-                if (example) {
-                    toolInfo += `\n   Example: ${example}`;
-                }
-            }
-            toolsInfo.push(toolInfo);
-        });
-        return toolsInfo.join('\n\n');
-    }
-    generateToolExample(tool) {
-        // Generate simple examples based on tool name
-        const toolName = tool.function.name.toLowerCase();
-        if (toolName.includes('read') && toolName.includes('file')) {
-            return `${tool.function.name}({ filePath: "example.txt" })`;
-        }
-        if (toolName.includes('write') && toolName.includes('file')) {
-            return `${tool.function.name}({ filePath: "output.txt", content: "Hello World" })`;
-        }
-        if (toolName.includes('delete') && toolName.includes('file')) {
-            return `${tool.function.name}({ filePath: "temp.txt" })`;
-        }
-        if (toolName.includes('move') && toolName.includes('file')) {
-            return `${tool.function.name}({ sourcePath: "old.txt", destinationPath: "new.txt" })`;
-        }
-        if (toolName.includes('copy') && toolName.includes('file')) {
-            return `${tool.function.name}({ sourcePath: "source.txt", destinationPath: "copy.txt" })`;
-        }
-        // Generic example
-        return `${tool.function.name}({ /* parameters */ })`;
-    }
-}
-exports.ToolInjectionModifier = ToolInjectionModifier;

package/dist/processor-pieces/messageModifiers/addCurrentDirectoryRootFilesModifier.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 AddCurrentDirectoryRootFilesModifier extends BaseMessageModifier {
-    constructor();
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage, context?: Record<string, unknown>): Promise<ProcessedMessage>;
-}

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

@@ -1,93 +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;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddCurrentDirectoryRootFilesModifier = void 0;
-const base_1 = require("../base");
-const fs = __importStar(require("fs"));
-class AddCurrentDirectoryRootFilesModifier extends base_1.BaseMessageModifier {
-    constructor() {
-        super();
-    }
-    async modify(originalRequest, createdMessage, context) {
-        try {
-            // Use current working directory
-            const currentPath = process.cwd();
-            // Read directory contents
-            const files = await fs.promises.readdir(currentPath, { withFileTypes: true });
-            // Format files list with type indicators
-            const filesList = files
-                .map(file => {
-                return ` ${file.name}`;
-            })
-                .join('\n');
-            const filesContent = filesList || 'No files found';
-            // Find system message and append files list to it
-            const messages = [...createdMessage.message.messages];
-            const systemMessageIndex = messages.findIndex(message => message.role === 'system');
-            if (systemMessageIndex !== -1) {
-                // Update existing system message
-                messages[systemMessageIndex] = {
-                    ...messages[systemMessageIndex],
-                    content: `${messages[systemMessageIndex].content}\n\nCurrent directory root files:\n\n${filesContent}`
-                };
-            }
-            else {
-                // Add new system message if none exists
-                messages.unshift({
-                    role: 'system',
-                    content: `Current directory root files:\n\n${filesContent}`
-                });
-            }
-            // Return updated message
-            return {
-                message: {
-                    ...createdMessage.message,
-                    messages
-                },
-                metadata: {
-                    ...createdMessage.metadata,
-                    currentDirectoryFilesAdded: true,
-                    currentDirectoryPath: currentPath
-                }
-            };
-        }
-        catch (error) {
-            console.error('Error in AddCurrentDirectoryRootFilesModifier:', error);
-            // Return original message if there's an error
-            return createdMessage;
-        }
-    }
-}
-exports.AddCurrentDirectoryRootFilesModifier = AddCurrentDirectoryRootFilesModifier;

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

@@ -1,9 +0,0 @@
-import { ProcessedMessage } from "@codebolt/types/agent";
-import { BaseMessageModifier } from "../base";
-import { FlatUserMessage } from "@codebolt/types/sdk";
-export declare class AdvancedSystemInstructionMessageModifier extends BaseMessageModifier {
-    private readonly systemInstruction;
-    constructor(systemInstruction?: string);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
-    private getAdvancedSystemPrompt;
-}

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

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AdvancedSystemInstructionMessageModifier = void 0;
-const base_1 = require("../base");
-class AdvancedSystemInstructionMessageModifier extends base_1.BaseMessageModifier {
-    constructor(systemInstruction) {
-        super();
-        this.systemInstruction = systemInstruction || this.getAdvancedSystemPrompt();
-    }
-    async modify(originalRequest, createdMessage) {
-        try {
-            const systemMessage = {
-                role: 'system',
-                content: this.systemInstruction
-            };
-            const messages = [...(createdMessage.message.messages || [])];
-            const existingSystemIndex = messages.findIndex(msg => msg.role === 'system');
-            if (existingSystemIndex !== -1) {
-                messages[existingSystemIndex] = systemMessage;
-            }
-            else {
-                messages.unshift(systemMessage);
-            }
-            return {
-                message: {
-                    ...createdMessage.message,
-                    messages
-                },
-                metadata: {
-                    ...createdMessage.metadata
-                }
-            };
-        }
-        catch (error) {
-            console.error('Error in AdvancedSystemInstructionMessageModifier:', error);
-            throw error;
-        }
-    }
-    getAdvancedSystemPrompt() {
-        const advancedPrompt = `
-You are an advanced AI software engineering assistant with expertise in multiple programming languages, frameworks, and best practices. Your primary goal is to assist users efficiently and safely while adhering to the following guidelines:
-
-1. Code Quality and Best Practices:
-   - Write clean, efficient, and maintainable code
-   - Follow SOLID principles and design patterns when appropriate
-   - Implement proper error handling and logging
-   - Write unit tests for new functionality
-   - Ensure code is secure and follows cybersecurity best practices
-
-2. Project-Specific Considerations:
-   - Analyze and adhere to existing project structure, naming conventions, and coding style
-   - Use established libraries and frameworks within the project
-   - Consider scalability and performance implications of changes
-   - Maintain backward compatibility unless explicitly instructed otherwise
-
-3. Communication and Collaboration:
-   - Provide clear, concise explanations for your decisions and implementations
-   - Ask clarifying questions when requirements are ambiguous
-   - Suggest improvements or alternatives when appropriate
-   - Break down complex tasks into manageable steps
-
-4. Continuous Learning and Adaptation:
-   - Stay updated on latest industry trends and best practices
-   - Adapt your approach based on user feedback and project requirements
-   - Recommend modern tools and techniques when beneficial to the project
-
-5. Ethical Considerations:
-   - Respect intellectual property rights and licensing
-   - Avoid implementing features that could be used maliciously
-   - Promote inclusive and accessible code practices
-
-Remember to use the provided tools effectively, always prioritize user safety and project integrity, and strive for excellence in every task you undertake.
-`.trim();
-        return advancedPrompt;
-    }
-}
-exports.AdvancedSystemInstructionMessageModifier = AdvancedSystemInstructionMessageModifier;

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

@@ -1,19 +0,0 @@
-import { ProcessedMessage } from "@codebolt/types/agent";
-import { BaseMessageModifier } from "../base";
-import { FlatUserMessage } from "@codebolt/types/sdk";
-export interface ChatCompressionOptions {
-    tokenThreshold?: number;
-    compressionRatio?: number;
-    preserveRecentMessages?: number;
-    enableCompression?: boolean;
-}
-export declare class ChatCompressionModifier extends BaseMessageModifier {
-    private readonly options;
-    private hasFailedCompressionAttempt;
-    constructor(options?: ChatCompressionOptions);
-    modify(originalRequest: FlatUserMessage, createdMessage: ProcessedMessage): Promise<ProcessedMessage>;
-    private shouldCompressChat;
-    private compressMessages;
-    private createConversationSummary;
-    resetCompressionState(): void;
-}

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

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChatCompressionModifier = void 0;
-const base_1 = require("../base");
-class ChatCompressionModifier extends base_1.BaseMessageModifier {
-    constructor(options = {}) {
-        super();
-        this.hasFailedCompressionAttempt = false;
-        this.options = {
-            tokenThreshold: options.tokenThreshold || 8000, // Approximate token threshold
-            compressionRatio: options.compressionRatio || 0.5, // Compress to 50% of original
-            preserveRecentMessages: options.preserveRecentMessages || 5,
-            enableCompression: options.enableCompression !== false
-        };
-    }
-    async modify(originalRequest, createdMessage) {
-        try {
-            if (!this.options.enableCompression || this.hasFailedCompressionAttempt) {
-                return createdMessage;
-            }
-            const messages = createdMessage.message.messages;
-            // Skip compression if we don't have enough messages
-            if (messages.length <= this.options.preserveRecentMessages) {
-                return createdMessage;
-            }
-            const shouldCompress = await this.shouldCompressChat(messages);
-            if (!shouldCompress) {
-                return createdMessage;
-            }
-            const compressedMessages = await this.compressMessages(messages);
-            return Promise.resolve({
-                message: {
-                    ...createdMessage.message,
-                    messages: compressedMessages
-                },
-                metadata: {
-                    ...createdMessage.metadata,
-                    chatCompressed: true,
-                    originalMessageCount: messages.length,
-                    compressedMessageCount: compressedMessages.length
-                }
-            });
-        }
-        catch (error) {
-            console.error('Error in ChatCompressionModifier:', error);
-            this.hasFailedCompressionAttempt = true;
-            return createdMessage;
-        }
-    }
-    async shouldCompressChat(messages) {
-        // Estimate token count (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);
-        const estimatedTokens = totalCharacters / 4;
-        return estimatedTokens > this.options.tokenThreshold;
-    }
-    async compressMessages(messages) {
-        const preserveCount = this.options.preserveRecentMessages;
-        const recentMessages = messages.slice(-preserveCount);
-        const messagesToCompress = messages.slice(0, -preserveCount);
-        if (messagesToCompress.length === 0) {
-            return messages;
-        }
-        // Create a summary of the messages to compress
-        const conversationSummary = this.createConversationSummary(messagesToCompress);
-        const compressionMessage = {
-            role: 'system',
-            content: `[Conversation Summary - Previous ${messagesToCompress.length} messages compressed]
-
-${conversationSummary}
-
-[End of Summary - Continuing with recent conversation...]`
-        };
-        return [compressionMessage, ...recentMessages];
-    }
-    createConversationSummary(messages) {
-        const summaryParts = [];
-        let currentTopic = '';
-        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') {
-                // Extract key questions or requests
-                if (content.length > 20) { // Only include substantial messages
-                    userQuestions.push(content.substring(0, 100) + (content.length > 100 ? '...' : ''));
-                }
-            }
-            else if (message.role === 'assistant') {
-                // Extract key responses or actions
-                if (content.length > 20) {
-                    assistantResponses.push(content.substring(0, 100) + (content.length > 100 ? '...' : ''));
-                }
-            }
-        }
-        if (userQuestions.length > 0) {
-            summaryParts.push(`Key user requests: ${userQuestions.slice(0, 3).join('; ')}`);
-        }
-        if (assistantResponses.length > 0) {
-            summaryParts.push(`Key assistant actions: ${assistantResponses.slice(0, 3).join('; ')}`);
-        }
-        summaryParts.push(`Total messages compressed: ${messages.length}`);
-        return summaryParts.join('\n');
-    }
-    resetCompressionState() {
-        this.hasFailedCompressionAttempt = false;
-    }
-}
-exports.ChatCompressionModifier = ChatCompressionModifier;