snow-ai 0.3.37 → 0.4.1

package/dist/agents/promptOptimizeAgent.d.ts

@@ -0,0 +1,54 @@
+import { type ChatMessage } from '../api/chat.js';
+/**
+ * Prompt Optimization Agent Service
+ *
+ * Optimizes user prompts for better AI understanding and response quality.
+ * This service operates using the basic model for efficient, low-cost optimization.
+ *
+ * Features:
+ * - Uses basicModel for efficient prompt optimization
+ * - Follows the same API routing as main flow (chat, responses, gemini, anthropic)
+ * - Filters context to only include user->assistant pairs without tool calls
+ * - Returns optimized prompt that preserves user intent while improving clarity
+ * - Silent execution with error handling to prevent main flow disruption
+ */
+export declare class PromptOptimizeAgent {
+    private modelName;
+    private requestMethod;
+    private initialized;
+    /**
+     * Initialize the prompt optimization agent with current configuration
+     * @returns true if initialized successfully, false otherwise
+     */
+    private initialize;
+    /**
+     * Check if prompt optimization agent is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Call the model with streaming API and assemble complete response
+     * Uses the same routing logic as main flow for consistency
+     *
+     * @param messages - Chat messages
+     * @param abortSignal - Optional abort signal to cancel the request
+     */
+    private callModel;
+    /**
+     * Filter conversation history to only include user->assistant pairs without tool calls
+     * This creates a lightweight context for prompt optimization
+     *
+     * @param messages - Full conversation history
+     * @returns Filtered messages containing only user->assistant exchanges
+     */
+    private filterContextMessages;
+    /**
+     * Optimize user prompt for better AI understanding
+     *
+     * @param userPrompt - Original user prompt
+     * @param conversationHistory - Full conversation history for context
+     * @param abortSignal - Optional abort signal to cancel optimization
+     * @returns Optimized prompt, or original prompt if optimization fails
+     */
+    optimizePrompt(userPrompt: string, conversationHistory: ChatMessage[], abortSignal?: AbortSignal): Promise<string>;
+}
+export declare const promptOptimizeAgent: PromptOptimizeAgent;

package/dist/agents/promptOptimizeAgent.js

