snow-ai 0.3.12 → 0.3.13

package/dist/agents/compactAgent.js

@@ -102,6 +102,7 @@ export class CompactAgent {
                         messages,
                         max_tokens: 4096,
                         includeBuiltinSystemPrompt: false, // 不需要内置系统提示词
+                        disableThinking: true, // Agents 不使用 Extended Thinking
                     }, abortSignal);
                     break;
                 case 'gemini':
@@ -192,14 +193,14 @@ export class CompactAgent {
                         stack: streamError.stack,
                         name: streamError.name,
                         chunkCount,
-                        contentLength: completeContent.length
+                        contentLength: completeContent.length,
                     });
                 }
                 else {
                     logger.error('Compact agent: Unknown streaming error:', {
                         error: streamError,
                         chunkCount,
-                        contentLength: completeContent.length
+                        contentLength: completeContent.length,
                     });
                 }
                 throw streamError;
@@ -220,14 +221,14 @@ export class CompactAgent {
                     stack: error.stack,
                     name: error.name,
                     requestMethod: this.requestMethod,
-                    modelName: this.modelName
+                    modelName: this.modelName,
                 });
             }
             else {
                 logger.error('Compact agent: Unknown API error:', {
                     error,
                     requestMethod: this.requestMethod,
-                    modelName: this.modelName
+                    modelName: this.modelName,
                 });
             }
             throw error;
@@ -291,7 +292,7 @@ Provide the extracted content below:`;
                 logger.warn('Compact agent extraction failed, using original content:', {
                     error: error.message,
                     stack: error.stack,
-                    name: error.name
+                    name: error.name,
                 });
             }
             else {

package/dist/agents/reviewAgent.js

@@ -203,6 +203,7 @@ Please provide your review in a clear, structured format.`;
                     model: this.modelName,
                     messages: processedMessages,
                     max_tokens: 4096,
+                    disableThinking: true, // Agents 不使用 Extended Thinking
                 }, abortSignal);
                 break;
             case 'gemini':

package/dist/agents/summaryAgent.js

@@ -93,6 +93,7 @@ export class SummaryAgent {
                     messages,
                     max_tokens: 500, // Limited tokens for summary generation
                     includeBuiltinSystemPrompt: false, // 不需要内置系统提示词
+                    disableThinking: true, // Agents 不使用 Extended Thinking
                 }, abortSignal);
                 break;
             case 'gemini':

package/dist/api/anthropic.d.ts

@@ -7,9 +7,10 @@ export interface AnthropicOptions {
     tools?: ChatCompletionTool[];
     sessionId?: string;
     includeBuiltinSystemPrompt?: boolean;
+    disableThinking?: boolean;
 }
 export interface AnthropicStreamChunk {
-    type: 'content' | 'tool_calls' | 'tool_call_delta' | 'done' | 'usage';
+    type: 'content' | 'tool_calls' | 'tool_call_delta' | 'done' | 'usage' | 'reasoning_started' | 'reasoning_delta';
     content?: string;
     tool_calls?: Array<{
         id: string;
@@ -21,6 +22,11 @@ export interface AnthropicStreamChunk {
     }>;
     delta?: string;
     usage?: UsageInfo;
+    thinking?: {
+        type: 'thinking';
+        thinking: string;
+        signature?: string;
+    };
 }
 export interface AnthropicTool {
     name: string;

package/dist/api/anthropic.js

@@ -20,6 +20,7 @@ function getAnthropicConfig() {
                 : 'https://api.anthropic.com/v1',
             customHeaders,
             anthropicBeta: config.anthropicBeta,
+            thinking: config.thinking,
         };
     }
     return anthropicConfig;
@@ -124,6 +125,11 @@ function convertToAnthropicMessages(messages, includeBuiltinSystemPrompt = true)
             msg.tool_calls &&
             msg.tool_calls.length > 0) {
             const content = [];
+            // When thinking is enabled, thinking block must come first
+            if (msg.thinking) {
+                // Use the complete thinking block object (includes signature)
+                content.push(msg.thinking);
+            }
             if (msg.content) {
                 content.push({
                     type: 'text',
@@ -145,10 +151,29 @@ function convertToAnthropicMessages(messages, includeBuiltinSystemPrompt = true)
             continue;
         }
         if (msg.role === 'user' || msg.role === 'assistant') {
-            anthropicMessages.push({
-                role: msg.role,
-                content: msg.content,
-            });
+            // For assistant messages with thinking, convert to structured format
+            if (msg.role === 'assistant' && msg.thinking) {
+                const content = [];
+                // Thinking block must come first - use complete block object (includes signature)
+                content.push(msg.thinking);
+                // Then text content
+                if (msg.content) {
+                    content.push({
+                        type: 'text',
+                        text: msg.content,
+                    });
+                }
+                anthropicMessages.push({
+                    role: 'assistant',
+                    content,
+                });
+            }
+            else {
+                anthropicMessages.push({
+                    role: msg.role,
+                    content: msg.content,
+                });
+            }
         }
     }
     // 如果配置了自定义系统提示词（最高优先级，始终添加）
@@ -266,7 +291,6 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
         const requestBody = {
             model: options.model,
             max_tokens: options.max_tokens || 4096,
-            temperature: options.temperature ?? 0.7,
             system,
             messages,
             tools: convertToolsToAnthropic(options.tools),
@@ -275,11 +299,18 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
             },
             stream: true,
         };
+        // Add thinking configuration if enabled and not explicitly disabled
+        // When thinking is enabled, temperature must be 1
+        // Note: agents and other internal tools should set disableThinking=true
+        if (config.thinking && !options.disableThinking) {
+            requestBody.thinking = config.thinking;
+            requestBody.temperature = 1;
+        }
         // Prepare headers
         const headers = {
             'Content-Type': 'application/json',
             'x-api-key': config.apiKey,
-            'Authorization': `Bearer ${config.apiKey}`,
+            Authorization: `Bearer ${config.apiKey}`,
             'anthropic-version': '2023-06-01',
             ...config.customHeaders,
         };
@@ -305,10 +336,13 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
             throw new Error('No response body from Anthropic API');
         }
         let contentBuffer = '';
