fast-agent-mcp 0.2.40__py3-none-any.whl → 0.2.41__py3-none-any.whl

mcp_agent/core/agent_app.py

@@ -9,6 +9,7 @@ from mcp.types import PromptMessage
 from rich import print as rich_print
 
 from mcp_agent.agents.agent import Agent
+from mcp_agent.core.agent_types import AgentType
 from mcp_agent.core.interactive_prompt import InteractivePrompt
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.progress_display import progress_display
@@ -234,13 +235,14 @@ class AgentApp:
         """
         return await self.interactive(agent_name=agent_name, default_prompt=default_prompt)
 
-    async def interactive(self, agent_name: str | None = None, default_prompt: str = "") -> str:
+    async def interactive(self, agent_name: str | None = None, default_prompt: str = "", pretty_print_parallel: bool = False) -> str:
         """
         Interactive prompt for sending messages with advanced features.
 
         Args:
             agent_name: Optional target agent name (uses default if not specified)
             default: Default message to use when user presses enter
+            pretty_print_parallel: Enable clean parallel results display for parallel agents
 
         Returns:
             The result of the interactive session
@@ -275,10 +277,18 @@ class AgentApp:
         # Define the wrapper for send function
         async def send_wrapper(message, agent_name):
             result = await self.send(message, agent_name)
-            
+
+            # Show parallel results if enabled and this is a parallel agent
+            if pretty_print_parallel:
+                agent = self._agents.get(agent_name)
+                if agent and agent.agent_type == AgentType.PARALLEL:
+                    from mcp_agent.ui.console_display import ConsoleDisplay
+                    display = ConsoleDisplay(config=None)
+                    display.show_parallel_results(agent)
+
             # Show usage info after each turn if progress display is enabled
             self._show_turn_usage(agent_name)
-            
+
             return result
 
         # Start the prompt loop with the agent name (not the agent object)
@@ -293,32 +303,111 @@ class AgentApp:
     def _show_turn_usage(self, agent_name: str) -> None:
         """Show subtle usage information after each turn."""
         agent = self._agents.get(agent_name)
-        if not agent or not agent.usage_accumulator:
+        if not agent:
             return
-            
+
+        # Check if this is a parallel agent
+        if agent.agent_type == AgentType.PARALLEL:
+            self._show_parallel_agent_usage(agent)
+        else:
+            self._show_regular_agent_usage(agent)
+
+    def _show_regular_agent_usage(self, agent) -> None:
+        """Show usage for a regular (non-parallel) agent."""
+        usage_info = self._format_agent_usage(agent)
+        if usage_info:
+            with progress_display.paused():
+                rich_print(
+                    f"[dim]Last turn: {usage_info['display_text']}[/dim]{usage_info['cache_suffix']}"
+                )
+
+    def _show_parallel_agent_usage(self, parallel_agent) -> None:
+        """Show usage for a parallel agent and its children."""
+        # Collect usage from all child agents
+        child_usage_data = []
+        total_input = 0
+        total_output = 0
+        total_tool_calls = 0
+
+        # Get usage from fan-out agents
+        if hasattr(parallel_agent, "fan_out_agents") and parallel_agent.fan_out_agents:
+            for child_agent in parallel_agent.fan_out_agents:
+                usage_info = self._format_agent_usage(child_agent)
+                if usage_info:
+                    child_usage_data.append({**usage_info, "name": child_agent.name})
+                    total_input += usage_info["input_tokens"]
+                    total_output += usage_info["output_tokens"]
+                    total_tool_calls += usage_info["tool_calls"]
+
+        # Get usage from fan-in agent
+        if hasattr(parallel_agent, "fan_in_agent") and parallel_agent.fan_in_agent:
+            usage_info = self._format_agent_usage(parallel_agent.fan_in_agent)
+            if usage_info:
+                child_usage_data.append({**usage_info, "name": parallel_agent.fan_in_agent.name})
+                total_input += usage_info["input_tokens"]
+                total_output += usage_info["output_tokens"]
+                total_tool_calls += usage_info["tool_calls"]
+
+        if not child_usage_data:
+            return
+
+        # Show aggregated usage for parallel agent (no context percentage)
+        with progress_display.paused():
+            tool_info = f", {total_tool_calls} tool calls" if total_tool_calls > 0 else ""
+            rich_print(
+                f"[dim]Last turn (parallel): {total_input:,} Input, {total_output:,} Output{tool_info}[/dim]"
+            )
+
+            # Show individual child agent usage
+            for i, usage_data in enumerate(child_usage_data):
+                is_last = i == len(child_usage_data) - 1
+                prefix = "└─" if is_last else "├─"
+                rich_print(
+                    f"[dim]  {prefix} {usage_data['name']}: {usage_data['display_text']}[/dim]{usage_data['cache_suffix']}"
+                )
+
+    def _format_agent_usage(self, agent) -> Optional[Dict]:
+        """Format usage information for a single agent."""
+        if not agent or not agent.usage_accumulator:
+            return None
+
         # Get the last turn's usage (if any)
         turns = agent.usage_accumulator.turns
         if not turns:
