fast-agent-mcp 0.1.1__tar.gz → 0.1.3__tar.gz

{fast_agent_mcp-0.1.1 → fast_agent_mcp-0.1.3}/.gitignore

@@ -180,3 +180,5 @@ mcp_agent.config.yaml
 mcp_agent.secrets.yaml
 fastagent.secrets.yaml
 CLAUDE.md
+example-outputs/
+

{fast_agent_mcp-0.1.1 → fast_agent_mcp-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.1.1
+Version: 0.1.3
 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
@@ -366,7 +366,7 @@ Saved as `social.py` we can now run this workflow from the command line with:
 uv run social.py --agent social_media --message "<url>"
 ```
 
-Add the `--quiet` switch to only return the final response, which is useful for simple automations.
+Add the `--quiet` switch to disable progress and message display and return only the final response - useful for simple automations.
 
 ## Workflows
 
@@ -426,7 +426,7 @@ The Parallel Workflow sends the same message to multiple Agents simultaneously (
 )
 ```
 
-Look at the `parallel.py` workflow example for more examples. If you don't specify a `fan-in` agent, the `parallel` returns the combined Agent results verbatim.
+If you don't specify a `fan-in` agent, the `parallel` returns the combined Agent results verbatim.
 
 `parallel` is also useful to ensemble ideas from different LLMs.
 
@@ -526,6 +526,7 @@ agent["greeter"].send("Good Evening!")          # Dictionary access is supported
   name="chain",                          # name of the chain
   sequence=["agent1", "agent2", ...],    # list of agents in execution order
   instruction="instruction",             # instruction to describe the chain for other workflows
+  cumulative=False                       # whether to accumulate messages through the chain
   continue_with_final=True,              # open chat with agent at end of chain after prompting
 )
 ```

{fast_agent_mcp-0.1.1 → fast_agent_mcp-0.1.3}/README.md

@@ -129,7 +129,7 @@ Saved as `social.py` we can now run this workflow from the command line with:
 uv run social.py --agent social_media --message "<url>"
 ```
 
-Add the `--quiet` switch to only return the final response, which is useful for simple automations.
+Add the `--quiet` switch to disable progress and message display and return only the final response - useful for simple automations.
 
 ## Workflows
 
@@ -189,7 +189,7 @@ The Parallel Workflow sends the same message to multiple Agents simultaneously (
 )
 ```
 
-Look at the `parallel.py` workflow example for more examples. If you don't specify a `fan-in` agent, the `parallel` returns the combined Agent results verbatim.
+If you don't specify a `fan-in` agent, the `parallel` returns the combined Agent results verbatim.
 
 `parallel` is also useful to ensemble ideas from different LLMs.
 
@@ -289,6 +289,7 @@ agent["greeter"].send("Good Evening!")          # Dictionary access is supported
   name="chain",                          # name of the chain
   sequence=["agent1", "agent2", ...],    # list of agents in execution order
   instruction="instruction",             # instruction to describe the chain for other workflows
+  cumulative=False                       # whether to accumulate messages through the chain
   continue_with_final=True,              # open chat with agent at end of chain after prompting
 )
 ```

{fast_agent_mcp-0.1.1 → fast_agent_mcp-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.1.1"
+version = "0.1.3"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }

{fast_agent_mcp-0.1.1 → fast_agent_mcp-0.1.3}/src/mcp_agent/core/agent_utils.py

@@ -8,10 +8,11 @@ from mcp_agent.event_progress import ProgressAction
 
 # Handle circular imports
 if TYPE_CHECKING:
-    from mcp_agent.core.proxies import BaseAgentProxy, LLMAgentProxy
+    from mcp_agent.core.proxies import BaseAgentProxy
     from mcp_agent.core.types import AgentOrWorkflow, ProxyDict
 else:
-    from mcp_agent.core.proxies import BaseAgentProxy, LLMAgentProxy
+    from mcp_agent.core.proxies import BaseAgentProxy
+
     # Define minimal types for runtime
     AgentOrWorkflow = object  # Simple placeholder
     ProxyDict = dict  # Simple placeholder