+        let thinkingTextBuffer = ''; // Accumulate thinking text content
+        let thinkingSignature = ''; // Accumulate thinking signature
         let toolCallsBuffer = new Map();
         let hasToolCalls = false;
         let usageData;
         let blockIndexToId = new Map();
+        let blockIndexToType = new Map(); // Track block types (text, thinking, tool_use)
         let completedToolBlocks = new Set(); // Track which tool blocks have finished streaming
         for await (const event of parseSSEStream(response.body.getReader())) {
             if (abortSignal?.aborted) {
@@ -316,9 +350,11 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
             }
             if (event.type === 'content_block_start') {
                 const block = event.content_block;
+                const blockIndex = event.index;
+                // Track block type for later reference
+                blockIndexToType.set(blockIndex, block.type);
                 if (block.type === 'tool_use') {
                     hasToolCalls = true;
-                    const blockIndex = event.index;
                     blockIndexToId.set(blockIndex, block.id);
                     toolCallsBuffer.set(block.id, {
                         id: block.id,
@@ -333,6 +369,13 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
                         delta: block.name,
                     };
                 }
+                // Handle thinking block start (Extended Thinking feature)
+                else if (block.type === 'thinking') {
+                    // Thinking block started - emit reasoning_started event
+                    yield {
+                        type: 'reasoning_started',
+                    };
+                }
             }
             else if (event.type === 'content_block_delta') {
                 const delta = event.delta;
@@ -344,6 +387,21 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
                         content: text,
                     };
                 }
+                // Handle thinking_delta (Extended Thinking feature)
+                // Emit reasoning_delta event for thinking content
+                if (delta.type === 'thinking_delta') {
+                    const thinkingText = delta.thinking;
+                    thinkingTextBuffer += thinkingText; // Accumulate thinking text
+                    yield {
+                        type: 'reasoning_delta',
+                        delta: thinkingText,
+                    };
+                }
+                // Handle signature_delta (Extended Thinking feature)
+                // Signature is required for thinking blocks
+                if (delta.type === 'signature_delta') {
+                    thinkingSignature += delta.signature; // Accumulate signature
+                }
                 if (delta.type === 'input_json_delta') {
                     const jsonDelta = delta.partial_json;
                     const blockIndex = event.index;
@@ -457,8 +515,17 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
                 usage: usageData,
             };
         }
+        // Return complete thinking block with signature if thinking content exists
+        const thinkingBlock = thinkingTextBuffer
+            ? {
+                type: 'thinking',
+                thinking: thinkingTextBuffer,
+                signature: thinkingSignature || undefined,
+            }
+            : undefined;
         yield {
             type: 'done',
+            thinking: thinkingBlock,
         };
     }, {
         abortSignal,

package/dist/api/chat.js

@@ -185,7 +185,7 @@ export async function* createStreamingChatCompletion(options, abortSignal, onRet
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
-                'Authorization': `Bearer ${config.apiKey}`,
+                Authorization: `Bearer ${config.apiKey}`,
                 ...config.customHeaders,
             },
             body: JSON.stringify(requestBody),

package/dist/api/responses.js

@@ -256,7 +256,7 @@ export async function* createStreamingResponse(options, abortSignal, onRetry) {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
-                'Authorization': `Bearer ${config.apiKey}`,
+                Authorization: `Bearer ${config.apiKey}`,
                 ...config.customHeaders,
             },
             body: JSON.stringify(requestPayload),
@@ -442,7 +442,7 @@ export async function* createStreamingResponse(options, abortSignal, onRetry) {
                 usage: usageData,
             };
         }