@@ -0,0 +1,268 @@
+import { getOpenAiConfig } from '../utils/apiConfig.js';
+import { logger } from '../utils/logger.js';
+import { createStreamingChatCompletion } from '../api/chat.js';
+import { createStreamingResponse } from '../api/responses.js';
+import { createStreamingGeminiCompletion } from '../api/gemini.js';
+import { createStreamingAnthropicCompletion } from '../api/anthropic.js';
+/**
+ * Prompt Optimization Agent Service
+ *
+ * Optimizes user prompts for better AI understanding and response quality.
+ * This service operates using the basic model for efficient, low-cost optimization.
+ *
+ * Features:
+ * - Uses basicModel for efficient prompt optimization
+ * - Follows the same API routing as main flow (chat, responses, gemini, anthropic)
+ * - Filters context to only include user->assistant pairs without tool calls
+ * - Returns optimized prompt that preserves user intent while improving clarity
+ * - Silent execution with error handling to prevent main flow disruption
+ */
+export class PromptOptimizeAgent {
+    constructor() {
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "requestMethod", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'chat'
+        });
+        Object.defineProperty(this, "initialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    /**
+     * Initialize the prompt optimization agent with current configuration
+     * @returns true if initialized successfully, false otherwise
+     */
+    async initialize() {
+        try {
+            const config = getOpenAiConfig();
+            // Check if basic model is configured
+            if (!config.basicModel) {
+                logger.warn('Prompt optimize agent: Basic model not configured');
+                return false;
+            }
+            this.modelName = config.basicModel;
+            this.requestMethod = config.requestMethod;
+            this.initialized = true;
+            return true;
+        }
+        catch (error) {
+            logger.warn('Prompt optimize agent: Failed to initialize:', error);
+            return false;
+        }
+    }
+    /**
+     * Check if prompt optimization agent is available
+     */
+    async isAvailable() {
+        if (!this.initialized) {
+            return await this.initialize();
+        }
+        return true;
+    }
+    /**
+     * Call the model with streaming API and assemble complete response
+     * Uses the same routing logic as main flow for consistency
+     *
+     * @param messages - Chat messages
+     * @param abortSignal - Optional abort signal to cancel the request
+     */
+    async callModel(messages, abortSignal) {
+        let streamGenerator;
+        // Route to appropriate streaming API based on request method
+        switch (this.requestMethod) {
+            case 'anthropic':
+                streamGenerator = createStreamingAnthropicCompletion({
+                    model: this.modelName,
+                    messages,
+                    max_tokens: 1000, // Limited tokens for prompt optimization
+                    includeBuiltinSystemPrompt: false,
+                    disableThinking: true, // Agents don't use Extended Thinking
+                }, abortSignal);
+                break;
+            case 'gemini':
+                streamGenerator = createStreamingGeminiCompletion({
+                    model: this.modelName,
+                    messages,
+                    includeBuiltinSystemPrompt: false,
+                }, abortSignal);
+                break;
+            case 'responses':
+                streamGenerator = createStreamingResponse({
+                    model: this.modelName,
+                    messages,
+                    stream: true,
+                    includeBuiltinSystemPrompt: false,
+                }, abortSignal);
+                break;
+            case 'chat':
+            default:
+                streamGenerator = createStreamingChatCompletion({
+                    model: this.modelName,
+                    messages,
+                    stream: true,
+                    includeBuiltinSystemPrompt: false,
+                }, abortSignal);
+                break;
+        }
+        // Assemble complete content from streaming response
+        let completeContent = '';
+        try {
+            for await (const chunk of streamGenerator) {
+                // Check abort signal
+                if (abortSignal?.aborted) {
+                    throw new Error('Request aborted');
+                }
+                // Handle different chunk formats based on request method
+                if (this.requestMethod === 'chat') {
+                    // Chat API uses standard OpenAI format
+                    if (chunk.choices && chunk.choices[0]?.delta?.content) {
+                        completeContent += chunk.choices[0].delta.content;
+                    }
+                }
+                else {
+                    // Responses, Gemini, and Anthropic APIs use unified format
+                    if (chunk.type === 'content' && chunk.content) {
+                        completeContent += chunk.content;
+                    }
+                }
+            }
+        }
+        catch (streamError) {
+            logger.error('Prompt optimize agent: Streaming error:', streamError);
+            throw streamError;
+        }
+        return completeContent;
+    }
+    /**
+     * Filter conversation history to only include user->assistant pairs without tool calls
+     * This creates a lightweight context for prompt optimization
+     *
+     * @param messages - Full conversation history
+     * @returns Filtered messages containing only user->assistant exchanges
+     */
+    filterContextMessages(messages) {
+        const filtered = [];
+        for (const msg of messages) {
+            // Only include user and assistant messages
+            if (msg.role === 'user' || msg.role === 'assistant') {
+                // For assistant messages, skip if they contain tool calls
+                if (msg.role === 'assistant') {
+                    // Check if message has tool_calls (OpenAI format) or tool_use content (Anthropic format)
+                    const hasToolCalls = !!msg.tool_calls;
+                    const hasToolUseContent = Array.isArray(msg.content) &&
+                        msg.content.some((c) => c.type === 'tool_use' || c.type === 'tool_call');
+                    if (hasToolCalls || hasToolUseContent) {
+                        continue; // Skip assistant messages with tool calls
+                    }
+                }
+                // Add message to filtered list
+                filtered.push(msg);
+            }
+        }
+        return filtered;
+    }
+    /**
+     * Optimize user prompt for better AI understanding
+     *
+     * @param userPrompt - Original user prompt
+     * @param conversationHistory - Full conversation history for context
+     * @param abortSignal - Optional abort signal to cancel optimization
+     * @returns Optimized prompt, or original prompt if optimization fails
+     */
+    async optimizePrompt(userPrompt, conversationHistory, abortSignal) {
+        const available = await this.isAvailable();
+        if (!available) {
+            return userPrompt;
+        }
+        try {
+            // Check word count - if prompt > 100 words, skip optimization
+            // User likely provided detailed/important original text that should be preserved as-is
+            const wordCount = userPrompt.trim().split(/\s+/).length;
+            if (wordCount > 100) {
+                return userPrompt;
+            }
+            // Filter conversation history to lightweight context (only user<->assistant, no tool calls)
+            const contextMessages = this.filterContextMessages(conversationHistory);
+            // Build context summary if there's conversation history
+            let contextSummary = '';
+            if (contextMessages.length > 0) {
+                // Take last 8 messages to keep context focused, but use full content (no truncation)
+                const recentContext = contextMessages.slice(-8);
+                contextSummary =
+                    '\n\nRecent conversation context:\n' +
+                        recentContext
+                            .map((msg) => {
+                            const content = typeof msg.content === 'string'
+                                ? msg.content
+                                : JSON.stringify(msg.content);
+                            // Use full message content (no truncation)
+                            return `${msg.role}: ${content}`;
+                        })
+                            .join('\n');
+            }
+            const optimizationPrompt = `You are a prompt optimization assistant. Your task is to improve user prompts for better AI understanding while maintaining HIGH FIDELITY to the original content.
+
+User's original prompt:
+${userPrompt}${contextSummary}
+
+Your optimization goals (in priority order):
+1. **HIGH FIDELITY REQUIREMENT**: Preserve ALL important information, details, and requirements from the user's original prompt - DO NOT lose or omit any critical content
+2. Preserve the EXACT SAME LANGUAGE as the user (if Chinese, stay Chinese; if English, stay English)
+3. Keep the core intent and meaning unchanged
+4. Make the prompt clearer and more specific ONLY if vague - if already clear, keep it as-is
+5. Add relevant context if the user is asking follow-up questions
+6. Break down complex requests into clear requirements without losing details
+7. Keep the tone natural and conversational
+8. DO NOT add unnecessary formality or change the user's communication style
+9. If the prompt is already clear and specific, return it as-is
+
+CRITICAL RULES:
+- NEVER remove important details, specific requirements, file paths, code snippets, or technical specifications
+- NEVER simplify the prompt if it means losing user-provided information
+- When in doubt, prefer preserving the original over optimizing
+- The goal is CLARITY, not BREVITY - keep all important content
+
+IMPORTANT: Output ONLY the optimized prompt text. No explanations, no meta-commentary, no JSON format. Just the optimized prompt itself.`;
+            const messages = [
+                {
+                    role: 'user',
+                    content: optimizationPrompt,
+                },
+            ];
+            const optimizedPrompt = await this.callModel(messages, abortSignal);
+            if (!optimizedPrompt || optimizedPrompt.trim().length === 0) {
+                logger.warn('Prompt optimize agent: Empty response, using original prompt');
+                return userPrompt;
+            }
+            // Clean up the response (remove any markdown formatting if present)
+            let cleanedPrompt = optimizedPrompt.trim();
+            // Remove markdown code blocks if present
+            const codeBlockMatch = cleanedPrompt.match(/```[\s\S]*?\n([\s\S]*?)```/);
+            if (codeBlockMatch) {
+                cleanedPrompt = codeBlockMatch[1].trim();
+            }
+            // If optimized prompt is suspiciously short or looks like it failed, use original
+            if (cleanedPrompt.length < userPrompt.length * 0.3) {
+                logger.warn('Prompt optimize agent: Optimized prompt too short, using original');
+                return userPrompt;
+            }
+            return cleanedPrompt;
+        }
+        catch (error) {
+            logger.error('Prompt optimize agent: Failed to optimize prompt', error);
+            return userPrompt;
+        }
+    }
+}
+// Export singleton instance
+export const promptOptimizeAgent = new PromptOptimizeAgent();

package/dist/api/anthropic.js

@@ -6,6 +6,8 @@ import { logger } from '../utils/logger.js';
 import { addProxyToFetchOptions } from '../utils/proxyUtils.js';
 import { saveUsageToFile } from '../utils/usageLogger.js';
 let anthropicConfig = null;
