snow-ai 0.3.27 → 0.3.29

package/dist/utils/sessionConverter.js

@@ -18,27 +18,30 @@ export function convertSessionMessagesToUI(sessionMessages) {
         // Handle sub-agent internal tool call messages
         if (msg.subAgentInternal && msg.role === 'assistant' && msg.tool_calls) {
             for (const toolCall of msg.tool_calls) {
-                const toolDisplay = formatToolCallMessage(toolCall);
-                let toolArgs;
-                try {
-                    toolArgs = JSON.parse(toolCall.function.arguments);
-                }
-                catch (e) {
-                    toolArgs = {};
+                // 只有耗时工具才创建"进行中"消息
+                if (isToolNeedTwoStepDisplay(toolCall.function.name)) {
+                    const toolDisplay = formatToolCallMessage(toolCall);
+                    let toolArgs;
+                    try {
+                        toolArgs = JSON.parse(toolCall.function.arguments);
+                    }
+                    catch (e) {
+                        toolArgs = {};
+                    }
+                    uiMessages.push({
+                        role: 'subagent',
+                        content: `\x1b[38;2;184;122;206m⚇⚡ ${toolDisplay.toolName}\x1b[0m`,
+                        streaming: false,
+                        toolCall: {
+                            name: toolCall.function.name,
+                            arguments: toolArgs,
+                        },
+                        toolDisplay,
+                        toolCallId: toolCall.id,
+                        toolPending: false,
+                        subAgentInternal: true,
+                    });
                 }
-                uiMessages.push({
-                    role: 'subagent',
-                    content: `\x1b[38;2;184;122;206m⚇⚡ ${toolDisplay.toolName}\x1b[0m`,
-                    streaming: false,
-                    toolCall: {
-                        name: toolCall.function.name,
-                        arguments: toolArgs,
-                    },
-                    toolDisplay,
-                    toolCallId: toolCall.id,
-                    toolPending: false,
-                    subAgentInternal: true,
-                });
                 processedToolCalls.add(toolCall.id);
             }
             continue;
@@ -103,6 +106,12 @@ export function convertSessionMessagesToUI(sessionMessages) {
             msg.tool_calls &&
             msg.tool_calls.length > 0 &&
             !msg.subAgentInternal) {
+            // Generate parallel group ID for non-time-consuming tools
+            const hasMultipleTools = msg.tool_calls.length > 1;
+            const hasNonTimeConsumingTool = msg.tool_calls.some(tc => !isToolNeedTwoStepDisplay(tc.function.name));
+            const parallelGroupId = hasMultipleTools && hasNonTimeConsumingTool
+                ? `parallel-${i}-${Math.random()}`
+                : undefined;
             for (const toolCall of msg.tool_calls) {
                 // Skip if already processed
                 if (processedToolCalls.has(toolCall.id))
@@ -130,7 +139,15 @@ export function convertSessionMessagesToUI(sessionMessages) {
                         toolDisplay,
                     });
                 }
-                processedToolCalls.add(toolCall.id);
+                // Store parallel group info for this tool call
+                if (parallelGroupId && !needTwoSteps) {
+                    processedToolCalls.add(toolCall.id);
+                    // Mark this tool call with parallel group (will be used when processing tool results)
+                    toolCall.parallelGroupId = parallelGroupId;
+                }
+                else {
+                    processedToolCalls.add(toolCall.id);
+                }
             }
             continue;
         }
@@ -219,6 +236,23 @@ export function convertSessionMessagesToUI(sessionMessages) {
                     }
                 }
             }
