fast-agent-mcp 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

mcp_agent/core/enhanced_prompt.py

@@ -2,15 +2,16 @@
 Enhanced prompt functionality with advanced prompt_toolkit features.
 """
 
-from typing import List, Optional
 from importlib.metadata import version
+from typing import List, Optional
+
 from prompt_toolkit import PromptSession
+from prompt_toolkit.completion import Completer, Completion, WordCompleter
+from prompt_toolkit.filters import Condition
 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, WordCompleter
 from prompt_toolkit.lexers import PygmentsLexer
-from prompt_toolkit.filters import Condition
 from prompt_toolkit.styles import Style
 from pygments.lexers.python import PythonLexer
 from rich import print as rich_print
@@ -45,7 +46,7 @@ class AgentCompleter(Completer):
         commands: List[str] = None,
         agent_types: dict = None,
         is_human_input: bool = False,
-    ):
+    ) -> None:
         self.agents = agents
         # Map commands to their descriptions for better completion hints
         self.commands = {
@@ -61,9 +62,7 @@ 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("prompt", None)  # Remove prompt command in human input mode
         self.agent_types = agent_types or {}
 
     def get_completions(self, document, complete_event):
@@ -103,23 +102,23 @@ def create_keybindings(on_toggle_multiline=None, app=None):
     kb = KeyBindings()
 
     @kb.add("c-m", filter=Condition(lambda: not in_multiline_mode))
-    def _(event):
+    def _(event) -> None:
         """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):
