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

mcp_agent/human_input/handler.py

@@ -1,6 +1,5 @@
 import asyncio
 from rich.panel import Panel
-from rich.prompt import Prompt
 
 from mcp_agent.console import console
 from mcp_agent.human_input.types import (
@@ -8,10 +7,11 @@ from mcp_agent.human_input.types import (
     HumanInputResponse,
 )
 from mcp_agent.progress_display import progress_display
+from mcp_agent.core.enhanced_prompt import get_enhanced_input, handle_special_commands
 
 
 async def console_input_callback(request: HumanInputRequest) -> HumanInputResponse:
-    """Request input from a human user via console using rich panel and prompt."""
+    """Request input from a human user via console using prompt_toolkit."""
 
     # Prepare the prompt text
     prompt_text = request.prompt
@@ -28,26 +28,51 @@ async def console_input_callback(request: HumanInputRequest) -> HumanInputRespon
         padding=(1, 2),
     )
 
+    # Extract agent name from metadata dictionary
+    agent_name = (
+        request.metadata.get("agent_name", "Unknown Agent")
+        if request.metadata
+        else "Unknown Agent"
+    )
+
     # Use the context manager to pause the progress display while getting input
     with progress_display.paused():
         console.print(panel)
 
-        if request.timeout_seconds:
-            try:
-                loop = asyncio.get_event_loop()
-                response = await asyncio.wait_for(
-                    loop.run_in_executor(
-                        None, lambda: Prompt.ask("Provide your response ")
-                    ),
-                    request.timeout_seconds,
+        try:
+            if request.timeout_seconds:
+                try:
+                    # Use get_enhanced_input with empty agent list to disable agent switching
+                    response = await asyncio.wait_for(
+                        get_enhanced_input(
+                            agent_name=agent_name,
+                            available_agent_names=[],  # No agents for selection
+                            show_stop_hint=False,
+                            is_human_input=True,
+                            toolbar_color="ansimagenta",
+                        ),
+                        request.timeout_seconds,
+                    )
+                except asyncio.TimeoutError:
+                    console.print("\n[red]Timeout waiting for input[/red]")
+                    raise TimeoutError("No response received within timeout period")
+            else:
+                response = await get_enhanced_input(
+                    agent_name=agent_name,
+                    available_agent_names=[],  # No agents for selection
+                    show_stop_hint=False,
+                    is_human_input=True,
+                    toolbar_color="ansimagenta",
                 )
-            except asyncio.TimeoutError:
-                console.print("\n[red]Timeout waiting for input[/red]")
-                raise TimeoutError("No response received within timeout period")
-        else:
-            loop = asyncio.get_event_loop()
-            response = await loop.run_in_executor(
-                None, lambda: Prompt.ask("Provide your response ")
-            )
+
+            #            if response and (response.startswith("/") or response.startswith("@")):
+            await handle_special_commands(response)
+
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Input interrupted[/yellow]")
+            response = ""
+        except EOFError:
+            console.print("\n[yellow]Input terminated[/yellow]")
+            response = ""
 
     return HumanInputResponse(request_id=request.request_id, response=response.strip())

mcp_agent/mcp/mcp_connection_manager.py

@@ -75,15 +75,15 @@ class ServerConnection:
 
         # Signal we want to shut down
         self._shutdown_event = Event()
-        
+
         # Track error state
         self._error_occurred = False
         self._error_message = None
-        
+
     def is_healthy(self) -> bool:
         """Check if the server connection is healthy and ready to use."""
         return self.session is not None and not self._error_occurred
-        
+
     def reset_error_state(self) -> None:
         """Reset the error state, allowing reconnection attempts."""
         self._error_occurred = False
@@ -216,10 +216,10 @@ class MCPConnectionManager(ContextDependent):
         try:
             # First request all servers to shutdown
             await self.disconnect_all()
-            
+
             # Add a small delay to allow for clean shutdown
             await asyncio.sleep(0.5)
-            
+
             # Then close the task group if it's active
             if self._task_group_active:
                 await self._task_group.__aexit__(exc_type, exc_val, exc_tb)
@@ -305,10 +305,12 @@ class MCPConnectionManager(ContextDependent):
             server_conn = self.running_servers.get(server_name)
             if server_conn and server_conn.is_healthy():
                 return server_conn
-                
+
             # If server exists but isn't healthy, remove it so we can create a new one
             if server_conn:
-                logger.info(f"{server_name}: Server exists but is unhealthy, recreating...")
+                logger.info(
+                    f"{server_name}: Server exists but is unhealthy, recreating..."
+                )
                 self.running_servers.pop(server_name)
                 server_conn.request_shutdown()
 
@@ -326,9 +328,9 @@ class MCPConnectionManager(ContextDependent):
         if not server_conn.is_healthy():
             error_msg = server_conn._error_message or "Unknown error"
             raise ServerInitializationError(
-                f"{server_name}: Failed to initialize server: {error_msg}"
+                f"MCP Server: '{server_name}': Failed to initialize with error: '{error_msg}'. Check fastagent.config.yaml"
             )
-        
+
         return server_conn
 
     async def disconnect_server(self, server_name: str) -> None:
@@ -353,16 +355,16 @@ class MCPConnectionManager(ContextDependent):
         """Disconnect all servers that are running under this connection manager."""
         # Get a copy of servers to shutdown
         servers_to_shutdown = []
-        
+
         async with self._lock:
             if not self.running_servers:
                 return
-                
+
             # Make a copy of the servers to shut down
             servers_to_shutdown = list(self.running_servers.items())
             # Clear the dict immediately to prevent any new access
             self.running_servers.clear()
-            
+
         # Release the lock before waiting for servers to shut down
         for name, conn in servers_to_shutdown:
             logger.info(f"{name}: Requesting shutdown...")

mcp_agent/resources/examples/internal/agent.py

@@ -0,0 +1,17 @@
+import asyncio
+from mcp_agent.core.fastagent import FastAgent
+
+# Create the application
+fast = FastAgent("FastAgent Example")
+
+
+# Define the agent
+@fast.agent(servers=["fetch"])
+async def main():
+    # use the --model command line switch or agent arguments to change model
+    async with fast.run() as agent:
+        await agent()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_agent/resources/examples/internal/job.py

@@ -52,7 +52,7 @@ fast = FastAgent("PMO Job Description Generator")
 )
 @fast.evaluator_optimizer(
     name="job_description_writer",
-    optimizer="content_generator",
+    generator="content_generator",
     evaluator="consistency_checker",
     min_rating="EXCELLENT",
     max_refinements=2,

mcp_agent/resources/examples/mcp_researcher/researcher-eval.py

@@ -35,7 +35,7 @@ Summarize your evaluation as a structured response with:
 - Specific feedback and areas for improvement.""",
 )
 @agents.evaluator_optimizer(
-    optimizer="Researcher",
+    generator="Researcher",
     evaluator="Evaluator",
     max_refinements=5,
     min_rating="EXCELLENT",

mcp_agent/resources/examples/researcher/fastagent.config.yaml

@@ -0,0 +1,53 @@
+#
+# Please edit this configuration file to match your environment (on Windows).
+# Examples in comments below - check/change the paths.
+#
+#
+
+execution_engine: asyncio
+logger:
+  type: file
+  level: error
+  truncate_tools: true
+
+mcp:
+  servers:
+    brave:
+      # On windows replace the command and args line to use `node` and the absolute path to the server.
+      # Use `npm i -g @modelcontextprotocol/server-brave-search` to install the server globally.
+      # Use `npm -g root` to find the global node_modules path.`
+      # command: "node"
+      # args: ["c:/Program Files/nodejs/node_modules/@modelcontextprotocol/server-brave-search/dist/index.js"]
+      command: "npx"
+      args: ["-y", "@modelcontextprotocol/server-brave-search"]
+      env:
+        # You can also place your BRAVE_API_KEY in the fastagent.secrets.yaml file.
+        BRAVE_API_KEY: <your_brave_api_key>
+    filesystem:
+      # On windows update the command and arguments to use `node` and the absolute path to the server.
+      # Use `npm i -g @modelcontextprotocol/server-filesystem` to install the server globally.
+      # Use `npm -g root` to find the global node_modules path.`
+      # command: "node"
+      # args: ["c:/Program Files/nodejs/node_modules/@modelcontextprotocol/server-filesystem/dist/index.js","./agent_folder"]
+      command: "npx"
+      args: ["-y", "@modelcontextprotocol/server-filesystem", "./agent_folder/"]
+    interpreter:
+      command: "docker"
+      args: [
+          "run",
+          "-i",
+          "--rm",
+          "--pull=always",
+          "-v",
+          "./agent_folder:/mnt/data/",
+          # Docker needs the absolute path on Windows (e.g. "x:/fastagent/agent_folder:/mnt/data/")
+          # "./agent_folder:/mnt/data/",
+          "ghcr.io/evalstate/mcp-py-repl:latest",
+        ]
+      roots:
+        - uri: "file://./agent_folder/"
+          name: "agent_folder"
+          server_uri_alias: "file:///mnt/data/"
+    fetch:
+      command: "uvx"
+      args: ["mcp-server-fetch"]

mcp_agent/resources/examples/researcher/researcher-eval.py

@@ -0,0 +1,53 @@
+import asyncio
+
+from mcp_agent.core.fastagent import FastAgent
+
+agents = FastAgent(name="Researcher")
+
+
+@agents.agent(
+    name="Researcher",
+    instruction="""
+You are a research assistant, with access to internet search (via Brave),
+website fetch, a python interpreter (you can install packages with uv) and a filesystem.
+Use the current working directory to save and create files with both the Interpreter and Filesystem tools.
+The interpreter has numpy, pandas, matplotlib and seaborn already installed.
+
+You must always provide a summary of the specific sources you have used in your research.
+    """,
+    servers=["brave", "interpreter", "filesystem", "fetch"],
+)
+@agents.agent(
+    name="Evaluator",
+    model="sonnet",
+    instruction="""
+Evaluate the response from the researcher based on the criteria:
+ - Sources cited. Has the researcher provided a summary of the specific sources used in the research?
+ - Validity. Has the researcher cross-checked and validated data and assumptions.
+ - Alignment. Has the researher acted and addressed feedback from any previous assessments?
+ 
+For each criterion:
+- Provide a rating (EXCELLENT, GOOD, FAIR, or POOR).
+- Offer specific feedback or suggestions for improvement.
+
+Summarize your evaluation as a structured response with:
+- Overall quality rating.
+- Specific feedback and areas for improvement.""",
+)
+@agents.evaluator_optimizer(
+    generator="Researcher",
+    evaluator="Evaluator",
+    max_refinements=5,
+    min_rating="EXCELLENT",
+    name="Researcher_Evaluator",
+)
+async def main():
+    async with agents.run() as agent:
+        await agent.prompt("Researcher_Evaluator")
+
+        print("Ask follow up quesions to the Researcher?")
+        await agent.prompt("Researcher", default="STOP")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_agent/resources/examples/workflows/chaining.py

@@ -23,7 +23,11 @@ async def main():
             await agent.url_fetcher("http://llmindset.co.uk/resources/mcp-hfspace/")
         )
 
-    # alternative syntax for above is agent["social_media"].send(message)
+
+#      uncomment below to interact with agents
+#      await agent()
+
+# alternative syntax for above is agent["social_media"].send(message)
 
 
 if __name__ == "__main__":

mcp_agent/resources/examples/workflows/evaluator.py

@@ -9,9 +9,9 @@ from mcp_agent.core.fastagent import FastAgent
 fast = FastAgent("Evaluator-Optimizer")
 
 
-# Define optimizer agent
+# Define generator agent
 @fast.agent(
-    name="optimizer",
+    name="generator",
     instruction="""You are a career coach specializing in cover letter writing.
     You are tasked with generating a compelling cover letter given the job posting,
     candidate details, and company information. Tailor the response to the company and job requirements.
@@ -38,12 +38,13 @@ fast = FastAgent("Evaluator-Optimizer")
     Summarize your evaluation as a structured response with:
     - Overall quality rating.
     - Specific feedback and areas for improvement.""",
-    model="sonnet",
+    # instructor doesn't seem to work for sonnet37
+    # model="sonnet35",
 )
 # Define the evaluator-optimizer workflow
 @fast.evaluator_optimizer(
     name="cover_letter_writer",
-    optimizer="optimizer",  # Reference to optimizer agent
+    generator="generator",  # Reference to generator agent
     evaluator="evaluator",  # Reference to evaluator agent
     min_rating="EXCELLENT",  # Strive for excellence
     max_refinements=3,  # Maximum iterations
@@ -70,6 +71,8 @@ async def main():
             f"Company information: {company_information}",
         )
 
+        await agent()
+
 
 if __name__ == "__main__":
     asyncio.run(main())

mcp_agent/resources/examples/workflows/fastagent.config.yaml

@@ -0,0 +1,24 @@
+# Please edit this configuration file to match your environment (on Windows).
+# Examples in comments below - check/change the paths.
+#
+#
+
+execution_engine: asyncio
+logger:
+  type: file
+  level: error
+  truncate_tools: true
+
+mcp:
+  servers:
+    filesystem:
+      # On windows update the command and arguments to use `node` and the absolute path to the server.
+      # Use `npm i -g @modelcontextprotocol/server-filesystem` to install the server globally.
+      # Use `npm -g root` to find the global node_modules path.`
+      # command: "node"
+      # args: ["c:/Program Files/nodejs/node_modules/@modelcontextprotocol/server-filesystem/dist/index.js","."]
+      command: "npx"
+      args: ["-y", "@modelcontextprotocol/server-filesystem", "."]
+    fetch:
+      command: "uvx"
+      args: ["mcp-server-fetch"]

mcp_agent/resources/examples/workflows/orchestrator.py

@@ -45,10 +45,11 @@ fast = FastAgent("Orchestrator-Workers")
 @fast.orchestrator(
     name="orchestrate",
     agents=["finder", "writer", "proofreader"],
-    model="sonnet",
+    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"
         )
@@ -65,7 +66,7 @@ async def main():
 
         # Send the task
         await agent.orchestrate(task)
-
+        await agent()
 
 if __name__ == "__main__":
     asyncio.run(main())

mcp_agent/resources/examples/workflows/parallel.py

@@ -69,8 +69,9 @@ async def main():
     # Use the app's context manager
     async with fast.run() as agent:
         await agent.parallel(f"student short story submission: {SHORT_STORY}")
+
         # follow-on prompt to task agent
-        # await agent.style_enforcer.prompt(default="STOP")
+        await agent.style_enforcer.prompt(default_prompt="STOP")
 
 
 if __name__ == "__main__":

mcp_agent/workflows/evaluator_optimizer/evaluator_optimizer.py

@@ -66,18 +66,19 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
 
     def __init__(
         self,
-        optimizer: Agent | AugmentedLLM,
+        generator: Agent | AugmentedLLM,
         evaluator: str | Agent | AugmentedLLM,
         min_rating: QualityRating = QualityRating.GOOD,
         max_refinements: int = 3,
-        llm_factory: Callable[[Agent], AugmentedLLM] | None = None,  # TODO: Remove legacy - factory should only be needed for str evaluator
+        llm_factory: Callable[[Agent], AugmentedLLM]
+        | None = None,  # TODO: Remove legacy - factory should only be needed for str evaluator
         context: Optional["Context"] = None,
     ):
         """
         Initialize the evaluator-optimizer workflow.
 
         Args:
-            optimizer: The agent/LLM/workflow that generates responses. Can be:
+            generator: The agent/LLM/workflow that generates responses. Can be:
                      - An Agent that will be converted to an AugmentedLLM
                      - An AugmentedLLM instance
                      - An Orchestrator/Router/ParallelLLM workflow
@@ -90,38 +91,38 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         super().__init__(context=context)
 
         # Set up the optimizer
-        self.name = optimizer.name
+        self.name = generator.name
         self.llm_factory = llm_factory
-        self.optimizer = optimizer
+        self.generator = generator
         self.evaluator = evaluator
 
         # TODO: Remove legacy - optimizer should always be an AugmentedLLM, no conversion needed
-        if isinstance(optimizer, Agent):
+        if isinstance(generator, Agent):
             if not llm_factory:
                 raise ValueError("llm_factory is required when using an Agent")
 
             # Only create new LLM if agent doesn't have one
-            if hasattr(optimizer, "_llm") and optimizer._llm:
-                self.optimizer_llm = optimizer._llm
+            if hasattr(generator, "_llm") and generator._llm:
+                self.generator_llm = generator._llm
             else:
-                self.optimizer_llm = llm_factory(agent=optimizer)
-            
-            self.aggregator = optimizer
+                self.generator_llm = llm_factory(agent=generator)
+
+            self.aggregator = generator
             self.instruction = (
-                optimizer.instruction
-                if isinstance(optimizer.instruction, str)
+                generator.instruction
+                if isinstance(generator.instruction, str)
                 else None
             )
 
-        elif isinstance(optimizer, AugmentedLLM):
-            self.optimizer_llm = optimizer
-            self.aggregator = optimizer.aggregator
-            self.instruction = optimizer.instruction
+        elif isinstance(generator, AugmentedLLM):
+            self.generator_llm = generator
+            self.aggregator = generator.aggregator
+            self.instruction = generator.instruction
 
         else:
-            raise ValueError(f"Unsupported optimizer type: {type(optimizer)}")
+            raise ValueError(f"Unsupported optimizer type: {type(generator)}")
 
-        self.history = self.optimizer_llm.history
+        self.history = self.generator_llm.history
 
         # Set up the evaluator
         if isinstance(evaluator, AugmentedLLM):
@@ -169,17 +170,17 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         best_response = None
         best_rating = QualityRating.POOR
         self.refinement_history = []
-        
+
         # Use a single AsyncExitStack for the entire method to maintain connections
         async with contextlib.AsyncExitStack() as stack:
             # Enter all agent contexts once at the beginning
-            if isinstance(self.optimizer, Agent):
-                await stack.enter_async_context(self.optimizer)
+            if isinstance(self.generator, Agent):
+                await stack.enter_async_context(self.generator)
             if isinstance(self.evaluator, Agent):
                 await stack.enter_async_context(self.evaluator)
-                
+
             # Initial generation
-            response = await self.optimizer_llm.generate(
+            response = await self.generator_llm.generate(
                 message=message,
                 request_params=request_params,
             )
@@ -251,7 +252,7 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
                 )
 
                 # No nested AsyncExitStack here either
-                response = await self.optimizer_llm.generate(
+                response = await self.generator_llm.generate(
                     message=refinement_prompt,
                     request_params=request_params,
                 )
@@ -274,13 +275,13 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         # Handle case where response is a single message
         if not isinstance(response, list):
             return str(response)
-            
+
         # Convert all messages to strings, handling different message types
         result_strings = []
         for r in response:
-            if hasattr(r, 'text'):
+            if hasattr(r, "text"):
                 result_strings.append(r.text)
-            elif hasattr(r, 'content'):
+            elif hasattr(r, "content"):
                 # Handle ToolUseBlock and similar
                 if isinstance(r.content, list):
                     # Typically content is a list of blocks
@@ -290,7 +291,7 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
             else:
                 # Fallback to string representation
                 result_strings.append(str(r))
-                
+
         return "\n".join(result_strings)
 
     async def generate_structured(
@@ -304,7 +305,7 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
             message=message, request_params=request_params
         )
 
-        return await self.optimizer.generate_structured(
+        return await self.generator.generate_structured(
             message=response_str,
             response_model=response_model,
             request_params=request_params,

mcp_agent/workflows/llm/augmented_llm.py

@@ -15,6 +15,7 @@ from mcp.types import (
 )
 
 from mcp_agent.context_dependent import ContextDependent
+from mcp_agent.core.exceptions import PromptExitError
 from mcp_agent.event_progress import ProgressAction
 from mcp_agent.mcp.mcp_aggregator import MCPAggregator, SEP
 from mcp_agent.workflows.llm.llm_selector import ModelSelector
@@ -495,7 +496,10 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
         console.console.print("\n")
 
     async def show_assistant_message(
-        self, message_text: str | Text, highlight_namespaced_tool: str = ""
+        self,
+        message_text: str | Text,
+        highlight_namespaced_tool: str = "",
+        title: str = "ASSISTANT",
     ):
         """Display an assistant message in a formatted panel."""
 
@@ -525,7 +529,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
 
         panel = Panel(
             message_text,
-            title=f"[ASSISTANT]{f' ({self.name})' if self.name else ''}",
+            title=f"[{title}]{f' ({self.name})' if self.name else ''}",
             title_align="left",
             style="green",
             border_style="bold white",
@@ -605,6 +609,8 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
                 result = postprocess
 
             return result
+        except PromptExitError:
+            raise
         except Exception as e:
             return CallToolResult(
                 isError=True,

mcp_agent/workflows/llm/augmented_llm_anthropic.py

@@ -331,7 +331,9 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
             messages=[{"role": "user", "content": response}],
             max_tokens=params.maxTokens,
         )
-
+        await self.show_assistant_message(
+            str(structured_response), title="ASSISTANT/STRUCTURED"
+        )
         return structured_response
 
     @classmethod