-        // 发送完成信号
+        // 发送完成信号 - For Responses API, thinking content is in reasoning object, not separate thinking field
         yield {
             type: 'done',
         };

package/dist/api/systemPrompt.js

@@ -33,7 +33,7 @@ const SYSTEM_PROMPT_TEMPLATE = `You are Snow AI CLI, an intelligent command-line
 1. **Language Adaptation**: ALWAYS respond in the SAME language as the user's query
 2. **ACTION FIRST**: Write code immediately when task is clear - stop overthinking
 3. **Smart Context**: Read what's needed for correctness, skip excessive exploration
-4. **Quality Verification**: Use \'ide-get_diagnostics\' to get diagnostic information or run build/test after changes
+4. **Quality Verification**: run build/test after changes
 
 ## 🚀 Execution Strategy - BALANCE ACTION & ANALYSIS
 
@@ -124,10 +124,9 @@ system administration and data processing challenges.
 ## 🔍 Quality Assurance
 
 Guidance and recommendations:
-1. Use \`ide-get_diagnostics\` to verify quality
-2. Run build: \`npm run build\` or \`tsc\`
-3. Fix any errors immediately
-4. Never leave broken code
+1. Run build: \`npm run build\` or \`tsc\`
+2. Fix any errors immediately
+3. Never leave broken code
 
 ## 📚 Project Context (SNOW.md)
 

package/dist/api/types.d.ts

@@ -29,6 +29,11 @@ export interface ChatMessage {
         content?: any;
         encrypted_content?: string;
     };
+    thinking?: {
+        type: 'thinking';
+        thinking: string;
+        signature?: string;
+    };
 }
 export interface ChatCompletionTool {
     type: 'function';

package/dist/hooks/useConversation.js

@@ -114,6 +114,7 @@ export async function handleConversationWithTools(options) {
             let streamedContent = '';
             let receivedToolCalls;
             let receivedReasoning;
+            let receivedThinking; // Accumulate thinking content from all platforms
             // Stream AI response - choose API based on config
             let toolCallAccumulator = ''; // Accumulate tool call deltas for token counting
             let reasoningAccumulator = ''; // Accumulate reasoning summary deltas for token counting (Responses API only)
@@ -194,6 +195,8 @@ export async function handleConversationWithTools(options) {
                 }
                 else if (chunk.type === 'tool_call_delta' && chunk.delta) {
                     // Accumulate tool call deltas and update token count in real-time
+                    // When tool calls start, reasoning is done (OpenAI generally doesn't output text content during tool calls)
+                    setIsReasoning?.(false);
                     toolCallAccumulator += chunk.delta;
                     try {
                         const tokens = encoder.encode(streamedContent + toolCallAccumulator + reasoningAccumulator);
@@ -222,6 +225,10 @@ export async function handleConversationWithTools(options) {
                     // Capture reasoning data from Responses API
                     receivedReasoning = chunk.reasoning;
                 }
+                else if (chunk.type === 'done' && chunk.thinking) {
+                    // Capture thinking content from Anthropic only (includes signature)
+                    receivedThinking = chunk.thinking;
+                }
                 else if (chunk.type === 'usage' && chunk.usage) {
                     // Capture usage information both in state and locally
                     setContextUsage(chunk.usage);
@@ -256,7 +263,8 @@ export async function handleConversationWithTools(options) {
                         }
                         if (chunk.usage.cached_tokens !== undefined) {
                             accumulatedUsage.cached_tokens =
-                                (accumulatedUsage.cached_tokens || 0) + chunk.usage.cached_tokens;
+                                (accumulatedUsage.cached_tokens || 0) +
+                                    chunk.usage.cached_tokens;
                         }
                     }
                 }
@@ -283,7 +291,8 @@ export async function handleConversationWithTools(options) {
                             arguments: tc.function.arguments,
                         },
                     })),
-                    reasoning: receivedReasoning, // Include reasoning data for caching
+                    reasoning: receivedReasoning, // Include reasoning data for caching (Responses API)
+                    thinking: receivedThinking, // Include thinking content (Anthropic/OpenAI)
                 };
                 conversationMessages.push(assistantMessage);
                 // Save assistant message with tool calls
@@ -819,7 +828,8 @@ export async function handleConversationWithTools(options) {
                 const assistantMessage = {
                     role: 'assistant',
                     content: streamedContent.trim(),
-                    reasoning: receivedReasoning, // Include reasoning data for caching
+                    reasoning: receivedReasoning, // Include reasoning data for caching (Responses API)
+                    thinking: receivedThinking, // Include thinking content (Anthropic/OpenAI)
                 };
                 conversationMessages.push(assistantMessage);
                 saveMessage(assistantMessage).catch(error => {

package/dist/ui/pages/ChatScreen.js

@@ -302,7 +302,9 @@ export default function ChatScreen({ skipWelcome }) {
                                 // 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) {
+                                    if (followMsg &&
+                                        followMsg.role === 'tool' &&
+                                        followMsg.tool_call_id) {
                                         toolCallIds.delete(followMsg.tool_call_id);
                                     }
                                 }
@@ -908,7 +910,9 @@ export default function ChatScreen({ skipWelcome }) {
             React.createElement(Text, { color: "gray", dimColor: true },
                 React.createElement(ShimmerText, { text: streamingState.isReasoning
                         ? 'Deep thinking...'
-                        : 'Thinking...' }),
+                        : streamingState.streamTokenCount > 0
+                            ? 'Writing...'
+                            : 'Thinking...' }),
                 ' ',
                 "(",
                 formatElapsedTime(streamingState.elapsedSeconds),

package/dist/ui/pages/ConfigScreen.js

@@ -49,6 +49,8 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
     const [apiKey, setApiKey] = useState('');
     const [requestMethod, setRequestMethod] = useState('chat');
     const [anthropicBeta, setAnthropicBeta] = useState(false);
+    const [thinkingEnabled, setThinkingEnabled] = useState(false);
+    const [thinkingBudgetTokens, setThinkingBudgetTokens] = useState(10000);
     // Model settings
     const [advancedModel, setAdvancedModel] = useState('');
     const [basicModel, setBasicModel] = useState('');
@@ -66,6 +68,8 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
     const [manualInputMode, setManualInputMode] = useState(false);
     const [manualInputValue, setManualInputValue] = useState('');
     const [, forceUpdate] = useState(0);
+    // Scrolling configuration
+    const MAX_VISIBLE_FIELDS = 8;
     const requestMethodOptions = [
         {
             label: 'Chat Completions - Modern chat API (GPT-4, GPT-3.5-turbo)',
@@ -84,9 +88,45 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
             value: 'anthropic',
         },
     ];
+    // Get all available fields based on current request method
+    const getAllFields = () => {
+        return [
+            'profile',
+            'baseUrl',
+            'apiKey',
+            'requestMethod',
+            ...(requestMethod === 'anthropic'
+                ? [
+                    'anthropicBeta',
+                    'thinkingEnabled',
+                    'thinkingBudgetTokens',
+                ]
+                : []),
+            'advancedModel',
+            'basicModel',
+            'compactModelName',
+            'maxContextTokens',
+            'maxTokens',
+        ];
+    };
+    // Get current field index and total count
+    const allFields = getAllFields();
+    const currentFieldIndex = allFields.indexOf(currentField);
+    const totalFields = allFields.length;
     useEffect(() => {
         loadProfilesAndConfig();
     }, []);
+    // Auto-adjust currentField when requestMethod changes
+    useEffect(() => {
+        // If requestMethod is not 'anthropic' and currentField is on Anthropic-specific fields,
+        // move to the next available field
+        if (requestMethod !== 'anthropic' &&
+            (currentField === 'anthropicBeta' ||
+                currentField === 'thinkingEnabled' ||
+                currentField === 'thinkingBudgetTokens')) {
+            setCurrentField('advancedModel');
+        }
+    }, [requestMethod, currentField]);
     const loadProfilesAndConfig = () => {
         // Load profiles
         const loadedProfiles = getAllProfiles();
@@ -97,6 +137,8 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
         setApiKey(config.apiKey);
         setRequestMethod(config.requestMethod || 'chat');
         setAnthropicBeta(config.anthropicBeta || false);
+        setThinkingEnabled(config.thinking?.type === 'enabled' || false);
+        setThinkingBudgetTokens(config.thinking?.budget_tokens || 10000);
         setAdvancedModel(config.advancedModel || '');
         setBasicModel(config.basicModel || '');
         setMaxContextTokens(config.maxContextTokens || 4000);
@@ -153,6 +195,8 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
             return maxContextTokens.toString();
         if (currentField === 'maxTokens')
             return maxTokens.toString();
+        if (currentField === 'thinkingBudgetTokens')
+            return thinkingBudgetTokens.toString();
         if (currentField === 'compactModelName')
             return compactModelName;
         return '';
@@ -171,6 +215,9 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                     apiKey,
                     requestMethod,
                     anthropicBeta,
+                    thinking: thinkingEnabled
+                        ? { type: 'enabled', budget_tokens: thinkingBudgetTokens }
+                        : undefined,
                     advancedModel,
                     basicModel,
                     maxContextTokens,
@@ -248,6 +295,17 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                 maxContextTokens,
                 maxTokens,
             };
+            // Save thinking configuration (always save to preserve settings)
+            if (thinkingEnabled) {
+                config.thinking = {
+                    type: 'enabled',
+                    budget_tokens: thinkingBudgetTokens,
+                };
+            }
+            else {
+                // Explicitly set to undefined to clear it when disabled
+                config.thinking = undefined;
+            }
             // Only save compactModel if modelName is provided (uses same baseUrl/apiKey)
             if (compactModelName) {
                 config.compactModel = {
@@ -264,6 +322,9 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                         apiKey,
                         requestMethod,
                         anthropicBeta,
+                        thinking: thinkingEnabled
+                            ? { type: 'enabled', budget_tokens: thinkingBudgetTokens }
+                            : undefined,
                         advancedModel,
                         basicModel,
                         maxContextTokens,
@@ -286,6 +347,121 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
             return false;
         }
     };
+    // Helper function to render a single field
+    const renderField = (field) => {
+        const isActive = field === currentField;
+        const isCurrentlyEditing = isEditing && isActive;
+        switch (field) {
+            case 'profile':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Profile:"),
+                    !isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, profiles.find(p => p.name === activeProfile)?.displayName ||
+                            activeProfile)))));
+            case 'baseUrl':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Base URL:"),
+                    isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(TextInput, { value: baseUrl, onChange: value => setBaseUrl(stripFocusArtifacts(value)), placeholder: "https://api.openai.com/v1" }))),
+                    !isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, baseUrl || 'Not set')))));
+            case 'apiKey':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "API Key:"),
+                    isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(TextInput, { value: apiKey, onChange: value => setApiKey(stripFocusArtifacts(value)), placeholder: "sk-...", mask: "*" }))),
+                    !isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, apiKey ? '*'.repeat(Math.min(apiKey.length, 20)) : 'Not set')))));
+            case 'requestMethod':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Request Method:"),
+                    !isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, requestMethodOptions.find(opt => opt.value === requestMethod)
+                            ?.label || 'Not set')))));
+            case 'anthropicBeta':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Anthropic Beta:"),
+                    React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" },
+                            anthropicBeta ? '☒ Enabled' : '☐ Disabled',
+                            " (Press Enter to toggle)"))));
+            case 'thinkingEnabled':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Thinking Enabled:"),
+                    React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" },
+                            thinkingEnabled ? '☒ Enabled' : '☐ Disabled',
+                            " (Press Enter to toggle)"))));
+            case 'thinkingBudgetTokens':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Thinking Budget Tokens:"),
+                    isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "cyan" },
+                            "Enter value: ",
+                            thinkingBudgetTokens))),
+                    !isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, thinkingBudgetTokens)))));
+            case 'advancedModel':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Advanced Model:"),
+                    !isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, advancedModel || 'Not set')))));
+            case 'basicModel':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Basic Model:"),
+                    !isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, basicModel || 'Not set')))));
+            case 'compactModelName':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Compact Model:"),
+                    !isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, compactModelName || 'Not set')))));
+            case 'maxContextTokens':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Max Context Tokens:"),
+                    isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "cyan" },
+                            "Enter value: ",
+                            maxContextTokens))),
+                    !isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, maxContextTokens)))));
+            case 'maxTokens':
+                return (React.createElement(Box, { key: field, flexDirection: "column" },
+                    React.createElement(Text, { color: isActive ? 'green' : 'white' },
+                        isActive ? '❯ ' : '  ',
+                        "Max Tokens:"),
+                    isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "cyan" },
+                            "Enter value: ",
+                            maxTokens))),
+                    !isCurrentlyEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, maxTokens)))));
+            default:
+                return null;
+        }
+    };
     useInput((rawInput, key) => {
         const input = stripFocusArtifacts(rawInput);
         if (!input && isFocusEventInput(rawInput)) {
@@ -403,41 +579,68 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                 return;
             }
             // Handle numeric input for token fields
-            if (currentField === 'maxContextTokens' || currentField === 'maxTokens') {
+            if (currentField === 'maxContextTokens' ||
+                currentField === 'maxTokens' ||
+                currentField === 'thinkingBudgetTokens') {
                 if (input && input.match(/[0-9]/)) {
-                    const currentValue = currentField === 'maxContextTokens' ? maxContextTokens : maxTokens;
+                    const currentValue = currentField === 'maxContextTokens'
+                        ? maxContextTokens
+                        : currentField === 'maxTokens'
+                            ? maxTokens
+                            : thinkingBudgetTokens;
                     const newValue = parseInt(currentValue.toString() + input, 10);
                     if (!isNaN(newValue)) {
                         if (currentField === 'maxContextTokens') {
                             setMaxContextTokens(newValue);
                         }
-                        else {
+                        else if (currentField === 'maxTokens') {
                             setMaxTokens(newValue);
                         }
+                        else {
+                            setThinkingBudgetTokens(newValue);
+                        }
                     }
                 }
                 else if (key.backspace || key.delete) {
-                    const currentValue = currentField === 'maxContextTokens' ? maxContextTokens : maxTokens;
+                    const currentValue = currentField === 'maxContextTokens'
+                        ? maxContextTokens
+                        : currentField === 'maxTokens'
+                            ? maxTokens
+                            : thinkingBudgetTokens;
                     const currentStr = currentValue.toString();
                     const newStr = currentStr.slice(0, -1);
                     const newValue = parseInt(newStr, 10);
                     if (currentField === 'maxContextTokens') {
                         setMaxContextTokens(!isNaN(newValue) ? newValue : 0);
                     }
-                    else {
+                    else if (currentField === 'maxTokens') {
                         setMaxTokens(!isNaN(newValue) ? newValue : 0);
                     }
+                    else {
+                        setThinkingBudgetTokens(!isNaN(newValue) ? newValue : 0);
+                    }
                 }
                 else if (key.return) {
-                    const minValue = currentField === 'maxContextTokens' ? 4000 : 100;
-                    const currentValue = currentField === 'maxContextTokens' ? maxContextTokens : maxTokens;
+                    const minValue = currentField === 'maxContextTokens'
+                        ? 4000
+                        : currentField === 'maxTokens'
+                            ? 100
+                            : 1000;
+                    const currentValue = currentField === 'maxContextTokens'
+                        ? maxContextTokens
+                        : currentField === 'maxTokens'
+                            ? maxTokens
+                            : thinkingBudgetTokens;
                     const finalValue = currentValue < minValue ? minValue : currentValue;
                     if (currentField === 'maxContextTokens') {
                         setMaxContextTokens(finalValue);
                     }
-                    else {
+                    else if (currentField === 'maxTokens') {
                         setMaxTokens(finalValue);
                     }
+                    else {
+                        setThinkingBudgetTokens(finalValue);
+                    }
                     setIsEditing(false);
                 }
                 return;
@@ -470,8 +673,12 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                 if (currentField === 'anthropicBeta') {
                     setAnthropicBeta(!anthropicBeta);
                 }
+                else if (currentField === 'thinkingEnabled') {
+                    setThinkingEnabled(!thinkingEnabled);
+                }
                 else if (currentField === 'maxContextTokens' ||
-                    currentField === 'maxTokens') {
+                    currentField === 'maxTokens' ||
+                    currentField === 'thinkingBudgetTokens') {
                     setIsEditing(true);
                 }
                 else if (currentField === 'advancedModel' ||
@@ -504,36 +711,14 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
             }
         }
         else if (!isEditing && key.upArrow) {
-            const fields = [
-                'profile',
-                'baseUrl',
-                'apiKey',
-                'requestMethod',
-                'anthropicBeta',
-                'advancedModel',
-                'basicModel',
-                'compactModelName',
-                'maxContextTokens',
-                'maxTokens',
-            ];
+            const fields = getAllFields();
             const currentIndex = fields.indexOf(currentField);
             if (currentIndex > 0) {
                 setCurrentField(fields[currentIndex - 1]);
             }
         }
         else if (!isEditing && key.downArrow) {
-            const fields = [
-                'profile',
-                'baseUrl',
-                'apiKey',
-                'requestMethod',
-                'anthropicBeta',
-                'advancedModel',
-                'basicModel',
-                'compactModelName',
-                'maxContextTokens',
-                'maxTokens',
-            ];
+            const fields = getAllFields();
             const currentIndex = fields.indexOf(currentField);
             if (currentIndex < fields.length - 1) {
                 setCurrentField(fields[currentIndex + 1]);
@@ -619,6 +804,16 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                 activeProfile && (React.createElement(Text, { color: "cyan", dimColor: true },
                     "Active Profile: ",
                     activeProfile))))),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: "yellow", bold: true },
+                "Settings (",
+                currentFieldIndex + 1,
+                "/",
+                totalFields,
+                ")"),
+            totalFields > MAX_VISIBLE_FIELDS && (React.createElement(Text, { color: "gray", dimColor: true },
+                ' ',
+                "\u00B7 \u2191\u2193 to scroll"))),
         isEditing &&
             (currentField === 'profile' ||
                 currentField === 'requestMethod' ||
@@ -672,83 +867,23 @@ export default function ConfigScreen({ onBack, onSave, inlineMode = false, }) {
                     currentField === 'profile' &&
                         '↑↓ to select profile, N to create new, D to delete, Enter to confirm, Esc to cancel',
                     currentField === 'requestMethod' &&
-                        '↑↓ to select, Enter to confirm, Esc to cancel')))) : (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { color: currentField === 'profile' ? 'green' : 'white' },
-                    currentField === 'profile' ? '❯ ' : '  ',
-                    "Profile:"),
-                (!isEditing || currentField !== 'profile') && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Text, { color: "gray" }, profiles.find(p => p.name === activeProfile)?.displayName ||
-                        activeProfile)))),
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { color: currentField === 'baseUrl' ? 'green' : 'white' },
-                    currentField === 'baseUrl' ? '❯ ' : '  ',
-                    "Base URL:"),
-                currentField === 'baseUrl' && isEditing && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(TextInput, { value: baseUrl, onChange: value => setBaseUrl(stripFocusArtifacts(value)), placeholder: "https://api.openai.com/v1" }))),
-                (!isEditing || currentField !== 'baseUrl') && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Text, { color: "gray" }, baseUrl || 'Not set')))),
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { color: currentField === 'apiKey' ? 'green' : 'white' },
-                    currentField === 'apiKey' ? '❯ ' : '  ',
-                    "API Key:"),
-                currentField === 'apiKey' && isEditing && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(TextInput, { value: apiKey, onChange: value => setApiKey(stripFocusArtifacts(value)), placeholder: "sk-...", mask: "*" }))),
-                (!isEditing || currentField !== 'apiKey') && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Text, { color: "gray" }, apiKey ? '*'.repeat(Math.min(apiKey.length, 20)) : 'Not set')))),
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { color: currentField === 'requestMethod' ? 'green' : 'white' },
-                    currentField === 'requestMethod' ? '❯ ' : '  ',
-                    "Request Method:"),
-                (!isEditing || currentField !== 'requestMethod') && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Text, { color: "gray" }, requestMethodOptions.find(opt => opt.value === requestMethod)
-                        ?.label || 'Not set')))),
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { color: currentField === 'anthropicBeta' ? 'green' : 'white' },
-                    currentField === 'anthropicBeta' ? '❯ ' : '  ',
-                    "Anthropic Beta:"),
-                React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Text, { color: "gray" },
-                        anthropicBeta ? '☒ Enabled' : '☐ Disabled',
-                        " (Press Enter to toggle)"))),
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { color: currentField === 'advancedModel' ? 'green' : 'white' },
-                    currentField === 'advancedModel' ? '❯ ' : '  ',
-                    "Advanced Model:"),
-                (!isEditing || currentField !== 'advancedModel') && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Text, { color: "gray" }, advancedModel || 'Not set')))),
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { color: currentField === 'basicModel' ? 'green' : 'white' },
-                    currentField === 'basicModel' ? '❯ ' : '  ',
-                    "Basic Model:"),
-                (!isEditing || currentField !== 'basicModel') && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Text, { color: "gray" }, basicModel || 'Not set')))),
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { color: currentField === 'compactModelName' ? 'green' : 'white' },
-                    currentField === 'compactModelName' ? '❯ ' : '  ',
-                    "Compact Model:"),
-                (!isEditing || currentField !== 'compactModelName') && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Text, { color: "gray" }, compactModelName || 'Not set')))),
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { color: currentField === 'maxContextTokens' ? 'green' : 'white' },
-                    currentField === 'maxContextTokens' ? '❯ ' : '  ',
-                    "Max Context Tokens:"),
-                currentField === 'maxContextTokens' && isEditing && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Text, { color: "cyan" },
-                        "Enter value: ",
-                        maxContextTokens))),
-                (!isEditing || currentField !== 'maxContextTokens') && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Text, { color: "gray" }, maxContextTokens)))),
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { color: currentField === 'maxTokens' ? 'green' : 'white' },
-                    currentField === 'maxTokens' ? '❯ ' : '  ',
-                    "Max Tokens:"),
-                currentField === 'maxTokens' && isEditing && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Text, { color: "cyan" },
-                        "Enter value: ",
-                        maxTokens))),
-                (!isEditing || currentField !== 'maxTokens') && (React.createElement(Box, { marginLeft: 3 },
-                    React.createElement(Text, { color: "gray" }, maxTokens)))))),
+                        '↑↓ to select, Enter to confirm, Esc to cancel')))) : (React.createElement(Box, { flexDirection: "column" }, (() => {
+            // Calculate visible window
+            if (allFields.length <= MAX_VISIBLE_FIELDS) {
+                // Show all fields if less than max
+                return allFields.map(field => renderField(field));
+            }
+            // Calculate scroll window
+            const halfWindow = Math.floor(MAX_VISIBLE_FIELDS / 2);
+            let startIndex = Math.max(0, currentFieldIndex - halfWindow);
+            let endIndex = Math.min(allFields.length, startIndex + MAX_VISIBLE_FIELDS);
+            // Adjust if we're near the end
+            if (endIndex - startIndex < MAX_VISIBLE_FIELDS) {
+                startIndex = Math.max(0, endIndex - MAX_VISIBLE_FIELDS);
+            }
+            const visibleFields = allFields.slice(startIndex, endIndex);
+            return visibleFields.map(field => renderField(field));
+        })())),
         errors.length > 0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 },
             React.createElement(Text, { color: "red", bold: true }, "Errors:"),
             errors.map((error, index) => (React.createElement(Text, { key: index, color: "red" },

package/dist/ui/pages/HeadlessModeScreen.js

@@ -279,7 +279,9 @@ export default function HeadlessModeScreen({ prompt, onComplete }) {
                 // Show normal thinking status with colors
                 const thinkingText = streamingState.isReasoning
                     ? 'Deep thinking...'
-                    : 'Thinking...';
+                    : streamingState.streamTokenCount > 0
+                        ? 'Writing...'
+                        : 'Thinking...';
                 process.stdout.write(`\r\x1b[96m❆\x1b[90m ${thinkingText} \x1b[37m(\x1b[33m${streamingState.elapsedSeconds}s\x1b[37m · \x1b[32m↓ ${streamingState.streamTokenCount} tokens\x1b[37m)\x1b[0m`);
             }
         }

package/dist/utils/apiConfig.d.ts

@@ -2,6 +2,10 @@ export type RequestMethod = 'chat' | 'responses' | 'gemini' | 'anthropic';
 export interface CompactModelConfig {
     modelName: string;
 }
+export interface ThinkingConfig {
+    type: 'enabled';
+    budget_tokens: number;
+}
 export interface ApiConfig {
     baseUrl: string;
     apiKey: string;
@@ -12,6 +16,7 @@ export interface ApiConfig {
     maxTokens?: number;
     compactModel?: CompactModelConfig;
     anthropicBeta?: boolean;
+    thinking?: ThinkingConfig;
 }
 export interface MCPServer {
     url?: string;

package/dist/utils/apiConfig.js

@@ -24,7 +24,10 @@ const CONFIG_DIR = join(homedir(), '.snow');
 const SYSTEM_PROMPT_FILE = join(CONFIG_DIR, 'system-prompt.txt');
 const CUSTOM_HEADERS_FILE = join(CONFIG_DIR, 'custom-headers.json');
 function normalizeRequestMethod(method) {
-    if (method === 'chat' || method === 'responses' || method === 'gemini' || method === 'anthropic') {
+    if (method === 'chat' ||
+        method === 'responses' ||
+        method === 'gemini' ||
+        method === 'anthropic') {
         return method;
     }
     if (method === 'completions') {
@@ -84,7 +87,8 @@ export function loadConfig() {
             snowcfg: apiConfig,
         };
         // 如果是从旧版本迁移过来的，保存新配置
-        if (legacyMcp !== undefined || (configWithoutMcp.openai && !configWithoutMcp.snowcfg)) {
+        if (legacyMcp !== undefined ||
+            (configWithoutMcp.openai && !configWithoutMcp.snowcfg)) {
             saveConfig(mergedConfig);
         }
         return mergedConfig;
@@ -264,7 +268,9 @@ export function getCustomHeaders() {
         const content = readFileSync(CUSTOM_HEADERS_FILE, 'utf8');
         const headers = JSON.parse(content);
         // 验证格式：必须是对象，且所有值都是字符串
-        if (typeof headers !== 'object' || headers === null || Array.isArray(headers)) {
+        if (typeof headers !== 'object' ||
+            headers === null ||
+            Array.isArray(headers)) {
             return {};
         }
         // 过滤掉非字符串的值

package/dist/utils/contextCompressor.js

@@ -73,7 +73,9 @@ function findPreserveStartIndex(messages) {
         // 向前找对应的 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) {
+            if (msg?.role === 'assistant' &&
+                msg.tool_calls &&
+                msg.tool_calls.length > 0) {
                 // 找到了，从这个 assistant 开始保留
                 return i;
             }
@@ -82,7 +84,9 @@ function findPreserveStartIndex(messages) {
         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) {
+    if (lastMsg?.role === 'assistant' &&
+        lastMsg.tool_calls &&
+        lastMsg.tool_calls.length > 0) {
         // 保留这个待处理的 tool_calls
         return messages.length - 1;
     }
@@ -244,6 +248,7 @@ async function compressWithAnthropic(modelName, conversationMessages, customSyst
         model: modelName,
         messages,
         max_tokens: 4096,
+        disableThinking: true, // Context compression 不使用 Extended Thinking
     })) {
         // Collect content
         if (chunk.type === 'content' && chunk.content) {

package/dist/utils/subAgentExecutor.js

@@ -75,7 +75,7 @@ export async function executeSubAgent(agentId, prompt, onMessage, abortSignal, r
             // Get API configuration
             const config = getOpenAiConfig();
             const currentSession = sessionManager.getCurrentSession();
-            const model = config.advancedModel || 'claude-3-5-sonnet-20241022';
+            const model = config.advancedModel || 'gpt-5';
             // Call API with sub-agent's tools - choose API based on config
             const stream = config.requestMethod === 'anthropic'
                 ? createStreamingAnthropicCompletion({
@@ -85,6 +85,7 @@ export async function executeSubAgent(agentId, prompt, onMessage, abortSignal, r
                     max_tokens: config.maxTokens || 4096,
                     tools: allowedTools,
                     sessionId: currentSession?.id,
+                    disableThinking: true, // Sub-agents 不使用 Extended Thinking
                 }, abortSignal)
                 : config.requestMethod === 'gemini'
                     ? createStreamingGeminiCompletion({

package/package.json

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