+    def _(event) -> None:
         """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):
+    def _(event) -> None:
         """Ctrl+J (equivalent to Ctrl+Enter): Submit in multiline mode."""
         event.current_buffer.validate_and_handle()
 
     @kb.add("c-t")
-    def _(event):
+    def _(event) -> None:
         """Ctrl+T: Toggle multiline mode."""
         global in_multiline_mode
         in_multiline_mode = not in_multiline_mode
@@ -138,7 +137,7 @@ def create_keybindings(on_toggle_multiline=None, app=None):
         # The toolbar will show the current mode
 
     @kb.add("c-l")
-    def _(event):
+    def _(event) -> None:
         """Ctrl+L: Clear the input buffer."""
         event.current_buffer.text = ""
 
@@ -187,7 +186,7 @@ async def get_enhanced_input(
         agent_histories[agent_name] = InMemoryHistory()
 
     # Define callback for multiline toggle
-    def on_multiline_toggle(enabled):
+    def on_multiline_toggle(enabled) -> None:
         nonlocal session
         if hasattr(session, "app") and session.app:
             session.app.invalidate()
@@ -209,9 +208,7 @@ async def get_enhanced_input(
             ("↑/↓", "History"),
         ]
 
-        newline = (
-            "Ctrl+<Enter>:Submit" if in_multiline_mode else "<Enter>:Submit"
-        )
+        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]
@@ -250,9 +247,7 @@ async def get_enhanced_input(
     )
 
     # Create key bindings with a reference to the app
-    bindings = create_keybindings(
-        on_toggle_multiline=on_multiline_toggle, app=session.app
-    )
+    bindings = create_keybindings(on_toggle_multiline=on_multiline_toggle, app=session.app)
     session.app.key_bindings = bindings
 
     # Create formatted prompt text
@@ -267,20 +262,14 @@ async def get_enhanced_input(
         if default == "STOP":
             rich_print("Enter a prompt, [red]STOP[/red] to finish")
             if default:
-                rich_print(
-                    f"Press <ENTER> to use the default prompt:\n[cyan]{default}[/cyan]"
-                )
+                rich_print(f"Press <ENTER> to use the default prompt:\n[cyan]{default}[/cyan]")
 
     # Mention available features but only on first usage globally
     if not help_message_shown:
         if is_human_input:
-            rich_print(
-                "[dim]Type /help for commands. Ctrl+T toggles multiline mode.[/dim]"
-            )
+            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]"
-            )
+            rich_print("[dim]Type /help for commands, @agent to switch agent. Ctrl+T toggles multiline mode.[/dim]")
         rich_print()
         help_message_shown = True
 
@@ -366,9 +355,7 @@ async def get_selection_input(
 
         try:
             # Get user input
-            selection = await prompt_session.prompt_async(
-                prompt_text, default=default or ""
-            )
+            selection = await prompt_session.prompt_async(prompt_text, default=default or "")
 
             # Handle cancellation
             if allow_cancel and not selection.strip():
@@ -409,9 +396,7 @@ async def get_argument_input(
     if description:
         rich_print(f"  [dim]{arg_name}: {description}[/dim]")
 
-    prompt_text = HTML(
-        f"Enter value for <ansibrightcyan>{arg_name}</ansibrightcyan> {required_text}: "
-    )
+    prompt_text = HTML(f"Enter value for <ansibrightcyan>{arg_name}</ansibrightcyan> {required_text}: ")
 
     # Create prompt session
     prompt_session = PromptSession()
@@ -452,13 +437,9 @@ async def handle_special_commands(command, agent_app=None):
         rich_print("  /prompt <name> - Apply a specific prompt by name")
         rich_print("  @agent_name    - Switch to agent")
         rich_print("  STOP           - Return control back to the workflow")
-        rich_print(
-            "  EXIT           - Exit fast-agent, terminating any running workflows"
-        )
+        rich_print("  EXIT           - Exit fast-agent, terminating any running workflows")
         rich_print("\n[bold]Keyboard Shortcuts:[/bold]")
-        rich_print(
-            "  Enter          - Submit (normal mode) / New line (multiline mode)"
-        )
+        rich_print("  Enter          - Submit (normal mode) / New line (multiline mode)")
         rich_print("  Ctrl+Enter      - Always submit (in any mode)")
         rich_print("  Ctrl+T         - Toggle multiline mode")
         rich_print("  Ctrl+L         - Clear input")
@@ -489,14 +470,10 @@ async def handle_special_commands(command, agent_app=None):
             rich_print("\n[bold]Fetching available MCP prompts...[/bold]")
             return {"list_prompts": True}
         else:
-            rich_print(
-                "[yellow]Prompt listing is not available outside of an agent context[/yellow]"
-            )
+            rich_print("[yellow]Prompt listing is not available outside of an agent context[/yellow]")
             return True
 
-    elif command == "SELECT_PROMPT" or (
-        isinstance(command, str) and command.startswith("SELECT_PROMPT:")
-    ):
+    elif command == "SELECT_PROMPT" or (isinstance(command, str) and command.startswith("SELECT_PROMPT:")):
         # Handle prompt selection UI
         if agent_app:
             # If it's a specific prompt, extract the name
@@ -507,9 +484,7 @@ async def handle_special_commands(command, agent_app=None):
             # Return a dictionary with a select_prompt action to be handled by the caller
             return {"select_prompt": True, "prompt_name": prompt_name}
         else:
-            rich_print(
-                "[yellow]Prompt selection is not available outside of an agent context[/yellow]"
-            )
+            rich_print("[yellow]Prompt selection is not available outside of an agent context[/yellow]")
             return True
 
     elif isinstance(command, str) and command.startswith("SWITCH:"):
@@ -519,9 +494,7 @@ async def handle_special_commands(command, agent_app=None):
                 #                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]"
-                )
+                rich_print("[yellow]Agent switching not available in this context[/yellow]")
         else:
             rich_print(f"[red]Unknown agent: {agent_name}[/red]")
         return True

mcp_agent/core/error_handling.py

@@ -20,4 +20,4 @@ def handle_error(e: Exception, error_type: str, suggestion: str = None) -> None:
         print("\nDetails:")
         print(e.details)
     if suggestion:
-        print(f"\n{suggestion}")
+        print(f"\n{suggestion}")

mcp_agent/core/exceptions.py

@@ -7,7 +7,7 @@ Enables user-friendly error handling for common issues.
 class FastAgentError(Exception):
     """Base exception class for FastAgent errors"""
 
-    def __init__(self, message: str, details: str = ""):
+    def __init__(self, message: str, details: str = "") -> None:
         self.message = message
         self.details = details
         super().__init__(f"{message}\n\n{details}" if details else message)
@@ -18,7 +18,7 @@ class ServerConfigError(FastAgentError):
     Example: Server name referenced in agent.servers[] but not defined in config
     """
 
