fast-agent-mcp 0.2.58__py3-none-any.whl → 0.3.0__py3-none-any.whl

{mcp_agent/core → fast_agent/ui}/interactive_prompt.py

@@ -18,24 +18,24 @@ from typing import Awaitable, Callable, Dict, List, Mapping, Optional, Protocol,
 
 from mcp.types import Prompt, PromptMessage
 from rich import print as rich_print
-from rich.console import Console
-from rich.table import Table
 
-from mcp_agent.core.agent_types import AgentType
-from mcp_agent.core.enhanced_prompt import (
+from fast_agent.agents.agent_types import AgentType
+from fast_agent.history.history_exporter import HistoryExporter
+from fast_agent.interfaces import AgentProtocol
+from fast_agent.mcp.mcp_aggregator import SEP
+from fast_agent.types import PromptMessageExtended
+from fast_agent.ui.enhanced_prompt import (
     _display_agent_info_helper,
     get_argument_input,
     get_enhanced_input,
     get_selection_input,
     handle_special_commands,
 )
-from mcp_agent.core.usage_display import collect_agents_from_provider, display_usage_report
-from mcp_agent.mcp.mcp_aggregator import SEP
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-from mcp_agent.progress_display import progress_display
+from fast_agent.ui.progress_display import progress_display
+from fast_agent.ui.usage_display import collect_agents_from_provider, display_usage_report
 
 # Type alias for the send function
-SendFunc = Callable[[Union[str, PromptMessage, PromptMessageMultipart], str], Awaitable[str]]
+SendFunc = Callable[[Union[str, PromptMessage, PromptMessageExtended], str], Awaitable[str]]
 
 # Type alias for the agent getter function
 AgentGetter = Callable[[str], Optional[object]]
@@ -45,7 +45,7 @@ class PromptProvider(Protocol):
     """Protocol for objects that can provide prompt functionality."""
 
     async def list_prompts(
-        self, server_name: Optional[str] = None, agent_name: Optional[str] = None
+        self, namespace: Optional[str] = None, agent_name: Optional[str] = None
     ) -> Mapping[str, List[Prompt]]:
         """List available prompts."""
         ...
@@ -62,6 +62,14 @@ class PromptProvider(Protocol):
         """Apply a prompt."""
         ...
 
+    def _agent(self, agent_name: str) -> AgentProtocol:
+        """Return the concrete agent by name (AgentApp provides this)."""
+        ...
+
+    def _show_turn_usage(self, agent_name: str) -> None:
+        """Display usage for a given agent after a turn."""
+        ...
+
 
 class InteractivePrompt:
     """
@@ -83,7 +91,7 @@ class InteractivePrompt:
         send_func: SendFunc,
         default_agent: str,
         available_agents: List[str],
-        prompt_provider: Optional[PromptProvider] = None,
+        prompt_provider: PromptProvider,
         default: str = "",
     ) -> str:
         """
@@ -144,11 +152,11 @@ class InteractivePrompt:
                             rich_print(f"[red]Agent '{new_agent}' not found[/red]")
                             continue
                     # Keep the existing list_prompts handler for backward compatibility
-                    elif "list_prompts" in command_result and prompt_provider:
+                    elif "list_prompts" in command_result:
                         # Use the prompt_provider directly
                         await self._list_prompts(prompt_provider, agent)
                         continue
-                    elif "select_prompt" in command_result and prompt_provider:
+                    elif "select_prompt" in command_result:
                         # Handle prompt selection, using both list_prompts and apply_prompt
                         prompt_name = command_result.get("prompt_name")
                         prompt_index = command_result.get("prompt_index")
@@ -181,7 +189,7 @@ 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:
+                    elif "list_tools" in command_result:
                         # Handle tools list display
                         await self._list_tools(prompt_provider, agent)
                         continue
@@ -193,6 +201,22 @@ class InteractivePrompt:
                         # Handle markdown display
                         await self._show_markdown(prompt_provider, agent)
                         continue
+                    elif "save_history" in command_result:
+                        # Save history for the current agent
+                        filename = command_result.get("filename")
+                        try:
+                            agent_obj = prompt_provider._agent(agent)
+
+                            # Prefer type-safe exporter over magic string
+                            saved_path = await HistoryExporter.save(agent_obj, filename)
+                            rich_print(f"[green]History saved to {saved_path}[/green]")
+                        except Exception:
+                            # Fallback to magic string path for maximum compatibility
+                            control = "***SAVE_HISTORY" + (f" {filename}" if filename else "")
+                            result = await send_func(control, agent)
+                            if result:
+                                rich_print(f"[green]{result}[/green]")
+                        continue
 
                 # Skip further processing if:
                 # 1. The command was handled (command_result is truthy)
@@ -216,6 +240,51 @@ class InteractivePrompt:
 
         return result
 
+    def _create_combined_separator_status(
+        self, left_content: str, right_info: str, console
+    ) -> None:
+        """
+        Create a combined separator and status line using the new visual style.
+
+        Args:
+            left_content: The main content (block, arrow, name) - left justified with color
+            right_info: Supplementary information to show in brackets - right aligned
+            console: Rich console instance to use
+        """
+        from rich.text import Text
+
+        width = console.size.width
+
+        # Create left text
+        left_text = Text.from_markup(left_content)
+
+        # Create right text if we have info
+        if right_info and right_info.strip():
+            # Add dim brackets around the right info
+            right_text = Text()
+            right_text.append("[", style="dim")
+            right_text.append_text(Text.from_markup(right_info))
+            right_text.append("]", style="dim")
+            # Calculate separator count
+            separator_count = width - left_text.cell_len - right_text.cell_len
+            if separator_count < 1:
+                separator_count = 1  # Always at least 1 separator
+        else:
+            right_text = Text("")
+            separator_count = width - left_text.cell_len
+
+        # Build the combined line
+        combined = Text()
+        combined.append_text(left_text)
+        combined.append(" ", style="default")
+        combined.append("─" * (separator_count - 1), style="dim")
+        combined.append_text(right_text)
+
+        # Print with empty line before
+        rich_print()
+        console.print(combined)
+        rich_print()
+
     async def _get_all_prompts(
         self, prompt_provider: PromptProvider, agent_name: Optional[str] = None
     ):
@@ -232,7 +301,7 @@ class InteractivePrompt:
         try:
             # Call list_prompts on the provider
             prompt_servers = await prompt_provider.list_prompts(
-                server_name=None, agent_name=agent_name
+                namespace=None, agent_name=agent_name
             )
 
             all_prompts = []
@@ -305,44 +374,94 @@ class InteractivePrompt:
             prompt_provider: Provider that implements list_prompts
             agent_name: Name of the agent
         """
-        console = Console()
-
         try:
-            # Directly call the list_prompts function for this agent
-            rich_print(f"\n[bold]Fetching prompts for agent [cyan]{agent_name}[/cyan]...[/bold]")
-
             # Get all prompts using the helper function
             all_prompts = await self._get_all_prompts(prompt_provider, agent_name)
 
-            if all_prompts:
-                # Create a table for better display
-                table = Table(title="Available MCP Prompts")
-                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")
-
-                # Add prompts to table
-                for i, prompt in enumerate(all_prompts):
-                    table.add_row(
-                        str(i + 1),
-                        prompt["server"],
-                        prompt["name"],
-                        prompt["title"],
-                        prompt["description"],
-                        str(prompt["arg_count"]),
-                    )
+            rich_print(f"\n[bold]Prompts for agent [cyan]{agent_name}[/cyan]:[/bold]")
 
-                console.print(table)
+            if not all_prompts:
+                rich_print("[yellow]No prompts available for this agent[/yellow]")
+                return
+
+            rich_print()
+
+            # Display prompts using clean compact format
+            for i, prompt in enumerate(all_prompts, 1):
+                # Main line: [ 1] server•prompt_name Title
+                from rich.text import Text
+
+                prompt_line = Text()
+                prompt_line.append(f"[{i:2}] ", style="dim cyan")
+                prompt_line.append(f"{prompt['server']}•", style="dim green")
+                prompt_line.append(prompt["name"], style="bright_blue bold")
+
+                # Add title if available
+                if prompt["title"] and prompt["title"].strip():
+                    prompt_line.append(f" {prompt['title']}", style="default")
+
+                rich_print(prompt_line)
+
+                # Description lines - show 2-3 rows if needed
+                if prompt["description"] and prompt["description"].strip():
+                    description = prompt["description"].strip()
+                    # Calculate rough character limit for 2-3 lines (assuming ~80 chars per line with indent)
+                    char_limit = 240  # About 3 lines worth
+
+                    if len(description) > char_limit:
+                        # Find a good break point near the limit (prefer sentence/word boundaries)
+                        truncate_pos = char_limit
+                        # Look back for sentence end
+                        sentence_break = description.rfind(". ", 0, char_limit + 20)
+                        if sentence_break > char_limit - 50:  # If we found a nearby sentence break
+                            truncate_pos = sentence_break + 1
+                        else:
+                            # Look for word boundary
+                            word_break = description.rfind(" ", 0, char_limit + 10)
+                            if word_break > char_limit - 30:  # If we found a nearby word break
+                                truncate_pos = word_break
+
+                        description = description[:truncate_pos].rstrip() + "..."
+
+                    # Split into lines and wrap
+                    import textwrap
+
+                    wrapped_lines = textwrap.wrap(description, width=72, subsequent_indent="     ")
+                    for line in wrapped_lines:
+                        if line.startswith("     "):  # Already indented continuation line
+                            rich_print(f"     [white]{line[5:]}[/white]")
+                        else:  # First line needs indent
+                            rich_print(f"     [white]{line}[/white]")
+
+                # Arguments line - show argument names if available
+                if prompt["arg_count"] > 0:
+                    arg_names = prompt.get("arg_names", [])
+                    required_args = prompt.get("required_args", [])
+
+                    if arg_names:
+                        arg_list = []
+                        for arg_name in arg_names:
+                            if arg_name in required_args:
+                                arg_list.append(f"{arg_name}*")
+                            else:
+                                arg_list.append(arg_name)
+
+                        args_text = ", ".join(arg_list)
+                        if len(args_text) > 80:
+                            args_text = args_text[:77] + "..."
+                        rich_print(f"     [dim magenta]args: {args_text}[/dim magenta]")
+                    else:
+                        rich_print(
+                            f"     [dim magenta]args: {prompt['arg_count']} parameter{'s' if prompt['arg_count'] != 1 else ''}[/dim magenta]"
+                        )
+
+                rich_print()  # Space between prompts
+
+            # Add usage instructions
+            rich_print(
+                "[dim]Usage: /prompt <number> to select by number, or /prompts for interactive selection[/dim]"
+            )
 
-                # Add usage instructions
-                rich_print("\n[bold]Usage:[/bold]")
-                rich_print("  • Use [cyan]/prompt <number>[/cyan] to select a prompt by number")
-                rich_print("  • Or use [cyan]/prompts[/cyan] to open the prompt selection UI")
-            else:
-                rich_print("[yellow]No prompts available[/yellow]")
         except Exception as e:
             import traceback
 
@@ -364,15 +483,13 @@ class InteractivePrompt:
             agent_name: Name of the agent
             requested_name: Optional name of the prompt to apply
         """
-        console = Console()
-
         try:
             # Get all available prompts directly from the prompt provider
             rich_print(f"\n[bold]Fetching prompts for agent [cyan]{agent_name}[/cyan]...[/bold]")
 
             # Call list_prompts on the provider
             prompt_servers = await prompt_provider.list_prompts(
-                server_name=None, agent_name=agent_name
+                namespace=None, agent_name=agent_name
             )
 
             if not prompt_servers:
@@ -487,40 +604,85 @@ class InteractivePrompt:
                         rich_print("[red]Invalid input, please enter a number[/red]")
                         return
             else:
-                # Show prompt selection UI
-                table = Table(title="Available MCP Prompts")
-                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")
-
-                # Add prompts to table
-                for i, prompt in enumerate(all_prompts):
-                    required_args = prompt["required_args"]
-                    optional_args = prompt["optional_args"]
-
-                    # Format args column
-                    if required_args and optional_args:
-                        args_display = f"[bold]{len(required_args)}[/bold]+{len(optional_args)}"
-                    elif required_args:
-                        args_display = f"[bold]{len(required_args)}[/bold]"
-                    elif optional_args:
-                        args_display = f"{len(optional_args)} opt"
-                    else:
-                        args_display = "0"
-
-                    table.add_row(
-                        str(i + 1),
-                        prompt["server"],
-                        prompt["name"],
-                        prompt["title"] or "No title",
-                        prompt["description"] or "No description",
-                        args_display,
-                    )
+                # Show prompt selection UI using clean compact format
+                rich_print(f"\n[bold]Select a prompt for agent [cyan]{agent_name}[/cyan]:[/bold]")
+                rich_print()
+
+                # Display prompts using the same format as _list_prompts
+                for i, prompt in enumerate(all_prompts, 1):
+                    # Main line: [ 1] server•prompt_name Title
+                    from rich.text import Text
+
+                    prompt_line = Text()
+                    prompt_line.append(f"[{i:2}] ", style="dim cyan")
+                    prompt_line.append(f"{prompt['server']}•", style="dim green")
+                    prompt_line.append(prompt["name"], style="bright_blue bold")
+
+                    # Add title if available
+                    if prompt["title"] and prompt["title"].strip():
+                        prompt_line.append(f" {prompt['title']}", style="default")
+
+                    rich_print(prompt_line)
+
+                    # Description lines - show 2-3 rows if needed
+                    if prompt["description"] and prompt["description"].strip():
+                        description = prompt["description"].strip()
+                        # Calculate rough character limit for 2-3 lines (assuming ~80 chars per line with indent)
+                        char_limit = 240  # About 3 lines worth
+
+                        if len(description) > char_limit:
+                            # Find a good break point near the limit (prefer sentence/word boundaries)
+                            truncate_pos = char_limit
+                            # Look back for sentence end
+                            sentence_break = description.rfind(". ", 0, char_limit + 20)
+                            if (
+                                sentence_break > char_limit - 50
+                            ):  # If we found a nearby sentence break
+                                truncate_pos = sentence_break + 1
+                            else:
+                                # Look for word boundary
+                                word_break = description.rfind(" ", 0, char_limit + 10)
+                                if word_break > char_limit - 30:  # If we found a nearby word break
+                                    truncate_pos = word_break
+
+                            description = description[:truncate_pos].rstrip() + "..."
+
+                        # Split into lines and wrap
+                        import textwrap
+
+                        wrapped_lines = textwrap.wrap(
+                            description, width=72, subsequent_indent="     "
+                        )
+                        for line in wrapped_lines:
+                            if line.startswith("     "):  # Already indented continuation line
+                                rich_print(f"     [white]{line[5:]}[/white]")
+                            else:  # First line needs indent
+                                rich_print(f"     [white]{line}[/white]")
+
+                    # Arguments line - show argument names if available
+                    if prompt["arg_count"] > 0:
+                        arg_names = prompt.get("arg_names", [])
+                        required_args = prompt.get("required_args", [])
+
+                        if arg_names:
+                            arg_list = []
+                            for arg_name in arg_names:
+                                if arg_name in required_args:
+                                    arg_list.append(f"{arg_name}*")
+                                else:
+                                    arg_list.append(arg_name)
+
+                            args_text = ", ".join(arg_list)
+                            if len(args_text) > 80:
+                                args_text = args_text[:77] + "..."
+                            rich_print(f"     [dim magenta]args: {args_text}[/dim magenta]")
+                        else:
+                            rich_print(
+                                f"     [dim magenta]args: {prompt['arg_count']} parameter{'s' if prompt['arg_count'] != 1 else ''}[/dim magenta]"
+                            )
+
+                    rich_print()  # Space between prompts
 
-                console.print(table)
                 prompt_names = [str(i + 1) for i in range(len(all_prompts))]
 
                 # Get user selection
@@ -595,12 +757,10 @@ class InteractivePrompt:
             rich_print(f"\n[bold]Applying prompt [cyan]{namespaced_name}[/cyan]...[/bold]")
 
             # 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
+            assert hasattr(prompt_provider, "_agent"), (
+                "Interactive prompt expects an AgentApp with _agent()"
+            )
+            agent = prompt_provider._agent(agent_name)
 
             try:
                 # Use agent.apply_prompt() which handles everything properly:
@@ -620,9 +780,9 @@ class InteractivePrompt:
                     return
 
                 # Convert to multipart format
-                from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+                from fast_agent.types import PromptMessageExtended
 
-                multipart_messages = PromptMessageMultipart.from_get_prompt_result(prompt_result)
+                multipart_messages = PromptMessageExtended.from_get_prompt_result(prompt_result)
 
                 # Now start progress display for the actual generation
                 progress_display.resume()
@@ -633,8 +793,7 @@ class InteractivePrompt:
                     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)