-            return
-            
+            return None
+
         last_turn = turns[-1]
         input_tokens = last_turn.display_input_tokens
         output_tokens = last_turn.output_tokens
-        
+
         # Build cache indicators with bright colors
         cache_indicators = ""
         if last_turn.cache_usage.cache_write_tokens > 0:
             cache_indicators += "[bright_yellow]^[/bright_yellow]"
-        if last_turn.cache_usage.cache_read_tokens > 0 or last_turn.cache_usage.cache_hit_tokens > 0:
+        if (
+            last_turn.cache_usage.cache_read_tokens > 0
+            or last_turn.cache_usage.cache_hit_tokens > 0
+        ):
             cache_indicators += "[bright_green]*[/bright_green]"
-            
+
         # Build context percentage - get from accumulator, not individual turn
         context_info = ""
         context_percentage = agent.usage_accumulator.context_usage_percentage
         if context_percentage is not None:
             context_info = f" ({context_percentage:.1f}%)"
-            
-        # Show subtle usage line - pause progress display to ensure visibility
-        with progress_display.paused():
-            cache_suffix = f" {cache_indicators}" if cache_indicators else ""
-            rich_print(f"[dim]Last turn: {input_tokens:,} Input, {output_tokens:,} Output{context_info}[/dim]{cache_suffix}")
+
+        # Build tool call info
+        tool_info = f", {last_turn.tool_calls} tool calls" if last_turn.tool_calls > 0 else ""
+
+        # Build display text
+        display_text = f"{input_tokens:,} Input, {output_tokens:,} Output{tool_info}{context_info}"
+        cache_suffix = f" {cache_indicators}" if cache_indicators else ""
+
+        return {
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+            "tool_calls": last_turn.tool_calls,
+            "context_percentage": context_percentage,
+            "display_text": display_text,
+            "cache_suffix": cache_suffix,
+        }

mcp_agent/core/agent_types.py

@@ -38,6 +38,7 @@ class AgentConfig:
     agent_type: AgentType = AgentType.BASIC
     default: bool = False
     elicitation_handler: ElicitationFnT | None = None
+    api_key: str | None = None
 
     def __post_init__(self):
         """Ensure default_request_params exists with proper history setting"""

mcp_agent/core/direct_decorators.py

@@ -138,6 +138,7 @@ def _decorator_impl(
             human_input=human_input,
             default=default,
             elicitation_handler=extra_kwargs.get("elicitation_handler"),
+            api_key=extra_kwargs.get("api_key"),
         )
 
         # Update request params if provided
@@ -182,6 +183,7 @@ def agent(
     human_input: bool = False,
     default: bool = False,
     elicitation_handler: Optional[ElicitationFnT] = None,
+    api_key: str | None = None,
 ) -> Callable[[AgentCallable[P, R]], DecoratedAgentProtocol[P, R]]:
     """
     Decorator to create and register a standard agent with type-safe signature.
@@ -215,6 +217,7 @@ def agent(
         human_input=human_input,
         default=default,
         elicitation_handler=elicitation_handler,
+        api_key=api_key,
     )
 
 
@@ -232,6 +235,7 @@ def custom(
     human_input: bool = False,
     default: bool = False,
     elicitation_handler: Optional[ElicitationFnT] = None,
+    api_key: str | None = None,
 ) -> Callable[[AgentCallable[P, R]], DecoratedAgentProtocol[P, R]]:
     """
     Decorator to create and register a standard agent with type-safe signature.