-    def __init__(self, message: str, details: str = ""):
+    def __init__(self, message: str, details: str = "") -> None:
         super().__init__(message, details)
 
 
@@ -27,7 +27,7 @@ class AgentConfigError(FastAgentError):
     Example: Parallel fan-in references unknown agent
     """
 
-    def __init__(self, message: str, details: str = ""):
+    def __init__(self, message: str, details: str = "") -> None:
         super().__init__(message, details)
 
 
@@ -36,14 +36,14 @@ class ProviderKeyError(FastAgentError):
     Example: OpenAI/Anthropic key not configured but model requires it
     """
 
-    def __init__(self, message: str, details: str = ""):
+    def __init__(self, message: str, details: str = "") -> None:
         super().__init__(message, details)
 
 
 class ServerInitializationError(FastAgentError):
     """Raised when a server fails to initialize properly."""
 
-    def __init__(self, message: str, details: str = ""):
+    def __init__(self, message: str, details: str = "") -> None:
         super().__init__(message, details)
 
 
@@ -52,14 +52,14 @@ class ModelConfigError(FastAgentError):
     Example: Unknown model name in model specification string
     """
 
-    def __init__(self, message: str, details: str = ""):
+    def __init__(self, message: str, details: str = "") -> None:
         super().__init__(message, details)
 
 
 class CircularDependencyError(FastAgentError):
     """Raised when we detect a Circular Dependency in the workflow"""
 
-    def __init__(self, message: str, details: str = ""):
+    def __init__(self, message: str, details: str = "") -> None:
         super().__init__(message, details)
 
 
@@ -67,5 +67,5 @@ 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 = ""):
+    def __init__(self, message: str, details: str = "") -> None:
         super().__init__(message, details)

mcp_agent/core/factory.py

@@ -2,10 +2,22 @@
 Factory functions for creating agent and workflow instances.
 """
 
-from typing import Dict, Any, Optional, TypeVar, Callable
+from typing import Any, Callable, Dict, Optional, TypeVar
 
+from mcp_agent.agents.agent import Agent
 from mcp_agent.app import MCPApp
