@xagent-ai/cli 1.2.2 → 1.3.1

package/dist/context-compressor.js

@@ -1,112 +1,538 @@
-import { AIClient } from './ai-client.js';
+import { getCancellationManager } from './cancellation.js';
+import { createAIClient } from './ai-client-factory.js';
+import { output as logOutput } from './output-util.js';
+/**
+ * Model context window sizes (in tokens)
+ * Add models here as needed
+ */
+const MODEL_CONTEXT_WINDOWS = {
+    // OpenAI
+    'gpt-4': 8192,
+    'gpt-4-32k': 32768,
+    'gpt-4-turbo': 128000,
+    'gpt-4o': 128000,
+    'gpt-4o-mini': 128000,
+    'gpt-5': 200000,
+    // Anthropic Claude
+    'claude-sonnet-4-20250514': 200000,
+    'claude-sonnet-4': 200000,
+    'claude-opus-4': 200000,
+    'claude-3-5-sonnet': 200000,
+    'claude-3-opus': 200000,
+    // Google
+    'gemini-pro': 32768,
+    'gemini-ultra': 1000000,
+    // DeepSeek
+    'deepseek-chat': 128000,
+    'deepseek-coder': 128000,
+    'deepseek-reasoner': 128000,
+    // Qwen (Tongyi Qianwen)
+    'qwen-max': 32768,
+    'qwen-plus': 64000,
+    'qwen-turbo': 8000,
+    'qwen-long': 100000,
+    'qwen-vl-max': 128000,
+    'Qwen3-Coder': 32768,
+    // Zhipu AI (GLM)
+    'glm-4': 128000,
+    'glm-4-plus': 128000,
+    'glm-4-air': 128000,
+    'glm-4.7': 200000,
+    'glm-5': 200000,
+    // MiniMax
+    'MiniMax-M2': 200000,
+    'MiniMax-M2.1': 200000,
+    'MiniMax-M2.5': 200000,
+    // Moonshot (Kimi)
+    'moonshot-v1-8k': 8192,
+    'moonshot-v1-32k': 32768,
+    'moonshot-v1-128k': 131072,
+    // Doubao
+    'doubao-seed-1-8-251228': 256000,
+    'doubao-1-5-ui-tars-250428': 256000,
+    // Default fallback
+    'default': 200000
+};
+// Compression ratio constants - easier to tune and maintain
+const COMPRESSION_RATIO = {
+    RESERVE_RATIO: 0.50, // Reserve 50% of context window for system prompt and recent messages
+    SUMMARY_THRESHOLD_RATIO: 0.15, // Use 15% of available space for summary
+    MAX_TOKENS_RATIO: 0.8, // Use 80% of reserved tokens for compression
+    SUMMARY_MAX_TOKENS_RATIO: 0.5, // Use 50% of reserved tokens for summary
+    MIN_SUMMARY_TOKENS: 800 // Minimum tokens for summary
+};
+/**
+ * Get the context window for a model
+ */
+export function getModelContextWindow(modelName) {
+    if (!modelName)
+        return MODEL_CONTEXT_WINDOWS['default'];
+    // Try exact match first
+    if (MODEL_CONTEXT_WINDOWS[modelName]) {
+        return MODEL_CONTEXT_WINDOWS[modelName];
+    }
+    // Try case-insensitive match
+    const lowerName = modelName.toLowerCase();
+    for (const [key, value] of Object.entries(MODEL_CONTEXT_WINDOWS)) {
+        if (key.toLowerCase() === lowerName) {
+            return value;
+        }
+    }
+    // Try partial match (e.g., "claude" matches "claude-sonnet-4")
+    for (const [key, value] of Object.entries(MODEL_CONTEXT_WINDOWS)) {
+        if (lowerName.includes(key.toLowerCase()) || key.toLowerCase().includes(lowerName)) {
+            return value;
+        }
+    }
+    return MODEL_CONTEXT_WINDOWS['default'];
+}
+const SUMMARIZATION_PROMPT = `The messages above are a conversation to summarize. Create a structured context checkpoint summary that another LLM will use to continue the work.
+
+Use this EXACT format:
+
+## Goal
+[What is the user trying to accomplish? Can be multiple items if the session covers different tasks.]
+
+## Constraints & Preferences
+- [Any constraints, preferences, or requirements mentioned by user]
+- [Or "(none)" if none were mentioned]
+
+## Progress
+### Done
+- [x] [Completed tasks/changes]
+
+### In Progress
+- [ ] [Current work]
+
+### Blocked
+- [Issues preventing progress, if any]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale]
+
+## Next Steps
+1. [Ordered list of what should happen next]
+
+## Critical Context
+
+### Key Files & Code
+- [File path]: [Brief description of key content/structure]
+- [File path]: [Brief description of key content/structure]
+
+### Execution Results
+- **Files**: [What files were read, written, or edited and key findings]
+- **Commands**: [Key commands run and their outputs]
+- **Search/Analysis**: [Key findings from code search or analysis]
+
+### Project Context
+- [Architecture patterns identified]
+- [Important configurations]
+- [Dependencies or libraries relevant to the task]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+const UPDATE_SUMMARIZATION_PROMPT = `The messages above are NEW conversation messages to incorporate into the existing summary provided in <previous-summary> tags.
+
+Update the existing structured summary with new information. RULES:
+- PRESERVE all existing information from the previous summary
+- ADD new progress, decisions, and context from the new messages
+- UPDATE the Progress section: move items from "In Progress" to "Done" when completed
+- UPDATE "Next Steps" based on what was accomplished
+- PRESERVE exact file paths, function names, and error messages
+- If something is no longer relevant, you may remove it
+
+Use this EXACT format:
+
+## Goal
+[Preserve existing goals, add new ones if the task expanded]
+
+## Constraints & Preferences
+- [Preserve existing, add new ones discovered]
+
+## Progress
+### Done
+- [x] [Include previously done items AND newly completed items]
+
+### In Progress
+- [ ] [Current work - update based on progress]
+
+### Blocked
+- [Current blockers - remove if resolved]
+
+## Key Decisions
+- **[Decision]**: [Brief rationale] (preserve all previous, add new)
+
+## Next Steps
+1. [Update based on current state]
+
+## Critical Context
+
+### Key Files & Code
+- [Preserve existing file info, add new files read]
+- [Include brief descriptions of key code structures]
+
+### Execution Results
+- **Files**: [Preserve file list, add new files read/written/edited]
+- **Commands**: [Preserve outputs, add new command results]
+- **Search/Analysis**: [Preserve findings, add new search results]
+
+### Project Context
+- [Preserve architecture info, add new patterns discovered]
+- [Preserve configs, add new relevant dependencies]
+
+Keep each section concise. Preserve exact file paths, function names, and error messages.`;
+const TURN_PREFIX_SUMMARIZATION_PROMPT = `This is the PREFIX of a turn that was too large to keep. The SUFFIX (recent work) is retained.
+
+Summarize the prefix to provide context for the retained suffix:
+
+## Original Request
+[What did the user ask for in this turn?]
+
+## Early Progress
+- [Key decisions and work done in the prefix]
+
+## Critical Context
+
+### Key Files & Code
+- [File path]: [Brief description of key content/structure]
+
+### Execution Results
+- **Files**: [What files were read, written, or edited in this prefix]
+- **Commands**: [Key commands run and outputs]
+
+### Context for Suffix
+- [Information needed to understand the retained recent work]
+
+Be concise. Focus on what's needed to understand the kept suffix.`;
 export class ContextCompressor {
     aiClient = null;
     defaultConfig = {
-        enabled: true,
-        maxMessages: 50,
-        maxContextSize: 150000,
-        preserveRecentMessages: 0,
-        enableSummary: true
+        enabled: true
     };
     constructor(authConfig) {
         if (authConfig) {
-            this.aiClient = new AIClient(authConfig);
+            this.aiClient = createAIClient(authConfig);
         }
     }
     setAIClient(aiClient) {
         this.aiClient = aiClient;
     }
     /**
-     * Check if compression is needed
+     * Check if compression is needed based on token budget and model context window
+     * @param messages - Conversation messages
+     * @param config - Compression config
+     * @param modelName - Optional model name to determine context window
      */
-    needsCompression(messages, config) {
-        const cfg = { ...this.defaultConfig, ...config };
-        const userMessageCount = messages.filter(m => m.role === 'user').length;
-        const contextSize = this.calculateContextSize(messages);
-        if (userMessageCount > cfg.maxMessages) {
+    needsCompression(messages, config, modelName) {
+        const _cfg = { ...this.defaultConfig, ...config };
+        const _messageCount = messages.length;
+        const tokenCount = this.estimateContextTokens(messages);
+        // Get model context window
+        const contextWindow = getModelContextWindow(modelName);
+        // Calculate threshold using compression ratio constants
+        const reserveTokens = Math.floor(contextWindow * COMPRESSION_RATIO.RESERVE_RATIO);
+        const threshold = contextWindow - reserveTokens;
+        if (tokenCount > threshold) {
             return {
                 needsCompression: true,
-                reason: `User message count (${userMessageCount}) exceeds maximum (${cfg.maxMessages})`
+                reason: `Token count (${tokenCount}) exceeds ${modelName ? `${modelName}` : ''} context budget (${threshold}, contextWindow: ${contextWindow})`,
+                tokenCount
             };
         }
-        if (contextSize > cfg.maxContextSize) {
-            return {
-                needsCompression: true,
-                reason: `Context size (${contextSize} chars) exceeds maximum (${cfg.maxContextSize} chars)`
-            };
+        return { needsCompression: false, reason: '', tokenCount };
+    }
+    /**
+     * Estimate token count for a single message using message-type-aware heuristic
+     */
+    estimateMessageTokens(message) {
+        let chars = 0;
+        switch (message.role) {
+            case 'user':
+            case 'system':
+            case 'tool': {
+                chars = message.content.length;
+                break;
+            }
+            case 'assistant': {
+                if (message.reasoning_content) {
+                    chars += message.reasoning_content.length;
+                }
+                const toolCalls = message.tool_calls;
+                if (toolCalls && toolCalls.length > 0) {
+                    for (const toolCall of toolCalls) {
+                        chars += JSON.stringify(toolCall).length;
+                    }
+                }
+                chars += message.content.length;
+                break;
+            }
         }
-        return { needsCompression: false, reason: '' };
+        return Math.ceil(chars / 4);
     }
     /**
-     * Calculate context size（字符数）
+     * Estimate total token count for a conversation
      */
-    calculateContextSize(messages) {
-        return messages.reduce((total, msg) => {
-            return total + msg.content.length + (msg.role.length + 10);
-        }, 0);
+    estimateContextTokens(messages) {
+        let total = 0;
+        for (const msg of messages) {
+            total += this.estimateMessageTokens(msg);
+        }
+        return total;
     }
     /**
-     * Compress conversation history
+     * Find valid cut points: indices of messages that can be cut at
+     * Never cut at tool results (they must follow their tool call)
      */
-    async compressContext(messages, systemPrompt, config) {
-        const cfg = { ...this.defaultConfig, ...config };
-        const originalMessageCount = messages.length;
-        const originalSize = this.calculateContextSize(messages);
-        // Separate system messages、用户消息和助手消息
-        const systemMessages = messages.filter(m => m.role === 'system');
-        const nonSystemMessages = messages.filter(m => m.role !== 'system');
-        // 如果消息数量和大小都在限制内，不需要压缩
-        const { needsCompression } = this.needsCompression(nonSystemMessages, config);
-        if (!needsCompression) {
-            return {
-                compressedMessages: messages,
-                wasCompressed: false,
-                originalMessageCount,
-                compressedMessageCount: messages.length,
-                originalSize,
-                compressedSize: originalSize,
-                compressionMethod: 'none'
-            };
+    findValidCutPoints(messages, startIndex, endIndex) {
+        const cutPoints = [];
+        for (let i = startIndex; i < endIndex; i++) {
+            const msg = messages[i];
+            switch (msg.role) {
+                case 'user':
+                case 'assistant':
+                case 'system':
+                    cutPoints.push(i);
+                    break;
+                case 'tool':
+                    // Tool results cannot be cut at (they must follow their tool call)
+                    break;
+            }
+        }
+        return cutPoints;
+    }
+    /**
+     * Find the user message that starts the turn containing the given index
+     */
+    findTurnStartIndex(messages, entryIndex, startIndex) {
+        for (let i = entryIndex; i >= startIndex; i--) {
+            const role = messages[i].role;
+            if (role === 'user') {
+                return i;
+            }
+        }
+        return -1;
+    }
+    /**
+     * Find the cut point that keeps approximately keepRecentTokens
+     * Walks backwards from newest, accumulating estimated message sizes
+     */
+    findCutPoint(messages, startIndex, endIndex, keepRecentTokens) {
+        const cutPoints = this.findValidCutPoints(messages, startIndex, endIndex);
+        if (cutPoints.length === 0) {
+            return { firstKeptEntryIndex: startIndex, turnStartIndex: -1, isSplitTurn: false };
         }
-        // Use AI to generate summary压缩全部历史对话
-        const compressedMessages = await this.summarizeAllMessages(nonSystemMessages, systemPrompt, cfg);
-        // 注意：不再保留原始的 systemMessages，因为 generateResponse 会自动添加系统提示
-        // 压缩后的消息只includes摘要（role: assistant），避免重复的 system 消息导致 API 报错
-        const finalMessages = [...compressedMessages];
+        // Walk backwards from newest, accumulating estimated message sizes
+        let accumulatedTokens = 0;
+        let cutIndex = cutPoints[cutPoints.length - 1]; // Start with the last cut point
+        for (let i = endIndex - 1; i >= startIndex; i--) {
+            const messageTokens = this.estimateMessageTokens(messages[i]);
+            accumulatedTokens += messageTokens;
+            if (accumulatedTokens >= keepRecentTokens) {
+                // Find the closest valid cut point at or after this entry
+                // Search from the END of cutPoints array (closest to i)
+                for (let c = cutPoints.length - 1; c >= 0; c--) {
+                    if (cutPoints[c] >= i) {
+                        cutIndex = cutPoints[c];
+                    }
+                    else {
+                        // Since cutPoints is sorted ascending, no need to continue
+                        break;
+                    }
+                }
+                break;
+            }
+        }
+        // Determine if this is a split turn
+        const isUserMessage = messages[cutIndex].role === 'user';
+        const turnStartIndex = isUserMessage ? -1 : this.findTurnStartIndex(messages, cutIndex, startIndex);
         return {
-            compressedMessages: finalMessages,
-            wasCompressed: true,
-            originalMessageCount,
-            compressedMessageCount: finalMessages.length,
-            originalSize,
-            compressedSize: this.calculateContextSize(finalMessages),
-            compressionMethod: 'summary'
+            firstKeptEntryIndex: cutIndex,
+            turnStartIndex,
+            isSplitTurn: !isUserMessage && turnStartIndex !== -1
         };
     }
     /**
-     * Use AI to generate summary来压缩全部对话历史
+     * Extract file operations from messages by analyzing tool calls
      */
-    async summarizeAllMessages(messages, systemPrompt, config) {
-        // 生成完整对话的摘要
-        const summary = await this.generateSummary(messages, systemPrompt);
-        // 构建压缩后的对话：只有摘要作为 system 消息
-        const compressed = [];
-        // 添加摘要作为 assistant 消息，避免与系统提示重复导致 API 报错
-        compressed.push({
-            role: 'assistant',
-            content: `[Conversation Summary - ${messages.length} messages compressed]\n\n${summary}`,
-            timestamp: Date.now()
-        });
-        return compressed;
+    extractFileOperations(messages) {
+        const fileOps = {
+            read: new Set(),
+            modified: new Set()
+        };
+        let _totalToolCalls = 0;
+        let _matchedToolCalls = 0;
+        // Normalize tool name (handle both API format and internal format)
+        const isReadTool = (name) => name === 'read_file' || name === 'Read';
+        const isWriteTool = (name) => name === 'write_file' || name === 'Write';
+        const isEditTool = (name) => name === 'Edit';
+        const isDeleteTool = (name) => name === 'DeleteFile';
+        const getFilePath = (args) => {
+            return args.filePath || args.absolute_path || args.path || '';
+        };
+        for (const msg of messages) {
+            // Case 1: assistant with tool_calls field
+            if (msg.role === 'assistant' && msg.tool_calls) {
+                for (const toolCall of msg.tool_calls) {
+                    _totalToolCalls++;
+                    const toolName = toolCall.function?.name || '';
+                    let args = {};
+                    try {
+                        args = JSON.parse(toolCall.function?.arguments || '{}');
+                    }
+                    catch {
+                        continue;
+                    }
+                    const filePath = getFilePath(args);
+                    if (!filePath)
+                        continue;
+                    if (isReadTool(toolName)) {
+                        fileOps.read.add(filePath);
+                        _matchedToolCalls++;
+                    }
+                    else if (isWriteTool(toolName) || isEditTool(toolName) || isDeleteTool(toolName)) {
+                        fileOps.modified.add(filePath);
+                        _matchedToolCalls++;
+                    }
+                }
+            }
+            // Case 2: tool role with JSON content (like {"name":"Read","parameters":...})
+            if (msg.role === 'tool' && typeof msg.content === 'string') {
+                try {
+                    const content = JSON.parse(msg.content);
+                    _totalToolCalls++;
+                    const toolName = content.name || '';
+                    const args = content.parameters || {};
+                    const filePath = getFilePath(args);
+                    if (!filePath)
+                        continue;
+                    if (isReadTool(toolName)) {
+                        fileOps.read.add(filePath);
+                        _matchedToolCalls++;
+                    }
+                    else if (isWriteTool(toolName) || isEditTool(toolName) || isDeleteTool(toolName)) {
+                        fileOps.modified.add(filePath);
+                        _matchedToolCalls++;
+                    }
+                }
+                catch {
+                    // Not JSON, skip
+                }
+            }
+        }
+        return fileOps;
+    }
+    /**
+     * Merge file operations from previous compaction
+     */
+    mergeFileOps(ops1, ops2) {
+        return {
+            read: new Set([...ops1.read, ...ops2.read]),
+            modified: new Set([...ops1.modified, ...ops2.modified])
+        };
+    }
+    /**
+     * Format file operations for inclusion in summary
+     */
+    formatFileOperations(fileOps) {
+        const readFiles = Array.from(fileOps.read);
+        const modifiedFiles = Array.from(fileOps.modified);
+        if (readFiles.length === 0 && modifiedFiles.length === 0) {
+            return '';
+        }
+        let formatted = '\n\n## File Operations\n\n';
+        if (readFiles.length > 0) {
+            formatted += '### Files read_file\n';
+            for (const file of readFiles) {
+                formatted += `- ${file}\n`;
+            }
+        }
+        if (modifiedFiles.length > 0) {
+            formatted += '\n### Files Modified\n';
+            for (const file of modifiedFiles) {
+                formatted += `- ${file}\n`;
+            }
+        }
+        return formatted;
+    }
+    /**
+     * Prepare compaction - calculate cut point and extract messages to summarize
+     */
+    prepareCompaction(messages, keepRecentTokens) {
+        if (messages.length === 0) {
+            return undefined;
+        }
+        // Check if last message already contains a compression summary
+        const lastMsg = messages[messages.length - 1];
+        const isAlreadyCompressed = lastMsg.role === 'user' &&
+            lastMsg.content.includes('[Previous conversation summarized');
+        if (isAlreadyCompressed) {
+            return undefined;
+        }
+        const startIndex = 0;
+        const endIndex = messages.length;
+        // Find cut point
+        const cutPoint = this.findCutPoint(messages, startIndex, endIndex, keepRecentTokens);
+        // Extract messages to summarize
+        const historyEnd = cutPoint.firstKeptEntryIndex;
+        const messagesToSummarize = [];
+        for (let i = startIndex; i < historyEnd; i++) {
+            messagesToSummarize.push(messages[i]);
+        }
+        // Extract turn prefix messages if splitting (disabled for simplicity)
+        const turnPrefixMessages = [];
+        if (cutPoint.isSplitTurn) {
+            for (let i = cutPoint.turnStartIndex; i < cutPoint.firstKeptEntryIndex; i++) {
+                turnPrefixMessages.push(messages[i]);
+            }
+        }
+        // Get previous summary if exists (look for embedded summary in user messages)
+        let previousSummary;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const msg = messages[i];
+            if (msg.role === 'user' && msg.content.includes('[Previous conversation summarized')) {
+                // Extract the summary part from the content
+                const match = msg.content.match(/\[Previous conversation summarized.*?\]\n(.+?)(?=\n\n---\n\n|\n\n\[)/s);
+                if (match) {
+                    previousSummary = match[1];
+                }
+                else {
+                    previousSummary = msg.content;
+                }
+                break;
+            }
+        }
+        // Extract file operations
+        const fileOps = this.extractFileOperations(messagesToSummarize);
+        // Also extract from turn prefix
+        if (cutPoint.isSplitTurn) {
+            const prefixOps = this.extractFileOperations(turnPrefixMessages);
+            return {
+                firstKeptEntryIndex: cutPoint.firstKeptEntryIndex,
+                messagesToSummarize,
+                turnPrefixMessages,
+                isSplitTurn: cutPoint.isSplitTurn,
+                tokensBefore: this.estimateContextTokens(messagesToSummarize),
+                previousSummary,
+                fileOps: this.mergeFileOps(fileOps, prefixOps)
+            };
+        }
+        return {
+            firstKeptEntryIndex: cutPoint.firstKeptEntryIndex,
+            messagesToSummarize,
+            turnPrefixMessages,
+            isSplitTurn: cutPoint.isSplitTurn,
+            tokensBefore: this.estimateContextTokens(messagesToSummarize),
+            previousSummary,
+            fileOps
+        };
     }
     /**
-     * Generate conversation summary
+     * Generate summary using AI
      */
-    async generateSummary(messages, systemPrompt) {
+    async generateSummary(messages, systemPrompt, reserveTokens, previousSummary, customInstructions) {
         if (!this.aiClient) {
             throw new Error('AI client not initialized for summarization');
         }
-        // Extract all conversation content
+        // Serialize conversation
         const conversationText = messages
             .map((m, idx) => {
             const role = m.role === 'user' ? 'User' :
@@ -115,91 +541,235 @@ export class ContextCompressor {
             return `[${idx + 1}] ${role}:\n${m.content}`;
         })
             .join('\n\n' + '='.repeat(50) + '\n\n');
-        const summaryPrompt = `You are an expert at summarizing conversations. Please create a comprehensive summary of the following conversation.
-
-## Instructions
-1. Analyze ALL messages in the conversation
-2. Create a detailed summary that captures:
-   - Complete context and background
-   - All topics discussed
-   - All decisions made
-   - All files created, modified, or analyzed
-   - All code changes and implementations
-   - All problems solved
-   - Current state and progress
-   - Any pending or ongoing tasks
-3. Be extremely thorough - this summary will replace the entire conversation history
-4. Include specific details like file paths, code snippets, command outputs, etc.
-
-## Conversation to summarize
-${conversationText}
-
-## Output Format
-Provide a detailed, comprehensive summary in the following format:
-
-### Conversation Summary
-
-#### Overview
-[Brief description of what this conversation was about]
-
-#### Background & Context
-[Complete background information]
-
-#### Topics Discussed
-- [Topic 1: detailed description]
-- [Topic 2: detailed description]
-- [All topics with full details]
-
-#### Key Decisions
-- [Decision 1: details and rationale]
-- [All decisions made during the conversation]
-
-#### File Operations
-- Created: [file paths]
-- Modified: [file paths]
-- Analyzed: [file paths]
-- Deleted: [file paths]
-
-#### Code Changes
-- [Specific code changes with details]
-- [All implementations]
-
-#### Problems & Solutions
-- Problem: [description]
-  Solution: [how it was solved]
-- [All problems and solutions]
-
-#### Current State
-[What is the current status of the project/work]
-
-#### Pending Tasks
-- [Any ongoing or pending work]
-
-#### Important Details
-[Any other crucial information]
-
-Please provide the comprehensive summary possible. Do not omit any important information.`;
+        // Select prompt based on whether we have previous summary
+        let basePrompt = previousSummary ? UPDATE_SUMMARIZATION_PROMPT : SUMMARIZATION_PROMPT;
+        if (customInstructions) {
+            basePrompt = `${basePrompt}\n\nAdditional focus: ${customInstructions}`;
+        }
+        // Build prompt
+        let promptText = `<conversation>\n${conversationText}\n</conversation>\n\n`;
+        if (previousSummary) {
+            promptText += `<previous-summary>\n${previousSummary}\n</previous-summary>\n\n`;
+        }
+        promptText += basePrompt;
+        const maxTokens = Math.floor(reserveTokens * COMPRESSION_RATIO.MAX_TOKENS_RATIO);
+        const summaryMessage = {
+            role: 'user',
+            content: promptText
+        };
+        const aiPromise = this.aiClient.compress([summaryMessage], {
+            maxTokens,
+            temperature: 0.3
+        });
         try {
-            const summaryMessage = {
-                role: 'user',
-                content: summaryPrompt
-            };
-            const response = await this.aiClient.chatCompletion([summaryMessage], {
-                maxTokens: 8192,
-                temperature: 0.3
-            });
+            const response = await getCancellationManager().withCancellation(aiPromise, 'context-compression-summary');
             const summary = response.choices[0]?.message?.content || '';
             return typeof summary === 'string' ? summary : JSON.stringify(summary);
         }
         catch (error) {
+            if (error.message === 'Operation cancelled by user') {
+                throw error;
+            }
             console.error('Failed to generate summary:', error);
+            await logOutput('error', 'Failed to generate summary', { error: error.message });
             const userCount = messages.filter(m => m.role === 'user').length;
             const toolCount = messages.filter(m => m.role === 'tool').length;
             return `[Summary of ${messages.length} messages: ${userCount} user exchanges, ${toolCount} tool calls. Key topics discussed but details unavailable due to summarization error.]`;
         }
     }
     /**
-     * Create compressed message copy（用于保存）
+     * Generate turn prefix summary when splitting a turn
+     */
+    async generateTurnPrefixSummary(messages, reserveTokens) {
+        if (!this.aiClient) {
+            throw new Error('AI client not initialized for summarization');
+        }
+        const conversationText = messages
+            .map((m, idx) => {
+            const role = m.role === 'user' ? 'User' :
+                m.role === 'assistant' ? 'Assistant' :
+                    m.role === 'tool' ? 'Tool' : m.role;
+            return `[${idx + 1}] ${role}:\n${m.content}`;
+        })
+            .join('\n\n' + '='.repeat(50) + '\n\n');
+        const promptText = `<conversation>\n${conversationText}\n</conversation>\n\n${TURN_PREFIX_SUMMARIZATION_PROMPT}`;
+        const maxTokens = Math.floor(reserveTokens * COMPRESSION_RATIO.SUMMARY_MAX_TOKENS_RATIO);
+        const summaryMessage = {
+            role: 'user',
+            content: promptText
+        };
+        const aiPromise = this.aiClient.compress([summaryMessage], {
+            maxTokens,
+            temperature: 0.3
+        });
+        try {
+            const response = await getCancellationManager().withCancellation(aiPromise, 'context-compression-turn-prefix');
+            const content = response.choices[0]?.message?.content || '';
+            return typeof content === 'string' ? content : JSON.stringify(content);
+        }
+        catch (error) {
+            if (error.message === 'Operation cancelled by user') {
+                throw error;
+            }
+            console.error('Failed to generate turn prefix summary:', error);
+            await logOutput('error', 'Failed to generate turn prefix summary', { error: error.message });
+            return '[Turn prefix summary unavailable]';
+        }
+    }
+    /**
+     * Main compression function with incremental compaction support
+     */
+    async compressContext(messages, systemPrompt, config, previousSummary, modelName) {
+        const _cfg = { ...this.defaultConfig, ...config };
+        const originalMessageCount = messages.length;
+        const originalSize = messages.reduce((total, msg) => total + msg.content.length, 0);
+        const _originalTokens = this.estimateContextTokens(messages);
+        const contextWindow = getModelContextWindow(modelName);
+        // Check if compression is needed
+        const { needsCompression } = this.needsCompression(messages, config, modelName);
+        if (!needsCompression) {
+            return {
+                compressedMessages: messages,
+                wasCompressed: false,
+                originalMessageCount,
+                compressedMessageCount: messages.length,
+                originalSize,
+                compressedSize: originalSize,
+                compressionMethod: 'none'
+            };
+        }
+        // Prepare compaction
+        // Reserve 50% of context window for new conversation, 15% for summary
+        const reserveTokens = Math.floor(contextWindow * COMPRESSION_RATIO.RESERVE_RATIO);
+        const summaryReserveTokens = Math.max(COMPRESSION_RATIO.MIN_SUMMARY_TOKENS, Math.floor((contextWindow - reserveTokens) * COMPRESSION_RATIO.SUMMARY_THRESHOLD_RATIO));
+        const keepRecentTokens = contextWindow - reserveTokens - summaryReserveTokens;
+        const preparation = this.prepareCompaction(messages, Math.max(0, keepRecentTokens));
+        if (!preparation) {
+            // Already compressed or no valid cut point
+            return {
+                compressedMessages: messages,
+                wasCompressed: false,
+                originalMessageCount,
+                compressedMessageCount: messages.length,
+                originalSize,
+                compressedSize: originalSize,
+                compressionMethod: 'none'
+            };
+        }
+        const { firstKeptEntryIndex, messagesToSummarize, turnPrefixMessages, isSplitTurn, tokensBefore, fileOps } = preparation;
+        // Generate summary
+        let summary;
+        if (isSplitTurn && turnPrefixMessages.length > 0) {
+            // Generate both summaries in parallel
+            const [historyResult, turnPrefixResult] = await Promise.all([
+                messagesToSummarize.length > 0
+                    ? this.generateSummary(messagesToSummarize, systemPrompt, summaryReserveTokens, previousSummary)
+                    : Promise.resolve('No prior history.'),
+                this.generateTurnPrefixSummary(turnPrefixMessages, summaryReserveTokens)
+            ]);
+            summary = `${historyResult}\n\n---\n\n**Turn Context (split turn):**\n\n${turnPrefixResult}`;
+        }
+        else {
+            summary = await this.generateSummary(messagesToSummarize, systemPrompt, summaryReserveTokens, previousSummary);
+        }
+        // Add file operations to summary
+        summary += this.formatFileOperations(fileOps);
+        // Build compressed messages: summary + kept messages
+        // Summary is inserted as prefix in first user message to maintain valid message order
+        const compressedMessages = [];
+        if (messagesToSummarize.length > 0) {
+            // Find first user message in kept messages
+            let firstKeptUserMsg = null;
+            let firstKeptUserIndex = -1;
+            for (let i = firstKeptEntryIndex; i < messages.length; i++) {
+                if (messages[i].role === 'user') {
+                    firstKeptUserMsg = messages[i];
+                    firstKeptUserIndex = i;
+                    break;
+                }
+            }
+            if (firstKeptUserMsg) {
+                // Prepend summary to first user message content
+                const summaryPrefix = `[Previous conversation summarized (${messagesToSummarize.length} messages):]\n${summary}\n\n---\n\n`;
+                compressedMessages.push({
+                    role: 'user',
+                    content: summaryPrefix + firstKeptUserMsg.content,
+                    timestamp: firstKeptUserMsg.timestamp,
+                    images: firstKeptUserMsg.images
+                });
+                // Add remaining kept messages (skip the modified first user message)
+                for (let i = firstKeptUserIndex + 1; i < messages.length; i++) {
+                    const msg = messages[i];
+                    compressedMessages.push({
+                        role: msg.role,
+                        content: msg.content,
+                        timestamp: msg.timestamp,
+                        images: msg.images,
+                        reasoning_content: msg.reasoning_content,
+                        tool_calls: msg.tool_calls,
+                        tool_call_id: msg.tool_call_id
+                    });
+                }
+            }
+            else {
+                // No user message in kept messages (rare case)
+                // Insert summary as a user message, then add all kept messages
+                // This ensures valid message order: user �?assistant �?tool �?tool...
+                compressedMessages.push({
+                    role: 'user',
+                    content: `[Conversation Summary - ${messagesToSummarize.length} messages compressed]\n\n${summary}`,
+                    timestamp: Date.now()
+                });
+                // Add all kept messages (they may start with assistant or tool)
+                for (let i = firstKeptEntryIndex; i < messages.length; i++) {
+                    const msg = messages[i];
+                    compressedMessages.push({
+                        role: msg.role,
+                        content: msg.content,
+                        timestamp: msg.timestamp,
+                        images: msg.images,
+                        reasoning_content: msg.reasoning_content,
+                        tool_calls: msg.tool_calls,
+                        tool_call_id: msg.tool_call_id
+                    });
+                }
+            }
+        }
+        else {
+            // No messages to summarize, just keep all messages
+            for (let i = firstKeptEntryIndex; i < messages.length; i++) {
+                const msg = messages[i];
+                compressedMessages.push({
+                    role: msg.role,
+                    content: msg.content,
+                    timestamp: msg.timestamp,
+                    images: msg.images,
+                    reasoning_content: msg.reasoning_content,
+                    tool_calls: msg.tool_calls,
+                    tool_call_id: msg.tool_call_id
+                });
+            }
+        }
+        const compressedSize = compressedMessages.reduce((total, msg) => total + msg.content.length, 0);
+        const _compressedTokens = this.estimateContextTokens(compressedMessages);
+        const _reductionPercent = Math.round((1 - compressedSize / originalSize) * 100);
+        return {
+            compressedMessages,
+            wasCompressed: true,
+            originalMessageCount,
+            compressedMessageCount: compressedMessages.length,
+            originalSize,
+            compressedSize,
+            compressionMethod: 'summary',
+            tokensBefore,
+            details: {
+                readFiles: Array.from(fileOps.read),
+                modifiedFiles: Array.from(fileOps.modified)
+            }
+        };
+    }
+    /**
+     * Create compressed message copy for saving
      */
     createCompressedSnapshot(messages, compressionResult) {
         return {
@@ -209,17 +779,11 @@ Please provide the comprehensive summary possible. Do not omit any important inf
             originalSize: compressionResult.originalSize,
             compressedSize: compressionResult.compressedSize,
             compressionMethod: compressionResult.compressionMethod,
+            tokensBefore: compressionResult.tokensBefore,
+            details: compressionResult.details,
             messages: compressionResult.compressedMessages
         };
     }
-    /**
-     * Estimate token count (rough estimate)
-     */
-    estimateTokens(text) {
-        const chineseChars = (text.match(/[\u4e00-\u9fa5]/g) || []).length;
-        const otherChars = text.length - chineseChars;
-        return Math.ceil(chineseChars / 2 + otherChars / 4);
-    }
 }
 let compressorInstance = null;
 export function getContextCompressor(authConfig) {