+                prompt_provider._show_turn_usage(agent_name)
 
             except Exception as e:
                 rich_print(f"[red]Error applying prompt: {e}[/red]")
@@ -653,18 +812,14 @@ class InteractivePrompt:
             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
+            assert hasattr(prompt_provider, "_agent"), (
+                "Interactive prompt expects an AgentApp with _agent()"
+            )
+            agent = prompt_provider._agent(agent_name)
 
-            rich_print(f"\n[bold]Fetching tools for agent [cyan]{agent_name}[/cyan]...[/bold]")
+            rich_print(f"\n[bold]Tools for agent [cyan]{agent_name}[/cyan]:[/bold]")
 
             # Get tools using list_tools
             tools_result = await agent.list_tools()
@@ -673,23 +828,75 @@ class InteractivePrompt:
                 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("Title")
-            table.add_column("Description")
-
-            # Add tools to table
-            for i, tool in enumerate(tools_result.tools):
-                table.add_row(
-                    str(i + 1),
-                    tool.name,
-                    tool.title or "No title",
-                    tool.description or "No description",
-                )
+            rich_print()
 
-            console.print(table)
+            # Display tools using clean compact format
+            for i, tool in enumerate(tools_result.tools, 1):
+                # Main line: [ 1] tool_name Title
+                from rich.text import Text
+
+                tool_line = Text()
+                tool_line.append(f"[{i:2}] ", style="dim cyan")
+                tool_line.append(tool.name, style="bright_blue bold")
+
+                # Add title if available
+                if tool.title and tool.title.strip():
+                    tool_line.append(f" {tool.title}", style="default")
+
+                rich_print(tool_line)
+
+                # Description lines - show 2-3 rows if needed
+                if tool.description and tool.description.strip():
+                    description = tool.description.strip()
+                    # Calculate rough character limit for 2-3 lines (assuming ~80 chars per line with indent)
+                    char_limit = 240  # About 3 lines worth
+
+                    if len(description) > char_limit:
+                        # Find a good break point near the limit (prefer sentence/word boundaries)
+                        truncate_pos = char_limit
+                        # Look back for sentence end
+                        sentence_break = description.rfind(". ", 0, char_limit + 20)
+                        if sentence_break > char_limit - 50:  # If we found a nearby sentence break
+                            truncate_pos = sentence_break + 1
+                        else:
+                            # Look for word boundary
+                            word_break = description.rfind(" ", 0, char_limit + 10)
+                            if word_break > char_limit - 30:  # If we found a nearby word break
+                                truncate_pos = word_break
+
+                        description = description[:truncate_pos].rstrip() + "..."
+
+                    # Split into lines and wrap
+                    import textwrap
+
+                    wrapped_lines = textwrap.wrap(description, width=72, subsequent_indent="     ")
+                    for line in wrapped_lines:
+                        if line.startswith("     "):  # Already indented continuation line
+                            rich_print(f"     [white]{line[5:]}[/white]")
+                        else:  # First line needs indent
+                            rich_print(f"     [white]{line}[/white]")
+
+                # Arguments line - show schema info if available
+                if hasattr(tool, "inputSchema") and tool.inputSchema:
+                    schema = tool.inputSchema
+                    if "properties" in schema:
+                        properties = schema["properties"]
+                        required = schema.get("required", [])
+
+                        arg_list = []
+                        for prop_name, prop_info in properties.items():
+                            if prop_name in required:
+                                arg_list.append(f"{prop_name}*")
+                            else:
+                                arg_list.append(prop_name)
+
+                        if arg_list:
+                            args_text = ", ".join(arg_list)
+                            if len(args_text) > 80:
+                                args_text = args_text[:77] + "..."
+                            rich_print(f"     [dim magenta]args: {args_text}[/dim magenta]")
+
+                rich_print()  # Space between tools
 
         except Exception as e:
             import traceback
@@ -729,12 +936,10 @@ class InteractivePrompt:
         """
         try:
             # Get agent to display 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
+            assert hasattr(prompt_provider, "_agent"), (
+                "Interactive prompt expects an AgentApp with _agent()"
+            )
+            agent = prompt_provider._agent(agent_name)
 
             # Check if agent has message history
             if not hasattr(agent, "_llm") or not agent._llm:
@@ -764,7 +969,7 @@ class InteractivePrompt:
             rich_print("\n[bold blue]Last Assistant Response (Plain Text):[/bold blue]")
             rich_print("─" * 60)
             # Use console.print with markup=False to display raw text
-            from mcp_agent import console
+            from fast_agent.ui import console
 
             console.console.print(content, markup=False)
             rich_print("─" * 60)