snow-ai 0.3.12 → 0.3.14

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.d.ts

@@ -10,7 +10,7 @@ export interface ResponseOptions {
     reasoning?: {
         summary?: 'auto' | 'none';
         effort?: 'low' | 'medium' | 'high';
-    };
+    } | null;
     prompt_cache_key?: string;
     store?: boolean;
     include?: string[];

package/dist/api/responses.js

@@ -246,7 +246,10 @@ export async function* createStreamingResponse(options, abortSignal, onRetry) {
             tools: convertToolsForResponses(options.tools),
             tool_choice: options.tool_choice,
             parallel_tool_calls: false,
-            reasoning: options.reasoning || { effort: 'high', summary: 'auto' },
+            // Only add reasoning if not explicitly disabled (null means don't pass it)
+            ...(options.reasoning !== null && {
+                reasoning: options.reasoning || { effort: 'high', summary: 'auto' },
+            }),
             store: false,
             stream: true,
             prompt_cache_key: options.prompt_cache_key,
@@ -256,7 +259,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 +445,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
 
@@ -121,13 +121,19 @@ and other shell features. Your capabilities include text processing, data filter
 manipulation, workflow automation, and complex command chaining to solve sophisticated 
 system administration and data processing challenges.
 
+**Sub-Agent:**
+A sub-agent is a separate session isolated from the main session, and a sub-agent may have some of the tools described above to focus on solving a specific problem.
+If you have a sub-agent tool, then you can leave some of the work to the sub-agent to solve.
+For example, if you have a sub-agent of a work plan, you can hand over the work plan to the sub-agent to solve when you receive user requirements. 
+This way, the master agent can focus on task fulfillment.
+*If you don't have a sub-agent tool, ignore this feature*
+
 ## 🔍 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

@@ -21,6 +21,10 @@ export async function handleConversationWithTools(options) {
     const { userContent, imageContents, controller, 
     // messages, // No longer used - we load from session instead to get complete history with tool calls
     saveMessage, setMessages, setStreamTokenCount, setCurrentTodos, requestToolConfirmation, isToolAutoApproved, addMultipleToAlwaysApproved, yoloMode, setContextUsage, setIsReasoning, setRetryStatus, } = options;
+    // Create a wrapper function for adding single tool to always-approved list
+    const addToAlwaysApproved = (toolName) => {
+        addMultipleToAlwaysApproved([toolName]);
+    };
     // Step 1: Ensure session exists and get existing TODOs
     let currentSession = sessionManager.getCurrentSession();
     if (!currentSession) {
@@ -64,13 +68,18 @@ export async function handleConversationWithTools(options) {
         images: imageContents,
     });
     // Save user message (directly save API format message)
-    saveMessage({
-        role: 'user',
-        content: userContent,
-        images: imageContents,
-    }).catch(error => {
+    // IMPORTANT: await to ensure message is saved before continuing
+    // This prevents loss of user message if conversation is interrupted (ESC)
+    try {
+        await saveMessage({
+            role: 'user',
+            content: userContent,
+            images: imageContents,
+        });
+    }
+    catch (error) {
         console.error('Failed to save user message:', error);
-    });
+    }
     // Initialize token encoder with proper cleanup tracking
     let encoder;
     let encoderFreed = false;
@@ -114,6 +123,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)
@@ -141,6 +151,8 @@ export async function handleConversationWithTools(options) {
                     max_tokens: config.maxTokens || 4096,
                     tools: mcpTools.length > 0 ? mcpTools : undefined,
                     sessionId: currentSession?.id,
+                    // Disable thinking for basicModel (e.g., init command)
+                    disableThinking: options.useBasicModel,
                 }, controller.signal, onRetry)
                 : config.requestMethod === 'gemini'
                     ? createStreamingGeminiCompletion({
@@ -157,6 +169,9 @@ export async function handleConversationWithTools(options) {
                             tools: mcpTools.length > 0 ? mcpTools : undefined,
                             tool_choice: 'auto',
                             prompt_cache_key: cacheKey, // Use session ID as cache key
+                            // Don't pass reasoning for basicModel (small models may not support it)
+                            // Pass null to explicitly disable reasoning in API call
+                            reasoning: options.useBasicModel ? null : undefined,
                         }, controller.signal, onRetry)
                         : createStreamingChatCompletion({
                             model,
@@ -194,6 +209,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 +239,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 +277,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 +305,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
@@ -402,6 +425,8 @@ export async function handleConversationWithTools(options) {
                     approvedTools.push(...toolsNeedingConfirmation);
                 }
                 // Execute approved tools with sub-agent message callback and terminal output callback
+                // Track sub-agent content for token counting
+                let subAgentContentAccumulator = '';
                 const toolResults = await executeToolCalls(approvedTools, controller.signal, setStreamTokenCount, async (subAgentMessage) => {
                     // Handle sub-agent messages - display and save to session
                     setMessages(prev => {
@@ -515,9 +540,20 @@ export async function handleConversationWithTools(options) {
                         let content = '';
                         if (subAgentMessage.message.type === 'content') {
                             content = subAgentMessage.message.content;
+                            // Update token count for sub-agent content
+                            subAgentContentAccumulator += content;
+                            try {
+                                const tokens = encoder.encode(subAgentContentAccumulator);
+                                setStreamTokenCount(tokens.length);
+                            }
+                            catch (e) {
+                                // Ignore encoding errors
+                            }
                         }
                         else if (subAgentMessage.message.type === 'done') {
-                            // Mark as complete
+                            // Mark as complete and reset token counter
+                            subAgentContentAccumulator = '';
+                            setStreamTokenCount(0);
                             if (existingIndex !== -1) {
                                 const updated = [...prev];
                                 const existing = updated[existingIndex];
@@ -565,7 +601,7 @@ export async function handleConversationWithTools(options) {
                         }
                         return prev;
                     });
-                }, requestToolConfirmation, isToolAutoApproved, yoloMode);
+                }, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved);
                 // Check if aborted during tool execution
                 if (controller.signal.aborted) {
                     freeEncoder();
@@ -819,7 +855,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/hooks/useToolConfirmation.js

@@ -1,15 +1,17 @@
-import { useState } from 'react';
+import { useState, useRef, useCallback } from 'react';
 /**
  * Hook for managing tool confirmation state and logic
  */
 export function useToolConfirmation() {
     const [pendingToolConfirmation, setPendingToolConfirmation] = useState(null);
+    // Use ref for always-approved tools to ensure closure functions always see latest state
+    const alwaysApprovedToolsRef = useRef(new Set());
     const [alwaysApprovedTools, setAlwaysApprovedTools] = useState(new Set());
     /**
      * Request user confirmation for tool execution
      */
     const requestToolConfirmation = async (toolCall, batchToolNames, allTools) => {
-        return new Promise((resolve) => {
+        return new Promise(resolve => {
             setPendingToolConfirmation({
                 tool: toolCall,
                 batchToolNames,
@@ -17,34 +19,43 @@ export function useToolConfirmation() {
                 resolve: (result) => {
                     setPendingToolConfirmation(null);
                     resolve(result);
-                }
+                },
             });
         });
     };
     /**
      * Check if a tool is auto-approved
+     * Uses ref to ensure it always sees the latest approved tools
      */
-    const isToolAutoApproved = (toolName) => {
-        return alwaysApprovedTools.has(toolName) || toolName.startsWith('todo-') || toolName.startsWith('subagent-');
-    };
+    const isToolAutoApproved = useCallback((toolName) => {
+        return (alwaysApprovedToolsRef.current.has(toolName) ||
+            toolName.startsWith('todo-') ||
+            toolName.startsWith('subagent-'));
+    }, []);
     /**
      * Add a tool to the always-approved list
      */
-    const addToAlwaysApproved = (toolName) => {
+    const addToAlwaysApproved = useCallback((toolName) => {
+        // Update ref immediately (for closure functions)
+        alwaysApprovedToolsRef.current.add(toolName);
+        // Update state (for UI reactivity)
         setAlwaysApprovedTools(prev => new Set([...prev, toolName]));
-    };
+    }, []);
     /**
      * Add multiple tools to the always-approved list
      */
-    const addMultipleToAlwaysApproved = (toolNames) => {
+    const addMultipleToAlwaysApproved = useCallback((toolNames) => {
+        // Update ref immediately (for closure functions)
+        toolNames.forEach(name => alwaysApprovedToolsRef.current.add(name));
+        // Update state (for UI reactivity)
         setAlwaysApprovedTools(prev => new Set([...prev, ...toolNames]));
-    };
+    }, []);
     return {
         pendingToolConfirmation,
         alwaysApprovedTools,
         requestToolConfirmation,
         isToolAutoApproved,
         addToAlwaysApproved,
-        addMultipleToAlwaysApproved
+        addMultipleToAlwaysApproved,
     };
 }

package/dist/mcp/subagent.d.ts

@@ -8,6 +8,7 @@ export interface SubAgentToolExecutionOptions {
     requestToolConfirmation?: (toolCall: ToolCall, batchToolNames?: string, allTools?: ToolCall[]) => Promise<string>;
     isToolAutoApproved?: (toolName: string) => boolean;
     yoloMode?: boolean;
+    addToAlwaysApproved?: (toolName: string) => void;
 }
 /**
  * Sub-Agent MCP Service

package/dist/mcp/subagent.js

@@ -9,7 +9,7 @@ export class SubAgentService {
      * Execute a sub-agent as a tool
      */
     async execute(options) {
-        const { agentId, prompt, onMessage, abortSignal, requestToolConfirmation, isToolAutoApproved, yoloMode, } = options;
+        const { agentId, prompt, onMessage, abortSignal, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved, } = options;
         // Create a tool confirmation adapter for sub-agent if needed
         const subAgentToolConfirmation = requestToolConfirmation
             ? async (toolName, toolArgs) => {
@@ -25,7 +25,7 @@ export class SubAgentService {
                 return await requestToolConfirmation(fakeToolCall);
             }
             : undefined;
-        const result = await executeSubAgent(agentId, prompt, onMessage, abortSignal, subAgentToolConfirmation, isToolAutoApproved, yoloMode);
+        const result = await executeSubAgent(agentId, prompt, onMessage, abortSignal, subAgentToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved);
         if (!result.success) {
             throw new Error(result.error || 'Sub-agent execution failed');
         }