fast-agent-mcp 0.2.35__py3-none-any.whl → 0.2.37__py3-none-any.whl

mcp_agent/core/enhanced_prompt.py

@@ -40,6 +40,59 @@ in_multiline_mode = False
 # Track whether help text has been shown globally
 help_message_shown = False
 
+# Track which agents have shown their info
+_agent_info_shown = set()
+
+
+async def _display_agent_info_helper(agent_name: str, agent_provider: object) -> None:
+    """Helper function to display agent information."""
+    # Only show once per agent
+    if agent_name in _agent_info_shown:
+        return
+
+    try:
+        # Get agent info
+        if hasattr(agent_provider, "_agent"):
+            # This is an AgentApp - get the specific agent
+            agent = agent_provider._agent(agent_name)
+        else:
+            # This is a single agent
+            agent = agent_provider
+
+        # Get counts
+        servers = await agent.list_servers()
+        server_count = len(servers) if servers else 0
+
+        tools_result = await agent.list_tools()
+        tool_count = (
+            len(tools_result.tools) if tools_result and hasattr(tools_result, "tools") 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]"
+            )
+        else:
+            # 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
+
 
 class AgentCompleter(Completer):
     """Provide completion for agent names and common commands."""
@@ -54,11 +107,11 @@ class AgentCompleter(Completer):
         self.agents = agents
         # Map commands to their descriptions for better completion hints
         self.commands = {
-            "help": "Show available commands",
-            "prompts": "List and select MCP prompts",  # Changed description
-            "prompt": "Apply a specific prompt by name (/prompt <name>)",  # New command
+            "tools": "List and call MCP tools",
+            "prompt": "List and select MCP prompts, or apply specific prompt (/prompt <name>)",
             "agents": "List available agents",
             "usage": "Show current usage statistics",
+            "help": "Show available commands",
             "clear": "Clear the screen",
             "STOP": "Stop this prompting session and move to next workflow step",
             "EXIT": "Exit fast-agent, terminating any running workflows",
@@ -66,8 +119,8 @@ class AgentCompleter(Completer):
         }
         if is_human_input:
             self.commands.pop("agents")
-            self.commands.pop("prompts")  # Remove prompts command in human input mode
             self.commands.pop("prompt", None)  # Remove prompt command in human input mode
+            self.commands.pop("tools", None)  # Remove tools command in human input mode
             self.commands.pop("usage", None)  # Remove usage command in human input mode
         self.agent_types = agent_types or {}
 
@@ -260,6 +313,7 @@ async def get_enhanced_input(
     agent_types: dict[str, AgentType] = None,
     is_human_input: bool = False,
     toolbar_color: str = "ansiblue",
+    agent_provider: object = None,
 ) -> str:
     """
     Enhanced input with advanced prompt_toolkit features.
@@ -274,6 +328,7 @@ async def get_enhanced_input(
         agent_types: Dictionary mapping agent names to their types for display
         is_human_input: Whether this is a human input request (disables agent selection features)
         toolbar_color: Color to use for the agent name in the toolbar (default: "ansiblue")
+        agent_provider: Optional agent provider for displaying agent info
 
     Returns:
         User input string
@@ -300,14 +355,15 @@ async def get_enhanced_input(
         if in_multiline_mode:
             mode_style = "ansired"  # More noticeable for multiline mode
             mode_text = "MULTILINE"
-            toggle_text = "Normal Editing"
+            toggle_text = "Normal"
         else:
             mode_style = "ansigreen"
             mode_text = "NORMAL"
-            toggle_text = "Multiline Editing"
+            toggle_text = "Multiline"
 
         shortcuts = [
             ("Ctrl+T", toggle_text),
+            ("Ctrl+E", "External"),
             ("Ctrl+L", "Clear"),
             ("↑/↓", "History"),
         ]
@@ -373,8 +429,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]"
+                "[dim]Type /help for commands, @agent to switch agent. Ctrl+T toggles multiline mode.[/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)
+
         rich_print()
         help_message_shown = True
 
@@ -394,12 +455,8 @@ async def get_enhanced_input(
                 return "LIST_AGENTS"
             elif cmd == "usage":
                 return "SHOW_USAGE"
-            elif cmd == "prompts":
-                # Return a dictionary with select_prompt action instead of a string
-                # This way it will match what the command handler expects
-                return {"select_prompt": True, "prompt_name": None}
             elif cmd == "prompt":
-                # Handle /prompt with no arguments the same way as /prompts
+                # Handle /prompt with no arguments as interactive mode
                 if len(cmd_parts) > 1:
                     # Direct prompt selection with name or number
                     prompt_arg = cmd_parts[1].strip()
@@ -409,8 +466,11 @@ async def get_enhanced_input(
                     else:
                         return f"SELECT_PROMPT:{prompt_arg}"
                 else:
-                    # If /prompt is used without arguments, treat it the same as /prompts
+                    # If /prompt is used without arguments, show interactive selection
                     return {"select_prompt": True, "prompt_name": None}
+            elif cmd == "tools":
+                # Return a dictionary with list_tools action
+                return {"list_tools": True}
             elif cmd == "exit":
                 return "EXIT"
             elif cmd.lower() == "stop":

mcp_agent/core/fastagent.py

@@ -81,7 +81,8 @@ class FastAgent:
         name: str,
         config_path: str | None = None,
         ignore_unknown_args: bool = False,
-        parse_cli_args: bool = True,  # Add new parameter with default True
+        parse_cli_args: bool = True,
+        quiet: bool = False,  # Add quiet parameter
     ) -> None:
         """
         Initialize the fast-agent application.
