snow-ai 0.3.4 → 0.3.6

package/dist/utils/subAgentExecutor.js

@@ -0,0 +1,272 @@
+import { createStreamingAnthropicCompletion } from '../api/anthropic.js';
+import { createStreamingResponse } from '../api/responses.js';
+import { createStreamingGeminiCompletion } from '../api/gemini.js';
+import { createStreamingChatCompletion } from '../api/chat.js';
+import { getSubAgent } from './subAgentConfig.js';
+import { collectAllMCPTools, executeMCPTool } from './mcpToolsManager.js';
+import { getOpenAiConfig } from './apiConfig.js';
+import { sessionManager } from './sessionManager.js';
+/**
+ * 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 async function executeSubAgent(agentId, prompt, onMessage, abortSignal, requestToolConfirmation, isToolAutoApproved, yoloMode) {
+    try {
+        // Get sub-agent configuration
+        const agent = getSubAgent(agentId);
+        if (!agent) {
+            return {
+                success: false,
+                result: '',
+                error: `Sub-agent with ID "${agentId}" not found`,
+            };
+        }
+        // Get all available tools
+        const allTools = await collectAllMCPTools();
+        // Filter tools based on sub-agent's allowed tools
+        const allowedTools = allTools.filter((tool) => {
+            const toolName = tool.function.name;
+            return agent.tools.some(allowedTool => {
+                // Normalize both tool names: replace underscores with hyphens for comparison
+                const normalizedToolName = toolName.replace(/_/g, '-');
+                const normalizedAllowedTool = allowedTool.replace(/_/g, '-');
+                // Support both exact match and prefix match (e.g., "filesystem" matches "filesystem-read")
+                return (normalizedToolName === normalizedAllowedTool ||
+                    normalizedToolName.startsWith(`${normalizedAllowedTool}-`));
+            });
+        });
+        if (allowedTools.length === 0) {
+            return {
+                success: false,
+                result: '',
+                error: `Sub-agent "${agent.name}" has no valid tools configured`,
+            };
+        }
+        // Build conversation history for sub-agent
+        const messages = [
+            {
+                role: 'user',
+                content: prompt,
+            },
+        ];
+        // Stream sub-agent execution
+        let finalResponse = '';
+        let hasError = false;
+        let errorMessage = '';
+        const maxIterations = 10; // Prevent infinite loops
+        let iteration = 0;
+        while (iteration < maxIterations) {
+            iteration++;
+            // Check abort signal
+            if (abortSignal?.aborted) {
+                return {
+                    success: false,
+                    result: finalResponse,
+                    error: 'Sub-agent execution aborted',
+                };
+            }
+            // Get API configuration
+            const config = getOpenAiConfig();
+            const currentSession = sessionManager.getCurrentSession();
+            const model = config.advancedModel || 'claude-3-5-sonnet-20241022';
+            // Call API with sub-agent's tools - choose API based on config
+            const stream = config.requestMethod === 'anthropic'
+                ? createStreamingAnthropicCompletion({
+                    model,
+                    messages,
+                    temperature: 0,
+                    max_tokens: config.maxTokens || 4096,
+                    tools: allowedTools,
+                    sessionId: currentSession?.id,
+                }, abortSignal)
+                : config.requestMethod === 'gemini'
+                    ? createStreamingGeminiCompletion({
+                        model,
+                        messages,
+                        temperature: 0,
+                        tools: allowedTools,
+                    }, abortSignal)
+                    : config.requestMethod === 'responses'
+                        ? createStreamingResponse({
+                            model,
+                            messages,
+                            temperature: 0,
+                            tools: allowedTools,
+                            prompt_cache_key: currentSession?.id,
+                        }, abortSignal)
+                        : createStreamingChatCompletion({
+                            model,
+                            messages,
+                            temperature: 0,
+                            tools: allowedTools,
+                        }, abortSignal);
+            let currentContent = '';
+            let toolCalls = [];
+            for await (const event of stream) {
+                // Forward message to UI (but don't save to main conversation)
+                if (onMessage) {
+                    onMessage({
+                        type: 'sub_agent_message',
+                        agentId: agent.id,
+                        agentName: agent.name,
+                        message: event,
+                    });
+                }
+                if (event.type === 'content' && event.content) {
+                    currentContent += event.content;
+                }
+                else if (event.type === 'tool_calls' && event.tool_calls) {
+                    toolCalls = event.tool_calls;
+                }
+            }
+            if (hasError) {
+                return {
+                    success: false,
+                    result: finalResponse,
+                    error: errorMessage,
+                };
+            }
+            // Add assistant response to conversation
+            if (currentContent || toolCalls.length > 0) {
+                const assistantMessage = {
+                    role: 'assistant',
+                    content: currentContent || '',
+                };
+                if (toolCalls.length > 0) {
+                    assistantMessage.tool_calls = toolCalls;
+                }
+                messages.push(assistantMessage);
+                finalResponse = currentContent;
+            }
+            // If no tool calls, we're done
+            if (toolCalls.length === 0) {
+                break;
+            }
+            // Check tool approvals before execution
+            const approvedToolCalls = [];
+            const rejectedToolCalls = [];
+            for (const toolCall of toolCalls) {
+                const toolName = toolCall.function.name;
+                let args;
+                try {
+                    args = JSON.parse(toolCall.function.arguments);
+                }
+                catch (e) {
+                    args = {};
+                }
+                // Check if tool needs confirmation
+                let needsConfirmation = true;
+                // In YOLO mode, auto-approve all tools
+                if (yoloMode) {
+                    needsConfirmation = false;
+                }
+                // Check if tool is in auto-approved list
+                else if (isToolAutoApproved && isToolAutoApproved(toolName)) {
+                    needsConfirmation = false;
+                }
+                if (needsConfirmation && requestToolConfirmation) {
+                    // Request confirmation from user
+                    const confirmation = await requestToolConfirmation(toolName, args);
+                    if (confirmation === 'reject') {
+                        rejectedToolCalls.push(toolCall);
+                        continue;
+                    }
+                    // If approved or approved_always, continue execution
+                    // (approved_always is handled by the main flow's session-approved list)
+                }
+                approvedToolCalls.push(toolCall);
+            }
+            // Handle rejected tools
+            if (rejectedToolCalls.length > 0) {
+                return {
+                    success: false,
+                    result: finalResponse,
+                    error: `User rejected tool execution: ${rejectedToolCalls
+                        .map(tc => tc.function.name)
+                        .join(', ')}`,
+                };
+            }
+            // Execute approved tool calls
+            const toolResults = [];
+            for (const toolCall of approvedToolCalls) {
+                try {
+                    const args = JSON.parse(toolCall.function.arguments);
+                    const result = await executeMCPTool(toolCall.function.name, args, abortSignal);
+                    const toolResult = {
+                        role: 'tool',
+                        tool_call_id: toolCall.id,
+                        content: JSON.stringify(result),
+                    };
+                    toolResults.push(toolResult);
+                    // Send tool result to UI
+                    if (onMessage) {
+                        onMessage({
+                            type: 'sub_agent_message',
+                            agentId: agent.id,
+                            agentName: agent.name,
+                            message: {
+                                type: 'tool_result',
+                                tool_call_id: toolCall.id,
+                                tool_name: toolCall.function.name,
+                                content: JSON.stringify(result),
+                            },
+                        });
+                    }
+                }
+                catch (error) {
+                    const errorResult = {
+                        role: 'tool',
+                        tool_call_id: toolCall.id,
+                        content: `Error: ${error instanceof Error ? error.message : 'Tool execution failed'}`,
+                    };
+                    toolResults.push(errorResult);
+                    // Send error result to UI
+                    if (onMessage) {
+                        onMessage({
+                            type: 'sub_agent_message',
+                            agentId: agent.id,
+                            agentName: agent.name,
+                            message: {
+                                type: 'tool_result',
+                                tool_call_id: toolCall.id,
+                                tool_name: toolCall.function.name,
+                                content: `Error: ${error instanceof Error
+                                    ? error.message
+                                    : 'Tool execution failed'}`,
+                            },
+                        });
+                    }
+                }
+            }
+            // Add tool results to conversation
+            messages.push(...toolResults);
+            // Continue to next iteration if there were tool calls
+            // The loop will continue until no more tool calls or max iterations
+        }
+        if (iteration >= maxIterations) {
+            return {
+                success: false,
+                result: finalResponse,
+                error: 'Sub-agent exceeded maximum iterations',
+            };
+        }
+        return {
+            success: true,
+            result: finalResponse,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            result: '',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}

package/dist/utils/toolExecutor.d.ts

@@ -1,3 +1,4 @@
+import type { SubAgentMessage } from './subAgentExecutor.js';
 export interface ToolCall {
     id: string;
     type: 'function';
@@ -11,11 +12,18 @@ export interface ToolResult {
     role: 'tool';
     content: string;
 }
+export type SubAgentMessageCallback = (message: SubAgentMessage) => void;
+export interface ToolConfirmationCallback {
+    (toolCall: ToolCall, batchToolNames?: string, allTools?: ToolCall[]): Promise<string>;
+}
+export interface ToolApprovalChecker {
+    (toolName: string): boolean;
+}
 /**
  * Execute a single tool call and return the result
  */