@@ -27,8 +28,13 @@ def unwrap_proxy(proxy: BaseAgentProxy) -> AgentOrWorkflow:
     Returns:
         The underlying Agent or workflow instance
     """
+    from mcp_agent.core.proxies import LLMAgentProxy, ChainProxy
+
     if isinstance(proxy, LLMAgentProxy):
         return proxy._agent
+    elif isinstance(proxy, ChainProxy):
+        # Return the ChainProxy itself as the workflow
+        return proxy
     return proxy._workflow
 
 
@@ -51,7 +57,7 @@ def get_agent_instances(
 def log_agent_load(app, agent_name: str) -> None:
     """
     Log agent loading event to application logger.
-    
+
     Args:
         app: The application instance
         agent_name: Name of the agent being loaded
@@ -62,4 +68,4 @@ def log_agent_load(app, agent_name: str) -> None:
             "progress_action": ProgressAction.LOADED,
             "agent_name": agent_name,
         },
-    )
+    )

{fast_agent_mcp-0.1.1 → fast_agent_mcp-0.1.3}/src/mcp_agent/core/enhanced_prompt.py

@@ -11,6 +11,7 @@ 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 prompt_toolkit.styles import Style
 from pygments.lexers.python import PythonLexer
 from rich import print as rich_print
 
@@ -31,8 +32,8 @@ 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()
+# Track whether help text has been shown globally
+help_message_shown = False
 
 
 class AgentCompleter(Completer):
@@ -87,7 +88,7 @@ class AgentCompleter(Completer):
                         start_position=-len(agent_name),
                         display=agent,
                         display_meta=agent_type,
-                        style="bg:ansiblack fg:ansiblue",
+                        #                        style="bg:ansiblack fg:ansiblue",
                     )
 
 