+            // Check if this tool result is part of a parallel group
+            let parallelGroupId;
+            for (let j = i - 1; j >= 0; j--) {
+                const prevMsg = sessionMessages[j];
+                if (!prevMsg)
+                    continue;
+                if (prevMsg.role === 'assistant' &&
+                    prevMsg.tool_calls &&
+                    !prevMsg.subAgentInternal) {
+                    const tc = prevMsg.tool_calls.find(t => t.id === msg.tool_call_id);
+                    if (tc) {
+                        parallelGroupId = tc.parallelGroupId;
+                        break;
+                    }
+                }
+            }
+            const isNonTimeConsuming = !isToolNeedTwoStepDisplay(toolName);
             uiMessages.push({
                 role: 'assistant',
                 content: `${statusIcon} ${toolName}${statusText}`,
@@ -231,6 +265,19 @@ export function convertSessionMessagesToUI(sessionMessages) {
                     }
                     : undefined,
                 terminalResult: terminalResultData,
+                // Add toolDisplay for non-time-consuming tools
+                toolDisplay: isNonTimeConsuming && !editDiffData
+                    ? formatToolCallMessage({
+                        id: msg.tool_call_id || '',
+                        type: 'function',
+                        function: {
+                            name: toolName,
+                            arguments: JSON.stringify(toolArgs),
+                        },
+                    })
+                    : undefined,
+                // Mark parallel group for non-time-consuming tools
+                parallelGroup: isNonTimeConsuming && parallelGroupId ? parallelGroupId : undefined,
             });
             continue;
         }

package/dist/utils/subAgentConfig.d.ts