-export declare function executeToolCall(toolCall: ToolCall, abortSignal?: AbortSignal, onTokenUpdate?: (tokenCount: number) => void): Promise<ToolResult>;
+export declare function executeToolCall(toolCall: ToolCall, abortSignal?: AbortSignal, onTokenUpdate?: (tokenCount: number) => void, onSubAgentMessage?: SubAgentMessageCallback, requestToolConfirmation?: ToolConfirmationCallback, isToolAutoApproved?: ToolApprovalChecker, yoloMode?: boolean): Promise<ToolResult>;
 /**
  * Execute multiple tool calls in parallel
  */
-export declare function executeToolCalls(toolCalls: ToolCall[], abortSignal?: AbortSignal, onTokenUpdate?: (tokenCount: number) => void): Promise<ToolResult[]>;
+export declare function executeToolCalls(toolCalls: ToolCall[], abortSignal?: AbortSignal, onTokenUpdate?: (tokenCount: number) => void, onSubAgentMessage?: SubAgentMessageCallback, requestToolConfirmation?: ToolConfirmationCallback, isToolAutoApproved?: ToolApprovalChecker, yoloMode?: boolean): Promise<ToolResult[]>;

package/dist/utils/toolExecutor.js

@@ -1,28 +1,69 @@
 import { executeMCPTool } from './mcpToolsManager.js';