+// Persistent userId that remains the same until application restart
+let persistentUserId = null;
 function getAnthropicConfig() {
     if (!anthropicConfig) {
         const config = getOpenAiConfig();
@@ -27,18 +29,22 @@ function getAnthropicConfig() {
 }
 export function resetAnthropicClient() {
     anthropicConfig = null;
+    persistentUserId = null; // Reset userId on client reset
 }
 /**
- * Generate a user_id in the format: user_<hash>_account__session_<uuid>
+ * Generate a persistent user_id that remains the same until application restart
+ * Format: user_<hash>_account__session_<uuid>
  * This matches Anthropic's expected format for tracking and caching
- * The hash is based on sessionId only to keep it consistent within the same session
  */
-function generateUserId(sessionId) {
-    // Generate a 64-character hash (consistent for the same session)
-    const hash = createHash('sha256')
-        .update(`anthropic_user_${sessionId}`)
-        .digest('hex');
-    return `user_${hash}_account__session_${sessionId}`;
+function getPersistentUserId() {
+    if (!persistentUserId) {
+        const sessionId = randomUUID();
+        const hash = createHash('sha256')
+            .update(`anthropic_user_${sessionId}`)
+            .digest('hex');
+        persistentUserId = `user_${hash}_account__session_${sessionId}`;
+    }
+    return persistentUserId;
 }
 /**
  * Convert OpenAI-style tools to Anthropic tool format
@@ -286,8 +292,8 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
     yield* withRetryGenerator(async function* () {
         const config = getAnthropicConfig();
         const { system, messages } = convertToAnthropicMessages(options.messages, options.includeBuiltinSystemPrompt !== false);
-        const sessionId = options.sessionId || randomUUID();
-        const userId = generateUserId(sessionId);
+        // Use persistent userId that remains the same until application restart
+        const userId = getPersistentUserId();
         const requestBody = {
             model: options.model,
             max_tokens: options.max_tokens || 4096,

package/dist/hooks/useConversation.js

@@ -781,7 +781,9 @@ export async function handleConversationWithTools(options) {
                     break;
                 }
                 // 在工具执行完成后、发送结果到AI前，检查是否需要压缩
-                if (options.getCurrentContextPercentage &&
+                const config = getOpenAiConfig();
+                if (config.enableAutoCompress !== false &&
+                    options.getCurrentContextPercentage &&
                     shouldAutoCompress(options.getCurrentContextPercentage())) {
                     try {
                         // 显示压缩提示消息
@@ -934,7 +936,9 @@ export async function handleConversationWithTools(options) {
                     const pendingMessages = options.getPendingMessages();
                     if (pendingMessages.length > 0) {
                         // 检查 token 占用，如果 >= 80% 先执行自动压缩
-                        if (options.getCurrentContextPercentage &&
+                        const config = getOpenAiConfig();
+                        if (config.enableAutoCompress !== false &&
+                            options.getCurrentContextPercentage &&
                             shouldAutoCompress(options.getCurrentContextPercentage())) {
                             try {
                                 // 显示压缩提示消息

package/dist/i18n/lang/en.js

@@ -119,6 +119,8 @@ export const en = {
         apiKey: 'API Key:',
         requestMethod: 'Request Method:',
         anthropicBeta: 'Anthropic Beta:',
+        enablePromptOptimization: 'Enable Prompt Optimization:',
+        enableAutoCompress: 'Enable Auto Compression:',
         thinkingEnabled: 'Thinking Enabled:',
         thinkingBudgetTokens: 'Thinking Budget Tokens:',
         geminiThinkingEnabled: 'Gemini Thinking Enabled:',

package/dist/i18n/lang/es.js

@@ -119,7 +119,9 @@ export const es = {
         apiKey: 'Clave API:',
         requestMethod: 'Método de Solicitud:',
         anthropicBeta: 'Anthropic Beta:',
-        thinkingEnabled: 'Habilitar Modo de Pensamiento:',
+        enablePromptOptimization: 'Enable Prompt Optimization:',
+        enableAutoCompress: 'Enable Auto Compression:',
+        thinkingEnabled: 'Thinking Enabled:',
         thinkingBudgetTokens: 'Tokens de Presupuesto de Pensamiento:',
         geminiThinkingEnabled: 'Habilitar Pensamiento Gemini:',
         geminiThinkingBudget: 'Presupuesto de Pensamiento Gemini:',

package/dist/i18n/lang/ja.js

@@ -119,7 +119,9 @@ export const ja = {
         apiKey: 'APIキー:',
         requestMethod: 'リクエスト方式:',
         anthropicBeta: 'Anthropic Beta:',
-        thinkingEnabled: '思考モードを有効化:',
+        enablePromptOptimization: 'Enable Prompt Optimization:',
+        enableAutoCompress: 'Enable Auto Compression:',
+        thinkingEnabled: 'Thinking Enabled:',
         thinkingBudgetTokens: '思考予算トークン数:',
         geminiThinkingEnabled: 'Gemini思考を有効化:',
         geminiThinkingBudget: 'Gemini思考予算:',

package/dist/i18n/lang/ko.js

@@ -119,7 +119,9 @@ export const ko = {
         apiKey: 'API 키:',
         requestMethod: '요청 방식:',
         anthropicBeta: 'Anthropic Beta:',
-        thinkingEnabled: '사고 모드 활성화:',
+        enablePromptOptimization: 'Enable Prompt Optimization:',
+        enableAutoCompress: 'Enable Auto Compression:',
+        thinkingEnabled: 'Thinking Enabled:',
         thinkingBudgetTokens: '사고 예산 토큰 수:',
         geminiThinkingEnabled: 'Gemini 사고 활성화:',
         geminiThinkingBudget: 'Gemini 사고 예산:',

package/dist/i18n/lang/zh-TW.js

@@ -119,6 +119,8 @@ export const zhTW = {
         apiKey: 'API 金鑰:',
         requestMethod: '請求方式:',
         anthropicBeta: 'Anthropic Beta:',
+        enablePromptOptimization: '啟用提示詞優化:',
+        enableAutoCompress: '啟用自動壓縮:',
         thinkingEnabled: '啟用思考模式:',
         thinkingBudgetTokens: '思考預算令牌數:',
         geminiThinkingEnabled: '啟用 Gemini 思考:',

package/dist/i18n/lang/zh.js

@@ -119,6 +119,8 @@ export const zh = {
         apiKey: 'API 密钥:',
         requestMethod: '请求方式:',
         anthropicBeta: 'Anthropic Beta:',
+        enablePromptOptimization: '启用提示词优化:',
+        enableAutoCompress: '启用自动压缩:',
         thinkingEnabled: '启用思考模式:',
         thinkingBudgetTokens: '思考预算令牌数:',
         geminiThinkingEnabled: '启用 Gemini 思考:',

package/dist/i18n/types.d.ts

@@ -120,6 +120,8 @@ export type TranslationKeys = {
         apiKey: string;
         requestMethod: string;
         anthropicBeta: string;
+        enablePromptOptimization: string;
+        enableAutoCompress: string;
         thinkingEnabled: string;
         thinkingBudgetTokens: string;
         geminiThinkingEnabled: string;

package/dist/mcp/bash.js

@@ -65,7 +65,14 @@ export class TerminalCommandService {
                 childProcess.on('error', reject);
                 childProcess.on('close', (code, signal) => {
                     if (signal) {
-                        reject(new Error(`Process killed by signal ${signal}`));
+                        // Process was killed by signal (e.g., timeout, manual kill)
+                        // CRITICAL: Still preserve stdout/stderr for debugging
+                        const error = new Error(`Process killed by signal ${signal}`);
+                        error.code = code || 1;
+                        error.stdout = stdoutData;
+                        error.stderr = stderrData;
+                        error.signal = signal;
+                        reject(error);
                     }
                     else if (code === 0) {
                         resolve({ stdout: stdoutData, stderr: stderrData });

package/dist/mcp/filesystem.js

@@ -1,7 +1,6 @@
 import { promises as fs } from 'fs';
 import * as path from 'path';
-import { exec } from 'child_process';
-import { promisify } from 'util';
+import * as prettier from 'prettier';
 // IDE connection supports both VSCode and JetBrains IDEs
 import { vscodeConnection } from '../utils/vscodeConnection.js';
 import { incrementalSnapshotManager } from '../utils/incrementalSnapshot.js';
@@ -16,7 +15,6 @@ import { parseFileSymbols } from './utils/aceCodeSearch/symbol.utils.js';
 // Notebook utilities for automatic note retrieval
 import { queryNotebook } from '../utils/notebookManager.js';
 const { resolve, dirname, isAbsolute } = path;
-const execAsync = promisify(exec);
 /**
  * Filesystem MCP Service
  * Provides basic file operations: read, create, and delete files
@@ -681,11 +679,14 @@ export class FilesystemMCPService {
             const shouldFormat = this.prettierSupportedExtensions.includes(fileExtension);
             if (shouldFormat) {
                 try {
-                    await execAsync(`npx prettier --write "${fullPath}"`, {
-                        encoding: 'utf-8',
+                    // Use Prettier API for better performance (avoids npx overhead)
+                    const prettierConfig = await prettier.resolveConfig(fullPath);
+                    finalContent = await prettier.format(modifiedContent, {
+                        filepath: fullPath,
+                        ...prettierConfig,
                     });
-                    // Re-read the file after formatting
-                    finalContent = await fs.readFile(fullPath, 'utf-8');
+                    // Write formatted content back to file
+                    await fs.writeFile(fullPath, finalContent, 'utf-8');
                     finalLines = finalContent.split('\n');
                     finalTotalLines = finalLines.length;
                     finalContextEnd = Math.min(finalTotalLines, contextStart + (contextEnd - contextStart) + lineDifference);
@@ -912,11 +913,15 @@ export class FilesystemMCPService {
             const shouldFormat = this.prettierSupportedExtensions.includes(fileExtension);
             if (shouldFormat) {
                 try {
-                    await execAsync(`npx prettier --write "${fullPath}"`, {
-                        encoding: 'utf-8',
+                    // Use Prettier API for better performance (avoids npx overhead)
+                    const prettierConfig = await prettier.resolveConfig(fullPath);
+                    const newContent = modifiedLines.join('\n');
+                    const formattedContent = await prettier.format(newContent, {
+                        filepath: fullPath,
+                        ...prettierConfig,
                     });
-                    // Re-read the file after formatting to get the formatted content
-                    const formattedContent = await fs.readFile(fullPath, 'utf-8');
+                    // Write formatted content back to file
+                    await fs.writeFile(fullPath, formattedContent, 'utf-8');
                     finalLines = formattedContent.split('\n');
                     finalTotalLines = finalLines.length;
                     // Recalculate the context end line based on formatted content
@@ -1072,7 +1077,7 @@ export const filesystemService = new FilesystemMCPService();
 export const mcpTools = [
     {
         name: 'filesystem-read',
-        description: 'Read file content with line numbers. **Read only when the actual file or folder path is found or provided by the user, do not make random guesses.** **SUPPORTS MULTIPLE FILES WITH FLEXIBLE LINE RANGES**: Pass either (1) a single file path (string), (2) array of file paths (strings) with unified startLine/endLine, or (3) array of file config objects with per-file line ranges. **INTEGRATED DIRECTORY LISTING**: When filePath is a directory, automatically lists its contents instead of throwing error. ⚠️ **IMPORTANT WORKFLOW**: (1) ALWAYS use ACE search tools FIRST (ace-text_search/ace-search_symbols/ace-file_outline) to locate the relevant code, (2) ONLY use filesystem-read when you know the approximate location and need precise line numbers for editing. **ANTI-PATTERN**: Reading files line-by-line from the top wastes tokens - use search instead! **USAGE**: Call without parameters to read entire file(s), or specify startLine/endLine for partial reads. Returns content with line numbers (format: "123→code") for precise editing. **EXAMPLES**: (A) Unified: filePath=["a.ts", "b.ts"], startLine=1, endLine=500 reads lines 1-500 from both. (B) Per-file: filePath=[{path:"a.ts", startLine:1, endLine:300}, {path:"b.ts", startLine:100, endLine:550}] reads different ranges from each file. (C) Directory: filePath="./src" returns list of files in src/.',
+        description: 'Read file content with line numbers. **Read only when the actual file or folder path is found or provided by the user, do not make random guesses,Search for specific documents or line numbers before reading more accurately** **SUPPORTS MULTIPLE FILES WITH FLEXIBLE LINE RANGES**: Pass either (1) a single file path (string), (2) array of file paths (strings) with unified startLine/endLine, or (3) array of file config objects with per-file line ranges. **INTEGRATED DIRECTORY LISTING**: When filePath is a directory, automatically lists its contents instead of throwing error. ⚠️ **IMPORTANT WORKFLOW**: (1) ALWAYS use ACE search tools FIRST (ace-text_search/ace-search_symbols/ace-file_outline) to locate the relevant code, (2) ONLY use filesystem-read when you know the approximate location and need precise line numbers for editing. **ANTI-PATTERN**: Reading files line-by-line from the top wastes tokens - use search instead! **USAGE**: Call without parameters to read entire file(s), or specify startLine/endLine for partial reads. Returns content with line numbers (format: "123→code") for precise editing. **EXAMPLES**: (A) Unified: filePath=["a.ts", "b.ts"], startLine=1, endLine=500 reads lines 1-500 from both. (B) Per-file: filePath=[{path:"a.ts", startLine:1, endLine:300}, {path:"b.ts", startLine:100, endLine:550}] reads different ranges from each file. (C) Directory: filePath="./src" returns list of files in src/.',
         inputSchema: {
             type: 'object',
             properties: {

package/dist/ui/components/ChatInput.js

@@ -346,7 +346,7 @@ export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type you
                         React.createElement(Text, { color: color },
                             percentage.toFixed(1),
                             "%"),
-                        React.createElement(Text, null, " "),
+                        React.createElement(Text, null, " \u00B7 "),
                         React.createElement(Text, { color: color }, formatNumber(totalInputTokens)),
                         React.createElement(Text, null, t.chatScreen.tokens),
                         hasCacheMetrics && (React.createElement(React.Fragment, null,

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

@@ -7,5 +7,5 @@ interface Props {
     completeNewContent?: string;
     startLineNumber?: number;
 }
-export default function DiffViewer({ oldContent, newContent, filename, completeOldContent, completeNewContent, startLineNumber, }: Props): React.JSX.Element;
+export default function DiffViewer({ oldContent, newContent, filename, completeOldContent, completeNewContent, startLineNumber, }: Props): React.JSX.Element | null;
 export {};

package/dist/ui/components/DiffViewer.js

@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { useMemo } from 'react';
 import { Box, Text } from 'ink';
 import * as Diff from 'diff';
 // Helper function to strip line numbers from content (format: "123→content")
@@ -23,109 +23,119 @@ export default function DiffViewer({ oldContent = '', newContent, filename, comp
         : stripLineNumbers(newContent);
     // If no old content, show as new file creation
     const isNewFile = !diffOldContent || diffOldContent.trim() === '';
-    if (isNewFile) {
+    // Memoize new file rendering to avoid re-splitting lines on every render
+    const newFileContent = useMemo(() => {
+        if (!isNewFile)
+            return null;
         const allLines = diffNewContent.split('\n');
         return (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Box, { marginBottom: 1 },
                 React.createElement(Text, { bold: true, color: "green" }, "[New File]"),
-                filename && (React.createElement(Text, { color: "cyan" },
-                    ' ',
-                    filename))),
+                filename && React.createElement(Text, { color: "cyan" },
+                    " ",
+                    filename)),
             React.createElement(Box, { flexDirection: "column" }, allLines.map((line, index) => (React.createElement(Text, { key: index, color: "white", backgroundColor: "#006400" },
                 "+ ",
                 line))))));
+    }, [isNewFile, diffNewContent, filename]);
+    if (isNewFile) {
+        return newFileContent;
     }
-    // Generate line-by-line diff
-    const diffResult = Diff.diffLines(diffOldContent, diffNewContent);
-    const allChanges = [];
-    let oldLineNum = startLineNumber;
-    let newLineNum = startLineNumber;
-    diffResult.forEach((part) => {
-        const lines = part.value.replace(/\n$/, '').split('\n');
-        lines.forEach((line) => {
-            if (part.added) {
-                allChanges.push({
-                    type: 'added',
-                    content: line,
-                    oldLineNum: null,
-                    newLineNum: newLineNum++,
-                });
-            }
-            else if (part.removed) {
-                allChanges.push({
-                    type: 'removed',
-                    content: line,
-                    oldLineNum: oldLineNum++,
-                    newLineNum: null,
-                });
-            }
-            else {
-                allChanges.push({
-                    type: 'unchanged',
-                    content: line,
-                    oldLineNum: oldLineNum++,
-                    newLineNum: newLineNum++,
-                });
-            }
-        });
-    });
-    // Find diff hunks (groups of changes with context)
-    const hunks = [];
-    const contextLines = 3; // Number of context lines before and after changes
-    for (let i = 0; i < allChanges.length; i++) {
-        const change = allChanges[i];
-        if (change?.type !== 'unchanged') {
-            // Found a change, create a hunk
-            const hunkStart = Math.max(0, i - contextLines);
-            let hunkEnd = i;
-            // Extend the hunk to include all consecutive changes
-            while (hunkEnd < allChanges.length - 1) {
-                const nextChange = allChanges[hunkEnd + 1];
-                if (!nextChange)
-                    break;
-                // If next line is a change, extend the hunk
-                if (nextChange.type !== 'unchanged') {
-                    hunkEnd++;
-                    continue;
+    // Memoize expensive diff calculation - only recompute when content changes
+    const hunks = useMemo(() => {
+        // Generate line-by-line diff
+        const diffResult = Diff.diffLines(diffOldContent, diffNewContent);
+        const allChanges = [];
+        let oldLineNum = startLineNumber;
+        let newLineNum = startLineNumber;
+        diffResult.forEach(part => {
+            const lines = part.value.replace(/\n$/, '').split('\n');
+            lines.forEach(line => {
+                if (part.added) {
+                    allChanges.push({
+                        type: 'added',
+                        content: line,
+                        oldLineNum: null,
+                        newLineNum: newLineNum++,
+                    });
+                }
+                else if (part.removed) {
+                    allChanges.push({
+                        type: 'removed',
+                        content: line,
+                        oldLineNum: oldLineNum++,
+                        newLineNum: null,
+                    });
+                }
+                else {
+                    allChanges.push({
+                        type: 'unchanged',
+                        content: line,
+                        oldLineNum: oldLineNum++,
+                        newLineNum: newLineNum++,
+                    });
                 }
-                // If there are more changes within context distance, extend the hunk
-                let hasMoreChanges = false;
-                for (let j = hunkEnd + 1; j < Math.min(allChanges.length, hunkEnd + 1 + contextLines * 2); j++) {
-                    if (allChanges[j]?.type !== 'unchanged') {
-                        hasMoreChanges = true;
+            });
+        });
+        // Find diff hunks (groups of changes with context)
+        const computedHunks = [];
+        const contextLines = 3; // Number of context lines before and after changes
+        for (let i = 0; i < allChanges.length; i++) {
+            const change = allChanges[i];
+            if (change?.type !== 'unchanged') {
+                // Found a change, create a hunk
+                const hunkStart = Math.max(0, i - contextLines);
+                let hunkEnd = i;
+                // Extend the hunk to include all consecutive changes
+                while (hunkEnd < allChanges.length - 1) {
+                    const nextChange = allChanges[hunkEnd + 1];
+                    if (!nextChange)
+                        break;
+                    // If next line is a change, extend the hunk
+                    if (nextChange.type !== 'unchanged') {
+                        hunkEnd++;
+                        continue;
+                    }
+                    // If there are more changes within context distance, extend the hunk
+                    let hasMoreChanges = false;
+                    for (let j = hunkEnd + 1; j < Math.min(allChanges.length, hunkEnd + 1 + contextLines * 2); j++) {
+                        if (allChanges[j]?.type !== 'unchanged') {
+                            hasMoreChanges = true;
+                            break;
+                        }
+                    }
+                    if (hasMoreChanges) {
+                        hunkEnd++;
+                    }
+                    else {
                         break;
                     }
                 }
-                if (hasMoreChanges) {
-                    hunkEnd++;
-                }
-                else {
-                    break;
+                // Add context lines after the hunk
+                hunkEnd = Math.min(allChanges.length - 1, hunkEnd + contextLines);
+                // Extract the hunk
+                const hunkChanges = allChanges.slice(hunkStart, hunkEnd + 1);
+                const firstChange = hunkChanges[0];
+                const lastChange = hunkChanges[hunkChanges.length - 1];
+                if (firstChange && lastChange) {
+                    computedHunks.push({
+                        startLine: firstChange.oldLineNum || firstChange.newLineNum || 1,
+                        endLine: lastChange.oldLineNum || lastChange.newLineNum || 1,
+                        changes: hunkChanges,
+                    });
                 }
+                // Skip to the end of this hunk
+                i = hunkEnd;
             }
-            // Add context lines after the hunk
-            hunkEnd = Math.min(allChanges.length - 1, hunkEnd + contextLines);
-            // Extract the hunk
-            const hunkChanges = allChanges.slice(hunkStart, hunkEnd + 1);
-            const firstChange = hunkChanges[0];
-            const lastChange = hunkChanges[hunkChanges.length - 1];
-            if (firstChange && lastChange) {
-                hunks.push({
-                    startLine: firstChange.oldLineNum || firstChange.newLineNum || 1,
-                    endLine: lastChange.oldLineNum || lastChange.newLineNum || 1,
-                    changes: hunkChanges,
-                });
-            }
-            // Skip to the end of this hunk
-            i = hunkEnd;
         }
-    }
+        return computedHunks;
+    }, [diffOldContent, diffNewContent, startLineNumber]);
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { bold: true, color: "yellow" }, "[File Modified]"),
-            filename && (React.createElement(Text, { color: "cyan" },
-                ' ',
-                filename))),
+            filename && React.createElement(Text, { color: "cyan" },
+                " ",
+                filename)),
         React.createElement(Box, { flexDirection: "column" },
             hunks.map((hunk, hunkIndex) => (React.createElement(Box, { key: hunkIndex, flexDirection: "column", marginBottom: 1 },
                 React.createElement(Text, { color: "cyan", dimColor: true },
@@ -136,10 +146,10 @@ export default function DiffViewer({ oldContent = '', newContent, filename, comp
                     " @@"),
                 hunk.changes.map((change, changeIndex) => {
                     // Calculate line number to display
-                    const lineNum = change.type === 'added'
-                        ? change.newLineNum
-                        : change.oldLineNum;
-                    const lineNumStr = lineNum ? String(lineNum).padStart(4, ' ') : '    ';
+                    const lineNum = change.type === 'added' ? change.newLineNum : change.oldLineNum;
+                    const lineNumStr = lineNum
+                        ? String(lineNum).padStart(4, ' ')
+                        : '    ';
                     if (change.type === 'added') {
                         return (React.createElement(Text, { key: changeIndex, color: "white", backgroundColor: "#006400" },
                             lineNumStr,
@@ -155,7 +165,7 @@ export default function DiffViewer({ oldContent = '', newContent, filename, comp
                     // Unchanged lines (context)
                     return (React.createElement(Text, { key: changeIndex, dimColor: true },
                         lineNumStr,
-                        "   ",
+                        " ",
                         change.content));
                 })))),
             hunks.length > 1 && (React.createElement(Box, { marginTop: 1 },

package/dist/ui/components/FileList.js

@@ -15,9 +15,15 @@ const FileList = memo(forwardRef(({ query, selectedIndex, visible, maxItems = 10
             ? Math.min(maxItems, MAX_DISPLAY_ITEMS)
             : MAX_DISPLAY_ITEMS;
     }, [maxItems]);
-    // Get files from directory - optimized for performance with no depth limit
+    // Get files from directory - optimized for performance with depth limit
     const loadFiles = useCallback(async () => {
+        const MAX_DEPTH = 5; // Limit recursion depth to prevent performance issues
+        const MAX_FILES = 1000; // Reduced from 2000 for better performance
         const getFilesRecursively = async (dir, depth = 0) => {
+            // Stop recursion if depth limit reached
+            if (depth > MAX_DEPTH) {
+                return [];
+            }
             try {
                 const entries = await fs.promises.readdir(dir, {
                     withFileTypes: true,
@@ -48,6 +54,10 @@ const FileList = memo(forwardRef(({ query, selectedIndex, visible, maxItems = 10
                     '.env',
                 ];
                 for (const entry of entries) {
+                    // Early exit if we've collected enough files
+                    if (result.length >= MAX_FILES) {
+                        break;
+                    }
                     // Skip hidden files and ignore patterns
                     if (entry.name.startsWith('.') ||
                         ignorePatterns.includes(entry.name)) {
@@ -70,20 +80,18 @@ const FileList = memo(forwardRef(({ query, selectedIndex, visible, maxItems = 10
                         !path.isAbsolute(relativePath)) {
                         relativePath = './' + relativePath;
                     }
+                    // Normalize to forward slashes for cross-platform consistency
+                    relativePath = relativePath.replace(/\\/g, '/');
                     result.push({
                         name: entry.name,
                         path: relativePath,
                         isDirectory: entry.isDirectory(),
                     });
-                    // Recursively get files from subdirectories (no depth limit)
-                    if (entry.isDirectory()) {
+                    // Recursively get files from subdirectories with depth limit
+                    if (entry.isDirectory() && depth < MAX_DEPTH) {
                         const subFiles = await getFilesRecursively(fullPath, depth + 1);
                         result = result.concat(subFiles);
                     }
-                    // Limit total files for performance (increased from 500 to 2000)
-                    if (result.length > 2000) {
-                        break;
-                    }
                 }
                 return result;
             }
@@ -211,12 +219,15 @@ const FileList = memo(forwardRef(({ query, selectedIndex, visible, maxItems = 10
         }
         return results;
     }, [files, rootPath, terminalWidth]);
-    // Load files on mount - only once when visible
+    // Load files when component becomes visible
+    // This ensures the file list is always fresh without complex file watching
     useEffect(() => {
-        if (visible && files.length === 0) {
-            loadFiles();
+        if (!visible) {
+            return;
         }
-    }, [visible, loadFiles]);
+        // Always reload when becoming visible to ensure fresh data
+        loadFiles();
+    }, [visible, rootPath, loadFiles]);
     // State for filtered files (needed for async content search)
     const [allFilteredFiles, setAllFilteredFiles] = useState([]);
     // Filter files based on query and search mode with debounce

package/dist/ui/components/ToolResultPreview.js

@@ -76,18 +76,30 @@ function renderTerminalExecutePreview(data, isSubAgentInternal) {
                 hasStderr &&
                     ` (${data.stderr.trim().split('\n').length} lines stderr)`)));
     }
-    // For main flow tools, show detailed info as before
+    // For main flow tools, show summary unless there's an error
+    // Only show full output when exitCode !== 0 or has stderr
+    const showFullOutput = hasError || hasStderr;
+    if (!showFullOutput) {
+        // Success case - show compact summary
+        const stdoutLines = hasStdout ? data.stdout.trim().split('\n').length : 0;
+        return (React.createElement(Box, { marginLeft: 2 },
+            React.createElement(Text, { color: "green", dimColor: true },
+                "\u2514\u2500 \u2713 Exit code: ",
+                data.exitCode,
+                hasStdout && ` (${stdoutLines} ${stdoutLines === 1 ? 'line' : 'lines'} output)`)));
+    }
+    // Error case - show full details
     return (React.createElement(Box, { flexDirection: "column", marginLeft: 2 },
         React.createElement(Text, { color: "gray", dimColor: true },
             "\u251C\u2500 command: ",
             data.command),
-        React.createElement(Text, { color: hasError ? 'red' : 'green', bold: hasError },
+        React.createElement(Text, { color: "red", bold: true },
             "\u251C\u2500 exitCode: ",
             data.exitCode,
-            hasError && ' ⚠️ FAILED'),
+            " \u26A0\uFE0F FAILED"),
         hasStdout && (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Text, { color: "gray", dimColor: true }, "\u251C\u2500 stdout:"),
-            React.createElement(Box, { marginLeft: 2, flexDirection: "column" }, data.stdout.split('\n').map((line, idx) => (React.createElement(Text, { key: idx, color: hasError ? 'yellow' : 'white' }, line)))))),
+            React.createElement(Box, { marginLeft: 2, flexDirection: "column" }, data.stdout.split('\n').map((line, idx) => (React.createElement(Text, { key: idx, color: "yellow" }, line)))))),
         hasStderr && (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Text, { color: "red", bold: true }, "\u251C\u2500 stderr:"),
             React.createElement(Box, { marginLeft: 2, flexDirection: "column" }, data.stderr.split('\n').map((line, idx) => (React.createElement(Text, { key: idx, color: "red" }, line)))))),

package/dist/ui/pages/ChatScreen.js

@@ -22,6 +22,7 @@ import { sessionManager } from '../../utils/sessionManager.js';
 import { useSessionSave } from '../../hooks/useSessionSave.js';
 import { useToolConfirmation } from '../../hooks/useToolConfirmation.js';
 import { handleConversationWithTools } from '../../hooks/useConversation.js';
+import { promptOptimizeAgent } from '../../agents/promptOptimizeAgent.js';
 import { useVSCodeState } from '../../hooks/useVSCodeState.js';
 import { useSnapshotState } from '../../hooks/useSnapshotState.js';
 import { useStreamingState } from '../../hooks/useStreamingState.js';
@@ -675,8 +676,9 @@ export default function ChatScreen({ skipWelcome }) {
         await processMessage(message, images);
     };
     const processMessage = async (message, images, useBasicModel, hideUserMessage) => {
-        // 检查 token 占用，如果 >= 80% 先执行自动压缩
-        if (shouldAutoCompress(currentContextPercentageRef.current)) {
+        // 检查 token 占用，如果 >= 80% 且配置启用了自动压缩，先执行自动压缩
+        const autoCompressConfig = getOpenAiConfig();
+        if (autoCompressConfig.enableAutoCompress !== false && shouldAutoCompress(currentContextPercentageRef.current)) {
             setIsCompressing(true);
             setCompressionError(null);
             try {
@@ -717,7 +719,7 @@ export default function ChatScreen({ skipWelcome }) {
         }
         // Clear any previous retry status when starting a new request
         streamingState.setRetryStatus(null);
-        // Parse and validate file references
+        // Parse and validate file references (use original message for immediate UI display)
         const { cleanContent, validFiles } = await parseAndValidateFileReferences(message);
         // Separate image files from regular files
         const imageFiles = validFiles.filter(f => f.isImage && f.imageData && f.mimeType);
@@ -735,7 +737,7 @@ export default function ChatScreen({ skipWelcome }) {
                 mimeType: f.mimeType,
             })),
         ];
-        // Only add user message to UI if not hidden
+        // Only add user message to UI if not hidden (显示原始用户消息)
         if (!hideUserMessage) {
             const userMessage = {
                 role: 'user',
@@ -749,16 +751,58 @@ export default function ChatScreen({ skipWelcome }) {
         // Create new abort controller for this request
         const controller = new AbortController();
         streamingState.setAbortController(controller);
+        // Optimize user prompt in the background (silent execution)
+        let originalMessage = message;
+        let optimizedMessage = message;
+        let optimizedCleanContent = cleanContent;
+        // Check if prompt optimization is enabled in config
+        const config = getOpenAiConfig();
+        const isOptimizationEnabled = config.enablePromptOptimization !== false; // Default to true
+        if (isOptimizationEnabled) {
+            try {
+                // Convert current UI messages to ChatMessage format for context
+                const conversationHistory = messages
+                    .filter(m => m.role === 'user' || m.role === 'assistant')
+                    .map(m => ({
+                    role: m.role,
+                    content: typeof m.content === 'string' ? m.content : '',
+                }));
+                // Try to optimize the prompt (background execution)
+                optimizedMessage = await promptOptimizeAgent.optimizePrompt(message, conversationHistory, controller.signal);
+                // Re-parse the optimized message to get clean content for AI
+                if (optimizedMessage !== originalMessage) {
+                    const optimizedParsed = await parseAndValidateFileReferences(optimizedMessage);
+                    optimizedCleanContent = optimizedParsed.cleanContent;
+                }
+            }
+            catch (error) {
+                // If optimization fails, silently fall back to original message
+                logger.warn('Prompt optimization failed, using original:', error);
+            }
+        }
         try {
-            // Create message for AI with file read instructions and editor context
-            const messageForAI = createMessageWithFileInstructions(cleanContent, regularFiles, vscodeState.vscodeConnected ? vscodeState.editorContext : undefined);
+            // Create message for AI with file read instructions and editor context (使用优化后的内容)
+            const messageForAI = createMessageWithFileInstructions(optimizedCleanContent, regularFiles, vscodeState.vscodeConnected ? vscodeState.editorContext : undefined);
+            // Wrap saveMessage to add originalContent for user messages
+            const saveMessageWithOriginal = async (msg) => {
+                // If this is a user message and we have an optimized version, add originalContent
+                if (msg.role === 'user' && optimizedMessage !== originalMessage) {
+                    await saveMessage({
+                        ...msg,
+                        originalContent: originalMessage,
+                    });
+                }
+                else {
+                    await saveMessage(msg);
+                }
+            };
             // Start conversation with tool support
             await handleConversationWithTools({
                 userContent: messageForAI,
                 imageContents,
                 controller,
                 messages,
-                saveMessage,
+                saveMessage: saveMessageWithOriginal,
                 setMessages,
                 setStreamTokenCount: streamingState.setStreamTokenCount,
                 requestToolConfirmation,

package/dist/ui/pages/ConfigScreen.js

@@ -51,6 +51,8 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
     const [apiKey, setApiKey] = useState('');
     const [requestMethod, setRequestMethod] = useState('chat');
     const [anthropicBeta, setAnthropicBeta] = useState(false);
+    const [enablePromptOptimization, setEnablePromptOptimization] = useState(true);
+    const [enableAutoCompress, setEnableAutoCompress] = useState(true);
     const [thinkingEnabled, setThinkingEnabled] = useState(false);
     const [thinkingBudgetTokens, setThinkingBudgetTokens] = useState(10000);
     const [geminiThinkingEnabled, setGeminiThinkingEnabled] = useState(false);
@@ -101,6 +103,8 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
             'baseUrl',
             'apiKey',
             'requestMethod',
+            'enablePromptOptimization',
+            'enableAutoCompress',
             ...(requestMethod === 'anthropic'
                 ? [
                     'anthropicBeta',
@@ -167,6 +171,8 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
         setApiKey(config.apiKey);
         setRequestMethod(config.requestMethod || 'chat');
         setAnthropicBeta(config.anthropicBeta || false);
+        setEnablePromptOptimization(config.enablePromptOptimization !== false); // Default to true
+        setEnableAutoCompress(config.enableAutoCompress !== false); // Default to true
         setThinkingEnabled(config.thinking?.type === 'enabled' || false);
         setThinkingBudgetTokens(config.thinking?.budget_tokens || 10000);
         setGeminiThinkingEnabled(config.geminiThinking?.enabled || false);
@@ -328,6 +334,8 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                 apiKey,
                 requestMethod,
                 anthropicBeta,
+                enablePromptOptimization,
+                enableAutoCompress,
                 advancedModel,
                 basicModel,
                 maxContextTokens,
@@ -380,6 +388,8 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                         apiKey,
                         requestMethod,
                         anthropicBeta,
+                        enablePromptOptimization,
+                        enableAutoCompress,
                         thinking: thinkingEnabled
                             ? { type: 'enabled', budget_tokens: thinkingBudgetTokens }
                             : undefined,
@@ -460,6 +470,26 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                             anthropicBeta ? t.configScreen.enabled : t.configScreen.disabled,
                             " ",
                             t.configScreen.toggleHint))));
+            case 'enablePromptOptimization':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        t.configScreen.enablePromptOptimization),
+                    React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" },
+                            enablePromptOptimization ? t.configScreen.enabled : t.configScreen.disabled,
+                            " ",
+                            t.configScreen.toggleHint))));
+            case 'enableAutoCompress':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        t.configScreen.enableAutoCompress),
+                    React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" },
+                            enableAutoCompress ? t.configScreen.enabled : t.configScreen.disabled,
+                            " ",
+                            t.configScreen.toggleHint))));
             case 'thinkingEnabled':
                 return (React.createElement(Box, { key: field, flexDirection: "column" },
                     React.createElement(Text, { color: isActive ? 'green' : 'white' },
@@ -809,6 +839,12 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                 if (currentField === 'anthropicBeta') {
                     setAnthropicBeta(!anthropicBeta);
                 }
+                else if (currentField === 'enablePromptOptimization') {
+                    setEnablePromptOptimization(!enablePromptOptimization);
+                }
+                else if (currentField === 'enableAutoCompress') {
+                    setEnableAutoCompress(!enableAutoCompress);
+                }
                 else if (currentField === 'thinkingEnabled') {
                     setThinkingEnabled(!thinkingEnabled);
                 }

package/dist/utils/apiConfig.d.ts

@@ -27,6 +27,8 @@ export interface ApiConfig {
     thinking?: ThinkingConfig;
     geminiThinking?: GeminiThinkingConfig;
     responsesReasoning?: ResponsesReasoningConfig;
+    enablePromptOptimization?: boolean;
+    enableAutoCompress?: boolean;
 }
 export interface MCPServer {
     url?: string;

package/dist/utils/sessionManager.d.ts

@@ -1,6 +1,7 @@
 import type { ChatMessage as APIChatMessage } from '../api/chat.js';
 export interface ChatMessage extends APIChatMessage {
     timestamp: number;
+    originalContent?: string;
 }
 export interface Session {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.3.37",
+	"version": "0.4.1",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {
@@ -65,6 +65,7 @@
 	"devDependencies": {
 		"@sindresorhus/tsconfig": "^3.0.1",
 		"@types/diff": "^7.0.2",
+		"@types/prettier": "^2.7.3",
 		"@types/react": "^18.0.32",
 		"@types/ws": "^8.5.8",
 		"@vdemedes/prettier-config": "^2.0.1",