fast-agent-mcp 0.1.7__tar.gz → 0.1.8__tar.gz

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.1.7
+Version: 0.1.8
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>, Sarmad Qadri <sarmad@lastmileai.dev>
 License:                                  Apache License
@@ -209,9 +209,9 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
-Requires-Dist: anthropic>=0.42.0
+Requires-Dist: aiohttp>=3.11.13
+Requires-Dist: anthropic>=0.49.0
 Requires-Dist: fastapi>=0.115.6
-Requires-Dist: instructor>=1.7.2
 Requires-Dist: mcp==1.2.1
 Requires-Dist: numpy>=2.2.1
 Requires-Dist: openai>=1.63.2
@@ -224,11 +224,17 @@ Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=13.9.4
 Requires-Dist: scikit-learn>=1.6.0
 Requires-Dist: typer>=0.15.1
-Provides-Extra: anthropic
-Requires-Dist: anthropic>=0.42.0; extra == 'anthropic'
-Requires-Dist: instructor[anthropic]>=1.7.2; extra == 'anthropic'
 Provides-Extra: cohere
 Requires-Dist: cohere>=5.13.4; extra == 'cohere'
+Provides-Extra: dev
+Requires-Dist: anthropic>=0.42.0; extra == 'dev'
+Requires-Dist: pre-commit>=4.0.1; extra == 'dev'
+Requires-Dist: pydantic>=2.10.4; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.1; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Requires-Dist: pyyaml>=6.0.2; extra == 'dev'
+Requires-Dist: ruff>=0.8.4; extra == 'dev'
+Requires-Dist: tomli>=2.2.1; extra == 'dev'
 Provides-Extra: openai
 Requires-Dist: openai>=1.58.1; extra == 'openai'
 Provides-Extra: temporal

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.1.7"
+version = "0.1.8"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -16,7 +16,6 @@ classifiers = [
 requires-python = ">=3.10"
 dependencies = [
     "fastapi>=0.115.6",
-    "instructor>=1.7.2",
     "mcp==1.2.1",
     "opentelemetry-distro>=0.50b0",
     "opentelemetry-exporter-otlp-proto-http>=1.29.0",
@@ -27,25 +26,32 @@ dependencies = [
     "typer>=0.15.1",
     "numpy>=2.2.1",
     "scikit-learn>=1.6.0",
-    "anthropic>=0.42.0",
+    "anthropic>=0.49.0",
     "openai>=1.63.2",
     "prompt-toolkit>=3.0.50",
+    "aiohttp>=3.11.13",
 ]
 
 [project.optional-dependencies]
 temporal = [
     "temporalio>=1.8.0",
 ]
-anthropic = [
-    "anthropic>=0.42.0",
-    "instructor[anthropic]>=1.7.2",
-]
 openai = [
     "openai>=1.58.1",
 ]
 cohere = [
     "cohere>=5.13.4",
 ]
+dev = [
+    "anthropic>=0.42.0",
+    "pre-commit>=4.0.1",
+    "pydantic>=2.10.4",
+    "pyyaml>=6.0.2",
+    "ruff>=0.8.4",
+    "tomli>=2.2.1",
+    "pytest>=7.4.0",
+    "pytest-asyncio>=0.21.1",
+]
 
 [build-system]
 requires = ["hatchling"]
@@ -74,6 +80,8 @@ dev = [
     "pyyaml>=6.0.2",
     "ruff>=0.8.4",
     "tomli>=2.2.1",
+    "pytest>=7.4.0",
+    "pytest-asyncio>=0.21.1",
 ]
 
 [project.scripts]

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.8}/src/mcp_agent/core/agent_app.py

@@ -177,9 +177,6 @@ class AgentApp:
                         from rich import print as rich_print
                         from rich.table import Table
                         from rich.console import Console
-                        from prompt_toolkit import PromptSession
-                        from prompt_toolkit.formatted_text import HTML
-                        from prompt_toolkit.completion import WordCompleter
 
                         console = Console()
 
@@ -325,8 +322,11 @@ class AgentApp:
                                         )
 
                                     # Ask user to select one