@@ -265,6 +269,7 @@ def custom(
         agent_class=cls,
         default=default,
         elicitation_handler=elicitation_handler,
+        api_key=api_key,
     )
 
 
@@ -288,6 +293,7 @@ def orchestrator(
     plan_type: Literal["full", "iterative"] = "full",
     plan_iterations: int = 5,
     default: bool = False,
+    api_key: str | None = None,
 ) -> Callable[[AgentCallable[P, R]], DecoratedOrchestratorProtocol[P, R]]:
     """
     Decorator to create and register an orchestrator agent with type-safe signature.
@@ -326,6 +332,7 @@ def orchestrator(
             plan_type=plan_type,
             plan_iterations=plan_iterations,
             default=default,
+            api_key=api_key,
         ),
     )
 
@@ -345,6 +352,7 @@ def router(
     elicitation_handler: Optional[
         ElicitationFnT
     ] = None,  ## exclude from docs, decide whether allowable
+    api_key: str | None = None,
 ) -> Callable[[AgentCallable[P, R]], DecoratedRouterProtocol[P, R]]:
     """
     Decorator to create and register a router agent with type-safe signature.
@@ -383,6 +391,7 @@ def router(
             default=default,
             router_agents=agents,
             elicitation_handler=elicitation_handler,
+            api_key=api_key,
         ),
     )
 

mcp_agent/core/direct_factory.py

@@ -150,7 +150,11 @@ async def create_agents_by_type(
 
                 # Attach LLM to the agent
                 llm_factory = model_factory_func(model=config.model)
-                await agent.attach_llm(llm_factory, request_params=config.default_request_params)
+                await agent.attach_llm(
+                    llm_factory,
+                    request_params=config.default_request_params,
+                    api_key=config.api_key
+                )
                 result_agents[name] = agent
 
             elif agent_type == AgentType.CUSTOM:
@@ -165,7 +169,11 @@ async def create_agents_by_type(
 
                 # Attach LLM to the agent
                 llm_factory = model_factory_func(model=config.model)
-                await agent.attach_llm(llm_factory, request_params=config.default_request_params)
+                await agent.attach_llm(
+                    llm_factory,
+                    request_params=config.default_request_params,
+                    api_key=config.api_key
+                )
                 result_agents[name] = agent
 
             elif agent_type == AgentType.ORCHESTRATOR:
@@ -200,7 +208,9 @@ async def create_agents_by_type(
                 # Attach LLM to the orchestrator
                 llm_factory = model_factory_func(model=config.model)
                 await orchestrator.attach_llm(
-                    llm_factory, request_params=config.default_request_params
+                    llm_factory,
+                    request_params=config.default_request_params,
+                    api_key=config.api_key
                 )
 
                 result_agents[name] = orchestrator
@@ -261,7 +271,11 @@ async def create_agents_by_type(
 
                 # Attach LLM to the router
                 llm_factory = model_factory_func(model=config.model)
-                await router.attach_llm(llm_factory, request_params=config.default_request_params)
+                await router.attach_llm(
+                    llm_factory,
+                    request_params=config.default_request_params,
+                    api_key=config.api_key
+                )
                 result_agents[name] = router
 
             elif agent_type == AgentType.CHAIN:

mcp_agent/core/enhanced_prompt.py

@@ -71,27 +71,178 @@ async def _display_agent_info_helper(agent_name: str, agent_provider: object) ->
         prompts_dict = await agent.list_prompts()
         prompt_count = sum(len(prompts) for prompts in prompts_dict.values()) if prompts_dict else 0
 
-        # Display with proper pluralization and subdued formatting
-        if server_count == 0:
-            rich_print(
-                f"[dim]Agent [/dim][blue]{agent_name}[/blue][dim]: No MCP Servers attached[/dim]"
-            )
+        # Handle different agent types
+        if agent.agent_type == AgentType.PARALLEL:
+            # Count child agents for parallel agents
+            child_count = 0
+            if hasattr(agent, "fan_out_agents") and agent.fan_out_agents:
+                child_count += len(agent.fan_out_agents)
+            if hasattr(agent, "fan_in_agent") and agent.fan_in_agent:
+                child_count += 1
+
+            if child_count > 0:
+                child_word = "child agent" if child_count == 1 else "child agents"
+                rich_print(
+                    f"[dim]Agent [/dim][blue]{agent_name}[/blue][dim]:[/dim] {child_count:,}[dim] {child_word}[/dim]"
+                )
+        elif agent.agent_type == AgentType.ROUTER:
+            # Count child agents for router agents
+            child_count = 0
+            if hasattr(agent, "routing_agents") and agent.routing_agents:
+                child_count = len(agent.routing_agents)
+            elif hasattr(agent, "agents") and agent.agents:
+                child_count = len(agent.agents)
+
+            if child_count > 0:
+                child_word = "child agent" if child_count == 1 else "child agents"
+                rich_print(
+                    f"[dim]Agent [/dim][blue]{agent_name}[/blue][dim]:[/dim] {child_count:,}[dim] {child_word}[/dim]"
+                )
         else:
+            # For regular agents, only display if they have MCP servers attached
+            if server_count > 0:
+                # Pluralization helpers
+                server_word = "Server" if server_count == 1 else "Servers"
+                tool_word = "tool" if tool_count == 1 else "tools"
+                prompt_word = "prompt" if prompt_count == 1 else "prompts"
+
+                rich_print(
+                    f"[dim]Agent [/dim][blue]{agent_name}[/blue][dim]:[/dim] {server_count:,}[dim] MCP {server_word}, [/dim]{tool_count:,}[dim] {tool_word}, [/dim]{prompt_count:,}[dim] {prompt_word} available[/dim]"
+                )
+
+        # Mark as shown
+        _agent_info_shown.add(agent_name)
+
+    except Exception:
+        # Silently ignore errors to not disrupt the user experience
+        pass
+
+
+async def _display_all_agents_with_hierarchy(available_agents: List[str], agent_provider) -> None:
+    """Display all agents with tree structure for workflow agents."""
+    # Track which agents are children to avoid displaying them twice
+    child_agents = set()
+
+    # First pass: identify all child agents
+    for agent_name in available_agents:
+        try:
+            if hasattr(agent_provider, "_agent"):
+                agent = agent_provider._agent(agent_name)
+            else:
+                agent = agent_provider
+
+            if agent.agent_type == AgentType.PARALLEL:
+                if hasattr(agent, "fan_out_agents") and agent.fan_out_agents:
+                    for child_agent in agent.fan_out_agents:
+                        child_agents.add(child_agent.name)
+                if hasattr(agent, "fan_in_agent") and agent.fan_in_agent:
+                    child_agents.add(agent.fan_in_agent.name)
+            elif agent.agent_type == AgentType.ROUTER:
+                if hasattr(agent, "routing_agents") and agent.routing_agents:
+                    for child_agent in agent.routing_agents:
+                        child_agents.add(child_agent.name)
+                elif hasattr(agent, "agents") and agent.agents:
+                    for child_agent in agent.agents:
+                        child_agents.add(child_agent.name)
+        except Exception:
+            continue
+
+    # Second pass: display agents (parents with children, standalone agents without children)
+    for agent_name in sorted(available_agents):
+        # Skip if this agent is a child of another agent
+        if agent_name in child_agents:
+            continue
+
+        try:
+            if hasattr(agent_provider, "_agent"):
+                agent = agent_provider._agent(agent_name)
+            else:
+                agent = agent_provider
+
+            # Display parent agent
+            await _display_agent_info_helper(agent_name, agent_provider)
+
+            # If it's a workflow agent, display its children
+            if agent.agent_type == AgentType.PARALLEL:
+                await _display_parallel_children(agent, agent_provider)
+            elif agent.agent_type == AgentType.ROUTER:
+                await _display_router_children(agent, agent_provider)
+
+        except Exception:
+            continue
+
+
+async def _display_parallel_children(parallel_agent, agent_provider) -> None:
+    """Display child agents of a parallel agent in tree format."""
+    children = []
+
+    # Collect fan-out agents
+    if hasattr(parallel_agent, "fan_out_agents") and parallel_agent.fan_out_agents:
+        for child_agent in parallel_agent.fan_out_agents:
+            children.append(child_agent)
+
+    # Collect fan-in agent
+    if hasattr(parallel_agent, "fan_in_agent") and parallel_agent.fan_in_agent:
+        children.append(parallel_agent.fan_in_agent)
+
+    # Display children with tree formatting
+    for i, child_agent in enumerate(children):
+        is_last = i == len(children) - 1
+        prefix = "└─" if is_last else "├─"
+        await _display_child_agent_info(child_agent, prefix, agent_provider)
+
+
+async def _display_router_children(router_agent, agent_provider) -> None:
+    """Display child agents of a router agent in tree format."""
+    children = []
+
+    # Collect routing agents
+    if hasattr(router_agent, "routing_agents") and router_agent.routing_agents:
+        children = router_agent.routing_agents
+    elif hasattr(router_agent, "agents") and router_agent.agents:
+        children = router_agent.agents
+
+    # Display children with tree formatting
+    for i, child_agent in enumerate(children):
+        is_last = i == len(children) - 1
+        prefix = "└─" if is_last else "├─"
+        await _display_child_agent_info(child_agent, prefix, agent_provider)
+
+
+async def _display_child_agent_info(child_agent, prefix: str, agent_provider) -> None:
+    """Display info for a child agent with tree prefix."""
+    try:
+        # Get counts for child agent
+        servers = await child_agent.list_servers()
+        server_count = len(servers) if servers else 0
+
+        tools_result = await child_agent.list_tools()
+        tool_count = (
+            len(tools_result.tools) if tools_result and hasattr(tools_result, "tools") else 0
+        )
+
+        prompts_dict = await child_agent.list_prompts()
+        prompt_count = sum(len(prompts) for prompts in prompts_dict.values()) if prompts_dict else 0
+
+        # Only display if child has MCP servers
+        if server_count > 0:
             # Pluralization helpers
             server_word = "Server" if server_count == 1 else "Servers"
             tool_word = "tool" if tool_count == 1 else "tools"
             prompt_word = "prompt" if prompt_count == 1 else "prompts"
 
             rich_print(
-                f"[dim]Agent [/dim][blue]{agent_name}[/blue][dim]:[/dim] {server_count:,}[dim] MCP {server_word}, [/dim]{tool_count:,}[dim] {tool_word}, [/dim]{prompt_count:,}[dim] {prompt_word} available[/dim]"
+                f"[dim]  {prefix} [/dim][blue]{child_agent.name}[/blue][dim]:[/dim] {server_count:,}[dim] MCP {server_word}, [/dim]{tool_count:,}[dim] {tool_word}, [/dim]{prompt_count:,}[dim] {prompt_word} available[/dim]"
+            )
+        else:
+            # Show child even without MCP servers for context
+            rich_print(
+                f"[dim]  {prefix} [/dim][blue]{child_agent.name}[/blue][dim]: No MCP Servers[/dim]"
             )
-
-        # Mark as shown
-        _agent_info_shown.add(agent_name)
 
     except Exception:
-        # Silently ignore errors to not disrupt the user experience
-        pass
+        # Fallback: just show the name
+        rich_print(f"[dim]  {prefix} [/dim][blue]{child_agent.name}[/blue]")
 
 
 class AgentCompleter(Completer):
@@ -429,12 +580,13 @@ async def get_enhanced_input(
             rich_print("[dim]Type /help for commands. Ctrl+T toggles multiline mode.[/dim]")
         else:
             rich_print(
-                "[dim]Type /help for commands, @agent to switch agent. Ctrl+T toggles multiline mode.[/dim]\n"
+                "[dim]Type '/' for commands, '@' to switch agent. Ctrl+T multiline, CTRL+E external editor.[/dim]\n"
             )
 
             # Display agent info right after help text if agent_provider is available
             if agent_provider and not is_human_input:
-                await _display_agent_info_helper(agent_name, agent_provider)
+                # Display info for all available agents with tree structure for workflows
+                await _display_all_agents_with_hierarchy(available_agents, agent_provider)
 
         rich_print()
         help_message_shown = True

mcp_agent/core/fastagent.py

@@ -56,6 +56,7 @@ from mcp_agent.core.exceptions import (
 )
 from mcp_agent.core.usage_display import display_usage_report
 from mcp_agent.core.validation import (
+    validate_provider_keys_post_creation,
     validate_server_references,
     validate_workflow_references,
 )
@@ -313,6 +314,9 @@ class FastAgent:
                         self.agents,
                         model_factory_func,
                     )
+                    
+                    # Validate API keys after agent creation
+                    validate_provider_keys_post_creation(active_agents)
 
                     # Create a wrapper with all agents for simplified access
                     wrapper = AgentApp(active_agents)