snow-ai 0.3.8 → 0.3.10

package/dist/hooks/useCommandHandler.d.ts

@@ -1,5 +1,13 @@
 import type { Message } from '../ui/components/MessageList.js';
 import type { UsageInfo } from '../api/chat.js';
+/**
+ * 执行上下文压缩
+ * @returns 返回压缩后的UI消息列表和token使用信息，如果失败返回null
+ */
+export declare function executeContextCompression(): Promise<{
+    uiMessages: Message[];
+    usage: UsageInfo;
+} | null>;
 type CommandHandlerOptions = {
     messages: Message[];
     setMessages: React.Dispatch<React.SetStateAction<Message[]>>;

package/dist/hooks/useCommandHandler.js

@@ -6,6 +6,105 @@ import { navigateTo } from './useGlobalNavigation.js';
 import { resetTerminal } from '../utils/terminal.js';
 import { showSaveDialog, isFileDialogSupported } from '../utils/fileDialog.js';
 import { exportMessagesToFile } from '../utils/chatExporter.js';
+/**
+ * 执行上下文压缩
+ * @returns 返回压缩后的UI消息列表和token使用信息，如果失败返回null
+ */
+export async function executeContextCompression() {
+    try {
+        // 从会话文件读取真实的消息记录
+        const currentSession = sessionManager.getCurrentSession();
+        if (!currentSession || currentSession.messages.length === 0) {
+            throw new Error('No active session or no messages to compress');
+        }
+        // 使用会话文件中的消息进行压缩（这是真实的对话记录）
+        const sessionMessages = currentSession.messages;
+        // 转换为 ChatMessage 格式（保留所有关键字段）
+        const chatMessages = sessionMessages.map(msg => ({
+            role: msg.role,
+            content: msg.content,
+            tool_call_id: msg.tool_call_id,
+            tool_calls: msg.tool_calls,
+            images: msg.images,
+            reasoning: msg.reasoning,
+            subAgentInternal: msg.subAgentInternal,
+        }));
+        // Compress the context (全量压缩，保留最后一轮完整对话)
+        const compressionResult = await compressContext(chatMessages);
+        // 如果返回null，说明无法安全压缩（历史不足或只有当前轮次）
+        if (!compressionResult) {
+            console.warn('Compression skipped: not enough history to compress');
+            return null;
+        }
+        // 构建新的会话消息列表
+        const newSessionMessages = [];
+        // 添加压缩摘要到会话
+        newSessionMessages.push({
+            role: 'assistant',
+            content: compressionResult.summary,
+            timestamp: Date.now(),
+        });
+        // 添加保留的最后一轮完整对话（保留完整的消息结构）
+        if (compressionResult.preservedMessages && compressionResult.preservedMessages.length > 0) {
+            for (const msg of compressionResult.preservedMessages) {
+                // 保留完整的消息结构，包括所有关键字段
+                newSessionMessages.push({
+                    role: msg.role,
+                    content: msg.content,
+                    timestamp: Date.now(),
+                    ...(msg.tool_call_id && { tool_call_id: msg.tool_call_id }),
+                    ...(msg.tool_calls && { tool_calls: msg.tool_calls }),
+                    ...(msg.images && { images: msg.images }),
+                    ...(msg.reasoning && { reasoning: msg.reasoning }),
+                    ...(msg.subAgentInternal !== undefined && { subAgentInternal: msg.subAgentInternal }),
+                });
+            }
+        }
+        // 更新当前会话的消息（不新建会话）
+        currentSession.messages = newSessionMessages;
+        currentSession.messageCount = newSessionMessages.length;
+        currentSession.updatedAt = Date.now();
+        // 保存更新后的会话文件
+        await sessionManager.saveSession(currentSession);
+        // 同步更新UI消息列表：从会话消息转换为UI Message格式
+        const newUIMessages = [];
+        for (const sessionMsg of newSessionMessages) {
+            // 跳过 tool 角色的消息（工具执行结果），避免UI显示大量JSON
+            if (sessionMsg.role === 'tool') {
+                continue;
+            }
+            const uiMessage = {
+                role: sessionMsg.role,
+                content: sessionMsg.content,
+                streaming: false,
+            };
+            // 如果有 tool_calls，显示工具调用信息（但不显示详细参数）
+            if (sessionMsg.tool_calls && sessionMsg.tool_calls.length > 0) {
+                // 在内容中添加简洁的工具调用摘要
+                const toolSummary = sessionMsg.tool_calls
+                    .map((tc) => `[Tool: ${tc.function.name}]`)
+                    .join(', ');
+                // 如果内容为空或很短，显示工具调用摘要
+                if (!uiMessage.content || uiMessage.content.length < 10) {
+                    uiMessage.content = toolSummary;
+                }
+            }
+            newUIMessages.push(uiMessage);
+        }
+        return {
+            uiMessages: newUIMessages,
+            usage: {
+                prompt_tokens: compressionResult.usage.prompt_tokens,
+                completion_tokens: compressionResult.usage.completion_tokens,
+                total_tokens: compressionResult.usage.total_tokens,
+            },
+        };
+    }
+    catch (error) {
+        console.error('Context compression failed:', error);
+        return null;
+    }
+}
 export function useCommandHandler(options) {
     const { stdout } = useStdout();
     const handleCommandExecution = useCallback(async (commandName, result) => {
@@ -17,44 +116,19 @@ export function useCommandHandler(options) {
             options.setIsCompressing(true);
             options.setCompressionError(null);
             try {
-                // Convert messages to ChatMessage format for compression
-                const chatMessages = options.messages
-                    .filter(msg => msg.role !== 'command')
-                    .map(msg => ({
-                    role: msg.role,
-                    content: msg.content,
-                    tool_call_id: msg.toolCallId,
-                }));
-                // Compress the context
-                const result = await compressContext(chatMessages);
-                // Replace all messages with a summary message (不包含 "Context Compressed" 标题)
-                const summaryMessage = {
-                    role: 'assistant',
-                    content: result.summary,
-                    streaming: false,
-                };
-                // Clear session and create new session with compressed summary
-                sessionManager.clearCurrentSession();
-                const newSession = await sessionManager.createNewSession();
-                // Save the summary message to the new session so it's included in next API call
-                if (newSession) {
-                    await sessionManager.addMessage({
-                        role: 'assistant',
-                        content: result.summary,
-                        timestamp: Date.now(),
-                    });
+                // 使用提取的压缩函数
+                const compressionResult = await executeContextCompression();
+                if (!compressionResult) {
+                    throw new Error('Compression failed');
                 }
+                // 更新UI
                 options.clearSavedMessages();
-                options.setMessages([summaryMessage]);
+                options.setMessages(compressionResult.uiMessages);
                 options.setRemountKey(prev => prev + 1);
                 // Reset system info flag to include in next message
                 options.setShouldIncludeSystemInfo(true);
                 // Update token usage with compression result
-                options.setContextUsage({
-                    prompt_tokens: result.usage.prompt_tokens,
-                    completion_tokens: result.usage.completion_tokens,
-                    total_tokens: result.usage.total_tokens,
-                });
+                options.setContextUsage(compressionResult.usage);
             }
             catch (error) {
                 // Show error message

package/dist/hooks/useConversation.d.ts

@@ -34,6 +34,10 @@ export type ConversationHandlerOptions = {
         remainingSeconds?: number;
         errorMessage?: string;
     } | null>>;
+    clearSavedMessages?: () => void;
+    setRemountKey?: React.Dispatch<React.SetStateAction<number>>;
+    setShouldIncludeSystemInfo?: React.Dispatch<React.SetStateAction<boolean>>;
+    getCurrentContextPercentage?: () => number;
 };
 /**
  * Handle conversation with streaming and tool calls

package/dist/hooks/useConversation.js

@@ -12,6 +12,7 @@ import { formatTodoContext } from '../utils/todoPreprocessor.js';
 import { formatToolCallMessage } from '../utils/messageFormatter.js';
 import { resourceMonitor } from '../utils/resourceMonitor.js';
 import { isToolNeedTwoStepDisplay } from '../utils/toolDisplayConfig.js';
+import { shouldAutoCompress, performAutoCompression, } from '../utils/autoCompress.js';
 /**
  * Handle conversation with streaming and tool calls
  * Returns the usage data collected during the conversation
@@ -234,6 +235,7 @@ export async function handleConversationWithTools(options) {
                             total_tokens: chunk.usage.total_tokens || 0,
                             cache_creation_input_tokens: chunk.usage.cache_creation_input_tokens,
                             cache_read_input_tokens: chunk.usage.cache_read_input_tokens,
+                            cached_tokens: chunk.usage.cached_tokens,
                         };
                     }
                     else {
@@ -252,6 +254,10 @@ export async function handleConversationWithTools(options) {
                                 (accumulatedUsage.cache_read_input_tokens || 0) +
                                     chunk.usage.cache_read_input_tokens;
                         }
+                        if (chunk.usage.cached_tokens !== undefined) {
+                            accumulatedUsage.cached_tokens =
+                                (accumulatedUsage.cached_tokens || 0) + chunk.usage.cached_tokens;
+                        }
                     }
                 }
             }
@@ -552,6 +558,44 @@ export async function handleConversationWithTools(options) {
                     freeEncoder();
                     break;
                 }
+                // 在工具执行完成后、发送结果到AI前，检查是否需要压缩
+                if (options.getCurrentContextPercentage &&
+                    shouldAutoCompress(options.getCurrentContextPercentage())) {
+                    try {
+                        // 显示压缩提示消息
+                        const compressingMessage = {
+                            role: 'assistant',
+                            content: '✵ Auto-compressing context before sending tool results...',
+                            streaming: false,
+                        };
+                        setMessages(prev => [...prev, compressingMessage]);
+                        const compressionResult = await performAutoCompression();
+                        if (compressionResult && options.clearSavedMessages) {
+                            // 更新UI和token使用情况
+                            options.clearSavedMessages();
+                            setMessages(compressionResult.uiMessages);
+                            if (options.setRemountKey) {
+                                options.setRemountKey(prev => prev + 1);
+                            }
+                            options.setContextUsage(compressionResult.usage);
+                            if (options.setShouldIncludeSystemInfo) {
+                                options.setShouldIncludeSystemInfo(true);
+                            }
+                            // 更新累计的usage为压缩后的usage
+                            accumulatedUsage = compressionResult.usage;
+                            // 压缩后需要重新构建conversationMessages
+                            conversationMessages = [];
+                            const session = sessionManager.getCurrentSession();
+                            if (session && session.messages.length > 0) {
+                                conversationMessages.push(...session.messages);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        console.error('Auto-compression after tool execution failed:', error);
+                        // 即使压缩失败也继续处理工具结果
+                    }
+                }
                 // Check if there are TODO related tool calls, if yes refresh TODO list
                 const hasTodoTools = approvedTools.some(t => t.function.name.startsWith('todo-'));
                 const hasTodoUpdateTools = approvedTools.some(t => t.function.name === 'todo-update');
@@ -683,6 +727,44 @@ export async function handleConversationWithTools(options) {
                 if (options.getPendingMessages && options.clearPendingMessages) {
                     const pendingMessages = options.getPendingMessages();
                     if (pendingMessages.length > 0) {
+                        // 检查 token 占用，如果 >= 80% 先执行自动压缩
+                        if (options.getCurrentContextPercentage &&
+                            shouldAutoCompress(options.getCurrentContextPercentage())) {
+                            try {
+                                // 显示压缩提示消息
+                                const compressingMessage = {
+                                    role: 'assistant',
+                                    content: '✵ Auto-compressing context before processing pending messages...',
+                                    streaming: false,
+                                };
+                                setMessages(prev => [...prev, compressingMessage]);
+                                const compressionResult = await performAutoCompression();
+                                if (compressionResult && options.clearSavedMessages) {
+                                    // 更新UI和token使用情况
+                                    options.clearSavedMessages();
+                                    setMessages(compressionResult.uiMessages);
+                                    if (options.setRemountKey) {
+                                        options.setRemountKey(prev => prev + 1);
+                                    }
+                                    options.setContextUsage(compressionResult.usage);
+                                    if (options.setShouldIncludeSystemInfo) {
+                                        options.setShouldIncludeSystemInfo(true);
+                                    }
+                                    // 更新累计的usage为压缩后的usage
+                                    accumulatedUsage = compressionResult.usage;
+                                    // 压缩后需要重新构建conversationMessages
+                                    conversationMessages = [];
+                                    const session = sessionManager.getCurrentSession();
+                                    if (session && session.messages.length > 0) {
+                                        conversationMessages.push(...session.messages);
+                                    }
+                                }
+                            }
+                            catch (error) {
+                                console.error('Auto-compression before pending messages failed:', error);
+                                // 即使压缩失败也继续处理pending消息
+                            }
+                        }
                         // Clear pending messages
                         options.clearPendingMessages();
                         // Combine multiple pending messages into one

package/dist/ui/components/ChatInput.d.ts

@@ -1,4 +1,15 @@
 import React from 'react';
+/**
+ * Calculate context usage percentage
+ * This is the same logic used in ChatInput to display usage
+ */
+export declare function calculateContextPercentage(contextUsage: {
+    inputTokens: number;
+    maxContextTokens: number;
+    cacheCreationTokens?: number;
+    cacheReadTokens?: number;
+    cachedTokens?: number;
+}): number;
 type Props = {
     onSubmit: (message: string, images?: Array<{
         data: string;
@@ -22,6 +33,7 @@ type Props = {
         cachedTokens?: number;
     };
     initialContent?: string | null;
+    onContextPercentageChange?: (percentage: number) => void;
 };
-export default function ChatInput({ onSubmit, onCommand, placeholder, disabled, isProcessing, chatHistory, onHistorySelect, yoloMode, contextUsage, initialContent, }: Props): React.JSX.Element;
+export default function ChatInput({ onSubmit, onCommand, placeholder, disabled, isProcessing, chatHistory, onHistorySelect, yoloMode, contextUsage, initialContent, onContextPercentageChange, }: Props): React.JSX.Element;
 export {};

package/dist/ui/components/ChatInput.js

@@ -11,7 +11,24 @@ import { useClipboard } from '../../hooks/useClipboard.js';
 import { useKeyboardInput } from '../../hooks/useKeyboardInput.js';
 import { useTerminalSize } from '../../hooks/useTerminalSize.js';
 import { useTerminalFocus } from '../../hooks/useTerminalFocus.js';
-export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type your message...', disabled = false, isProcessing = false, chatHistory = [], onHistorySelect, yoloMode = false, contextUsage, initialContent = null, }) {
+/**
+ * Calculate context usage percentage
+ * This is the same logic used in ChatInput to display usage
+ */
+export function calculateContextPercentage(contextUsage) {
+    // Determine which caching system is being used
+    const isAnthropic = (contextUsage.cacheCreationTokens || 0) > 0 ||
+        (contextUsage.cacheReadTokens || 0) > 0;
+    // For Anthropic: Total = inputTokens + cacheCreationTokens + cacheReadTokens
+    // For OpenAI: Total = inputTokens (cachedTokens are already included in inputTokens)
+    const totalInputTokens = isAnthropic
+        ? contextUsage.inputTokens +
+            (contextUsage.cacheCreationTokens || 0) +
+            (contextUsage.cacheReadTokens || 0)
+        : contextUsage.inputTokens;
+    return Math.min(100, (totalInputTokens / contextUsage.maxContextTokens) * 100);
+}
+export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type your message...', disabled = false, isProcessing = false, chatHistory = [], onHistorySelect, yoloMode = false, contextUsage, initialContent = null, onContextPercentageChange, }) {
     // Use terminal size hook to listen for resize events
     const { columns: terminalWidth } = useTerminalSize();
     const prevTerminalWidthRef = useRef(terminalWidth);
@@ -101,6 +118,13 @@ export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type you
         }, 100);
         return () => clearTimeout(timer);
     }, [terminalWidth, forceUpdate]);
+    // Notify parent of context percentage changes
+    useEffect(() => {
+        if (contextUsage && onContextPercentageChange) {
+            const percentage = calculateContextPercentage(contextUsage);
+            onContextPercentageChange(percentage);
+        }
+    }, [contextUsage, onContextPercentageChange]);
     // Render cursor based on focus state
     const renderCursor = useCallback((char) => {
         if (hasFocus) {
@@ -245,14 +269,14 @@ export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type you
                     const isAnthropic = (contextUsage.cacheCreationTokens || 0) > 0 ||
                         (contextUsage.cacheReadTokens || 0) > 0;
                     const isOpenAI = (contextUsage.cachedTokens || 0) > 0;
-                    // For Anthropic: Total = inputTokens + cacheCreationTokens + cacheReadTokens
-                    // For OpenAI: Total = inputTokens (cachedTokens are already included in inputTokens)
+                    // Use the exported function for consistent calculation
+                    const percentage = calculateContextPercentage(contextUsage);
+                    // Calculate total tokens for display
                     const totalInputTokens = isAnthropic
                         ? contextUsage.inputTokens +
                             (contextUsage.cacheCreationTokens || 0) +
                             (contextUsage.cacheReadTokens || 0)
                         : contextUsage.inputTokens;
-                    const percentage = Math.min(100, (totalInputTokens / contextUsage.maxContextTokens) * 100);
                     let color;
                     if (percentage < 50)
                         color = 'green';

package/dist/ui/pages/ChatScreen.js

@@ -31,6 +31,7 @@ import { executeCommand } from '../../utils/commandExecutor.js';
 import { convertSessionMessagesToUI } from '../../utils/sessionConverter.js';
 import { incrementalSnapshotManager } from '../../utils/incrementalSnapshot.js';
 import { formatElapsedTime } from '../../utils/textUtils.js';
+import { shouldAutoCompress, performAutoCompression, } from '../../utils/autoCompress.js';
 // Import commands to register them
 import '../../utils/commands/clear.js';
 import '../../utils/commands/resume.js';
@@ -54,6 +55,12 @@ export default function ChatScreen({ skipWelcome }) {
     const [remountKey, setRemountKey] = useState(0);
     const [showMcpInfo, setShowMcpInfo] = useState(false);
     const [mcpPanelKey, setMcpPanelKey] = useState(0);
+    const [currentContextPercentage, setCurrentContextPercentage] = useState(0); // Track context percentage from ChatInput
+    const currentContextPercentageRef = useRef(0); // Use ref to avoid closure issues
+    // Sync state to ref
+    useEffect(() => {
+        currentContextPercentageRef.current = currentContextPercentage;
+    }, [currentContextPercentage]);
     const [yoloMode, setYoloMode] = useState(() => {
         // Load yolo mode from localStorage on initialization
         try {
@@ -265,6 +272,63 @@ export default function ChatScreen({ skipWelcome }) {
             streamingState.setRetryStatus(null);
             // Remove all pending tool call messages (those with toolPending: true)
             setMessages(prev => prev.filter(msg => !msg.toolPending));
+            // Clean up incomplete conversation in session (handled in useConversation abort cleanup)
+            // This will remove:
+            // 1. User message without AI response (scenario 1)
+            // 2. Assistant message with tool_calls but no tool results (scenario 2)
+            const session = sessionManager.getCurrentSession();
+            if (session && session.messages.length > 0) {
+                // Use async cleanup to avoid blocking UI
+                (async () => {
+                    try {
+                        // Find the last complete conversation round
+                        const messages = session.messages;
+                        let truncateIndex = messages.length;
+                        // Scan from the end to find incomplete round
+                        for (let i = messages.length - 1; i >= 0; i--) {
+                            const msg = messages[i];
+                            if (!msg)
+                                continue;
+                            // If last message is user message without assistant response, remove it
+                            if (msg.role === 'user' && i === messages.length - 1) {
+                                truncateIndex = i;
+                                break;
+                            }
+                            // If assistant message has tool_calls, verify all tool results exist
+                            if (msg.role === 'assistant' &&
+                                msg.tool_calls &&
+                                msg.tool_calls.length > 0) {
+                                const toolCallIds = new Set(msg.tool_calls.map(tc => tc.id));
+                                // Check if all tool results exist after this assistant message
+                                for (let j = i + 1; j < messages.length; j++) {
+                                    const followMsg = messages[j];
+                                    if (followMsg && followMsg.role === 'tool' && followMsg.tool_call_id) {
+                                        toolCallIds.delete(followMsg.tool_call_id);
+                                    }
+                                }
+                                // If some tool results are missing, remove from this assistant message onwards
+                                if (toolCallIds.size > 0) {
+                                    truncateIndex = i;
+                                    break;
+                                }
+                            }
+                            // If we found a complete assistant response without tool calls, we're done
+                            if (msg.role === 'assistant' && !msg.tool_calls) {
+                                break;
+                            }
+                        }
+                        // Truncate session if needed
+                        if (truncateIndex < messages.length) {
+                            await sessionManager.truncateMessages(truncateIndex);
+                            // Also clear from saved messages tracking
+                            clearSavedMessages();
+                        }
+                    }
+                    catch (error) {
+                        console.error('Failed to clean up incomplete conversation:', error);
+                    }
+                })();
+            }
             // Add discontinued message
             setMessages(prev => [
                 ...prev,
@@ -435,6 +499,47 @@ export default function ChatScreen({ skipWelcome }) {
         await processMessage(message, images);
     };
     const processMessage = async (message, images, useBasicModel, hideUserMessage) => {
+        // 检查 token 占用，如果 >= 80% 先执行自动压缩
+        if (shouldAutoCompress(currentContextPercentageRef.current)) {
+            setIsCompressing(true);
+            setCompressionError(null);
+            try {
+                // 显示压缩提示消息
+                const compressingMessage = {
+                    role: 'assistant',
+                    content: '✵ Auto-compressing context due to token limit...',
+                    streaming: false,
+                };
+                setMessages(prev => [...prev, compressingMessage]);
+                const compressionResult = await performAutoCompression();
+                if (compressionResult) {
+                    // 更新UI和token使用情况
+                    clearSavedMessages();
+                    setMessages(compressionResult.uiMessages);
+                    setRemountKey(prev => prev + 1);
+                    streamingState.setContextUsage(compressionResult.usage);
+                    setShouldIncludeSystemInfo(true);
+                }
+                else {
+                    throw new Error('Compression failed');
+                }
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+                setCompressionError(errorMsg);
+                const errorMessage = {
+                    role: 'assistant',
+                    content: `**Auto-compression Failed**\n\n${errorMsg}`,
+                    streaming: false,
+                };
+                setMessages(prev => [...prev, errorMessage]);
+                setIsCompressing(false);
+                return; // 停止处理，等待用户手动处理
+            }
+            finally {
+                setIsCompressing(false);
+            }
+        }
         // Clear any previous retry status when starting a new request
         streamingState.setRetryStatus(null);
         // Parse and validate file references
@@ -500,6 +605,10 @@ export default function ChatScreen({ skipWelcome }) {
                 setIsStreaming: streamingState.setIsStreaming,
                 setIsReasoning: streamingState.setIsReasoning,
                 setRetryStatus: streamingState.setRetryStatus,
+                clearSavedMessages,
+                setRemountKey,
+                setShouldIncludeSystemInfo,
+                getCurrentContextPercentage: () => currentContextPercentageRef.current,
             });
         }
         catch (error) {
@@ -587,6 +696,10 @@ export default function ChatScreen({ skipWelcome }) {
                 setIsStreaming: streamingState.setIsStreaming,
                 setIsReasoning: streamingState.setIsReasoning,
                 setRetryStatus: streamingState.setRetryStatus,
+                clearSavedMessages,
+                setRemountKey,
+                getCurrentContextPercentage: () => currentContextPercentageRef.current,
+                setShouldIncludeSystemInfo,
             });
         }
         catch (error) {
@@ -840,7 +953,7 @@ export default function ChatScreen({ skipWelcome }) {
                         cacheReadTokens: streamingState.contextUsage.cache_read_input_tokens,
                         cachedTokens: streamingState.contextUsage.cached_tokens,
                     }
-                    : undefined, initialContent: restoreInputContent }),
+                    : undefined, initialContent: restoreInputContent, onContextPercentageChange: setCurrentContextPercentage }),
             vscodeState.vscodeConnectionStatus !== 'disconnected' && (React.createElement(Box, { marginTop: 1, paddingX: 1 },
                 React.createElement(Text, { color: vscodeState.vscodeConnectionStatus === 'connecting'
                         ? 'yellow'

package/dist/utils/autoCompress.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 检查 token 使用率是否达到阈值
+ * @param percentage 当前上下文使用百分比（由 ChatInput 计算）
+ * @param threshold 阈值百分比（默认80）
+ * @returns 是否需要压缩
+ */
+export declare function shouldAutoCompress(percentage: number, threshold?: number): boolean;
+/**
+ * 执行自动压缩
+ * @returns 压缩结果，如果失败返回null
+ */
+export declare function performAutoCompression(): Promise<{
+    uiMessages: import("../ui/components/MessageList.js").Message[];
+    usage: import("../api/types.js").UsageInfo;
+} | null>;

package/dist/utils/autoCompress.js

@@ -0,0 +1,24 @@
+import { executeContextCompression } from '../hooks/useCommandHandler.js';
+/**
+ * 检查 token 使用率是否达到阈值
+ * @param percentage 当前上下文使用百分比（由 ChatInput 计算）
+ * @param threshold 阈值百分比（默认80）
+ * @returns 是否需要压缩
+ */
+export function shouldAutoCompress(percentage, threshold = 80) {
+    return percentage >= threshold;
+}
+/**
+ * 执行自动压缩
+ * @returns 压缩结果，如果失败返回null
+ */
+export async function performAutoCompression() {
+    try {
+        const result = await executeContextCompression();
+        return result;
+    }
+    catch (error) {
+        console.error('Auto-compression failed:', error);
+        return null;
+    }
+}

package/dist/utils/contextCompressor.d.ts

@@ -6,10 +6,11 @@ export interface CompressionResult {
         completion_tokens: number;
         total_tokens: number;
     };
+    preservedMessages?: ChatMessage[];
 }
 /**
  * Compress conversation history using the compact model
  * @param messages - Array of messages to compress
- * @returns Compressed summary and token usage information
+ * @returns Compressed summary and token usage information, or null if compression should be skipped
  */
-export declare function compressContext(messages: ChatMessage[]): Promise<CompressionResult>;
+export declare function compressContext(messages: ChatMessage[]): Promise<CompressionResult | null>;

package/dist/utils/contextCompressor.js

@@ -5,11 +5,94 @@ import { createStreamingResponse } from '../api/responses.js';
 import { createStreamingGeminiCompletion } from '../api/gemini.js';
 import { createStreamingAnthropicCompletion } from '../api/anthropic.js';
 /**
- * Compression request prompt - asks AI to summarize conversation with focus on task continuity
+ * Compression request prompt - asks AI to create a detailed, structured summary
+ * that preserves critical information for task continuity
  */
-const COMPRESSION_PROMPT = 'Please provide a concise summary of our conversation so far. Focus on: 1) The current task or goal we are working on, 2) Key decisions and approaches we have agreed upon, 3) Important context needed to continue, 4) Any pending or unfinished work. Keep it brief but ensure I can seamlessly continue assisting with the task.';
+const COMPRESSION_PROMPT = `You are compressing a conversation history to save context space while preserving all critical information. Create a comprehensive summary following this structure:
+
+## 📋 Current Task & Goals
+- What is the main task or project being worked on?
+- What are the specific objectives and desired outcomes?
+- What is the current progress status?
+
+## 🔧 Technical Context
+- Key technologies, frameworks, libraries, and tools being used
+- Important file paths, function names, and code locations mentioned
+- Architecture decisions and design patterns chosen
+- Configuration settings and environment details
+
+## 💡 Key Decisions & Approaches
+- Important decisions made and their rationale
+- Chosen approaches and methodologies
+- Solutions to problems encountered
+- Best practices or patterns agreed upon
+
+## ✅ Completed Work
+- What has been successfully implemented or resolved?
+- Important code changes, fixes, or features added
+- Test results or validation performed
+
+## 🚧 Pending & In-Progress Work
+- What tasks are currently unfinished?
+- Known issues or blockers that need addressing
+- Next steps planned or discussed
+- Open questions or areas needing clarification
+
+## 🔑 Critical Information
+- Important data, values, IDs, or credentials referenced (sanitized)
+- Error messages, warnings, or diagnostic information
+- User preferences, requirements, or constraints
+- Any other context essential for seamless continuation
+
+**Guidelines:**
+- Be specific with names, paths, and technical details
+- Preserve exact terminology and technical vocabulary
+- Include enough detail to continue work without confusion
+- Use code snippets or examples where helpful
+- Prioritize actionable information over general descriptions`;
+/**
+ * 找到需要保留的消息（最近的工具调用链）
+ *
+ * 保留策略：
+ * - 如果最后有未完成的工具调用（assistant with tool_calls 或 tool），保留这个链
+ * - 如果最后是普通 assistant 或 user，不需要保留（压缩全部）
+ *
+ * 注意：不保留 user 消息，因为：
+ * 1. 压缩摘要已包含历史上下文
+ * 2. 下一轮对话会有新的 user 消息
+ *
+ * @returns 保留消息的起始索引，如果全部压缩则返回 messages.length
+ */
+function findPreserveStartIndex(messages) {
+    if (messages.length === 0) {
+        return 0;
+    }
+    const lastMsg = messages[messages.length - 1];
+    // Case 1: 最后是 tool 消息 → 保留 assistant(tool_calls) → tool
+    if (lastMsg?.role === 'tool') {
+        // 向前找对应的 assistant with tool_calls
+        for (let i = messages.length - 2; i >= 0; i--) {
+            const msg = messages[i];
+            if (msg?.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0) {
+                // 找到了，从这个 assistant 开始保留
+                return i;
+            }
+        }
+        // 如果找不到对应的 assistant，保留最后的 tool（虽然不太可能）
+        return messages.length - 1;
+    }
+    // Case 2: 最后是 assistant with tool_calls → 保留 assistant(tool_calls)
+    if (lastMsg?.role === 'assistant' && lastMsg.tool_calls && lastMsg.tool_calls.length > 0) {
+        // 保留这个待处理的 tool_calls
+        return messages.length - 1;
+    }
+    // Case 3: 最后是普通 assistant 或 user → 全部压缩
+    // 因为没有未完成的工具调用链
+    return messages.length;
+}
 /**
  * Prepare messages for compression by adding system prompt and compression request
+ * Note: Only filters out system messages and tool messages, preserving user and assistant messages
  */
 function prepareMessagesForCompression(conversationMessages, customSystemPrompt) {
     const messages = [];
@@ -23,9 +106,11 @@ function prepareMessagesForCompression(conversationMessages, customSystemPrompt)
         // No custom system prompt: default as system
         messages.push({ role: 'system', content: getSystemPrompt() });
     }
-    // Add all conversation history (exclude system and tool messages)
+    // Add all conversation history for compression
+    // Filter out system messages (already added above) and tool messages (only needed for API, not for summary)
     for (const msg of conversationMessages) {
         if (msg.role !== 'system' && msg.role !== 'tool') {
+            // Only include user and assistant messages for compression
             messages.push({
                 role: msg.role,
                 content: msg.content,
@@ -181,7 +266,7 @@ async function compressWithAnthropic(modelName, conversationMessages, customSyst
 /**
  * Compress conversation history using the compact model
  * @param messages - Array of messages to compress
- * @returns Compressed summary and token usage information
+ * @returns Compressed summary and token usage information, or null if compression should be skipped
  */
 export async function compressContext(messages) {
     const config = getOpenAiConfig();
@@ -189,26 +274,51 @@ export async function compressContext(messages) {
     if (!config.compactModel || !config.compactModel.modelName) {
         throw new Error('Compact model not configured. Please configure it in API & Model Settings.');
     }
+    if (messages.length === 0) {
+        console.warn('No messages to compress');
+        return null;
+    }
     const modelName = config.compactModel.modelName;
     const requestMethod = config.requestMethod;
     // Get custom system prompt if configured
     const customSystemPrompt = getCustomSystemPrompt();
+    // 找到需要保留的消息起始位置
+    const preserveStartIndex = findPreserveStartIndex(messages);
+    // 如果 preserveStartIndex 为 0，说明所有消息都需要保留（没有历史可压缩）
+    // 例如：整个对话只有一条 user→assistant(tool_calls)，无法压缩
+    if (preserveStartIndex === 0) {
+        console.warn('Cannot compress: all messages need to be preserved (no history)');
+        return null;
+    }
+    // 分离待压缩和待保留的消息
+    const messagesToCompress = messages.slice(0, preserveStartIndex);
+    const preservedMessages = messages.slice(preserveStartIndex);
     try {
         // Choose compression method based on request method
         // All methods now reuse existing API modules which include proxy support
+        let result;
         switch (requestMethod) {
             case 'gemini':
-                return await compressWithGemini(modelName, messages, customSystemPrompt || null);
+                result = await compressWithGemini(modelName, messagesToCompress, customSystemPrompt || null);
+                break;
             case 'anthropic':
-                return await compressWithAnthropic(modelName, messages, customSystemPrompt || null);
+                result = await compressWithAnthropic(modelName, messagesToCompress, customSystemPrompt || null);
+                break;
             case 'responses':
                 // OpenAI Responses API
-                return await compressWithResponses(modelName, messages, customSystemPrompt || null);
+                result = await compressWithResponses(modelName, messagesToCompress, customSystemPrompt || null);
+                break;
             case 'chat':
             default:
                 // OpenAI Chat Completions API
-                return await compressWithChatCompletions(modelName, messages, customSystemPrompt || null);
+                result = await compressWithChatCompletions(modelName, messagesToCompress, customSystemPrompt || null);
+                break;
+        }
+        // 添加保留的消息到结果中
+        if (preservedMessages.length > 0) {
+            result.preservedMessages = preservedMessages;
         }
+        return result;
     }
     catch (error) {
         if (error instanceof Error) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.3.8",
+	"version": "0.3.10",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {

package/dist/constants/index.d.ts

@@ -1,18 +0,0 @@
-export declare const APP_NAME = "AI Bot CLI";
-export declare const APP_VERSION = "1.0.0";
-export declare const APP_DESCRIPTION = "Intelligent Command Line Assistant";
-export declare const COLORS: {
-    readonly primary: "cyan";
-    readonly secondary: "magenta";
-    readonly success: "green";
-    readonly warning: "yellow";
-    readonly error: "red";
-    readonly info: "blue";
-    readonly muted: "gray";
-};
-export declare const COMMANDS: {
-    readonly HELP: "help";
-    readonly VERSION: "version";
-    readonly EXIT: "exit";
-    readonly CLEAR: "clear";
-};

package/dist/constants/index.js

@@ -1,18 +0,0 @@
-export const APP_NAME = 'AI Bot CLI';
-export const APP_VERSION = '1.0.0';
-export const APP_DESCRIPTION = 'Intelligent Command Line Assistant';
-export const COLORS = {
-    primary: 'cyan',
-    secondary: 'magenta',
-    success: 'green',
-    warning: 'yellow',
-    error: 'red',
-    info: 'blue',
-    muted: 'gray',
-};
-export const COMMANDS = {
-    HELP: 'help',
-    VERSION: 'version',
-    EXIT: 'exit',
-    CLEAR: 'clear',
-};