fast-agent-mcp 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

mcp_agent/core/enhanced_prompt.py

@@ -0,0 +1,358 @@
+"""
+Enhanced prompt functionality with advanced prompt_toolkit features.
+"""
+
+from typing import List
+from prompt_toolkit import PromptSession
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.lexers import PygmentsLexer
+from prompt_toolkit.filters import Condition
+from pygments.lexers.python import PythonLexer
+from rich import print as rich_print
+
+from mcp_agent.core.exceptions import PromptExitError
+
+# Map of agent names to their history
+agent_histories = {}
+
+# Store available agents for auto-completion
+available_agents = set()
+
+# Keep track of multi-line mode state
+in_multiline_mode = False
+
+# Track which agents have already shown welcome messages
+agent_messages_shown = set()
+
+
+class AgentCompleter(Completer):
+    """Provide completion for agent names and common commands."""
+
+    def __init__(
+        self,
+        agents: List[str],
+        commands: List[str] = None,
+        agent_types: dict = None,
+        is_human_input: bool = False,
+    ):
+        self.agents = agents
+        # Map commands to their descriptions for better completion hints
+        self.commands = {
+            "help": "Show available commands",
+            "clear": "Clear the screen",
+            "agents": "List available agents",
+            "STOP": "Stop this prompting session and move to next workflow step",
+            "EXIT": "Exit FastAgent, terminating any running workflows",
+            **(commands or {}),  # Allow custom commands to be passed in
+        }
+        if is_human_input:
+            self.commands.pop("agents")
+        self.agent_types = agent_types or {}
+
+    def get_completions(self, document, complete_event):
+        """Synchronous completions method - this is what prompt_toolkit expects by default"""
+        text = document.text_before_cursor.lower()
+
+        # Complete commands
+        if text.startswith("/"):
+            cmd = text[1:]
+            for command, description in self.commands.items():
+                if command.lower().startswith(cmd):
+                    yield Completion(
+                        command,
+                        start_position=-len(cmd),
+                        display=command,
+                        display_meta=description,
+                    )
+
+        # Complete agent names for agent-related commands
+        elif text.startswith("@"):
+            agent_name = text[1:]
+            for agent in self.agents:
+                if agent.lower().startswith(agent_name.lower()):
+                    # Get agent type or default to "Agent"
+                    agent_type = self.agent_types.get(agent, "Agent")
+                    yield Completion(
+                        agent,
+                        start_position=-len(agent_name),
+                        display=agent,
+                        display_meta=agent_type,
+                        style="bg:ansiblack fg:ansiblue",
+                    )
+
+
+def create_keybindings(on_toggle_multiline=None, app=None):
+    """Create custom key bindings."""
+    kb = KeyBindings()
+
+    @kb.add("c-m", filter=Condition(lambda: not in_multiline_mode))
+    def _(event):
+        """Enter: accept input when not in multiline mode."""
+        event.current_buffer.validate_and_handle()
+
+    @kb.add("c-m", filter=Condition(lambda: in_multiline_mode))
+    def _(event):
+        """Enter: insert newline when in multiline mode."""
+        event.current_buffer.insert_text("\n")
+
+    # Use c-j (Ctrl+J) as an alternative to represent Ctrl+Enter in multiline mode
+    @kb.add("c-j", filter=Condition(lambda: in_multiline_mode))
+    def _(event):
+        """Ctrl+J (equivalent to Ctrl+Enter): Submit in multiline mode."""
+        event.current_buffer.validate_and_handle()
+
+    @kb.add("c-t")
+    def _(event):
+        """Ctrl+T: Toggle multiline mode."""
+        global in_multiline_mode
+        in_multiline_mode = not in_multiline_mode
+
+        # Force redraw the app to update toolbar
+        if event.app:
+            event.app.invalidate()
+        elif app:
+            app.invalidate()
+
+        # Call the toggle callback if provided
+        if on_toggle_multiline:
+            on_toggle_multiline(in_multiline_mode)
+
+        # Instead of printing, we'll just update the toolbar
+        # The toolbar will show the current mode
+
+    @kb.add("c-l")
+    def _(event):
+        """Ctrl+L: Clear the input buffer."""
+        event.current_buffer.text = ""
+
+    return kb
+
+
+async def get_enhanced_input(
+    agent_name: str,
+    default: str = "",
+    show_default: bool = False,
+    show_stop_hint: bool = False,
+    multiline: bool = False,
+    available_agent_names: List[str] = None,
+    syntax: str = None,
+    agent_types: dict = None,
+    is_human_input: bool = False,
+    toolbar_color: str = "ansiblue",
+) -> str:
+    """
+    Enhanced input with advanced prompt_toolkit features.
+
+    Args:
+        agent_name: Name of the agent (used for prompt and history)
+        default: Default value if user presses enter
+        show_default: Whether to show the default value in the prompt
+        show_stop_hint: Whether to show the STOP hint
+        multiline: Start in multiline mode
+        available_agent_names: List of agent names for auto-completion
+        syntax: Syntax highlighting (e.g., 'python', 'sql')
+        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")
+
+    Returns:
+        User input string
+    """
+    global in_multiline_mode, available_agents
+
+    # Update global state
+    in_multiline_mode = multiline
+    if available_agent_names:
+        available_agents = set(available_agent_names)
+
+    # Get or create history object for this agent
+    if agent_name not in agent_histories:
+        agent_histories[agent_name] = InMemoryHistory()
+
+    # Define callback for multiline toggle
+    def on_multiline_toggle(enabled):
+        nonlocal session
+        if hasattr(session, "app") and session.app:
+            session.app.invalidate()
+
+    # Define toolbar function that will update dynamically
+    def get_toolbar():
+        if in_multiline_mode:
+            mode_style = "ansired"  # More noticeable for multiline mode
+            mode_text = "MULTILINE"
+            toggle_text = "Normal Editing"
+        else:
+            mode_style = "ansigreen"
+            mode_text = "NORMAL"
+            toggle_text = "Multiline Editing"
+
+        shortcuts = [
+            ("Ctrl+T", toggle_text),
+            ("Ctrl+L", "Clear"),
+            ("↑/↓", "History"),
+        ]
+
+        newline = (
+            "Ctrl+<Enter>:Submit" if in_multiline_mode else "<Enter>:Submit"
+        )
+
+        # Only show relevant shortcuts based on mode
+        shortcuts = [(k, v) for k, v in shortcuts if v]
+
+        shortcut_text = " | ".join(f"{key}:{action}" for key, action in shortcuts)
+        return HTML(
+            f" <{toolbar_color}> {agent_name} </{toolbar_color}> | <b>Mode:</b> <{mode_style}> {mode_text} </{mode_style}> {newline} | {shortcut_text}"
+        )
+
+    # Create session with history and completions
+    session = PromptSession(
+        history=agent_histories[agent_name],
+        completer=AgentCompleter(
+            agents=list(available_agents) if available_agents else [],
+            agent_types=agent_types or {},
+            is_human_input=is_human_input,
+        ),
+        complete_while_typing=True,
+        lexer=PygmentsLexer(PythonLexer) if syntax == "python" else None,
+        multiline=Condition(lambda: in_multiline_mode),
+        complete_in_thread=True,
+        mouse_support=False,
+        bottom_toolbar=get_toolbar,  # Pass the function here
+    )
+
+    # Create key bindings with a reference to the app
+    bindings = create_keybindings(
+        on_toggle_multiline=on_multiline_toggle, app=session.app
+    )
+    session.app.key_bindings = bindings
+
+    # Create formatted prompt text
+    prompt_text = f"<ansicyan>{agent_name}</ansicyan> > "
+
+    # Add default value display if requested
+    if show_default and default and default != "STOP":
+        prompt_text = f"{prompt_text} [<ansigreen>{default}</ansigreen>] "
+
+    # Only show hints at startup if requested
+    if show_stop_hint:
+        if default == "STOP":
+            rich_print("[yellow]Press <ENTER> to finish.[/yellow]")
+        else:
+            rich_print("Enter a prompt, or [red]STOP[/red] to finish")
+            if default:
+                rich_print(
+                    f"Press <ENTER> to use the default prompt:\n[cyan]{default}[/cyan]"
+                )
+
+    # Mention available features but only on first usage for this agent
+    if agent_name not in agent_messages_shown:
+        if is_human_input:
+            rich_print(
+                "[dim]Tip: Type /help for commands. Ctrl+T toggles multiline mode. Ctrl+Enter to submit in multiline mode.[/dim]"
+            )
+        else:
+            rich_print(
+                "[dim]Tip: Type /help for commands, @Agent to switch agent. Ctrl+T toggles multiline mode. [/dim]"
+            )
+        agent_messages_shown.add(agent_name)
+
+    # Process special commands
+    def pre_process_input(text):
+        # Command processing
+        if text and text.startswith("/"):
+            cmd = text[1:].strip().lower()
+            if cmd == "help":
+                return "HELP"
+            elif cmd == "clear":
+                return "CLEAR"
+            elif cmd == "agents":
+                return "LIST_AGENTS"
+            elif cmd == "exit":
+                return "EXIT"
+            elif cmd == "stop":
+                return "STOP"
+
+        # Agent switching
+        if text and text.startswith("@"):
+            return f"SWITCH:{text[1:].strip()}"
+
+        return text
+
+    # Get the input - using async version
+    try:
+        result = await session.prompt_async(HTML(prompt_text), default=default)
+        return pre_process_input(result)
+    except KeyboardInterrupt:
+        # Handle Ctrl+C gracefully
+        return "STOP"
+    except EOFError:
+        # Handle Ctrl+D gracefully
+        return "STOP"
+    except Exception as e:
+        # Log and gracefully handle other exceptions
+        print(f"\nInput error: {type(e).__name__}: {e}")
+        return "STOP"
+
+
+async def handle_special_commands(command, agent_app=None):
+    """Handle special input commands."""
+    # Quick guard for empty or None commands
+    if not command:
+        return False
+
+    # Check for special commands
+    if command == "HELP":
+        rich_print("\n[bold]Available Commands:[/bold]")
+        rich_print("  /help          - Show this help")
+        rich_print("  /clear         - Clear screen")
+        rich_print("  /agents        - List available agents")
+        rich_print("  @agent_name    - Switch to agent")
+        rich_print("  STOP           - Return control back to the workflow")
+        rich_print(
+            "  EXIT           - Exit FastAgent, terminating any running workflows"
+        )
+        rich_print("\n[bold]Keyboard Shortcuts:[/bold]")
+        rich_print(
+            "  Enter          - Submit (normal mode) / New line (multiline mode)"
+        )
+        rich_print("  Ctrl+Enter      - Always submit (even in multiline mode)")
+        rich_print("  Ctrl+T         - Toggle multiline mode")
+        rich_print("  Ctrl+L         - Clear input")
+        rich_print("  Up/Down        - Navigate history")
+        return True
+
+    elif command == "CLEAR":
+        # Clear screen (ANSI escape sequence)
+        print("\033c", end="")
+        return True
+
+    elif command == "EXIT":
+        raise PromptExitError("User requested to exit FastAgent session")
+
+    elif command == "LIST_AGENTS":
+        if available_agents:
+            rich_print("\n[bold]Available Agents:[/bold]")
+            for agent in sorted(available_agents):
+                rich_print(f"  @{agent}")
+        else:
+            rich_print("[yellow]No agents available[/yellow]")
+        return True
+
+    elif isinstance(command, str) and command.startswith("SWITCH:"):
+        agent_name = command.split(":", 1)[1]
+        if agent_name in available_agents:
+            if agent_app:
+                rich_print(f"[green]Switching to agent: {agent_name}[/green]")
+                return {"switch_agent": agent_name}
+            else:
+                rich_print(
+                    "[yellow]Agent switching not available in this context[/yellow]"
+                )
+        else:
+            rich_print(f"[red]Unknown agent: {agent_name}[/red]")
+        return True
+
+    return False