@@ -2,6 +2,7 @@ export interface SubAgent {
     id: string;
     name: string;
     description: string;
+    role?: string;
     tools: string[];
     createdAt: string;
     updatedAt: string;
@@ -20,13 +21,14 @@ export declare function getSubAgent(id: string): SubAgent | null;
 /**
  * Create a new sub-agent
  */
-export declare function createSubAgent(name: string, description: string, tools: string[]): SubAgent;
+export declare function createSubAgent(name: string, description: string, tools: string[], role?: string): SubAgent;
 /**
  * Update an existing sub-agent
  */
 export declare function updateSubAgent(id: string, updates: {
     name?: string;
     description?: string;
+    role?: string;
     tools?: string[];
 }): SubAgent | null;
 /**

package/dist/utils/subAgentConfig.js

@@ -53,13 +53,14 @@ function saveSubAgents(agents) {
 /**
  * Create a new sub-agent
  */
-export function createSubAgent(name, description, tools) {
+export function createSubAgent(name, description, tools, role) {
     const agents = getSubAgents();
     const now = new Date().toISOString();
     const newAgent = {
         id: generateId(),
         name,
         description,
+        role,
         tools,
         createdAt: now,
         updatedAt: now,
@@ -85,6 +86,7 @@ export function updateSubAgent(id, updates) {
         id: existingAgent.id,
         name: updates.name ?? existingAgent.name,
         description: updates.description ?? existingAgent.description,
+        role: updates.role ?? existingAgent.role,
         tools: updates.tools ?? existingAgent.tools,
         createdAt: existingAgent.createdAt,
         updatedAt: new Date().toISOString(),

package/dist/utils/subAgentExecutor.js

@@ -50,10 +50,15 @@ export async function executeSubAgent(agentId, prompt, onMessage, abortSignal, r
             };
         }
         // Build conversation history for sub-agent
+        // Append role to prompt if configured
+        let finalPrompt = prompt;
+        if (agent.role) {
+            finalPrompt = `${prompt}\n\n${agent.role}`;
+        }
         const messages = [
             {
                 role: 'user',
-                content: prompt,
+                content: finalPrompt,
             },
         ];
         // Stream sub-agent execution

package/dist/utils/toolExecutor.d.ts

@@ -27,6 +27,8 @@ export interface AddToAlwaysApprovedCallback {
  */
 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
+ * Execute multiple tool calls with intelligent sequencing
+ * - Tools modifying the same resource execute sequentially
+ * - Independent tools execute in parallel
  */
 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

@@ -63,8 +63,96 @@ export async function executeToolCall(toolCall, abortSignal, onTokenUpdate, onSu
     }
 }
 /**
- * Execute multiple tool calls in parallel
+ * Categorize tools by their resource type for proper execution sequencing
+ */
+function getToolResourceType(toolName) {
+    // TODO tools all modify the same TODO file - must be sequential
+    if (toolName === 'todo-create' ||
+        toolName === 'todo-update' ||
+        toolName === 'todo-add' ||
+        toolName === 'todo-delete') {
+        return 'todo-state';
+    }
+    // Terminal commands must be sequential to avoid race conditions
+    // (e.g., npm install -> npm build, port conflicts, file locks)
+    if (toolName === 'terminal-execute') {
+        return 'terminal-execution';
+    }
+    // Each file is a separate resource
+    if (toolName === 'filesystem-edit' ||
+        toolName === 'filesystem-edit_search' ||
+        toolName === 'filesystem-create' ||
+        toolName === 'filesystem-delete') {
+        return 'filesystem'; // Will be further refined by file path
+    }
+    // Other tools are independent
+    return 'independent';
+}
+/**
+ * Get resource identifier for a tool call
+ * Tools modifying the same resource will have the same identifier
+ */
+function getResourceIdentifier(toolCall) {
+    const toolName = toolCall.function.name;
+    const resourceType = getToolResourceType(toolName);
+    if (resourceType === 'todo-state') {
+        return 'todo-state'; // All TODO operations share same resource
+    }
+    if (resourceType === 'terminal-execution') {
+        return 'terminal-execution'; // All terminal commands share same execution context
+    }
+    if (resourceType === 'filesystem') {
+        try {
+            const args = JSON.parse(toolCall.function.arguments);
+            // Support both single file and array of files
+            const filePath = args.filePath;
+            if (typeof filePath === 'string') {
+                return `filesystem:${filePath}`;
+            }
+            else if (Array.isArray(filePath)) {
+                // For batch operations, treat as independent (already handling multiple files)
+                return `filesystem-batch:${toolCall.id}`;
+            }
+        }
+        catch {
+            // Parsing error, treat as independent
+        }
+    }
+    // Each independent tool gets its own unique identifier
+    return `independent:${toolCall.id}`;
+}
+/**
+ * Execute multiple tool calls with intelligent sequencing
+ * - Tools modifying the same resource execute sequentially
+ * - Independent tools execute in parallel
  */
 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)));
+    // Group tool calls by their resource identifier
+    const resourceGroups = new Map();
+    for (const toolCall of toolCalls) {
+        const resourceId = getResourceIdentifier(toolCall);
+        const group = resourceGroups.get(resourceId) || [];
+        group.push(toolCall);
+        resourceGroups.set(resourceId, group);
+    }
+    // Execute each resource group sequentially, but execute different groups in parallel
+    const results = await Promise.all(Array.from(resourceGroups.values()).map(async (group) => {
+        // Within the same resource group, execute sequentially
+        const groupResults = [];
+        for (const toolCall of group) {
+            const result = await executeToolCall(toolCall, abortSignal, onTokenUpdate, onSubAgentMessage, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved);
+            groupResults.push(result);
+        }
+        return groupResults;
+    }));
+    // Flatten results and restore original order
+    const flatResults = results.flat();
+    const resultMap = new Map(flatResults.map(r => [r.tool_call_id, r]));
+    return toolCalls.map(tc => {
+        const result = resultMap.get(tc.id);
+        if (!result) {
+            throw new Error(`Result not found for tool call ${tc.id}`);
+        }
+        return result;
+    });
 }

package/dist/utils/vscodeConnection.d.ts

@@ -30,7 +30,14 @@ declare class VSCodeConnectionManager {
     private editorContext;
     private listeners;
     private currentWorkingDirectory;
+    private connectingPromise;
+    private connectionTimeout;
+    private readonly CONNECTION_TIMEOUT;
     start(): Promise<void>;
+    /**
+     * Clean up connection state and resources
+     */
+    private cleanupConnection;
     /**
      * Normalize path for cross-platform compatibility
      * - Converts Windows backslashes to forward slashes

package/dist/utils/vscodeConnection.js

@@ -89,15 +89,44 @@ class VSCodeConnectionManager {
             writable: true,
             value: process.cwd()
         });
+        // Connection state management
+        Object.defineProperty(this, "connectingPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "connectionTimeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "CONNECTION_TIMEOUT", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 10000
+        }); // 10 seconds timeout for initial connection
     }
     async start() {
         // If already connected, just return success
         if (this.client?.readyState === WebSocket.OPEN) {
             return Promise.resolve();
         }
+        // If already connecting, return the existing promise to avoid duplicate connections
+        if (this.connectingPromise) {
+            return this.connectingPromise;
+        }
         // Try to find the correct port for this workspace
         const targetPort = this.findPortForWorkspace();
-        return new Promise((resolve, reject) => {
+        // Create a new connection promise and store it
+        this.connectingPromise = new Promise((resolve, reject) => {
+            // Set connection timeout
+            this.connectionTimeout = setTimeout(() => {
+                this.cleanupConnection();
+                reject(new Error('Connection timeout after 10 seconds'));
+            }, this.CONNECTION_TIMEOUT);
             const tryConnect = (port) => {
                 // Check both VSCode and JetBrains port ranges
                 if (port > this.VSCODE_MAX_PORT && port < this.JETBRAINS_BASE_PORT) {
@@ -106,6 +135,7 @@ class VSCodeConnectionManager {
                     return;
                 }
                 if (port > this.JETBRAINS_MAX_PORT) {
+                    this.cleanupConnection();
                     reject(new Error(`Failed to connect: no IDE server found on ports ${this.VSCODE_BASE_PORT}-${this.VSCODE_MAX_PORT} or ${this.JETBRAINS_BASE_PORT}-${this.JETBRAINS_MAX_PORT}`));
                     return;
                 }
@@ -115,6 +145,12 @@ class VSCodeConnectionManager {
                         // Reset reconnect attempts on successful connection
                         this.reconnectAttempts = 0;
                         this.port = port;
+                        // Clear connection state
+                        if (this.connectionTimeout) {
+                            clearTimeout(this.connectionTimeout);
+                            this.connectionTimeout = null;
+                        }
+                        this.connectingPromise = null;
                         resolve();
                     });
                     this.client.on('message', message => {
@@ -148,6 +184,34 @@ class VSCodeConnectionManager {
             };
             tryConnect(targetPort);
         });
+        // Return the promise and clean up state when it completes or fails
+        return this.connectingPromise.finally(() => {
+            this.connectingPromise = null;
+            if (this.connectionTimeout) {
+                clearTimeout(this.connectionTimeout);
+                this.connectionTimeout = null;
+            }
+        });
+    }
+    /**
+     * Clean up connection state and resources
+     */
+    cleanupConnection() {
+        this.connectingPromise = null;
+        if (this.connectionTimeout) {
+            clearTimeout(this.connectionTimeout);
+            this.connectionTimeout = null;
+        }
+        if (this.client) {
+            try {
+                this.client.removeAllListeners();
+                this.client.close();
+            }
+            catch (error) {
+                // Ignore errors during cleanup
+            }
+            this.client = null;
+        }
     }
     /**
      * Normalize path for cross-platform compatibility
@@ -228,8 +292,21 @@ class VSCodeConnectionManager {
             clearTimeout(this.reconnectTimer);
             this.reconnectTimer = null;
         }
+        // Clear connection timeout
+        if (this.connectionTimeout) {
+            clearTimeout(this.connectionTimeout);
+            this.connectionTimeout = null;
+        }
+        // Clear connecting promise
+        this.connectingPromise = null;
         if (this.client) {
-            this.client.close();
+            try {
+                this.client.removeAllListeners();
+                this.client.close();
+            }
+            catch (error) {
+                // Ignore errors during cleanup
+            }
             this.client = null;
         }
         this.reconnectAttempts = 0;

package/package.json

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