snow-ai 0.3.13 → 0.3.14

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,

package/dist/api/systemPrompt.js

@@ -121,6 +121,13 @@ 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:

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;
@@ -142,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({
@@ -158,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,
@@ -411,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 => {
@@ -524,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];
@@ -574,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();

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');
         }

package/dist/ui/pages/ChatScreen.js

@@ -52,6 +52,7 @@ export default function ChatScreen({ skipWelcome }) {
     const [pendingMessages, setPendingMessages] = useState([]);
     const pendingMessagesRef = useRef([]);
     const hasAttemptedAutoVscodeConnect = useRef(false);
+    const userInterruptedRef = useRef(false); // Track if user manually interrupted via ESC
     const [remountKey, setRemountKey] = useState(0);
     const [showMcpInfo, setShowMcpInfo] = useState(false);
     const [mcpPanelKey, setMcpPanelKey] = useState(0);
@@ -266,85 +267,16 @@ export default function ChatScreen({ skipWelcome }) {
         if (key.escape &&
             streamingState.isStreaming &&
             streamingState.abortController) {
+            // Mark that user manually interrupted
+            userInterruptedRef.current = true;
             // Abort the controller
             streamingState.abortController.abort();
             // Clear retry status immediately when user cancels
             streamingState.setRetryStatus(null);
             // Remove all pending tool call messages (those with toolPending: true)
             setMessages(prev => prev.filter(msg => !msg.toolPending));
-            // Clean up incomplete conversation in session (handled in useConversation abort cleanup)
-            // This will remove:
-            // 1. User message without AI response (scenario 1)
-            // 2. Assistant message with tool_calls but no tool results (scenario 2)
-            const session = sessionManager.getCurrentSession();
-            if (session && session.messages.length > 0) {
-                // Use async cleanup to avoid blocking UI
-                (async () => {
-                    try {
-                        // Find the last complete conversation round
-                        const messages = session.messages;
-                        let truncateIndex = messages.length;
-                        // Scan from the end to find incomplete round
-                        for (let i = messages.length - 1; i >= 0; i--) {
-                            const msg = messages[i];
-                            if (!msg)
-                                continue;
-                            // If last message is user message without assistant response, remove it
-                            if (msg.role === 'user' && i === messages.length - 1) {
-                                truncateIndex = i;
-                                break;
-                            }
-                            // If assistant message has tool_calls, verify all tool results exist
-                            if (msg.role === 'assistant' &&
-                                msg.tool_calls &&
-                                msg.tool_calls.length > 0) {
-                                const toolCallIds = new Set(msg.tool_calls.map(tc => tc.id));
-                                // Check if all tool results exist after this assistant message
-                                for (let j = i + 1; j < messages.length; j++) {
-                                    const followMsg = messages[j];
-                                    if (followMsg &&
-                                        followMsg.role === 'tool' &&
-                                        followMsg.tool_call_id) {
-                                        toolCallIds.delete(followMsg.tool_call_id);
-                                    }
-                                }
-                                // If some tool results are missing, remove from this assistant message onwards
-                                if (toolCallIds.size > 0) {
-                                    truncateIndex = i;
-                                    break;
-                                }
-                            }
-                            // If we found a complete assistant response without tool calls, we're done
-                            if (msg.role === 'assistant' && !msg.tool_calls) {
-                                break;
-                            }
-                        }
-                        // Truncate session if needed
-                        if (truncateIndex < messages.length) {
-                            await sessionManager.truncateMessages(truncateIndex);
-                            // Also clear from saved messages tracking
-                            clearSavedMessages();
-                        }
-                    }
-                    catch (error) {
-                        console.error('Failed to clean up incomplete conversation:', error);
-                    }
-                })();
-            }
-            // Add discontinued message
-            setMessages(prev => [
-                ...prev,
-                {
-                    role: 'assistant',
-                    content: '',
-                    streaming: false,
-                    discontinued: true,
-                },
-            ]);
-            // Stop streaming state
-            streamingState.setIsStreaming(false);
-            streamingState.setAbortController(null);
-            streamingState.setStreamTokenCount(0);
+            // Note: discontinued message will be added in processMessage/processPendingMessages finally block
+            // Note: session cleanup will be handled in processMessage/processPendingMessages finally block
         }
     });
     const handleHistorySelect = async (selectedIndex, message) => {
@@ -389,6 +321,30 @@ export default function ChatScreen({ skipWelcome }) {
             const uiUserMessagesToDelete = messages
                 .slice(selectedIndex)
                 .filter(msg => msg.role === 'user').length;
+            // Check if the selected message is a user message that might not be in session
+            // (e.g., interrupted before AI response)
+            const selectedMessage = messages[selectedIndex];
+            const isUncommittedUserMessage = selectedMessage?.role === 'user' &&
+                uiUserMessagesToDelete === 1 &&
+                // Check if this is the last or second-to-last message (before discontinued)
+                (selectedIndex === messages.length - 1 ||
+                    (selectedIndex === messages.length - 2 &&
+                        messages[messages.length - 1]?.discontinued));
+            // If this is an uncommitted user message, just truncate UI and skip session modification
+            if (isUncommittedUserMessage) {
+                // Check if session ends with a complete assistant response
+                const lastSessionMsg = currentSession.messages[currentSession.messages.length - 1];
+                const sessionEndsWithAssistant = lastSessionMsg?.role === 'assistant' && !lastSessionMsg?.tool_calls;
+                if (sessionEndsWithAssistant) {
+                    // Session is complete, this user message wasn't saved
+                    // Just truncate UI, don't modify session
+                    setMessages(prev => prev.slice(0, selectedIndex));
+                    clearSavedMessages();
+                    setRemountKey(prev => prev + 1);
+                    snapshotState.setPendingRollback(null);
+                    return;
+                }
+            }
             // Find the corresponding user message in session to delete
             // We start from the end and count backwards
             let sessionUserMessageCount = 0;
@@ -629,6 +585,78 @@ export default function ChatScreen({ skipWelcome }) {
             }
         }
         finally {
+            // Handle user interruption uniformly
+            if (userInterruptedRef.current) {
+                // Clean up incomplete conversation in session
+                const session = sessionManager.getCurrentSession();
+                if (session && session.messages.length > 0) {
+                    (async () => {
+                        try {
+                            // Find the last complete conversation round
+                            const messages = session.messages;
+                            let truncateIndex = messages.length;
+                            // Scan from the end to find incomplete round
+                            for (let i = messages.length - 1; i >= 0; i--) {
+                                const msg = messages[i];
+                                if (!msg)
+                                    continue;
+                                // If last message is user message without assistant response, remove it
+                                // The user message was saved via await saveMessage() before interruption
+                                // So it's safe to truncate it from session when incomplete
+                                if (msg.role === 'user' && i === messages.length - 1) {
+                                    truncateIndex = i;
+                                    break;
+                                }
+                                // If assistant message has tool_calls, verify all tool results exist
+                                if (msg.role === 'assistant' &&
+                                    msg.tool_calls &&
+                                    msg.tool_calls.length > 0) {
+                                    const toolCallIds = new Set(msg.tool_calls.map(tc => tc.id));
+                                    // Check if all tool results exist after this assistant message
+                                    for (let j = i + 1; j < messages.length; j++) {
+                                        const followMsg = messages[j];
+                                        if (followMsg &&
+                                            followMsg.role === 'tool' &&
+                                            followMsg.tool_call_id) {
+                                            toolCallIds.delete(followMsg.tool_call_id);
+                                        }
+                                    }
+                                    // If some tool results are missing, remove from this assistant message onwards
+                                    if (toolCallIds.size > 0) {
+                                        truncateIndex = i;
+                                        break;
+                                    }
+                                }
+                                // If we found a complete assistant response without tool calls, we're done
+                                if (msg.role === 'assistant' && !msg.tool_calls) {
+                                    break;
+                                }
+                            }
+                            // Truncate session if needed
+                            if (truncateIndex < messages.length) {
+                                await sessionManager.truncateMessages(truncateIndex);
+                                // Also clear from saved messages tracking
+                                clearSavedMessages();
+                            }
+                        }
+                        catch (error) {
+                            console.error('Failed to clean up incomplete conversation:', error);
+                        }
+                    })();
+                }
+                // Add discontinued message after all processing is done
+                setMessages(prev => [
+                    ...prev,
+                    {
+                        role: 'assistant',
+                        content: '',
+                        streaming: false,
+                        discontinued: true,
+                    },
+                ]);
+                // Reset interruption flag
+                userInterruptedRef.current = false;
+            }
             // End streaming
             streamingState.setIsStreaming(false);
             streamingState.setAbortController(null);
@@ -720,6 +748,76 @@ export default function ChatScreen({ skipWelcome }) {
             }
         }
         finally {
+            // Handle user interruption uniformly
+            if (userInterruptedRef.current) {
+                // Clean up incomplete conversation in session
+                const session = sessionManager.getCurrentSession();
+                if (session && session.messages.length > 0) {
+                    (async () => {
+                        try {
+                            // Find the last complete conversation round
+                            const messages = session.messages;
+                            let truncateIndex = messages.length;
+                            // Scan from the end to find incomplete round
+                            for (let i = messages.length - 1; i >= 0; i--) {
+                                const msg = messages[i];
+                                if (!msg)
+                                    continue;
+                                // If last message is user message without assistant response, remove it
+                                if (msg.role === 'user' && i === messages.length - 1) {
+                                    truncateIndex = i;
+                                    break;
+                                }
+                                // If assistant message has tool_calls, verify all tool results exist
+                                if (msg.role === 'assistant' &&
+                                    msg.tool_calls &&
+                                    msg.tool_calls.length > 0) {
+                                    const toolCallIds = new Set(msg.tool_calls.map(tc => tc.id));
+                                    // Check if all tool results exist after this assistant message
+                                    for (let j = i + 1; j < messages.length; j++) {
+                                        const followMsg = messages[j];
+                                        if (followMsg &&
+                                            followMsg.role === 'tool' &&
+                                            followMsg.tool_call_id) {
+                                            toolCallIds.delete(followMsg.tool_call_id);
+                                        }
+                                    }
+                                    // If some tool results are missing, remove from this assistant message onwards
+                                    if (toolCallIds.size > 0) {
+                                        truncateIndex = i;
+                                        break;
+                                    }
+                                }
+                                // If we found a complete assistant response without tool calls, we're done
+                                if (msg.role === 'assistant' && !msg.tool_calls) {
+                                    break;
+                                }
+                            }
+                            // Truncate session if needed
+                            if (truncateIndex < messages.length) {
+                                await sessionManager.truncateMessages(truncateIndex);
+                                // Also clear from saved messages tracking
+                                clearSavedMessages();
+                            }
+                        }
+                        catch (error) {
+                            console.error('Failed to clean up incomplete conversation:', error);
+                        }
+                    })();
+                }
+                // Add discontinued message after all processing is done
+                setMessages(prev => [
+                    ...prev,
+                    {
+                        role: 'assistant',
+                        content: '',
+                        streaming: false,
+                        discontinued: true,
+                    },
+                ]);
+                // Reset interruption flag
+                userInterruptedRef.current = false;
+            }
             // End streaming
             streamingState.setIsStreaming(false);
             streamingState.setAbortController(null);
@@ -767,21 +865,25 @@ export default function ChatScreen({ skipWelcome }) {
                     let toolStatusColor = 'cyan';
                     let isToolMessage = false;
                     const isLastMessage = index === filteredMessages.length - 1;
-                    if (message.role === 'assistant') {
-                        if (message.content.startsWith('⚡')) {
+                    if (message.role === 'assistant' || message.role === 'subagent') {
+                        if (message.content.startsWith('⚡') ||
+                            message.content.includes('⚇⚡')) {
                             isToolMessage = true;
                             toolStatusColor = 'yellowBright';
                         }
-                        else if (message.content.startsWith('✓')) {
+                        else if (message.content.startsWith('✓') ||
+                            message.content.includes('⚇✓')) {
                             isToolMessage = true;
                             toolStatusColor = 'green';
                         }
-                        else if (message.content.startsWith('✗')) {
+                        else if (message.content.startsWith('✗') ||
+                            message.content.includes('⚇✗')) {
                             isToolMessage = true;
                             toolStatusColor = 'red';
                         }
                         else {
-                            toolStatusColor = 'blue';
+                            toolStatusColor =
+                                message.role === 'subagent' ? 'magenta' : 'blue';
                         }
                     }
                     return (React.createElement(Box, { key: `msg-${index}`, marginTop: index > 0 ? 1 : 0, marginBottom: isLastMessage ? 1 : 0, paddingX: 1, flexDirection: "column", width: terminalWidth },
@@ -850,13 +952,15 @@ export default function ChatScreen({ skipWelcome }) {
                                     }
                                     return null;
                                 }))),
-                                message.content.startsWith('✓') &&
+                                (message.content.startsWith('✓') ||
+                                    message.content.includes('⚇✓')) &&
                                     message.toolResult &&
                                     // 只在没有 diff 数据时显示预览（有 diff 的工具会用 DiffViewer 显示）
                                     !(message.toolCall &&
                                         (message.toolCall.arguments?.oldContent ||
                                             message.toolCall.arguments?.batchResults)) && (React.createElement(ToolResultPreview, { toolName: message.content
                                         .replace('✓ ', '')
+                                        .replace(/.*⚇✓\s*/, '')
                                         .split('\n')[0] || '', result: message.toolResult, maxLines: 5 })),
                                 message.role === 'user' && message.systemInfo && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
                                     React.createElement(Text, { color: "gray", dimColor: true },

package/dist/utils/commands/ide.js

@@ -3,14 +3,10 @@ import { vscodeConnection } from '../vscodeConnection.js';
 // IDE connection command handler
 registerCommand('ide', {
     execute: async () => {
-        // Check if already connected to IDE plugin
+        // If already connected, disconnect first to force reconnection
         if (vscodeConnection.isConnected()) {
-            return {
-                success: true,
-                action: 'info',
-                alreadyConnected: true,
-                message: `Already connected to IDE (port ${vscodeConnection.getPort()})`
-            };
+            vscodeConnection.stop();
+            vscodeConnection.resetReconnectAttempts();
         }
         // Try to connect to IDE plugin server
         try {
@@ -18,7 +14,7 @@ registerCommand('ide', {
             return {
                 success: true,
                 action: 'info',
-                message: `Connected to IDE on port ${vscodeConnection.getPort()}\nMake sure your IDE plugin (VSCode/JetBrains) is active and running.`
+                message: `Connected to IDE on port ${vscodeConnection.getPort()}\nMake sure your IDE plugin (VSCode/JetBrains) is active and running.`,
             };
         }
         catch (error) {
@@ -26,9 +22,9 @@ registerCommand('ide', {
                 success: false,
                 message: error instanceof Error
                     ? `Failed to connect to IDE: ${error.message}\nMake sure your IDE plugin is installed and active.`
-                    : 'Failed to connect to IDE. Make sure your IDE plugin is installed and active.'
+                    : 'Failed to connect to IDE. Make sure your IDE plugin is installed and active.',
             };
         }
-    }
+    },
 });
 export default {};

package/dist/utils/subAgentExecutor.d.ts

@@ -15,6 +15,9 @@ export interface ToolConfirmationCallback {
 export interface ToolApprovalChecker {
     (toolName: string): boolean;
 }
+export interface AddToAlwaysApprovedCallback {
+    (toolName: string): void;
+}
 /**
  * Execute a sub-agent as a tool
  * @param agentId - The ID of the sub-agent to execute
@@ -26,4 +29,4 @@ export interface ToolApprovalChecker {
  * @param yoloMode - Whether YOLO mode is enabled (auto-approve all tools)
  * @returns The final result from the sub-agent
  */
-export declare function executeSubAgent(agentId: string, prompt: string, onMessage?: (message: SubAgentMessage) => void, abortSignal?: AbortSignal, requestToolConfirmation?: ToolConfirmationCallback, isToolAutoApproved?: ToolApprovalChecker, yoloMode?: boolean): Promise<SubAgentResult>;
+export declare function executeSubAgent(agentId: string, prompt: string, onMessage?: (message: SubAgentMessage) => void, abortSignal?: AbortSignal, requestToolConfirmation?: ToolConfirmationCallback, isToolAutoApproved?: ToolApprovalChecker, yoloMode?: boolean, addToAlwaysApproved?: AddToAlwaysApprovedCallback): Promise<SubAgentResult>;

package/dist/utils/subAgentExecutor.js

@@ -17,7 +17,7 @@ import { sessionManager } from './sessionManager.js';
  * @param yoloMode - Whether YOLO mode is enabled (auto-approve all tools)
  * @returns The final result from the sub-agent
  */
-export async function executeSubAgent(agentId, prompt, onMessage, abortSignal, requestToolConfirmation, isToolAutoApproved, yoloMode) {
+export async function executeSubAgent(agentId, prompt, onMessage, abortSignal, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved) {
     try {
         // Get sub-agent configuration
         const agent = getSubAgent(agentId);
@@ -60,6 +60,9 @@ export async function executeSubAgent(agentId, prompt, onMessage, abortSignal, r
         let finalResponse = '';
         let hasError = false;
         let errorMessage = '';
+        // Local session-approved tools for this sub-agent execution
+        // This ensures tools approved during execution are immediately recognized
+        const sessionApprovedTools = new Set();
         const maxIterations = 10; // Prevent infinite loops
         let iteration = 0;
         while (iteration < maxIterations) {
@@ -168,8 +171,9 @@ export async function executeSubAgent(agentId, prompt, onMessage, abortSignal, r
                 if (yoloMode) {
                     needsConfirmation = false;
                 }
-                // Check if tool is in auto-approved list
-                else if (isToolAutoApproved && isToolAutoApproved(toolName)) {
+                // Check if tool is in auto-approved list (global or session)
+                else if (sessionApprovedTools.has(toolName) ||
+                    (isToolAutoApproved && isToolAutoApproved(toolName))) {
                     needsConfirmation = false;
                 }
                 if (needsConfirmation && requestToolConfirmation) {
@@ -179,8 +183,15 @@ export async function executeSubAgent(agentId, prompt, onMessage, abortSignal, r
                         rejectedToolCalls.push(toolCall);
                         continue;
                     }
-                    // If approved or approved_always, continue execution
-                    // (approved_always is handled by the main flow's session-approved list)
+                    // If approve_always, add to both global and session lists
+                    if (confirmation === 'approve_always') {
+                        // Add to local session set (immediate effect)
+                        sessionApprovedTools.add(toolName);
+                        // Add to global list (persistent across sub-agent calls)
+                        if (addToAlwaysApproved) {
+                            addToAlwaysApproved(toolName);
+                        }
+                    }
                 }
                 approvedToolCalls.push(toolCall);
             }

package/dist/utils/toolExecutor.d.ts

@@ -19,11 +19,14 @@ export interface ToolConfirmationCallback {
 export interface ToolApprovalChecker {
     (toolName: string): boolean;
 }
+export interface AddToAlwaysApprovedCallback {
+    (toolName: string): void;
+}
 /**
  * Execute a single tool call and return the result
  */
-export declare function executeToolCall(toolCall: ToolCall, abortSignal?: AbortSignal, onTokenUpdate?: (tokenCount: number) => void, onSubAgentMessage?: SubAgentMessageCallback, requestToolConfirmation?: ToolConfirmationCallback, isToolAutoApproved?: ToolApprovalChecker, yoloMode?: boolean): Promise<ToolResult>;
+export declare function executeToolCall(toolCall: ToolCall, abortSignal?: AbortSignal, onTokenUpdate?: (tokenCount: number) => void, onSubAgentMessage?: SubAgentMessageCallback, requestToolConfirmation?: ToolConfirmationCallback, isToolAutoApproved?: ToolApprovalChecker, yoloMode?: boolean, addToAlwaysApproved?: AddToAlwaysApprovedCallback): Promise<ToolResult>;
 /**
  * Execute multiple tool calls in parallel
  */
-export declare function executeToolCalls(toolCalls: ToolCall[], abortSignal?: AbortSignal, onTokenUpdate?: (tokenCount: number) => void, onSubAgentMessage?: SubAgentMessageCallback, requestToolConfirmation?: ToolConfirmationCallback, isToolAutoApproved?: ToolApprovalChecker, yoloMode?: boolean): Promise<ToolResult[]>;
+export declare function executeToolCalls(toolCalls: ToolCall[], abortSignal?: AbortSignal, onTokenUpdate?: (tokenCount: number) => void, onSubAgentMessage?: SubAgentMessageCallback, requestToolConfirmation?: ToolConfirmationCallback, isToolAutoApproved?: ToolApprovalChecker, yoloMode?: boolean, addToAlwaysApproved?: AddToAlwaysApprovedCallback): Promise<ToolResult[]>;

package/dist/utils/toolExecutor.js

@@ -3,7 +3,7 @@ import { subAgentService } from '../mcp/subagent.js';
 /**
  * Execute a single tool call and return the result
  */
-export async function executeToolCall(toolCall, abortSignal, onTokenUpdate, onSubAgentMessage, requestToolConfirmation, isToolAutoApproved, yoloMode) {
+export async function executeToolCall(toolCall, abortSignal, onTokenUpdate, onSubAgentMessage, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved) {
     try {
         const args = JSON.parse(toolCall.function.arguments);
         // Check if this is a sub-agent tool
@@ -38,6 +38,7 @@ export async function executeToolCall(toolCall, abortSignal, onTokenUpdate, onSu
                     : undefined,
                 isToolAutoApproved,
                 yoloMode,
+                addToAlwaysApproved,
             });
             return {
                 tool_call_id: toolCall.id,
@@ -64,6 +65,6 @@ export async function executeToolCall(toolCall, abortSignal, onTokenUpdate, onSu
 /**
  * Execute multiple tool calls in parallel
  */
-export async function executeToolCalls(toolCalls, abortSignal, onTokenUpdate, onSubAgentMessage, requestToolConfirmation, isToolAutoApproved, yoloMode) {
-    return Promise.all(toolCalls.map(tc => executeToolCall(tc, abortSignal, onTokenUpdate, onSubAgentMessage, requestToolConfirmation, isToolAutoApproved, yoloMode)));
+export async function executeToolCalls(toolCalls, abortSignal, onTokenUpdate, onSubAgentMessage, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved) {
+    return Promise.all(toolCalls.map(tc => executeToolCall(tc, abortSignal, onTokenUpdate, onSubAgentMessage, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved)));
 }

package/package.json

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