@@ -168,7 +169,7 @@ async def get_enhanced_input(
     Returns:
         User input string
     """
-    global in_multiline_mode, available_agents
+    global in_multiline_mode, available_agents, help_message_shown
 
     # Update global state
     in_multiline_mode = multiline
@@ -210,10 +211,21 @@ async def get_enhanced_input(
         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} | <dim>v{app_version}</dim>"
+            f" <style fg='{toolbar_color}' bg='ansiblack'> {agent_name} </style> Mode: <style fg='{mode_style}' bg='ansiblack'> {mode_text} </style> {newline} | {shortcut_text} | v{app_version}"
         )
 
+    # A more terminal-agnostic style that should work across themes
+    custom_style = Style.from_dict(
+        {
+            "completion-menu.completion": "bg:#ansiblack #ansigreen",
+            "completion-menu.completion.current": "bg:#ansiblack bold #ansigreen",
+            "completion-menu.meta.completion": "bg:#ansiblack #ansiblue",
+            "completion-menu.meta.completion.current": "bg:#ansibrightblack #ansiblue",
+            "bottom-toolbar": "#ansiblack bg:#ansigray",
+        }
+    )
     # Create session with history and completions
     session = PromptSession(
         history=agent_histories[agent_name],
@@ -227,7 +239,8 @@ async def get_enhanced_input(
         multiline=Condition(lambda: in_multiline_mode),
         complete_in_thread=True,
         mouse_support=False,
-        bottom_toolbar=get_toolbar,  # Pass the function here
+        bottom_toolbar=get_toolbar,
+        style=custom_style,
     )
 
     # Create key bindings with a reference to the app
@@ -237,7 +250,7 @@ async def get_enhanced_input(
     session.app.key_bindings = bindings
 
     # Create formatted prompt text
-    prompt_text = f"<ansicyan>{agent_name}</ansicyan> > "
+    prompt_text = f"<ansibrightblue>{agent_name}</ansibrightblue> > "
 
     # Add default value display if requested
     if show_default and default and default != "STOP":
@@ -246,25 +259,24 @@ async def get_enhanced_input(
     # 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")
+            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]"
                 )
 
-    # Mention available features but only on first usage for this agent
-    if agent_name not in agent_messages_shown:
+    # Mention available features but only on first usage globally
+    if not help_message_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]"
+                "[dim]Type /help for commands. Ctrl+T toggles multiline mode.[/dim]"
             )
         else:
             rich_print(
-                "[dim]Tip: Type /help for commands, @Agent to switch agent. Ctrl+T toggles multiline mode. [/dim]"
+                "[dim]Type /help for commands, @agent to switch agent. Ctrl+T toggles multiline mode. [/dim]"
             )
-        agent_messages_shown.add(agent_name)
+        rich_print()
+        help_message_shown = True
 
     # Process special commands
     def pre_process_input(text):
@@ -325,7 +337,6 @@ async def handle_special_commands(command, agent_app=None):
         rich_print(
             "  Enter          - Submit (normal mode) / New line (multiline mode)"
         )
-        rich_print("  \\ + Enter     - Insert new line in normal mode")
         rich_print("  Ctrl+Enter      - Always submit (in any mode)")
         rich_print("  Ctrl+T         - Toggle multiline mode")
         rich_print("  Ctrl+L         - Clear input")

{fast_agent_mcp-0.1.1 → fast_agent_mcp-0.1.3}/src/mcp_agent/core/fastagent.py

@@ -696,6 +696,7 @@ class FastAgent(ContextDependent):
         use_history: bool = True,
         request_params: Optional[Dict] = None,
         continue_with_final: bool = True,
+        cumulative: bool = False,
     ) -> Callable:
         """
         Decorator to create and register a chain of agents.
@@ -709,6 +710,8 @@ class FastAgent(ContextDependent):
             use_history: Whether to maintain conversation history
             request_params: Additional request parameters
             continue_with_final: When using prompt(), whether to continue with the final agent after processing chain (default: True)
+            cumulative: When True, each agent receives all previous agent responses concatenated (default: False)
+                        When False, each agent only gets the output of the previous agent (default behavior)
         """
         # Support both parameter names
         agent_sequence = sequence or agents
@@ -717,8 +720,11 @@ class FastAgent(ContextDependent):
 
         # Auto-generate instruction if not provided
         if instruction is None:
-            # We'll generate it later when we have access to the agent configs and can see servers
-            instruction = f"Chain of agents: {', '.join(agent_sequence)}"
+            # Generate an appropriate instruction based on mode
+            if cumulative:
+                instruction = f"Cumulative chain of agents: {', '.join(agent_sequence)}"
+            else:
+                instruction = f"Chain of agents: {', '.join(agent_sequence)}"
 
         decorator = self._create_decorator(
             AgentType.CHAIN,
@@ -734,6 +740,7 @@ class FastAgent(ContextDependent):
             use_history=use_history,
             request_params=request_params,
             continue_with_final=continue_with_final,
+            cumulative=cumulative,
         )
         return decorator
 
@@ -912,9 +919,13 @@ class FastAgent(ContextDependent):
                             f"evaluator={agent_data['evaluator']}"
                         )
 
-                    optimizer_model = (
-                        generator.config.model if isinstance(generator, Agent) else None
-                    )
+                    # 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'):
+                        # For ChainProxy, use the config model directly
+                        optimizer_model = config.model
 
                     instance = EvaluatorOptimizerLLM(
                         name=config.name,  # Pass name from config
@@ -993,6 +1004,10 @@ class FastAgent(ContextDependent):
                     instance._continue_with_final = agent_data.get(
                         "continue_with_final", True
                     )
+                    # Set cumulative behavior from configuration
+                    instance._cumulative = agent_data.get(
+                        "cumulative", False
+                    )
 
                 # We removed the AgentType.PASSTHROUGH case
                 # Passthrough agents are now created as BASIC agents with a special LLM
@@ -1307,12 +1322,6 @@ class FastAgent(ContextDependent):
                 # First create basic agents
                 active_agents = await self._create_basic_agents(agent_app)
 
-                # Create workflow types that don't depend on other workflows first
-                evaluator_optimizers = await self._create_evaluator_optimizers(
-                    agent_app, active_agents
-                )
-                active_agents.update(evaluator_optimizers)
-
                 # Create parallel agents next as they might be dependencies
                 parallel_agents = await self._create_parallel_agents(
                     agent_app, active_agents
@@ -1323,11 +1332,17 @@ class FastAgent(ContextDependent):
                 routers = await self._create_routers(agent_app, active_agents)
                 active_agents.update(routers)
 
-                # Create chains next
+                # Create chains next - MOVED UP because evaluator-optimizers might depend on chains
                 chains = await self._create_agents_in_dependency_order(
                     agent_app, active_agents, AgentType.CHAIN
                 )
                 active_agents.update(chains)
+                
+                # Now create evaluator-optimizers AFTER chains are available
+                evaluator_optimizers = await self._create_evaluator_optimizers(
+                    agent_app, active_agents
+                )
+                active_agents.update(evaluator_optimizers)
 
                 # Create orchestrators last as they might depend on any other agent type
                 orchestrators = await self._create_orchestrators(

fast_agent_mcp-0.1.3/src/mcp_agent/core/proxies.py

@@ -0,0 +1,170 @@
+"""
+Proxy classes for agent interactions.
+These proxies provide a consistent interface for interacting with different types of agents.
+"""
+
+from typing import List, Optional, Dict, TYPE_CHECKING
+
+from mcp_agent.agents.agent import Agent
+from mcp_agent.app import MCPApp
+
+# Handle circular imports
+if TYPE_CHECKING:
+    from mcp_agent.core.types import WorkflowType, ProxyDict
+else:
+    # Define minimal versions for runtime
+    from typing import Any
+
+    # Use Any for runtime to avoid circular imports
+    WorkflowType = Any
+    ProxyDict = Dict[str, "BaseAgentProxy"]
+
+
+class BaseAgentProxy:
+    """Base class for all proxy types"""
+
+    def __init__(self, app: MCPApp, name: str):
+        self._app = app
+        self._name = name
+
+    async def __call__(self, message: Optional[str] = None) -> str:
+        """Allow: agent.researcher('message')"""
+        return await self.send(message)
+
+    async def send(self, message: Optional[str] = None) -> str:
+        """Allow: agent.researcher.send('message')"""
+        if message is None:
+            return await self.prompt()
+        return await self.generate_str(message)
+
+    async def prompt(self, default_prompt: str = "") -> str:
+        """Allow: agent.researcher.prompt()"""
+        return await self._app.prompt(self._name, default_prompt)
+
+    async def generate_str(self, message: str) -> str:
+        """Generate response for a message - must be implemented by subclasses"""
+        raise NotImplementedError("Subclasses must implement generate_str")
+
+
+class AgentProxy(BaseAgentProxy):
+    """Legacy proxy for individual agent operations"""
+
+    async def generate_str(self, message: str, **kwargs) -> str:
+        """Forward only the message to app.send, ignoring kwargs for legacy compatibility"""
+        return await self._app.send(self._name, message)
+
+
+class LLMAgentProxy(BaseAgentProxy):
+    """Proxy for regular agents that use _llm.generate_str()"""
+
+    def __init__(self, app: MCPApp, name: str, agent: Agent):
+        super().__init__(app, name)
+        self._agent = agent
+
+    async def generate_str(self, message: str, **kwargs) -> str:
+        """Forward message and all kwargs to the agent's LLM"""
+        return await self._agent._llm.generate_str(message, **kwargs)
+
+
+class WorkflowProxy(BaseAgentProxy):
+    """Proxy for workflow types that implement generate_str() directly"""
+
+    def __init__(self, app: MCPApp, name: str, workflow: WorkflowType):
+        super().__init__(app, name)
+        self._workflow = workflow
+
+    async def generate_str(self, message: str, **kwargs) -> str:
+        """Forward message and all kwargs to the underlying workflow"""
+        return await self._workflow.generate_str(message, **kwargs)
+
+
+class RouterProxy(BaseAgentProxy):
+    """Proxy for LLM Routers"""
+
+    def __init__(self, app: MCPApp, name: str, workflow: WorkflowType):
+        super().__init__(app, name)
+        self._workflow = workflow
+
+    async def generate_str(self, message: str, **kwargs) -> str:
+        """
+        Route the message and forward kwargs to the resulting agent if applicable.
+        Note: For now, route() itself doesn't accept kwargs.
+        """
+        results = await self._workflow.route(message)
+        if not results:
+            return "No appropriate route found for the request."
+
+        # Get the top result
+        top_result = results[0]
+        if isinstance(top_result.result, Agent):
+            # Agent route - delegate to the agent, passing along kwargs
+            agent = top_result.result
+            return await agent._llm.generate_str(message, **kwargs)
+        elif isinstance(top_result.result, str):
+            # Server route - use the router directly
+            return "Tool call requested by router - not yet supported"
+
+        return f"Routed to: {top_result.result} ({top_result.confidence}): {top_result.reasoning}"
+
+
+class ChainProxy(BaseAgentProxy):
+    """Proxy for chained agent operations"""
+
+    def __init__(
+        self, app: MCPApp, name: str, sequence: List[str], agent_proxies: ProxyDict
+    ):
+        super().__init__(app, name)
+        self._sequence = sequence
+        self._agent_proxies = agent_proxies
+        self._continue_with_final = True  # Default behavior
+        self._cumulative = False  # Default to sequential chaining
+
+    async def generate_str(self, message: str) -> str:
+        """Chain message through a sequence of agents with optional cumulative behavior"""
+        if not self._cumulative:
+            # Original sequential behavior
+            current_message = message
+            for agent_name in self._sequence:
+                proxy = self._agent_proxies[agent_name]
+                current_message = await proxy.generate_str(current_message)
+            return current_message
+        else:
+            # Cumulative behavior
+            original_message = message
+            agent_responses = {}
+
+            for agent_name in self._sequence:
+                proxy = self._agent_proxies[agent_name]
+
+                if not agent_responses:  # First agent
+                    response = await proxy.generate_str(original_message)
+                else:
+                    # Construct context with previous responses
+                    context_message = "The following request was sent to the agents:\n"
+                    context_message += f"<fastagent:request>\n{original_message}\n</fastagent:request>\n\n"
+
+                    context_message += "Previous agent responses:\n"
+
+                    for prev_name in self._sequence:
+                        if prev_name in agent_responses:
+                            prev_response = agent_responses[prev_name]
+                            context_message += f'<fastagent:response agent="{prev_name}">\n{prev_response}\n</fastagent:response>\n\n'
+
+                    context_message += f"Your task is to build upon this work to address: {original_message}"
+
+                    response = await proxy.generate_str(context_message)
+
+                agent_responses[agent_name] = response
+
+            # Format final output with ALL responses in XML format
+            final_output = "The following request was sent to the agents:\n"
+            final_output += (
+                f"<fastagent:request>\n{original_message}\n</fastagent:request>\n\n"
+            )
+
+            for agent_name in self._sequence:
+                response = agent_responses[agent_name]
+                final_output += f'<fastagent:response agent="{agent_name}">\n{response}\n</fastagent:response>\n\n'
+
+            # Return the XML-structured combination of all responses
+            return final_output.strip()

fast_agent_mcp-0.1.3/src/mcp_agent/core/simulator_registry.py

@@ -0,0 +1,22 @@
+from typing import Optional, Any
+
+
+class SimulatorRegistry:
+    """Registry to access simulator instances for testing assertions"""
+
+    _instances = {}
+
+    @classmethod
+    def register(cls, name: str, simulator: "Any"):
+        """Register a simulator instance"""
+        cls._instances[name] = simulator
+
+    @classmethod
+    def get(cls, name: str) -> Optional["Any"]:
+        """Get a simulator by name"""
+        return cls._instances.get(name)
+
+    @classmethod
+    def clear(cls):
+        """Clear registry (useful between tests)"""
+        cls._instances.clear()

fast_agent_mcp-0.1.3/src/mcp_agent/resources/examples/data-analysis/fastagent.config.yaml

@@ -0,0 +1,41 @@
+default_model: sonnet
+
+# on windows, adjust the mount point to be the full path e.g. x:/temp/data-analysis/mount-point:/mnt/data/
+
+mcp:
+  servers:
+    interpreter:
+      command: "docker"
+      args:
+        [
+          "run",
+          "-i",
+          "--rm",
+          "--pull=always",
+          "-v",
+          "./mount-point:/mnt/data/",
+          "ghcr.io/evalstate/mcp-py-repl:latest",
+        ]
+      roots:
+        - uri: "file://./mount-point/"
+          name: "test_data"
+          server_uri_alias: "file:///mnt/data/"
+    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", "./mount-point/"]
+    fetch:
+      command: "uvx"
+      args: ["mcp-server-fetch"]
+    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"]