mcp_agent/core/exceptions.py

@@ -45,3 +45,20 @@ class ServerInitializationError(FastAgentError):
 
     def __init__(self, message: str, details: str = ""):
         super().__init__(message, details)
+
+
+class ModelConfigError(FastAgentError):
+    """Raised when there are issues with LLM model configuration
+    Example: Unknown model name in model specification string
+    """
+
+    def __init__(self, message: str, details: str = ""):
+        super().__init__(message, details)
+
+
+class PromptExitError(FastAgentError):
+    """Raised from enhanced_prompt when the user requests hard exits"""
+
+    # TODO an exception for flow control :(
+    def __init__(self, message: str, details: str = ""):
+        super().__init__(message, details)

mcp_agent/core/fastagent.py

@@ -3,7 +3,17 @@ Decorator-based interface for MCP Agent applications.
 Provides a simplified way to create and manage agents using decorators.
 """
 
-from typing import List, Optional, Dict, Callable, TypeVar, Any, Union, TypeAlias
+from typing import (
+    List,
+    Optional,
+    Dict,
+    Callable,
+    TypeVar,
+    Any,
+    Union,
+    TypeAlias,
+    Literal,
+)
 from enum import Enum
 import yaml
 import argparse
@@ -11,6 +21,8 @@ from contextlib import asynccontextmanager
 
 from mcp_agent.core.exceptions import (
     AgentConfigError,
+    ModelConfigError,
+    PromptExitError,
     ServerConfigError,
     ProviderKeyError,
     ServerInitializationError,
@@ -28,7 +40,6 @@ from mcp_agent.workflows.evaluator_optimizer.evaluator_optimizer import (
 )
 from mcp_agent.workflows.router.router_llm import LLMRouter
 from mcp_agent.config import Settings
-from rich.prompt import Prompt
 from rich import print
 from mcp_agent.progress_display import progress_display
 from mcp_agent.workflows.llm.model_factory import ModelFactory
@@ -161,34 +172,73 @@ class AgentApp:
 
     async def prompt(self, agent_name: Optional[str] = None, default: str = "") -> str:
         """
-        Interactive prompt for sending messages.
+        Interactive prompt for sending messages with advanced features.
 
         Args:
             agent_name: Optional target agent name (uses default if not specified)
-            default_prompt: Default message to use when user presses enter
+            default: Default message to use when user presses enter
         """
+        from .enhanced_prompt import get_enhanced_input, handle_special_commands
 
         agent = agent_name or self._default
 
         if agent not in self._agents:
             raise ValueError(f"No agent named '{agent}'")
+
+        # Pass all available agent names for auto-completion
+        available_agents = list(self._agents.keys())
+
+        # Create agent_types dictionary mapping agent names to their types
+        agent_types = {}
+        for name, proxy in self._agents.items():
+            # Determine agent type based on the proxy type
+            if isinstance(proxy, LLMAgentProxy):
+                # Convert AgentType.BASIC.value ("agent") to "Agent"
+                agent_types[name] = "Agent"
+            elif isinstance(proxy, RouterProxy):
+                agent_types[name] = "Router"
+            elif isinstance(proxy, WorkflowProxy):
+                # For workflow proxies, check the workflow type
+                workflow = proxy._workflow
+                if isinstance(workflow, Orchestrator):
+                    agent_types[name] = "Orchestrator"
+                elif isinstance(workflow, ParallelLLM):
+                    agent_types[name] = "Parallel"
+                elif isinstance(workflow, EvaluatorOptimizerLLM):
+                    agent_types[name] = "Evaluator"
+                else:
+                    agent_types[name] = "Workflow"
+
         result = ""
         while True:
             with progress_display.paused():
-                if default == "STOP":
-                    print("Press <ENTER> to finish.")
-                elif default != "":
-                    print("Enter a prompt, or [red]STOP[/red] to finish.")
-                    print(
-                        f"Press <ENTER> to use the default prompt:\n[cyan]{default}[/cyan]"
-                    )
-                else:
-                    print("Enter a prompt, or [red]STOP[/red] to finish")
-
-                prompt_text = f"[blue]{agent}[/blue] >"
-                user_input = Prompt.ask(
-                    prompt=prompt_text, default=default, show_default=False
+                # Use the enhanced input method with advanced features
+                user_input = await get_enhanced_input(
+                    agent_name=agent,
+                    default=default,
+                    show_default=(default != ""),
+                    show_stop_hint=True,
+                    multiline=False,  # Default to single-line mode
+                    available_agent_names=available_agents,
+                    syntax=None,  # Can enable syntax highlighting for code input
+                    agent_types=agent_types,  # Pass agent types for display
                 )
+
+                # Handle special commands
+                command_result = await handle_special_commands(user_input, self)
+
+                # Check if we should switch agents
+                if (
+                    isinstance(command_result, dict)
+                    and "switch_agent" in command_result
+                ):
+                    agent = command_result["switch_agent"]
+                    continue
+
+                # Skip further processing if command was handled
+                if command_result:
+                    continue
+
                 if user_input.upper() == "STOP":
                     return
                 if user_input == "":
@@ -400,12 +450,12 @@ class FastAgent(ContextDependent):
             elif agent_type == AgentType.EVALUATOR_OPTIMIZER.value:
                 # Check both evaluator and optimizer exist
                 evaluator = agent_data["evaluator"]
-                optimizer = agent_data["optimizer"]
+                generator = agent_data["generator"]
                 missing = []
                 if evaluator not in available_components:
                     missing.append(f"evaluator: {evaluator}")
-                if optimizer not in available_components:
-                    missing.append(f"optimizer: {optimizer}")
+                if generator not in available_components:
+                    missing.append(f"generator: {generator}")
                 if missing:
                     raise AgentConfigError(
                         f"Evaluator-Optimizer '{name}' references non-existent components: {', '.join(missing)}"
@@ -595,6 +645,7 @@ class FastAgent(ContextDependent):
         use_history: bool = False,
         request_params: Optional[Dict] = None,
         human_input: bool = False,
+        plan_type: Literal["full", "iterative"] = "full",
     ) -> Callable:
         """
         Decorator to create and register an orchestrator.