-                                    prompt_session = PromptSession()
-                                    selection = await prompt_session.prompt_async(
+                                    from mcp_agent.core.enhanced_prompt import (
+                                        get_selection_input,
+                                    )
+
+                                    selection = await get_selection_input(
                                         "Enter prompt number to select: ", default="1"
                                     )
 
@@ -381,12 +381,16 @@ class AgentApp:
                                 prompt_names = [
                                     str(i + 1) for i in range(len(all_prompts))
                                 ]
-                                completer = WordCompleter(prompt_names)
 
                                 # Ask user to select a prompt
-                                prompt_session = PromptSession(completer=completer)
-                                selection = await prompt_session.prompt_async(
-                                    "Enter prompt number to select (or press Enter to cancel): "
+                                from mcp_agent.core.enhanced_prompt import (
+                                    get_selection_input,
+                                )
+
+                                selection = await get_selection_input(
+                                    "Enter prompt number to select (or press Enter to cancel): ",
+                                    options=prompt_names,
+                                    allow_cancel=True,
                                 )
 
                                 # Make cancellation easier
@@ -437,37 +441,38 @@ class AgentApp:
 
                                 # Collect required arguments
                                 for arg_name in required_args:
-                                    # Show description if available
+                                    # Get description if available
                                     description = arg_descriptions.get(arg_name, "")
-                                    if description:
-                                        rich_print(
-                                            f"  [dim]{arg_name}: {description}[/dim]"
-                                        )
-                                    
+
                                     # Collect required argument value
-                                    arg_value = await PromptSession().prompt_async(
-                                        HTML(
-                                            f"Enter value for <ansibrightcyan>{arg_name}</ansibrightcyan> (required): "
-                                        )
+                                    from mcp_agent.core.enhanced_prompt import (
+                                        get_argument_input,
+                                    )
+
+                                    arg_value = await get_argument_input(
+                                        arg_name=arg_name,
+                                        description=description,
+                                        required=True,
                                     )
-                                    # Add to arg_values
-                                    arg_values[arg_name] = arg_value
+                                    # Add to arg_values if a value was provided
+                                    if arg_value is not None:
+                                        arg_values[arg_name] = arg_value
 
                                 # Only include non-empty values for optional arguments
                                 if optional_args:
                                     # Collect optional arguments
                                     for arg_name in optional_args:
-                                        # Show description if available
+                                        # Get description if available
                                         description = arg_descriptions.get(arg_name, "")
-                                        if description:
-                                            rich_print(
-                                                f"  [dim]{arg_name}: {description}[/dim]"
-                                            )
-
-                                        arg_value = await PromptSession().prompt_async(
-                                            HTML(
-                                                f"Enter value for <ansibrightcyan>{arg_name}</ansibrightcyan> (optional, press Enter to skip): "
-                                            )
+
+                                        from mcp_agent.core.enhanced_prompt import (
+                                            get_argument_input,
+                                        )
+
+                                        arg_value = await get_argument_input(
+                                            arg_name=arg_name,
+                                            description=description,
+                                            required=False,
                                         )
                                         # Only include non-empty values for optional arguments
                                         if arg_value:

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.8}/src/mcp_agent/core/decorators.py

@@ -256,7 +256,8 @@ def parallel(
         self.agents[passthrough_name] = {
             "config": AgentConfig(
                 name=passthrough_name,
-                instruction=f"Passthrough fan-in for {name}",
+                model="passthrough",
+                instruction=f"This agent combines the results from the fan-out agents verbatim. {name}",
                 servers=[],
                 use_history=use_history,
             ),
@@ -452,4 +453,4 @@ def passthrough(
         name=name,
         use_history=use_history,
     )
-    return decorator
+    return decorator

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.8}/src/mcp_agent/core/enhanced_prompt.py

@@ -2,13 +2,13 @@
 Enhanced prompt functionality with advanced prompt_toolkit features.
 """
 
-from typing import List
+from typing import List, Optional
 from importlib.metadata import version
 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.completion import Completer, Completion, WordCompleter
 from prompt_toolkit.lexers import PygmentsLexer
 from prompt_toolkit.filters import Condition
 from prompt_toolkit.styles import Style
@@ -330,6 +330,110 @@ async def get_enhanced_input(
         # Log and gracefully handle other exceptions
         print(f"\nInput error: {type(e).__name__}: {e}")
         return "STOP"
+    finally:
+        # Ensure the prompt session is properly cleaned up
+        # This is especially important on Windows to prevent resource leaks
+        if session.app.is_running:
+            session.app.exit()
+
+
+async def get_selection_input(
+    prompt_text: str,
+    options: List[str] = None,
+    default: str = None,
+    allow_cancel: bool = True,
+    complete_options: bool = True,
+) -> Optional[str]:
+    """
+    Display a selection prompt and return the user's selection.
+
+    Args:
+        prompt_text: Text to display as the prompt
+        options: List of valid options (for auto-completion)
+        default: Default value if user presses enter
+        allow_cancel: Whether to allow cancellation with empty input
+        complete_options: Whether to use the options for auto-completion
+
+    Returns:
+        Selected value, or None if cancelled
+    """
+    try:
+        # Initialize completer if options provided and completion requested
+        completer = WordCompleter(options) if options and complete_options else None
+
+        # Create prompt session
+        prompt_session = PromptSession(completer=completer)
+
+        try:
+            # Get user input
+            selection = await prompt_session.prompt_async(
+                prompt_text, default=default or ""
+            )
+
+            # Handle cancellation
+            if allow_cancel and not selection.strip():
+                return None
+
+            return selection
+        finally:
+            # Ensure prompt session cleanup
+            if prompt_session.app.is_running:
+                prompt_session.app.exit()
+    except (KeyboardInterrupt, EOFError):
+        return None
+    except Exception as e:
+        rich_print(f"\n[red]Error getting selection: {e}[/red]")
+        return None
+
+
+async def get_argument_input(
+    arg_name: str,
+    description: str = None,
+    required: bool = True,
+) -> Optional[str]:
+    """
+    Prompt for an argument value with formatting and help text.
+
+    Args:
+        arg_name: Name of the argument
+        description: Optional description of the argument
+        required: Whether this argument is required
+
+    Returns:
+        Input value, or None if cancelled/skipped
+    """
+    # Format the prompt differently based on whether it's required
+    required_text = "(required)" if required else "(optional, press Enter to skip)"
+
+    # Show description if available
+    if description:
+        rich_print(f"  [dim]{arg_name}: {description}[/dim]")
+
+    prompt_text = HTML(
+        f"Enter value for <ansibrightcyan>{arg_name}</ansibrightcyan> {required_text}: "
+    )
+
+    # Create prompt session
+    prompt_session = PromptSession()
+
+    try:
+        # Get user input
+        arg_value = await prompt_session.prompt_async(prompt_text)
+
+        # For optional arguments, empty input means skip
+        if not required and not arg_value:
+            return None
+
+        return arg_value
+    except (KeyboardInterrupt, EOFError):
+        return None
+    except Exception as e:
+        rich_print(f"\n[red]Error getting input: {e}[/red]")
+        return None
+    finally:
+        # Ensure prompt session cleanup
+        if prompt_session.app.is_running:
+            prompt_session.app.exit()
 
 
 async def handle_special_commands(command, agent_app=None):
@@ -408,24 +512,6 @@ async def handle_special_commands(command, agent_app=None):
             )
             return True
 
-    elif command == "SELECT_PROMPT" or (
-        isinstance(command, str) and command.startswith("SELECT_PROMPT:")
-    ):
-        # Handle prompt selection UI (previously named "list_prompts" action)
-        if agent_app:
-            # If it's a specific prompt, extract the name
-            prompt_name = None
-            if isinstance(command, str) and command.startswith("SELECT_PROMPT:"):
-                prompt_name = command.split(":", 1)[1].strip()
-
-            # 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]"
-            )
-            return True
-
     elif isinstance(command, str) and command.startswith("SWITCH:"):
         agent_name = command.split(":", 1)[1]
         if agent_name in available_agents:

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.8}/src/mcp_agent/core/factory.py

@@ -34,10 +34,7 @@ T = TypeVar("T")  # For the wrapper classes
 
 
 def create_proxy(
-    app: MCPApp,
-    name: str, 
-    instance: AgentOrWorkflow, 
-    agent_type: str
+    app: MCPApp, name: str, instance: AgentOrWorkflow, agent_type: str
 ) -> BaseAgentProxy:
     """Create appropriate proxy type based on agent type and validate instance type
 
@@ -61,9 +58,7 @@ def create_proxy(
         log_agent_load(app, name)
     if agent_type == AgentType.BASIC.value:
         if not isinstance(instance, Agent):
-            raise TypeError(
-                f"Expected Agent instance for {name}, got {type(instance)}"
-            )
+            raise TypeError(f"Expected Agent instance for {name}, got {type(instance)}")
         return LLMAgentProxy(app, name, instance)
     elif agent_type == AgentType.ORCHESTRATOR.value:
         if not isinstance(instance, Orchestrator):
@@ -177,42 +172,18 @@ async def create_agents_by_type(
             if agent_type == AgentType.BASIC:
                 # Get the agent name for special handling
                 agent_name = agent_data["config"].name
+                agent = Agent(config=config, context=app_instance.context)
 
-                # Check if this is an agent that should use the PassthroughLLM
-                if agent_name.endswith("_fan_in") or agent_name.startswith(
-                    "passthrough"
-                ):
-                    # Import here to avoid circular imports
-                    from mcp_agent.workflows.llm.augmented_llm import PassthroughLLM
-
-                    # Create basic agent with configuration
-                    agent = Agent(config=config, context=app_instance.context)
-
-                    # Set up a PassthroughLLM directly
-                    async with agent:
-                        agent._llm = PassthroughLLM(
-                            name=f"{config.name}_llm",
-                            context=app_instance.context,
-                            agent=agent,
-                            default_request_params=config.default_request_params,
-                        )
-
-                    # Store the agent
-                    instance = agent
-                else:
-                    # Standard basic agent with LLM
-                    agent = Agent(config=config, context=app_instance.context)
-
-                    # Set up LLM with proper configuration
-                    async with agent:
-                        llm_factory = model_factory_func(
-                            model=config.model,
-                            request_params=config.default_request_params,
-                        )
-                        agent._llm = await agent.attach_llm(llm_factory)
+                # Set up LLM with proper configuration
+                async with agent:
+                    llm_factory = model_factory_func(
+                        model=config.model,
+                        request_params=config.default_request_params,
+                    )
+                    agent._llm = await agent.attach_llm(llm_factory)
 
-                    # Store the agent
-                    instance = agent
+                # Store the agent
+                instance = agent
 
             elif agent_type == AgentType.ORCHESTRATOR:
                 # Get base params configured with model settings
@@ -276,12 +247,8 @@ async def create_agents_by_type(
 
             elif agent_type == AgentType.EVALUATOR_OPTIMIZER:
                 # Get the referenced agents - unwrap from proxies
-                generator = unwrap_proxy(
-                    active_agents[agent_data["generator"]]
-                )
-                evaluator = unwrap_proxy(
-                    active_agents[agent_data["evaluator"]]
-                )
+                generator = unwrap_proxy(active_agents[agent_data["generator"]])
+                evaluator = unwrap_proxy(active_agents[agent_data["evaluator"]])
 
                 if not generator or not evaluator:
                     raise ValueError(
@@ -294,7 +261,9 @@ async def create_agents_by_type(
                 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
 
@@ -311,9 +280,7 @@ async def create_agents_by_type(
 
             elif agent_type == AgentType.ROUTER:
                 # Get the router's agents - unwrap proxies
-                router_agents = get_agent_instances(
-                    agent_data["agents"], active_agents
-                )
+                router_agents = get_agent_instances(agent_data["agents"], active_agents)
 
                 # Create the router with proper configuration
                 llm_factory = model_factory_func(
@@ -376,20 +343,15 @@ async def create_agents_by_type(
                     "continue_with_final", True
                 )
                 # Set cumulative behavior from configuration
-                instance._cumulative = agent_data.get(
-                    "cumulative", False
-                )
+                instance._cumulative = agent_data.get("cumulative", False)
 
             elif agent_type == AgentType.PARALLEL:
-                # Get fan-out agents (could be basic agents or other parallels)
                 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"]]
-                )
+                fan_in_agent = unwrap_proxy(active_agents[agent_data["fan_in"]])
 
                 # Create the parallel workflow
                 llm_factory = model_factory_func(config.model)
@@ -416,7 +378,7 @@ async def create_agents_by_type(
 
 
 async def create_basic_agents(
-    app_instance: MCPApp, 
+    app_instance: MCPApp,
     agents_dict: Dict[str, Dict[str, Any]],
     model_factory_func: Callable,
 ) -> ProxyDict:
@@ -432,17 +394,17 @@ async def create_basic_agents(
         Dictionary of initialized basic agents wrapped in appropriate proxies
     """
     return await create_agents_by_type(
-        app_instance, 
-        agents_dict, 
-        AgentType.BASIC, 
-        model_factory_func=model_factory_func
+        app_instance,
+        agents_dict,
+        AgentType.BASIC,
+        model_factory_func=model_factory_func,
     )
 
 
 async def create_agents_in_dependency_order(
-    app_instance: MCPApp, 
+    app_instance: MCPApp,
     agents_dict: Dict[str, Dict[str, Any]],
-    active_agents: ProxyDict, 
+    active_agents: ProxyDict,
     agent_type: AgentType,
     model_factory_func: Callable,
 ) -> ProxyDict:
@@ -498,4 +460,4 @@ async def create_agents_in_dependency_order(
                     if agent_name in agent_result:
                         result_agents[agent_name] = agent_result[agent_name]
 
-    return result_agents
+    return result_agents

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.8}/src/mcp_agent/human_input/handler.py

@@ -69,7 +69,10 @@ async def console_input_callback(request: HumanInputRequest) -> HumanInputRespon
             command_result = await handle_special_commands(response)
             if isinstance(command_result, dict) and "list_prompts" in command_result:
                 from rich import print as rich_print
-                rich_print("[yellow]Prompt listing not available in human input context[/yellow]")
+
+                rich_print(
+                    "[yellow]Prompt listing not available in human input context[/yellow]"
+                )
 
         except KeyboardInterrupt:
             console.print("\n[yellow]Input interrupted[/yellow]")

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.8}/src/mcp_agent/mcp/mcp_aggregator.py

@@ -788,19 +788,23 @@ class MCPAggregator(ContextDependent):
                     # Add empty list to results for this server
                     results[s_name] = []
 
-            # Gather prompts from supported servers concurrently
+            # Process servers sequentially to ensure proper resource cleanup
+            # This helps prevent resource leaks especially on Windows
             if supported_servers:
-                tasks = [
-                    self._execute_on_server(
-                        server_name=s_name,
-                        operation_type="prompts-list",
-                        operation_name="",
-                        method_name="list_prompts",
-                        error_factory=lambda _: [],
-                    )
-                    for s_name in supported_servers
-                ]
-                server_results = await gather(*tasks, return_exceptions=True)
+                server_results = []
+                for s_name in supported_servers:
+                    try:
+                        result = await self._execute_on_server(
+                            server_name=s_name,
+                            operation_type="prompts-list",
+                            operation_name="",
+                            method_name="list_prompts",
+                            error_factory=lambda _: [],
+                        )
+                        server_results.append(result)
+                    except Exception as e:
+                        logger.debug(f"Error fetching prompts from {s_name}: {e}")
+                        server_results.append(e)
 
                 for i, result in enumerate(server_results):
                     if isinstance(result, BaseException):

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.8}/src/mcp_agent/resources/examples/researcher/researcher-eval.py

@@ -2,7 +2,7 @@ import asyncio
 
 from mcp_agent.core.fastagent import FastAgent
 
-agents = FastAgent(name="Researcher")
+agents = FastAgent(name="Researcher Agent (EO)")
 
 
 @agents.agent(

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.8}/src/mcp_agent/resources/examples/workflows/orchestrator.py

@@ -45,13 +45,14 @@ fast = FastAgent("Orchestrator-Workers")
 @fast.orchestrator(
     name="orchestrate",
     agents=["finder", "writer", "proofreader"],
-    plan_type="full",
+    plan_type="iterative",
 )
 async def main():
     async with fast.run() as agent:
-        await agent.author(
-            "write a 250 word short story about kittens discovering a castle, and save it to short_story.md"
-        )
+        await agent()
+#        await agent.author(
+#            "write a 250 word short story about kittens discovering a castle, and save it to short_story.md"
+#        )
 
         # The orchestrator can be used just like any other agent
         task = (

{fast_agent_mcp-0.1.7 → fast_agent_mcp-0.1.8}/src/mcp_agent/resources/examples/workflows/router.py

@@ -25,7 +25,6 @@ SAMPLE_REQUESTS = [
     name="fetcher",
     instruction="""You are an agent, with a tool enabling you to fetch URLs.""",
     servers=["fetch"],
-    model="haiku",
 )
 @fast.agent(
     name="code_expert",
@@ -33,7 +32,6 @@ SAMPLE_REQUESTS = [
     When asked about code, architecture, or development practices,
     you provide thorough and practical insights.""",
     servers=["filesystem"],
-    model="gpt-4o",
 )
 @fast.agent(
     name="general_assistant",