@@ -94,8 +95,10 @@ class FastAgent:
             parse_cli_args: If True, parse command line arguments using argparse.
                             Set to False when embedding FastAgent in another framework
                             (like FastAPI/Uvicorn) that handles its own arguments.
+            quiet: If True, disable progress display, tool and message logging for cleaner output
         """
         self.args = argparse.Namespace()  # Initialize args always
+        self._programmatic_quiet = quiet  # Store the programmatic quiet setting
 
         # --- Wrap argument parsing logic ---
         if parse_cli_args:
@@ -173,6 +176,10 @@ class FastAgent:
                 sys.exit(0)
         # --- End of wrapped logic ---
 
+        # Apply programmatic quiet setting (overrides CLI if both are set)
+        if self._programmatic_quiet:
+            self.args.quiet = True
+
         self.name = name
         self.config_path = config_path
 
@@ -180,12 +187,26 @@ class FastAgent:
             # Load configuration directly for this instance
             self._load_config()
 
+            # Apply programmatic quiet mode to config before creating app
+            if self._programmatic_quiet and hasattr(self, "config"):
+                if "logger" not in self.config:
+                    self.config["logger"] = {}
+                self.config["logger"]["progress_display"] = False
+                self.config["logger"]["show_chat"] = False
+                self.config["logger"]["show_tools"] = False
+
             # Create the app with our local settings
             self.app = MCPApp(
                 name=name,
                 settings=config.Settings(**self.config) if hasattr(self, "config") else None,
             )
 
+            # Stop progress display immediately if quiet mode is requested
+            if self._programmatic_quiet:
+                from mcp_agent.progress_display import progress_display
+
+                progress_display.stop()
+
         except yaml.parser.ParserError as e:
             handle_error(
                 e,
@@ -486,7 +507,7 @@ class FastAgent:
 
     async def start_server(
         self,
-        transport: str = "sse",
+        transport: str = "http",
         host: str = "0.0.0.0",
         port: int = 8000,
         server_name: Optional[str] = None,

mcp_agent/core/interactive_prompt.py

@@ -23,6 +23,7 @@ from rich.table import Table
 
 from mcp_agent.core.agent_types import AgentType
 from mcp_agent.core.enhanced_prompt import (
+    _display_agent_info_helper,
     get_argument_input,
     get_enhanced_input,
     get_selection_input,
@@ -121,6 +122,7 @@ class InteractivePrompt:
                     multiline=False,  # Default to single-line mode
                     available_agent_names=available_agents,
                     agent_types=self.agent_types,  # Pass agent types for display
+                    agent_provider=prompt_provider,  # Pass agent provider for info display
                 )
 
                 # Handle special commands - pass "True" to enable agent switching
@@ -132,6 +134,9 @@ class InteractivePrompt:
                         new_agent = command_result["switch_agent"]
                         if new_agent in available_agents_set:
                             agent = new_agent
+                            # Display new agent info immediately when switching
+                            rich_print()  # Add spacing
+                            await _display_agent_info_helper(agent, prompt_provider)
                             continue
                         else:
                             rich_print(f"[red]Agent '{new_agent}' not found[/red]")
@@ -174,6 +179,10 @@ class InteractivePrompt:
                             # Use the name-based selection
                             await self._select_prompt(prompt_provider, agent, prompt_name)
                         continue
+                    elif "list_tools" in command_result and prompt_provider:
+                        # Handle tools list display
+                        await self._list_tools(prompt_provider, agent)
+                        continue
                     elif "show_usage" in command_result:
                         # Handle usage display
                         await self._show_usage(prompt_provider, agent)
@@ -333,13 +342,17 @@ class InteractivePrompt:
             rich_print(f"[dim]{traceback.format_exc()}[/dim]")
 
     async def _select_prompt(
-        self, prompt_provider: PromptProvider, agent_name: str, requested_name: Optional[str] = None
+        self,
+        prompt_provider: PromptProvider,
+        agent_name: str,
+        requested_name: Optional[str] = None,
+        send_func: Optional[SendFunc] = None,
     ) -> None:
         """
         Select and apply a prompt.
 
         Args:
-            prompt_provider: Provider that implements list_prompts and apply_prompt
+            prompt_provider: Provider that implements list_prompts and get_prompt
             agent_name: Name of the agent
             requested_name: Optional name of the prompt to apply
         """
@@ -569,12 +582,54 @@ class InteractivePrompt:
                         if arg_value:
                             arg_values[arg_name] = arg_value
 
-            # Apply the prompt
+            # Apply the prompt using generate() for proper progress display
             namespaced_name = selected_prompt["namespaced_name"]
             rich_print(f"\n[bold]Applying prompt [cyan]{namespaced_name}[/cyan]...[/bold]")
 
-            # Call apply_prompt on the provider with the prompt name and arguments
-            await prompt_provider.apply_prompt(namespaced_name, arg_values, agent_name)
+            # Get the agent directly for generate() call
+            if hasattr(prompt_provider, "_agent"):
+                # This is an AgentApp - get the specific agent
+                agent = prompt_provider._agent(agent_name)
+            else:
+                # This is a single agent
+                agent = prompt_provider
+
+            try:
+                # Use agent.apply_prompt() which handles everything properly:
+                # - get_prompt() to fetch template
+                # - convert to multipart
+                # - call generate() for progress display
+                # - return response text
+                # Response display is handled by the agent's show_ methods, don't print it here
+
+                # Fetch the prompt first (without progress display)
+                prompt_result = await agent.get_prompt(namespaced_name, arg_values)
+
+                if not prompt_result or not prompt_result.messages:
+                    rich_print(
+                        f"[red]Prompt '{namespaced_name}' could not be found or contains no messages[/red]"
+                    )
+                    return
+
+                # Convert to multipart format
+                from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
+                multipart_messages = PromptMessageMultipart.from_get_prompt_result(prompt_result)
+
+                # Now start progress display for the actual generation
+                progress_display.resume()
+                try:
+                    await agent.generate(multipart_messages, None)
+                finally:
+                    # Pause again for the next UI interaction
+                    progress_display.pause()
+
+                # Show usage info after the turn (same as send_wrapper does)
+                if hasattr(prompt_provider, "_show_turn_usage"):
+                    prompt_provider._show_turn_usage(agent_name)
+
+            except Exception as e:
+                rich_print(f"[red]Error applying prompt: {e}[/red]")
 
         except Exception as e:
             import traceback
@@ -582,6 +637,61 @@ class InteractivePrompt:
             rich_print(f"[red]Error selecting or applying prompt: {e}[/red]")
             rich_print(f"[dim]{traceback.format_exc()}[/dim]")
 
+    async def _list_tools(self, prompt_provider: PromptProvider, agent_name: str) -> None:
+        """
+        List available tools for an agent.
+
+        Args:
+            prompt_provider: Provider that implements list_tools
+            agent_name: Name of the agent
+        """
+        console = Console()
+
+        try:
+            # Get agent to list tools from
+            if hasattr(prompt_provider, "_agent"):
+                # This is an AgentApp - get the specific agent
+                agent = prompt_provider._agent(agent_name)
+            else:
+                # This is a single agent
+                agent = prompt_provider
+
+            rich_print(f"\n[bold]Fetching tools for agent [cyan]{agent_name}[/cyan]...[/bold]")
+
+            # Get tools using list_tools
+            tools_result = await agent.list_tools()
+
+            if not tools_result or not hasattr(tools_result, "tools") or not tools_result.tools:
+                rich_print("[yellow]No tools available for this agent[/yellow]")
+                return
+
+            # Create a table for better display
+            table = Table(title="Available MCP Tools")
+            table.add_column("#", justify="right", style="cyan")
+            table.add_column("Tool Name", style="bright_blue")
+            table.add_column("Description")
+
+            # Add tools to table
+            for i, tool in enumerate(tools_result.tools):
+                table.add_row(
+                    str(i + 1),
+                    tool.name,
+                    getattr(tool, "description", "No 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
+
+            rich_print(f"[red]Error listing tools: {e}[/red]")
+            rich_print(f"[dim]{traceback.format_exc()}[/dim]")
+
     async def _show_usage(self, prompt_provider: PromptProvider, agent_name: str) -> None:
         """
         Show usage statistics for the current agent(s) in a colorful table format.
@@ -593,13 +703,13 @@ class InteractivePrompt:
         try:
             # Collect all agents from the prompt provider
             agents_to_show = collect_agents_from_provider(prompt_provider, agent_name)
-            
+
             if not agents_to_show:
                 rich_print("[yellow]No usage data available[/yellow]")
                 return
-                
+
             # Use the shared display utility
             display_usage_report(agents_to_show, show_if_progress_disabled=True)
-            
+
         except Exception as e:
             rich_print(f"[red]Error showing usage: {e}[/red]")