snow-ai 0.3.4 → 0.3.6

package/dist/utils/retryUtils.js

@@ -70,6 +70,11 @@ function isRetriableError(error) {
         errorMessage.includes('socket hang up')) {
         return true;
     }
+    // JSON parsing errors from streaming (incomplete or malformed tool calls)
+    if (errorMessage.includes('invalid tool call json') ||
+        errorMessage.includes('incomplete tool call json')) {
+        return true;
+    }
     return false;
 }
 /**

package/dist/utils/sessionConverter.d.ts

@@ -2,5 +2,6 @@ import type { ChatMessage } from '../api/chat.js';
 import type { Message } from '../ui/components/MessageList.js';
 /**
  * Convert API format session messages to UI format messages
+ * Process messages in order to maintain correct sequence
  */
 export declare function convertSessionMessagesToUI(sessionMessages: ChatMessage[]): Message[];

package/dist/utils/sessionConverter.js

@@ -1,34 +1,21 @@
 import { formatToolCallMessage } from './messageFormatter.js';
 /**
  * Convert API format session messages to UI format messages
+ * Process messages in order to maintain correct sequence
  */
 export function convertSessionMessagesToUI(sessionMessages) {
     const uiMessages = [];
-    // First pass: build a map of tool_call_id to tool results
-    const toolResultsMap = new Map();
-    for (const msg of sessionMessages) {
-        if (msg.role === 'tool' && msg.tool_call_id) {
-            toolResultsMap.set(msg.tool_call_id, msg.content);
-        }
-    }
-    for (const msg of sessionMessages) {
+    // Track which tool_calls have been processed
+    const processedToolCalls = new Set();
+    for (let i = 0; i < sessionMessages.length; i++) {
+        const msg = sessionMessages[i];
+        if (!msg)
+            continue;
         // Skip system messages
         if (msg.role === 'system')
             continue;
-        // Skip tool role messages (we'll attach them to tool calls)
-        if (msg.role === 'tool')
-            continue;
-        // Handle user and assistant messages
-        const uiMessage = {
-            role: msg.role,
-            content: msg.content,
-            streaming: false,
-            images: msg.images,
-        };
-        // If assistant message has tool_calls, expand to show each tool call
-        if (msg.role === 'assistant' &&
-            msg.tool_calls &&
-            msg.tool_calls.length > 0) {
+        // 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;
@@ -38,59 +25,96 @@ export function convertSessionMessagesToUI(sessionMessages) {
                 catch (e) {
                     toolArgs = {};
                 }
-                // Get the tool result for this tool call
-                const toolResult = toolResultsMap.get(toolCall.id);
-                const isError = toolResult?.startsWith('Error:') || false;
-                // For filesystem-edit and filesystem-edit_search, try to extract diff data from result
-                let editDiffData;
-                if ((toolCall.function.name === 'filesystem-edit' || toolCall.function.name === 'filesystem-edit_search') &&
-                    toolResult &&
-                    !isError) {
-                    try {
-                        const resultData = JSON.parse(toolResult);
-                        if (resultData.oldContent && resultData.newContent) {
-                            editDiffData = {
-                                oldContent: resultData.oldContent,
-                                newContent: resultData.newContent,
-                                filename: toolArgs.filePath,
-                                completeOldContent: resultData.completeOldContent,
-                                completeNewContent: resultData.completeNewContent,
-                                contextStartLine: resultData.contextStartLine
-                            };
-                            // Merge diff data into toolArgs for DiffViewer
-                            toolArgs.oldContent = resultData.oldContent;
-                            toolArgs.newContent = resultData.newContent;
-                            toolArgs.completeOldContent = resultData.completeOldContent;
-                            toolArgs.completeNewContent = resultData.completeNewContent;
-                            toolArgs.contextStartLine = resultData.contextStartLine;
+                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;
+        }
+        // Handle sub-agent internal tool result messages
+        if (msg.subAgentInternal && msg.role === 'tool' && msg.tool_call_id) {
+            const isError = msg.content.startsWith('Error:');
+            const statusIcon = isError ? '✗' : '✓';
+            const statusText = isError ? `\n  └─ ${msg.content}` : '';
+            // Find tool name from previous assistant message
+            let toolName = 'tool';
+            let terminalResultData;
+            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) {
+                        toolName = tc.function.name;
+                        if (toolName === 'terminal-execute' && !isError) {
+                            try {
+                                const resultData = JSON.parse(msg.content);
+                                if (resultData.stdout !== undefined ||
+                                    resultData.stderr !== undefined) {
+                                    terminalResultData = {
+                                        stdout: resultData.stdout,
+                                        stderr: resultData.stderr,
+                                        exitCode: resultData.exitCode,
+                                        command: resultData.command,
+                                    };
+                                }
+                            }
+                            catch (e) {
+                                // Ignore parse errors
+                            }
                         }
-                    }
-                    catch (e) {
-                        // If parsing fails, just show regular result
+                        break;
                     }
                 }
-                // For terminal-execute, try to extract terminal result data
-                let terminalResultData;
-                if (toolCall.function.name === 'terminal-execute' &&
-                    toolResult &&
-                    !isError) {
-                    try {
-                        const resultData = JSON.parse(toolResult);
-                        if (resultData.stdout !== undefined ||
-                            resultData.stderr !== undefined) {
-                            terminalResultData = {
-                                stdout: resultData.stdout,
-                                stderr: resultData.stderr,
-                                exitCode: resultData.exitCode,
-                                command: toolArgs.command,
-                            };
-                        }
-                    }
-                    catch (e) {
-                        // If parsing fails, just show regular result
+            }
+            uiMessages.push({
+                role: 'subagent',
+                content: `\x1b[38;2;0;186;255m⚇${statusIcon} ${toolName}\x1b[0m${statusText}`,
+                streaming: false,
+                toolResult: !isError ? msg.content : undefined,
+                terminalResult: terminalResultData,
+                toolCall: terminalResultData
+                    ? {
+                        name: toolName,
+                        arguments: terminalResultData,
                     }
+                    : undefined,
+                subAgentInternal: true,
+            });
+            continue;
+        }
+        // Handle regular assistant messages with tool_calls
+        if (msg.role === 'assistant' &&
+            msg.tool_calls &&
+            msg.tool_calls.length > 0 &&
+            !msg.subAgentInternal) {
+            for (const toolCall of msg.tool_calls) {
+                // Skip if already processed
+                if (processedToolCalls.has(toolCall.id))
+                    continue;
+                const toolDisplay = formatToolCallMessage(toolCall);
+                let toolArgs;
+                try {
+                    toolArgs = JSON.parse(toolCall.function.arguments);
                 }
-                // Create tool call message
+                catch (e) {
+                    toolArgs = {};
+                }
+                // Add tool call message
                 uiMessages.push({
                     role: 'assistant',
                     content: `⚡ ${toolDisplay.toolName}`,
@@ -101,29 +125,108 @@ export function convertSessionMessagesToUI(sessionMessages) {
                     },
                     toolDisplay,
                 });
-                // Create tool result message
-                if (toolResult) {
-                    const statusIcon = isError ? '✗' : '✓';
-                    const statusText = isError ? `\n  └─ ${toolResult}` : '';
-                    uiMessages.push({
-                        role: 'assistant',
-                        content: `${statusIcon} ${toolCall.function.name}${statusText}`,
-                        streaming: false,
-                        toolResult: !isError ? toolResult : undefined,
-                        toolCall: editDiffData || terminalResultData
-                            ? {
-                                name: toolCall.function.name,
-                                arguments: toolArgs,
+                processedToolCalls.add(toolCall.id);
+            }
+            continue;
+        }
+        // Handle regular tool result messages (non-subagent)
+        if (msg.role === 'tool' && msg.tool_call_id && !msg.subAgentInternal) {
+            const isError = msg.content.startsWith('Error:');
+            const statusIcon = isError ? '✗' : '✓';
+            const statusText = isError ? `\n  └─ ${msg.content}` : '';
+            // Find tool name and args from previous assistant message
+            let toolName = 'tool';
+            let toolArgs = {};
+            let editDiffData;
+            let terminalResultData;
+            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) {
+                        toolName = tc.function.name;
+                        try {
+                            toolArgs = JSON.parse(tc.function.arguments);
+                        }
+                        catch (e) {
+                            toolArgs = {};
+                        }
+                        // Extract edit diff data
+                        if ((toolName === 'filesystem-edit' ||
+                            toolName === 'filesystem-edit_search') &&
+                            !isError) {
+                            try {
+                                const resultData = JSON.parse(msg.content);
+                                if (resultData.oldContent && resultData.newContent) {
+                                    editDiffData = {
+                                        oldContent: resultData.oldContent,
+                                        newContent: resultData.newContent,
+                                        filename: toolArgs.filePath,
+                                        completeOldContent: resultData.completeOldContent,
+                                        completeNewContent: resultData.completeNewContent,
+                                        contextStartLine: resultData.contextStartLine,
+                                    };
+                                    toolArgs.oldContent = resultData.oldContent;
+                                    toolArgs.newContent = resultData.newContent;
+                                    toolArgs.completeOldContent = resultData.completeOldContent;
+                                    toolArgs.completeNewContent = resultData.completeNewContent;
+                                    toolArgs.contextStartLine = resultData.contextStartLine;
+                                }
+                            }
+                            catch (e) {
+                                // Ignore parse errors
+                            }
+                        }
+                        // Extract terminal result data
+                        if (toolName === 'terminal-execute' && !isError) {
+                            try {
+                                const resultData = JSON.parse(msg.content);
+                                if (resultData.stdout !== undefined ||
+                                    resultData.stderr !== undefined) {
+                                    terminalResultData = {
+                                        stdout: resultData.stdout,
+                                        stderr: resultData.stderr,
+                                        exitCode: resultData.exitCode,
+                                        command: toolArgs.command,
+                                    };
+                                }
+                            }
+                            catch (e) {
+                                // Ignore parse errors
                             }
-                            : undefined,
-                        terminalResult: terminalResultData,
-                    });
+                        }
+                        break;
+                    }
                 }
             }
+            uiMessages.push({
+                role: 'assistant',
+                content: `${statusIcon} ${toolName}${statusText}`,
+                streaming: false,
+                toolResult: !isError ? msg.content : undefined,
+                toolCall: editDiffData || terminalResultData
+                    ? {
+                        name: toolName,
+                        arguments: toolArgs,
+                    }
+                    : undefined,
+                terminalResult: terminalResultData,
+            });
+            continue;
         }
-        else {
-            // Add regular message directly
-            uiMessages.push(uiMessage);
+        // Handle regular user and assistant messages
+        if (msg.role === 'user' || msg.role === 'assistant') {
+            uiMessages.push({
+                role: msg.role,
+                content: msg.content,
+                streaming: false,
+                images: msg.images,
+            });
+            continue;
         }
     }
     return uiMessages;

package/dist/utils/subAgentConfig.d.ts

@@ -0,0 +1,43 @@
+export interface SubAgent {
+    id: string;
+    name: string;
+    description: string;
+    tools: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SubAgentsConfig {
+    agents: SubAgent[];
+}
+/**
+ * Get all sub-agents
+ */
+export declare function getSubAgents(): SubAgent[];
+/**
+ * Get a sub-agent by ID
+ */
+export declare function getSubAgent(id: string): SubAgent | null;
+/**
+ * Create a new sub-agent
+ */
+export declare function createSubAgent(name: string, description: string, tools: string[]): SubAgent;
+/**
+ * Update an existing sub-agent
+ */
+export declare function updateSubAgent(id: string, updates: {
+    name?: string;
+    description?: string;
+    tools?: string[];
+}): SubAgent | null;
+/**
+ * Delete a sub-agent
+ */
+export declare function deleteSubAgent(id: string): boolean;
+/**
+ * Validate sub-agent data
+ */
+export declare function validateSubAgent(data: {
+    name: string;
+    description: string;
+    tools: string[];
+}): string[];

package/dist/utils/subAgentConfig.js

@@ -0,0 +1,126 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const CONFIG_DIR = join(homedir(), '.snow');
+const SUB_AGENTS_CONFIG_FILE = join(CONFIG_DIR, 'sub-agents.json');
+function ensureConfigDirectory() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+function generateId() {
+    return `agent_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+/**
+ * Get all sub-agents
+ */
+export function getSubAgents() {
+    try {
+        ensureConfigDirectory();
+        if (!existsSync(SUB_AGENTS_CONFIG_FILE)) {
+            return [];
+        }
+        const configData = readFileSync(SUB_AGENTS_CONFIG_FILE, 'utf8');
+        const config = JSON.parse(configData);
+        return config.agents || [];
+    }
+    catch (error) {
+        console.error('Failed to load sub-agents:', error);
+        return [];
+    }
+}
+/**
+ * Get a sub-agent by ID
+ */
+export function getSubAgent(id) {
+    const agents = getSubAgents();
+    return agents.find(agent => agent.id === id) || null;
+}
+/**
+ * Save all sub-agents
+ */
+function saveSubAgents(agents) {
+    try {
+        ensureConfigDirectory();
+        const config = { agents };
+        const configData = JSON.stringify(config, null, 2);
+        writeFileSync(SUB_AGENTS_CONFIG_FILE, configData, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`Failed to save sub-agents: ${error}`);
+    }
+}
+/**
+ * Create a new sub-agent
+ */
+export function createSubAgent(name, description, tools) {
+    const agents = getSubAgents();
+    const now = new Date().toISOString();
+    const newAgent = {
+        id: generateId(),
+        name,
+        description,
+        tools,
+        createdAt: now,
+        updatedAt: now,
+    };
+    agents.push(newAgent);
+    saveSubAgents(agents);
+    return newAgent;
+}
+/**
+ * Update an existing sub-agent
+ */
+export function updateSubAgent(id, updates) {
+    const agents = getSubAgents();
+    const index = agents.findIndex(agent => agent.id === id);
+    if (index === -1) {
+        return null;
+    }
+    const existingAgent = agents[index];
+    if (!existingAgent) {
+        return null;
+    }
+    const updatedAgent = {
+        id: existingAgent.id,
+        name: updates.name ?? existingAgent.name,
+        description: updates.description ?? existingAgent.description,
+        tools: updates.tools ?? existingAgent.tools,
+        createdAt: existingAgent.createdAt,
+        updatedAt: new Date().toISOString(),
+    };
+    agents[index] = updatedAgent;
+    saveSubAgents(agents);
+    return updatedAgent;
+}
+/**
+ * Delete a sub-agent
+ */
+export function deleteSubAgent(id) {
+    const agents = getSubAgents();
+    const filteredAgents = agents.filter(agent => agent.id !== id);
+    if (filteredAgents.length === agents.length) {
+        return false; // Agent not found
+    }
+    saveSubAgents(filteredAgents);
+    return true;
+}
+/**
+ * Validate sub-agent data
+ */
+export function validateSubAgent(data) {
+    const errors = [];
+    if (!data.name || data.name.trim().length === 0) {
+        errors.push('Agent name is required');
+    }
+    if (data.name && data.name.length > 100) {
+        errors.push('Agent name must be less than 100 characters');
+    }
+    if (data.description && data.description.length > 500) {
+        errors.push('Description must be less than 500 characters');
+    }
+    if (!data.tools || data.tools.length === 0) {
+        errors.push('At least one tool must be selected');
+    }
+    return errors;
+}

package/dist/utils/subAgentExecutor.d.ts

@@ -0,0 +1,29 @@
+export interface SubAgentMessage {
+    type: 'sub_agent_message';
+    agentId: string;
+    agentName: string;
+    message: any;
+}
+export interface SubAgentResult {
+    success: boolean;
+    result: string;
+    error?: string;
+}
+export interface ToolConfirmationCallback {
+    (toolName: string, toolArgs: any): Promise<string>;
+}
+export interface ToolApprovalChecker {
+    (toolName: string): boolean;
+}
+/**
+ * Execute a sub-agent as a tool
+ * @param agentId - The ID of the sub-agent to execute
+ * @param prompt - The task prompt to send to the sub-agent
+ * @param onMessage - Callback for streaming sub-agent messages (for UI display)
+ * @param abortSignal - Optional abort signal
+ * @param requestToolConfirmation - Callback to request tool confirmation from user
+ * @param isToolAutoApproved - Function to check if a tool is auto-approved
+ * @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>;