-from mcp_agent.agents.agent import Agent, AgentConfig
+from mcp_agent.core.agent_types import AgentConfig, AgentType
+from mcp_agent.core.agent_utils import get_agent_instances, log_agent_load, unwrap_proxy
+from mcp_agent.core.exceptions import AgentConfigError
+from mcp_agent.core.proxies import (
+    BaseAgentProxy,
+    ChainProxy,
+    LLMAgentProxy,
+    RouterProxy,
+    WorkflowProxy,
+)
+from mcp_agent.core.types import AgentOrWorkflow, ProxyDict
+from mcp_agent.core.validation import get_dependencies
 from mcp_agent.event_progress import ProgressAction
 from mcp_agent.workflows.evaluator_optimizer.evaluator_optimizer import (
     EvaluatorOptimizerLLM,
@@ -17,25 +29,10 @@ from mcp_agent.workflows.orchestrator.orchestrator import Orchestrator
 from mcp_agent.workflows.parallel.parallel_llm import ParallelLLM
 from mcp_agent.workflows.router.router_llm import LLMRouter
 
-from mcp_agent.core.agent_types import AgentType
-from mcp_agent.core.exceptions import AgentConfigError
-from mcp_agent.core.proxies import (
-    BaseAgentProxy,
-    LLMAgentProxy,
-    WorkflowProxy,
-    RouterProxy,
-    ChainProxy,
-)
-from mcp_agent.core.types import AgentOrWorkflow, ProxyDict
-from mcp_agent.core.agent_utils import log_agent_load, unwrap_proxy, get_agent_instances
-from mcp_agent.core.validation import get_dependencies
-
 T = TypeVar("T")  # For the wrapper classes
 
 
-def create_proxy(
-    app: MCPApp, name: str, instance: AgentOrWorkflow, agent_type: str
-) -> BaseAgentProxy:
+def create_proxy(app: MCPApp, name: str, instance: AgentOrWorkflow, agent_type: str) -> BaseAgentProxy:
     """Create appropriate proxy type based on agent type and validate instance type
 
     Args:
@@ -62,27 +59,19 @@ def create_proxy(
         return LLMAgentProxy(app, name, instance)
     elif agent_type == AgentType.ORCHESTRATOR.value:
         if not isinstance(instance, Orchestrator):
-            raise TypeError(
-                f"Expected Orchestrator instance for {name}, got {type(instance)}"
-            )
+            raise TypeError(f"Expected Orchestrator instance for {name}, got {type(instance)}")
         return WorkflowProxy(app, name, instance)
     elif agent_type == AgentType.PARALLEL.value:
         if not isinstance(instance, ParallelLLM):
-            raise TypeError(
-                f"Expected ParallelLLM instance for {name}, got {type(instance)}"
-            )
+            raise TypeError(f"Expected ParallelLLM instance for {name}, got {type(instance)}")
         return WorkflowProxy(app, name, instance)
     elif agent_type == AgentType.EVALUATOR_OPTIMIZER.value:
         if not isinstance(instance, EvaluatorOptimizerLLM):
-            raise TypeError(
-                f"Expected EvaluatorOptimizerLLM instance for {name}, got {type(instance)}"
-            )
+            raise TypeError(f"Expected EvaluatorOptimizerLLM instance for {name}, got {type(instance)}")
         return WorkflowProxy(app, name, instance)
     elif agent_type == AgentType.ROUTER.value:
         if not isinstance(instance, LLMRouter):
-            raise TypeError(
-                f"Expected LLMRouter instance for {name}, got {type(instance)}"
-            )
+            raise TypeError(f"Expected LLMRouter instance for {name}, got {type(instance)}")
         return RouterProxy(app, name, instance)
     elif agent_type == AgentType.CHAIN.value:
         # Chain proxy is directly returned from _create_agents_by_type
@@ -188,11 +177,7 @@ async def create_agents_by_type(
 
             elif agent_type == AgentType.ORCHESTRATOR:
                 # Get base params configured with model settings
-                base_params = (
-                    config.default_request_params.model_copy()
-                    if config.default_request_params
-                    else RequestParams()
-                )
+                base_params = config.default_request_params.model_copy() if config.default_request_params else RequestParams()
                 base_params.use_history = False  # Force no history for orchestrator
 
                 # Get the child agents - need to unwrap proxies and validate LLM config
@@ -232,7 +217,6 @@ async def create_agents_by_type(
                 )
 
                 planner = await planner_agent.attach_llm(planner_factory)
-                await planner.initialize()
                 # Create the orchestrator with pre-configured planner
                 instance = Orchestrator(
                     name=config.name,
@@ -240,9 +224,7 @@ async def create_agents_by_type(
                     available_agents=child_agents,
                     context=app_instance.context,
                     request_params=planner.default_request_params,  # Base params already include model settings
-                    plan_type=agent_data.get(
-                        "plan_type", "full"
-                    ),  # Get plan_type from agent_data
+                    plan_type=agent_data.get("plan_type", "full"),  # Get plan_type from agent_data
                     verb=ProgressAction.PLANNING,
                 )
 
@@ -252,19 +234,13 @@ async def create_agents_by_type(
                 evaluator = unwrap_proxy(active_agents[agent_data["evaluator"]])
 
                 if not generator or not evaluator:
-                    raise ValueError(
-                        f"Missing agents for workflow {name}: "
-                        f"generator={agent_data['generator']}, "
-                        f"evaluator={agent_data['evaluator']}"
-                    )
+                    raise ValueError(f"Missing agents for workflow {name}: generator={agent_data['generator']}, evaluator={agent_data['evaluator']}")
 
                 # Get model from generator if it's an Agent, or from config otherwise
                 optimizer_model = None
                 if isinstance(generator, Agent):
                     optimizer_model = generator.config.model
-                elif hasattr(generator, "_sequence") and hasattr(
-                    generator, "_agent_proxies"
-                ):
+                elif hasattr(generator, "_sequence") and hasattr(generator, "_agent_proxies"):
                     # For ChainProxy, use the config model directly
                     optimizer_model = config.model
 
@@ -329,27 +305,19 @@ async def create_agents_by_type(
 
                     # Generate a better description
                     if agent_names:
-                        server_part = (
-                            f" with access to servers: {', '.join(sorted(all_servers))}"
-                            if all_servers
-                            else ""
-                        )
+                        server_part = f" with access to servers: {', '.join(sorted(all_servers))}" if all_servers else ""
                         config.instruction = f"Sequence of agents: {', '.join(agent_names)}{server_part}."
 
                 # Create a ChainProxy without needing a new instance
                 # Just pass the agent proxies and sequence
                 instance = ChainProxy(app_instance, name, sequence, active_agents)
                 # Set continue_with_final behavior from configuration
-                instance._continue_with_final = agent_data.get(
-                    "continue_with_final", True
-                )
+                instance._continue_with_final = agent_data.get("continue_with_final", True)
                 # Set cumulative behavior from configuration
                 instance._cumulative = agent_data.get("cumulative", False)
 
             elif agent_type == AgentType.PARALLEL:
-                fan_out_agents = get_agent_instances(
-                    agent_data["fan_out"], active_agents
-                )
+                fan_out_agents = get_agent_instances(agent_data["fan_out"], active_agents)
 
                 # Get fan-in agent - unwrap proxy
                 fan_in_agent = unwrap_proxy(active_agents[agent_data["fan_in"]])
@@ -371,9 +339,7 @@ async def create_agents_by_type(
                 raise ValueError(f"Unsupported agent type: {agent_type}")
 
             # Create the appropriate proxy and store in results
-            result_agents[name] = create_proxy(
-                app_instance, name, instance, agent_type.value
-            )
+            result_agents[name] = create_proxy(app_instance, name, instance, agent_type.value)
 
     return result_agents
 
@@ -427,24 +393,16 @@ async def create_agents_in_dependency_order(
     visited = set()
 
     # Get all agents of the specified type
-    agent_names = [
-        name
-        for name, agent_data in agents_dict.items()
-        if agent_data["type"] == agent_type.value
-    ]
+    agent_names = [name for name, agent_data in agents_dict.items() if agent_data["type"] == agent_type.value]
 
     # Create agents in dependency order
     for name in agent_names:
         # Get ordered dependencies if not already processed
         if name not in visited:
             try:
-                ordered_agents = get_dependencies(
-                    name, agents_dict, visited, set(), agent_type
-                )
+                ordered_agents = get_dependencies(name, agents_dict, visited, set(), agent_type)
             except ValueError as e:
-                raise ValueError(
-                    f"Error creating {agent_type.name.lower()} agent {name}: {str(e)}"
-                )
+                raise ValueError(f"Error creating {agent_type.name.lower()} agent {name}: {str(e)}")
 
             # Create each agent in order
             for agent_name in ordered_agents: