snow-ai 0.3.4 → 0.3.6

package/dist/api/anthropic.js

@@ -282,6 +282,7 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
         let hasToolCalls = false;
         let usageData;
         let blockIndexToId = new Map();
+        let completedToolBlocks = new Set(); // Track which tool blocks have finished streaming
         for await (const event of parseSSEStream(response.body.getReader())) {
             if (abortSignal?.aborted) {
                 return;
@@ -297,7 +298,7 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
                         type: 'function',
                         function: {
                             name: block.name,
-                            arguments: '{}'
+                            arguments: ''
                         }
                     });
                     yield {
@@ -323,20 +324,28 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
                     if (toolId) {
                         const toolCall = toolCallsBuffer.get(toolId);
                         if (toolCall) {
-                            if (toolCall.function.arguments === '{}') {
-                                toolCall.function.arguments = jsonDelta;
+                            // Filter out any XML-like tags that might be mixed in the JSON delta
+                            // This can happen when the model output contains XML that gets interpreted as JSON
+                            const cleanedDelta = jsonDelta.replace(/<\/?parameter[^>]*>/g, '');
+                            if (cleanedDelta) {
+                                toolCall.function.arguments += cleanedDelta;
+                                yield {
+                                    type: 'tool_call_delta',
+                                    delta: cleanedDelta
+                                };
                             }
-                            else {
-                                toolCall.function.arguments += jsonDelta;
-                            }
-                            yield {
-                                type: 'tool_call_delta',
-                                delta: jsonDelta
-                            };
                         }
                     }
                 }
             }
