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

mcp_agent/core/direct_decorators.py

@@ -9,6 +9,7 @@ from functools import wraps
 from typing import (
     Awaitable,
     Callable,
+    Dict,
     List,
     Literal,
     Optional,
@@ -93,6 +94,9 @@ def _decorator_impl(
     request_params: RequestParams | None = None,
     human_input: bool = False,
     default: bool = False,
+    tools: Optional[Dict[str, List[str]]] = None,
+    resources: Optional[Dict[str, List[str]]] = None,
+    prompts: Optional[Dict[str, List[str]]] = None,
     **extra_kwargs,
 ) -> Callable[[AgentCallable[P, R]], DecoratedAgentProtocol[P, R]]:
     """
@@ -133,11 +137,15 @@ def _decorator_impl(
             name=name,
             instruction=instruction,
             servers=servers,
+            tools=tools,
+            resources=resources,
+            prompts=prompts,
             model=model,
             use_history=use_history,
             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
@@ -176,12 +184,16 @@ def agent(
     *,
     instruction: str = "You are a helpful agent.",
     servers: List[str] = [],
+    tools: Optional[Dict[str, List[str]]] = None,
+    resources: Optional[Dict[str, List[str]]] = None,
+    prompts: Optional[Dict[str, List[str]]] = None,
     model: Optional[str] = None,
     use_history: bool = True,
     request_params: RequestParams | None = None,
     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.
@@ -191,12 +203,16 @@ def agent(
         instruction_or_kwarg: Optional positional parameter for instruction
         instruction: Base instruction for the agent (keyword arg)
         servers: List of server names the agent should connect to
+        tools: Optional list of tool names or patterns to include
+        resources: Optional list of resource names or patterns to include
+        prompts: Optional list of prompt names or patterns to include
         model: Model specification string
         use_history: Whether to maintain conversation history
         request_params: Additional request parameters for the LLM
         human_input: Whether to enable human input capabilities
         default: Whether to mark this as the default agent
         elicitation_handler: Custom elicitation handler function (ElicitationFnT)
+        api_key: Optional API key for the LLM provider
 
     Returns:
         A decorator that registers the agent with proper type annotations
@@ -215,6 +231,10 @@ def agent(
         human_input=human_input,
         default=default,
         elicitation_handler=elicitation_handler,
+        tools=tools,
+        resources=resources,
+        prompts=prompts,
+        api_key=api_key,
     )
 
 
@@ -226,12 +246,16 @@ def custom(
     *,
     instruction: str = "You are a helpful agent.",
     servers: List[str] = [],
+    tools: Optional[Dict[str, List[str]]] = None,
+    resources: Optional[Dict[str, List[str]]] = None,
+    prompts: Optional[Dict[str, List[str]]] = None,
     model: Optional[str] = None,
     use_history: bool = True,
     request_params: RequestParams | None = None,
     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 +289,10 @@ def custom(
         agent_class=cls,
         default=default,
         elicitation_handler=elicitation_handler,
+        api_key=api_key,
+        tools=tools,
+        resources=resources,
+        prompts=prompts,
     )
 
 
@@ -288,6 +316,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 +355,7 @@ def orchestrator(
             plan_type=plan_type,
             plan_iterations=plan_iterations,
             default=default,
+            api_key=api_key,
         ),
     )
 
@@ -337,6 +367,9 @@ def router(
     agents: List[str],
     instruction: Optional[str] = None,
     servers: List[str] = [],
+    tools: Optional[Dict[str, List[str]]] = None,
+    resources: Optional[Dict[str, List[str]]] = None,
+    prompts: Optional[Dict[str, List[str]]] = None,
     model: Optional[str] = None,
     use_history: bool = False,
     request_params: RequestParams | None = None,
@@ -345,6 +378,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 +417,10 @@ def router(
             default=default,
             router_agents=agents,
             elicitation_handler=elicitation_handler,
+            api_key=api_key,
+            tools=tools,
+            prompts=prompts,
+            resources=resources,
         ),
     )
 

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

@@ -68,30 +68,189 @@ async def _display_agent_info_helper(agent_name: str, agent_provider: object) ->
             len(tools_result.tools) if tools_result and hasattr(tools_result, "tools") else 0
         )
 
+        resources_dict = await agent.list_resources()
+        resource_count = sum(len(resources) for resources in resources_dict.values()) if resources_dict else 0
+
         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"
+                resource_word = "resource" if resource_count == 1 else "resources"
+                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]{resource_count:,}[dim] {resource_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
+        )
+
+        resources_dict = await child_agent.list_resources()
+        resource_count = sum(len(resources) for resources in resources_dict.values()) if resources_dict 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"
+            resource_word = "resource" if resource_count == 1 else "resources"
             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]{resource_count:,}[dim] {resource_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 +588,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)

mcp_agent/core/interactive_prompt.py

@@ -53,6 +53,7 @@ class PromptProvider(Protocol):
     async def apply_prompt(
         self,
         prompt_name: str,
+        prompt_title: Optional[str] = None,
         arguments: Optional[Dict[str, str]] = None,
         agent_name: Optional[str] = None,
         **kwargs,
@@ -243,9 +244,10 @@ class InteractivePrompt:
                                     "server": server_name,
                                     "name": prompt.name,
                                     "namespaced_name": f"{server_name}{SEP}{prompt.name}",
-                                    "description": getattr(prompt, "description", "No description"),
-                                    "arg_count": len(getattr(prompt, "arguments", [])),
-                                    "arguments": getattr(prompt, "arguments", []),
+                                    "title": prompt.title or None,
+                                    "description": prompt.description or "No description",
+                                    "arg_count": len(prompt.arguments or []),
+                                    "arguments": prompt.arguments or [],
                                 }
                             )
                     elif isinstance(prompts_info, list) and prompts_info:
@@ -256,6 +258,7 @@ class InteractivePrompt:
                                         "server": server_name,
                                         "name": prompt["name"],
                                         "namespaced_name": f"{server_name}{SEP}{prompt['name']}",
+                                        "title": prompt.get("title", None),
                                         "description": prompt.get("description", "No description"),
                                         "arg_count": len(prompt.get("arguments", [])),
                                         "arguments": prompt.get("arguments", []),
@@ -263,17 +266,15 @@ class InteractivePrompt:
                                 )
                             else:
                                 # Handle Prompt objects from mcp.types
-                                prompt_name = getattr(prompt, "name", str(prompt))
-                                description = getattr(prompt, "description", "No description")
-                                arguments = getattr(prompt, "arguments", [])
                                 all_prompts.append(
                                     {
                                         "server": server_name,
-                                        "name": prompt_name,
-                                        "namespaced_name": f"{server_name}{SEP}{prompt_name}",
-                                        "description": description,
-                                        "arg_count": len(arguments),
-                                        "arguments": arguments,
+                                        "name": prompt.name,
+                                        "namespaced_name": f"{server_name}{SEP}{prompt.name}",
+                                        "title": prompt.title or None,
+                                        "description": prompt.description or "No description",
+                                        "arg_count": len(prompt.arguments or []),
+                                        "arguments": prompt.arguments or [],
                                     }
                                 )
 
@@ -314,6 +315,7 @@ class InteractivePrompt:
                 table.add_column("#", justify="right", style="cyan")
                 table.add_column("Server", style="green")
                 table.add_column("Prompt Name", style="bright_blue")
+                table.add_column("Title")
                 table.add_column("Description")
                 table.add_column("Args", justify="center")
 
@@ -323,6 +325,7 @@ class InteractivePrompt:
                         str(i + 1),
                         prompt["server"],
                         prompt["name"],
+                        prompt["title"],
                         prompt["description"],
                         str(prompt["arg_count"]),
                     )
@@ -378,7 +381,7 @@ class InteractivePrompt:
                     continue
 
                 # Extract prompts
-                prompts = []
+                prompts: List[Prompt] = []
                 if hasattr(prompts_info, "prompts"):
                     prompts = prompts_info.prompts
                 elif isinstance(prompts_info, list):
@@ -387,8 +390,9 @@ class InteractivePrompt:
                 # Process each prompt
                 for prompt in prompts:
                     # Get basic prompt info
-                    prompt_name = getattr(prompt, "name", "Unknown")
-                    prompt_description = getattr(prompt, "description", "No description")
+                    prompt_name = prompt.name
+                    prompt_title = prompt.title or None
+                    prompt_description = prompt.description or "No description"
 
                     # Extract argument information
                     arg_names = []
@@ -397,23 +401,19 @@ class InteractivePrompt:
                     arg_descriptions = {}
 
                     # Get arguments list
-                    arguments = getattr(prompt, "arguments", None)
-                    if arguments:
-                        for arg in arguments:
-                            name = getattr(arg, "name", None)
-                            if name:
-                                arg_names.append(name)
-
-                                # Store description if available
-                                description = getattr(arg, "description", None)
-                                if description:
-                                    arg_descriptions[name] = description
-
-                                # Check if required
-                                if getattr(arg, "required", False):
-                                    required_args.append(name)
-                                else:
-                                    optional_args.append(name)
+                    if prompt.arguments:
+                        for arg in prompt.arguments:
+                            arg_names.append(arg.name)
+
+                            # Store description if available
+                            if arg.description:
+                                arg_descriptions[arg.name] = arg.description
+
+                            # Check if required
+                            if arg.required:
+                                required_args.append(arg.name)
+                            else:
+                                optional_args.append(arg.name)
 
                     # Create namespaced version using the consistent separator
                     namespaced_name = f"{server_name}{SEP}{prompt_name}"
@@ -424,6 +424,7 @@ class InteractivePrompt:
                             "server": server_name,
                             "name": prompt_name,
                             "namespaced_name": namespaced_name,
+                            "title": prompt_title,
                             "description": prompt_description,
                             "arg_count": len(arg_names),
                             "arg_names": arg_names,
@@ -486,6 +487,7 @@ class InteractivePrompt:
                 table.add_column("#", justify="right", style="cyan")
                 table.add_column("Server", style="green")
                 table.add_column("Prompt Name", style="bright_blue")
+                table.add_column("Title")
                 table.add_column("Description")
                 table.add_column("Args", justify="center")
 
@@ -508,6 +510,7 @@ class InteractivePrompt:
                         str(i + 1),
                         prompt["server"],
                         prompt["name"],
+                        prompt["title"] or "No title",
                         prompt["description"] or "No description",
                         args_display,
                     )
@@ -669,6 +672,7 @@ class InteractivePrompt:
             table = Table(title="Available MCP Tools")
             table.add_column("#", justify="right", style="cyan")
             table.add_column("Tool Name", style="bright_blue")
+            table.add_column("Title")
             table.add_column("Description")
 
             # Add tools to table
@@ -676,16 +680,12 @@ class InteractivePrompt:
                 table.add_row(
                     str(i + 1),
                     tool.name,
-                    getattr(tool, "description", "No description") or "No description",
+                    tool.title or "No title",
+                    tool.description or "No description",
                 )
 
             console.print(table)
 
-            # Add usage instructions
-            rich_print("\n[bold]Usage:[/bold]")
-            rich_print("  • Tools are automatically available in your conversation")
-            rich_print("  • Just ask the agent to use a tool by name or description")
-
         except Exception as e:
             import traceback