@@ -607,6 +658,7 @@ class FastAgent(ContextDependent):
             use_history: Whether to maintain conversation history (forced false)
             request_params: Additional request parameters for the LLM
             human_input: Whether to enable human input capabilities
+            plan_type: Planning approach - "full" generates entire plan first, "iterative" plans one step at a time
         """
         default_instruction = """
             You are an expert planner. Given an objective task and a list of MCP servers (which are collections of tools)
@@ -628,6 +680,7 @@ class FastAgent(ContextDependent):
             use_history=use_history,
             request_params=request_params,
             human_input=human_input,
+            plan_type=plan_type,
         )
         return decorator
 
@@ -672,7 +725,7 @@ class FastAgent(ContextDependent):
     def evaluator_optimizer(
         self,
         name: str,
-        optimizer: str,
+        generator: str,
         evaluator: str,
         min_rating: str = "GOOD",
         max_refinements: int = 3,
@@ -684,7 +737,7 @@ class FastAgent(ContextDependent):
 
         Args:
             name: Name of the workflow
-            optimizer: Name of the optimizer agent
+            generator: Name of the generator agent
             evaluator: Name of the evaluator agent
             min_rating: Minimum acceptable quality rating (EXCELLENT, GOOD, FAIR, POOR)
             max_refinements: Maximum number of refinement iterations
@@ -699,7 +752,7 @@ class FastAgent(ContextDependent):
             wrapper_needed=True,
         )(
             name=name,
-            optimizer=optimizer,
+            generator=generator,
             evaluator=evaluator,
             min_rating=min_rating,
             max_refinements=max_refinements,
@@ -826,7 +879,7 @@ class FastAgent(ContextDependent):
                         which can be performed by LLMs with access to the servers or agents.
                         """,
                         servers=[],  # Planner doesn't need server access
-                        model=config.model,  # Use same model as orchestrator
+                        model=config.model,
                         default_request_params=base_params,
                     )
                     planner_agent = Agent(
@@ -847,33 +900,35 @@ class FastAgent(ContextDependent):
                         available_agents=child_agents,
                         context=agent_app.context,
                         request_params=planner.default_request_params,  # Base params already include model settings
-                        plan_type="full",  # TODO -- support iterative plan type properly
-                        verb=ProgressAction.PLANNING,  # Using PLANNING instead of ORCHESTRATING
+                        plan_type=agent_data.get(
+                            "plan_type", "full"
+                        ),  # Get plan_type from agent_data
+                        verb=ProgressAction.PLANNING,
                     )
 
                 elif agent_type == AgentType.EVALUATOR_OPTIMIZER:
                     # Get the referenced agents - unwrap from proxies
-                    optimizer = self._unwrap_proxy(
-                        active_agents[agent_data["optimizer"]]
+                    generator = self._unwrap_proxy(
+                        active_agents[agent_data["generator"]]
                     )
                     evaluator = self._unwrap_proxy(
                         active_agents[agent_data["evaluator"]]
                     )
 
-                    if not optimizer or not evaluator:
+                    if not generator or not evaluator:
                         raise ValueError(
                             f"Missing agents for workflow {name}: "
-                            f"optimizer={agent_data['optimizer']}, "
+                            f"generator={agent_data['generator']}, "
                             f"evaluator={agent_data['evaluator']}"
                         )
 
                     # TODO: Remove legacy - factory usage is only needed for str evaluators
                     # Later this should only be passed when evaluator is a string
                     optimizer_model = (
-                        optimizer.config.model if isinstance(optimizer, Agent) else None
+                        generator.config.model if isinstance(generator, Agent) else None
                     )
                     instance = EvaluatorOptimizerLLM(
-                        optimizer=optimizer,
+                        generator=generator,
                         evaluator=evaluator,
                         min_rating=QualityRating[agent_data["min_rating"]],
                         max_refinements=agent_data["max_refinements"],
@@ -1190,10 +1245,28 @@ class FastAgent(ContextDependent):
             had_error = True
             self._handle_error(
                 e,
-                "Server Startup Error",
+                "MCP Server Startup Error",
                 "There was an error starting up the MCP Server.",
             )
             raise SystemExit(1)
+
+        except ModelConfigError as e:
+            had_error = True
+            self._handle_error(
+                e,
+                "Model Configuration Error",
+                "Common models: gpt-4o, o3-mini, sonnet, haiku. for o3, set reasoning effort with o3-mini.high",
+            )
+            raise SystemExit(1)
+
+        except PromptExitError as e:
+            had_error = True
+            self._handle_error(
+                e,
+                "User requested exit",
+            )
+            raise SystemExit(1)
+
         finally:
             # Clean up any active agents without re-raising errors
             if active_agents and not had_error:
@@ -1201,7 +1274,8 @@ class FastAgent(ContextDependent):
                     if isinstance(proxy, LLMAgentProxy):
                         try:
                             await proxy._agent.__aexit__(None, None, None)
-                        except Exception:
+                        except Exception as e:
+                            print(f"DEBUG {e.message}")
                             pass  # Ignore cleanup errors
 
     def _handle_error(