+            else if (event.type === 'content_block_stop') {
+                // Mark this block as completed
+                const blockIndex = event.index;
+                const toolId = blockIndexToId.get(blockIndex);
+                if (toolId) {
+                    completedToolBlocks.add(toolId);
+                }
+            }
             else if (event.type === 'message_start') {
                 if (event.message.usage) {
                     usageData = {
@@ -371,14 +380,30 @@ export async function* createStreamingAnthropicCompletion(options, abortSignal,
         if (hasToolCalls && toolCallsBuffer.size > 0) {
             const toolCalls = Array.from(toolCallsBuffer.values());
             for (const toolCall of toolCalls) {
+                // Normalize the arguments
+                let args = toolCall.function.arguments.trim();
+                // If arguments is empty, use empty object
+                if (!args) {
+                    args = '{}';
+                }
+                // Try to parse the JSON
                 try {
-                    const args = toolCall.function.arguments.trim() || '{}';
                     JSON.parse(args);
                     toolCall.function.arguments = args;
                 }
                 catch (e) {
-                    const errorMsg = e instanceof Error ? e.message : 'Unknown error';
-                    throw new Error(`Incomplete tool call JSON for ${toolCall.function.name}: ${toolCall.function.arguments} (${errorMsg})`);
+                    // Only throw error if this tool block was marked as completed
+                    // This prevents errors from incomplete streaming
+                    if (completedToolBlocks.has(toolCall.id)) {
+                        const errorMsg = e instanceof Error ? e.message : 'Unknown error';
+                        throw new Error(`Invalid tool call JSON for ${toolCall.function.name}: ${args} (${errorMsg})`);
+                    }
+                    else {
+                        // Tool block wasn't completed, likely interrupted stream
+                        // Use partial data or empty object
+                        console.warn(`Warning: Tool call ${toolCall.function.name} (${toolCall.id}) was incomplete. Using partial data.`);
+                        toolCall.function.arguments = '{}';
+                    }
                 }
             }
             yield {

package/dist/api/types.d.ts

@@ -20,6 +20,7 @@ export interface ChatMessage {
     tool_call_id?: string;
     tool_calls?: ToolCall[];
     images?: ImageContent[];
+    subAgentInternal?: boolean;
 }
 export interface ChatCompletionTool {
     type: 'function';

package/dist/hooks/useConversation.js

@@ -46,10 +46,13 @@ export async function handleConversationWithTools(options) {
     }
     // Add history messages from session (includes tool_calls and tool results)
     // Load from session to get complete conversation history with tool interactions
+    // Filter out internal sub-agent messages (marked with subAgentInternal: true)
     const session = sessionManager.getCurrentSession();
     if (session && session.messages.length > 0) {
         // Use session messages directly (they are already in API format)
-        conversationMessages.push(...session.messages);
+        // Filter out sub-agent internal messages before sending to API
+        const filteredMessages = session.messages.filter(msg => !msg.subAgentInternal);
+        conversationMessages.push(...filteredMessages);
     }
     // Add current user message
     conversationMessages.push({
@@ -336,8 +339,171 @@ export async function handleConversationWithTools(options) {
                     // Add all tools to approved list
                     approvedTools.push(...toolsNeedingConfirmation);
                 }
-                // Execute approved tools
-                const toolResults = await executeToolCalls(approvedTools, controller.signal, setStreamTokenCount);
+                // Execute approved tools with sub-agent message callback
+                const toolResults = await executeToolCalls(approvedTools, controller.signal, setStreamTokenCount, async (subAgentMessage) => {
+                    // Handle sub-agent messages - display and save to session
+                    setMessages(prev => {
+                        // Handle tool calls from sub-agent
+                        if (subAgentMessage.message.type === 'tool_calls') {
+                            const toolCalls = subAgentMessage.message.tool_calls;
+                            if (toolCalls && toolCalls.length > 0) {
+                                // Add tool call messages for each tool
+                                const toolMessages = toolCalls.map((toolCall) => {
+                                    const toolDisplay = formatToolCallMessage(toolCall);
+                                    let toolArgs;
+                                    try {
+                                        toolArgs = JSON.parse(toolCall.function.arguments);
+                                    }
+                                    catch (e) {
+                                        toolArgs = {};
+                                    }
+                                    const uiMsg = {
+                                        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: true,
+                                        subAgent: {
+                                            agentId: subAgentMessage.agentId,
+                                            agentName: subAgentMessage.agentName,
+                                            isComplete: false,
+                                        },
+                                        subAgentInternal: true, // Mark as internal sub-agent message
+                                    };
+                                    // Save to session as 'assistant' role for API compatibility
+                                    const sessionMsg = {
+                                        role: 'assistant',
+                                        content: `⚇⚡ ${toolDisplay.toolName}`,
+                                        subAgentInternal: true,
+                                        tool_calls: [toolCall],
+                                    };
+                                    saveMessage(sessionMsg).catch(err => console.error('Failed to save sub-agent tool call:', err));
+                                    return uiMsg;
+                                });
+                                return [...prev, ...toolMessages];
+                            }
+                        }
+                        // Handle tool results from sub-agent
+                        if (subAgentMessage.message.type === 'tool_result') {
+                            const msg = subAgentMessage.message;
+                            const isError = msg.content.startsWith('Error:');
+                            const statusIcon = isError ? '✗' : '✓';
+                            const statusText = isError ? `\n  └─ ${msg.content}` : '';
+                            // For terminal-execute, try to extract terminal result data
+                            let terminalResultData;
+                            if (msg.tool_name === '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) {
+                                    // If parsing fails, just show regular result
+                                }
+                            }
+                            // Create completed tool result message for UI
+                            const uiMsg = {
+                                role: 'subagent',
+                                content: `\x1b[38;2;0;186;255m⚇${statusIcon} ${msg.tool_name}\x1b[0m${statusText}`,
+                                streaming: false,
+                                toolResult: !isError ? msg.content : undefined,
+                                terminalResult: terminalResultData,
+                                toolCall: terminalResultData
+                                    ? {
+                                        name: msg.tool_name,
+                                        arguments: terminalResultData,
+                                    }
+                                    : undefined,
+                                subAgent: {
+                                    agentId: subAgentMessage.agentId,
+                                    agentName: subAgentMessage.agentName,
+                                    isComplete: false,
+                                },
+                                subAgentInternal: true,
+                            };
+                            // Save to session as 'tool' role for API compatibility
+                            const sessionMsg = {
+                                role: 'tool',
+                                tool_call_id: msg.tool_call_id,
+                                content: msg.content,
+                                subAgentInternal: true,
+                            };
+                            saveMessage(sessionMsg).catch(err => console.error('Failed to save sub-agent tool result:', err));
+                            // Add completed tool result message
+                            return [...prev, uiMsg];
+                        }
+                        // Check if we already have a message for this agent
+                        const existingIndex = prev.findIndex(m => m.role === 'subagent' &&
+                            m.subAgent?.agentId === subAgentMessage.agentId &&
+                            !m.subAgent?.isComplete &&
+                            !m.toolCall);
+                        // Extract content from the sub-agent message
+                        let content = '';
+                        if (subAgentMessage.message.type === 'content') {
+                            content = subAgentMessage.message.content;
+                        }
+                        else if (subAgentMessage.message.type === 'done') {
+                            // Mark as complete
+                            if (existingIndex !== -1) {
+                                const updated = [...prev];
+                                const existing = updated[existingIndex];
+                                if (existing && existing.subAgent) {
+                                    updated[existingIndex] = {
+                                        ...existing,
+                                        subAgent: {
+                                            ...existing.subAgent,
+                                            isComplete: true,
+                                        },
+                                    };
+                                }
+                                return updated;
+                            }
+                            return prev;
+                        }
+                        if (existingIndex !== -1) {
+                            // Update existing message
+                            const updated = [...prev];
+                            const existing = updated[existingIndex];
+                            if (existing) {
+                                updated[existingIndex] = {
+                                    ...existing,
+                                    content: (existing.content || '') + content,
+                                    streaming: true,
+                                };
+                            }
+                            return updated;
+                        }
+                        else if (content) {
+                            // Add new sub-agent message
+                            return [
+                                ...prev,
+                                {
+                                    role: 'subagent',
+                                    content,
+                                    streaming: true,
+                                    subAgent: {
+                                        agentId: subAgentMessage.agentId,
+                                        agentName: subAgentMessage.agentName,
+                                        isComplete: false,
+                                    },
+                                },
+                            ];
+                        }
+                        return prev;
+                    });
+                }, requestToolConfirmation, isToolAutoApproved, yoloMode);
                 // Check if aborted during tool execution
                 if (controller.signal.aborted) {
                     freeEncoder();
@@ -355,10 +521,40 @@ export async function handleConversationWithTools(options) {
                         }
                     }
                 }
+                // Remove only streaming sub-agent content messages (not tool-related messages)
+                // Keep sub-agent tool call and tool result messages for display
+                setMessages(prev => prev.filter(m => m.role !== 'subagent' ||
+                    m.toolCall !== undefined ||
+                    m.toolResult !== undefined ||
+                    m.subAgentInternal === true));
                 // Update existing tool call messages with results
                 for (const result of toolResults) {
                     const toolCall = receivedToolCalls.find(tc => tc.id === result.tool_call_id);
                     if (toolCall) {
+                        // Special handling for sub-agent tools - show completion message
+                        // Pass the full JSON result to ToolResultPreview for proper parsing
+                        if (toolCall.function.name.startsWith('subagent-')) {
+                            const isError = result.content.startsWith('Error:');
+                            const statusIcon = isError ? '✗' : '✓';
+                            const statusText = isError ? `\n  └─ ${result.content}` : '';
+                            // Display subagent completion message in main flow
+                            setMessages(prev => [
+                                ...prev,
+                                {
+                                    role: 'assistant',
+                                    content: `${statusIcon} ${toolCall.function.name}${statusText}`,
+                                    streaming: false,
+                                    // Pass the full result.content for ToolResultPreview to parse
+                                    toolResult: !isError ? result.content : undefined,
+                                },
+                            ]);
+                            // Save the tool result to conversation history
+                            conversationMessages.push(result);
+                            saveMessage(result).catch(error => {
+                                console.error('Failed to save tool result:', error);
+                            });
+                            continue;
+                        }
                         const isError = result.content.startsWith('Error:');
                         const statusIcon = isError ? '✗' : '✓';
                         const statusText = isError ? `\n  └─ ${result.content}` : '';
@@ -384,63 +580,34 @@ export async function handleConversationWithTools(options) {
                                 // If parsing fails, just show regular result
                             }
                         }
-                        // Check if this is a terminal execution result
-                        let terminalResultData;
-                        if (toolCall.function.name === 'terminal-execute' && !isError) {
-                            try {
-                                const resultData = JSON.parse(result.content);
-                                if (resultData.command !== undefined) {
-                                    terminalResultData = {
-                                        stdout: resultData.stdout || '',
-                                        stderr: resultData.stderr || '',
-                                        exitCode: resultData.exitCode || 0,
-                                        command: resultData.command,
-                                    };
-                                }
-                            }
-                            catch (e) {
-                                // If parsing fails, just show regular result
-                            }
-                        }
-                        // Check if this tool should show preview (websearch, ace, filesystem-read, etc.)
-                        const shouldShowPreview = toolCall.function.name.startsWith('websearch-') ||
-                            toolCall.function.name.startsWith('ace-') ||
-                            toolCall.function.name === 'filesystem-read' ||
-                            toolCall.function.name === 'filesystem-list' ||
-                            toolCall.function.name === 'filesystem-create' ||
-                            toolCall.function.name === 'filesystem-write';
-                        // Update the existing pending message instead of adding a new one
-                        setMessages(prev => prev.map(msg => {
-                            if (msg.toolCallId === toolCall.id && msg.toolPending) {
-                                return {
-                                    ...msg,
-                                    content: `${statusIcon} ${toolCall.function.name}${statusText}`,
-                                    toolPending: false,
-                                    toolCall: editDiffData
-                                        ? {
-                                            name: toolCall.function.name,
-                                            arguments: editDiffData,
-                                        }
-                                        : terminalResultData
-                                            ? {
-                                                name: toolCall.function.name,
-                                                arguments: terminalResultData,
-                                            }
-                                            : shouldShowPreview
-                                                ? undefined // Clear toolCall for preview-enabled tools
-                                                : msg.toolCall, // Keep original toolCall for other tools
-                                    // Store tool result for preview rendering
-                                    toolResult: !isError ? result.content : undefined,
-                                };
-                            }
-                            return msg;
-                        }));
+                        // Append completed message to static area (don't remove pending message)
+                        // Static area doesn't support deletion, only append
+                        // Completed message only shows diff data (for edit tools), no other parameters
+                        setMessages(prev => [
+                            ...prev,
+                            // Add new completed message
+                            {
+                                role: 'assistant',
+                                content: `${statusIcon} ${toolCall.function.name}${statusText}`,
+                                streaming: false,
+                                toolCall: editDiffData
+                                    ? {
+                                        name: toolCall.function.name,
+                                        arguments: editDiffData,
+                                    }
+                                    : undefined, // Don't show arguments for completed tools (already shown in pending)
+                                // Store tool result for preview rendering
+                                toolResult: !isError ? result.content : undefined,
+                            },
+                        ]);
+                    }
+                    // Add tool result to conversation history and save (skip if already saved above)
+                    if (toolCall && !toolCall.function.name.startsWith('subagent-')) {
+                        conversationMessages.push(result);
+                        saveMessage(result).catch(error => {
+                            console.error('Failed to save tool result:', error);
+                        });
                     }
-                    // Add tool result to conversation history and save
-                    conversationMessages.push(result);
-                    saveMessage(result).catch(error => {
-                        console.error('Failed to save tool result:', error);
-                    });
                 }
                 // After all tool results are processed, show TODO panel if there were todo-update calls
                 if (hasTodoUpdateTools) {

package/dist/hooks/useSnapshotState.d.ts

@@ -4,9 +4,11 @@ export declare function useSnapshotState(messagesLength: number): {
     pendingRollback: {
         messageIndex: number;
         fileCount: number;
+        filePaths?: string[];
     } | null;
     setPendingRollback: import("react").Dispatch<import("react").SetStateAction<{
         messageIndex: number;
         fileCount: number;
+        filePaths?: string[];
     } | null>>;
 };

package/dist/hooks/useToolConfirmation.js

@@ -25,7 +25,7 @@ export function useToolConfirmation() {
      * Check if a tool is auto-approved
      */
     const isToolAutoApproved = (toolName) => {
-        return alwaysApprovedTools.has(toolName) || toolName.startsWith('todo-');
+        return alwaysApprovedTools.has(toolName) || toolName.startsWith('todo-') || toolName.startsWith('subagent-');
     };
     /**
      * Add a tool to the always-approved list

package/dist/mcp/subagent.d.ts

@@ -0,0 +1,35 @@
+import type { SubAgentMessage } from '../utils/subAgentExecutor.js';
+import type { ToolCall } from '../utils/toolExecutor.js';
+export interface SubAgentToolExecutionOptions {
+    agentId: string;
+    prompt: string;
+    onMessage?: (message: SubAgentMessage) => void;
+    abortSignal?: AbortSignal;
+    requestToolConfirmation?: (toolCall: ToolCall, batchToolNames?: string, allTools?: ToolCall[]) => Promise<string>;
+    isToolAutoApproved?: (toolName: string) => boolean;
+    yoloMode?: boolean;
+}
+/**
+ * Sub-Agent MCP Service
+ * Provides tools for executing sub-agents with their own specialized system prompts and tool access
+ */
+export declare class SubAgentService {
+    /**
+     * Execute a sub-agent as a tool
+     */
+    execute(options: SubAgentToolExecutionOptions): Promise<any>;
+    /**
+     * Get all available sub-agents as MCP tools
+     */
+    getTools(): Array<{
+        name: string;
+        description: string;
+        inputSchema: any;
+    }>;
+}
+export declare const subAgentService: SubAgentService;
+export declare function getMCPTools(): Array<{
+    name: string;
+    description: string;
+    inputSchema: any;
+}>;

package/dist/mcp/subagent.js

@@ -0,0 +1,64 @@
+import { executeSubAgent } from '../utils/subAgentExecutor.js';
+import { getSubAgents } from '../utils/subAgentConfig.js';
+/**
+ * Sub-Agent MCP Service
+ * Provides tools for executing sub-agents with their own specialized system prompts and tool access
+ */
+export class SubAgentService {
+    /**
+     * Execute a sub-agent as a tool
+     */
+    async execute(options) {
+        const { agentId, prompt, onMessage, abortSignal, requestToolConfirmation, isToolAutoApproved, yoloMode, } = options;
+        // Create a tool confirmation adapter for sub-agent if needed
+        const subAgentToolConfirmation = requestToolConfirmation
+            ? async (toolName, toolArgs) => {
+                // Create a fake tool call for confirmation
+                const fakeToolCall = {
+                    id: 'subagent-tool',
+                    type: 'function',
+                    function: {
+                        name: toolName,
+                        arguments: JSON.stringify(toolArgs),
+                    },
+                };
+                return await requestToolConfirmation(fakeToolCall);
+            }
+            : undefined;
+        const result = await executeSubAgent(agentId, prompt, onMessage, abortSignal, subAgentToolConfirmation, isToolAutoApproved, yoloMode);
+        if (!result.success) {
+            throw new Error(result.error || 'Sub-agent execution failed');
+        }
+        return {
+            success: true,
+            result: result.result,
+        };
+    }
+    /**
+     * Get all available sub-agents as MCP tools
+     */
+    getTools() {
+        const subAgents = getSubAgents();
+        return subAgents.map(agent => ({
+            name: agent.id,
+            description: `${agent.name}: ${agent.description}`,
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    prompt: {
+                        type: 'string',
+                        description: 'The task prompt to send to the sub-agent',
+                    },
+                },
+                required: ['prompt'],
+            },
+        }));
+    }
+}
+// Export a default instance
+export const subAgentService = new SubAgentService();
+// MCP Tool definitions (dynamically generated from configuration)
+// Note: These are generated at runtime, so we export a function instead of a constant
+export function getMCPTools() {
+    return subAgentService.getTools();
+}

package/dist/ui/components/ChatInput.d.ts

@@ -20,7 +20,6 @@ type Props = {
         cacheReadTokens?: number;
         cachedTokens?: number;
     };
-    snapshotFileCount?: Map<number, number>;
 };
-export default function ChatInput({ onSubmit, onCommand, placeholder, disabled, chatHistory, onHistorySelect, yoloMode, contextUsage, snapshotFileCount, }: Props): React.JSX.Element;
+export default function ChatInput({ onSubmit, onCommand, placeholder, disabled, chatHistory, onHistorySelect, yoloMode, contextUsage, }: Props): React.JSX.Element;
 export {};