+import { subAgentService } from '../mcp/subagent.js';
 /**
  * Execute a single tool call and return the result
  */
-export async function executeToolCall(toolCall, abortSignal, onTokenUpdate) {
+export async function executeToolCall(toolCall, abortSignal, onTokenUpdate, onSubAgentMessage, requestToolConfirmation, isToolAutoApproved, yoloMode) {
     try {
         const args = JSON.parse(toolCall.function.arguments);
+        // Check if this is a sub-agent tool
+        if (toolCall.function.name.startsWith('subagent-')) {
+            const agentId = toolCall.function.name.substring('subagent-'.length);
+            // Create a tool confirmation adapter for sub-agent
+            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 subAgentService.execute({
+                agentId,
+                prompt: args.prompt,
+                onMessage: onSubAgentMessage,
+                abortSignal,
+                requestToolConfirmation: subAgentToolConfirmation
+                    ? async (toolCall) => {
+                        // Use the adapter to convert to the expected signature
+                        const args = JSON.parse(toolCall.function.arguments);
+                        return await subAgentToolConfirmation(toolCall.function.name, args);
+                    }
+                    : undefined,
+                isToolAutoApproved,
+                yoloMode,
+            });
+            return {
+                tool_call_id: toolCall.id,
+                role: 'tool',
+                content: JSON.stringify(result),
+            };
+        }
+        // Regular tool execution
         const result = await executeMCPTool(toolCall.function.name, args, abortSignal, onTokenUpdate);
         return {
             tool_call_id: toolCall.id,
             role: 'tool',
-            content: JSON.stringify(result)
+            content: JSON.stringify(result),
         };
     }
     catch (error) {
         return {
             tool_call_id: toolCall.id,
             role: 'tool',
-            content: `Error: ${error instanceof Error ? error.message : 'Tool execution failed'}`
+            content: `Error: ${error instanceof Error ? error.message : 'Tool execution failed'}`,
         };
     }
 }
 /**
  * Execute multiple tool calls in parallel
  */
-export async function executeToolCalls(toolCalls, abortSignal, onTokenUpdate) {
-    return Promise.all(toolCalls.map(tc => executeToolCall(tc, abortSignal, onTokenUpdate)));
+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)));
 }

package/package.json

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

package/dist/ui/pages/ConfigProfileScreen.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-type Props = {
-    onBack: () => void;
-    onSelectProfile: (profileName: string) => void;
-};
-export default function ConfigProfileScreen({ onBack, onSelectProfile, }: Props): React.JSX.Element;
-export {};