fast-agent-mcp 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

{fast_agent_mcp-0.1.2.dist-info → fast_agent_mcp-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.1.2
+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.2.dist-info → fast_agent_mcp-0.1.3.dist-info}/RECORD

@@ -19,13 +19,14 @@ mcp_agent/cli/commands/setup.py,sha256=_SCpd6_PrixqbSaE72JQ7erIRkZnJGmh_3TvvwSzE
 mcp_agent/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/core/agent_app.py,sha256=6U3HLYAJOfyVuUpZVELWT5lOo64-b_sfWp0yn88s7Wo,6085
 mcp_agent/core/agent_types.py,sha256=yKiMbv9QO2dduq4zXmoMZlOZpXJZhM4oNwIq1-134FE,318
-mcp_agent/core/agent_utils.py,sha256=yUJ-qvw5TblqqOsB1vj0Qvcz9mass9awPA6UNNvuw0A,1738
-mcp_agent/core/enhanced_prompt.py,sha256=XraDKdIMW960KXCiMfCEPKDakbf1wHYgvHwD-9CBDi0,13011
+mcp_agent/core/agent_utils.py,sha256=QMvwmxZyCqYhBzSyL9xARsxTuwdmlyjQvrPpsH36HnQ,1888
+mcp_agent/core/enhanced_prompt.py,sha256=Zh1I_PZtQmH_v70dJ-gK5lnLOc42h6_Ai8FGi3aLBvU,13400
 mcp_agent/core/error_handling.py,sha256=D3HMW5odrbJvaKqcpCGj6eDXrbFcuqYaCZz7fyYiTu4,623
 mcp_agent/core/exceptions.py,sha256=a2-JGRwFFRoQEPuAq0JC5PhAJ5TO3xVJfdS4-VN29cw,2225
-mcp_agent/core/fastagent.py,sha256=drf11eHH1xCiyS91v_ADWfaV8T9asm_2Vw0NXxjinpc,58730
-mcp_agent/core/proxies.py,sha256=hXDUpsgGO4xBTIjdUeXj6vULPb8sf55vAFVQh6Ybn60,4411
+mcp_agent/core/fastagent.py,sha256=G0GNOD1JMD37rAaZdYRNsa7gXYjvYiV6Cg39laBKRW8,59714
+mcp_agent/core/proxies.py,sha256=5eIqi63wcJMG9aLu_8QF78mS9w4hYas-bcdJqcWZ-fU,6638
 mcp_agent/core/server_validation.py,sha256=_59cn16nNT4HGPwg19HgxMtHK4MsdWYDUw_CuL-5xek,1696
+mcp_agent/core/simulator_registry.py,sha256=rcd1cyFGx8MAnN5O0UgwElmVKU_uoIBh9s24pxP33Jc,573
 mcp_agent/core/types.py,sha256=Zhi9iW7uiOfdpSt9NC0FCtGRFtJPg4mpZPK2aYi7a7M,817
 mcp_agent/eval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -56,7 +57,7 @@ mcp_agent/mcp/mcp_connection_manager.py,sha256=WLli0w3TVcsszyD9M7zP7vLKPetnQLTf_
 mcp_agent/mcp/stdio.py,sha256=tW075R5rQ-UlflXWFKIFDgCbWbuhKqxhiYolWvyEkFs,3985
 mcp_agent/resources/examples/data-analysis/analysis-campaign.py,sha256=EG-HhaDHltZ4hHAqhgfX_pHM2wem48aYhSIKJxyWHKc,7269
 mcp_agent/resources/examples/data-analysis/analysis.py,sha256=5zLoioZQNKUfXt1EXLrGX3TU06-0N06-L9Gtp9BIr6k,2611
-mcp_agent/resources/examples/data-analysis/fastagent.config.yaml,sha256=eTKGbjnTHhDTeNRPQvG_fr9OQpEZ5Y9v7X2NyCj0V70,530
+mcp_agent/resources/examples/data-analysis/fastagent.config.yaml,sha256=ini94PHyJCfgpjcjHKMMbGuHs6LIj46F1NwY0ll5HVk,1609
 mcp_agent/resources/examples/data-analysis/mount-point/WA_Fn-UseC_-HR-Employee-Attrition.csv,sha256=pcMeOL1_r8m8MziE6xgbBrQbjl5Ijo98yycZn7O-dlk,227977
 mcp_agent/resources/examples/internal/agent.py,sha256=f-jTgYabV3nWCQm0ZP9NtSEWjx3nQbRngzArRufcELg,384
 mcp_agent/resources/examples/internal/job.py,sha256=WEKIAANMEAuKr13__rYf3PqJeTAsNB_kqYqbqVYQlUM,4093
@@ -64,6 +65,7 @@ mcp_agent/resources/examples/internal/social.py,sha256=Cot2lg3PLhLm13gPdVFvFEN28
 mcp_agent/resources/examples/mcp_researcher/researcher-eval.py,sha256=kNPjIU-JwE0oIBQKwhv6lZsUF_SPtYVkiEEbY1ZVZxk,1807
 mcp_agent/resources/examples/researcher/fastagent.config.yaml,sha256=2_VXZneckR6zk6RWzzL-smV_oWmgg4uSkLWqZv8jF0I,1995
 mcp_agent/resources/examples/researcher/researcher-eval.py,sha256=kNPjIU-JwE0oIBQKwhv6lZsUF_SPtYVkiEEbY1ZVZxk,1807
+mcp_agent/resources/examples/researcher/researcher-imp.py,sha256=Xfw2YAyjXd47pQz-uljgG5ii5x77fVuCP2XCivRDI48,7885
 mcp_agent/resources/examples/researcher/researcher.py,sha256=jPRafm7jbpHKkX_dQiYGG3Sw-e1Dm86q-JZT-WZDhM0,1425
 mcp_agent/resources/examples/workflows/agent_build.py,sha256=ioG4X8IbR8wwja8Zdncsk8YAu0VD2Xt1Vhr7saNJCZQ,2855
 mcp_agent/resources/examples/workflows/chaining.py,sha256=1G_0XBcFkSJCOXb6N_iXWlSc_oGAlhENR0k_CN1vJKI,1208
@@ -81,7 +83,7 @@ mcp_agent/workflows/embedding/embedding_base.py,sha256=-c20ggQ8s7XhMxRX-WEhOgHE7
 mcp_agent/workflows/embedding/embedding_cohere.py,sha256=OKTJvKD_uEafd4c2uhR5tBjprea1nyvlJOO-3FDqOnk,1540
 mcp_agent/workflows/embedding/embedding_openai.py,sha256=dntjJ5P-FSMGYuyPZC8MuCU_ehwjXw9wDfzZZuSQN1E,1480
 mcp_agent/workflows/evaluator_optimizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_agent/workflows/evaluator_optimizer/evaluator_optimizer.py,sha256=N4HjckQf_boFRxoWJmuvwq1IEnGYW-k8pKtqjpsnLSE,19223
+mcp_agent/workflows/evaluator_optimizer/evaluator_optimizer.py,sha256=hocvUtTJ5YHiT7utFuzbzY1aqFWCheuB_5dQ_ttOAZ4,20009
 mcp_agent/workflows/intent_classifier/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/workflows/intent_classifier/intent_classifier_base.py,sha256=zTbOmq6EY_abOlme4zl28HM4RWNNS6bbHl3tF7SshJ0,4004
 mcp_agent/workflows/intent_classifier/intent_classifier_embedding.py,sha256=_bWZGukc_q9LdA_Q18UoAMSzhN8tt4K_bRHNUhy7Crw,3997
@@ -92,10 +94,11 @@ mcp_agent/workflows/intent_classifier/intent_classifier_llm_anthropic.py,sha256=
 mcp_agent/workflows/intent_classifier/intent_classifier_llm_openai.py,sha256=zj76WlTYnSCYjBQ_IDi5vFBQGmNwYaoUq1rT730sY98,1940
 mcp_agent/workflows/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/workflows/llm/augmented_llm.py,sha256=Hyx-jwgbMjE_WQ--YjIUvdj6HAgX36IvXBesGy6uic0,25884
-mcp_agent/workflows/llm/augmented_llm_anthropic.py,sha256=XZmumX-og07VR4O2TnEYQ9ZPwGgzLWt3uq6MII-tjnI,23076
+mcp_agent/workflows/llm/augmented_llm_anthropic.py,sha256=q-WWkD59b_aYMn5Dh1Vaz1pknBgFnacvfbdhRd-u9Kk,23183
 mcp_agent/workflows/llm/augmented_llm_openai.py,sha256=a95Q4AFiVw36bXMgYNLFrC2zyDmHERWwkjxJFHlL6JU,25061
+mcp_agent/workflows/llm/enhanced_passthrough.py,sha256=rHNbb6pYllIuVMOhuzUbt63_6WlUnjm57Y7r59N1pnk,2388
 mcp_agent/workflows/llm/llm_selector.py,sha256=G7pIybuBDwtmyxUDov_QrNYH2FoI0qFRu2JfoxWUF5Y,11045
-mcp_agent/workflows/llm/model_factory.py,sha256=7zTJrO2ReHa_6dfh_gY6xO8dTySqGFCKlOG9-AMJ-i8,6920
+mcp_agent/workflows/llm/model_factory.py,sha256=ZyO3FpiIiM2EiFgE8Y5PhdzLglKENfgknmF9unmKWJ8,7075
 mcp_agent/workflows/llm/prompt_utils.py,sha256=EY3eddqnmc_YDUQJFysPnpTH6hr4r2HneeEmX76P8TQ,4948
 mcp_agent/workflows/orchestrator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/workflows/orchestrator/orchestrator.py,sha256=Cu8cfDoTpT_FhGJp-T4NnCVvjkyDO1sbEJ7oKamK47k,26021
@@ -115,8 +118,8 @@ mcp_agent/workflows/swarm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 mcp_agent/workflows/swarm/swarm.py,sha256=-lAIeSWDqbGHGRPTvjiP9nIKWvxxy9DAojl9yQzO1Pw,11050
 mcp_agent/workflows/swarm/swarm_anthropic.py,sha256=pW8zFx5baUWGd5Vw3nIDF2oVOOGNorij4qvGJKdYPcs,1624
 mcp_agent/workflows/swarm/swarm_openai.py,sha256=wfteywvAGkT5bLmIxX_StHJq8144whYmCRnJASAjOes,1596
-fast_agent_mcp-0.1.2.dist-info/METADATA,sha256=qcYR5D0SlhnnqX7er7yFF_0nEOmt4J74hbWiftzw6iI,27861
-fast_agent_mcp-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_agent_mcp-0.1.2.dist-info/entry_points.txt,sha256=2IXtSmDK9XjWN__RWuRIJTgWyW17wJnJ_h-pb0pZAxo,174
-fast_agent_mcp-0.1.2.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
-fast_agent_mcp-0.1.2.dist-info/RECORD,,
+fast_agent_mcp-0.1.3.dist-info/METADATA,sha256=Hxlhct68x9F9beQ16vrdjC_AkzP9ex6-VuAuCkNpl-0,27924
+fast_agent_mcp-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.1.3.dist-info/entry_points.txt,sha256=2IXtSmDK9XjWN__RWuRIJTgWyW17wJnJ_h-pb0pZAxo,174
+fast_agent_mcp-0.1.3.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
+fast_agent_mcp-0.1.3.dist-info/RECORD,,

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,
         },
-    )
+    )

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")

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(

mcp_agent/core/proxies.py

@@ -13,12 +13,10 @@ if TYPE_CHECKING:
     from mcp_agent.core.types import WorkflowType, ProxyDict
 else:
     # Define minimal versions for runtime
-    from mcp_agent.workflows.orchestrator.orchestrator import Orchestrator
-    from mcp_agent.workflows.parallel.parallel_llm import ParallelLLM
-    from mcp_agent.workflows.evaluator_optimizer.evaluator_optimizer import EvaluatorOptimizerLLM
-    from mcp_agent.workflows.router.router_llm import LLMRouter
-    from typing import Union
-    WorkflowType = Union[Orchestrator, ParallelLLM, EvaluatorOptimizerLLM, LLMRouter]
+    from typing import Any
+
+    # Use Any for runtime to avoid circular imports
+    WorkflowType = Any
     ProxyDict = Dict[str, "BaseAgentProxy"]
 
 
@@ -51,7 +49,8 @@ class BaseAgentProxy:
 class AgentProxy(BaseAgentProxy):
     """Legacy proxy for individual agent operations"""
 
-    async def generate_str(self, message: str) -> str:
+    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)
 
 
@@ -62,8 +61,9 @@ class LLMAgentProxy(BaseAgentProxy):
         super().__init__(app, name)
         self._agent = agent
 
-    async def generate_str(self, message: str) -> str:
-        return await self._agent._llm.generate_str(message)
+    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):
@@ -73,8 +73,9 @@ class WorkflowProxy(BaseAgentProxy):
         super().__init__(app, name)
         self._workflow = workflow
 
-    async def generate_str(self, message: str) -> str:
-        return await self._workflow.generate_str(message)
+    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):
@@ -84,7 +85,11 @@ class RouterProxy(BaseAgentProxy):
         super().__init__(app, name)
         self._workflow = workflow
 
-    async def generate_str(self, message: str) -> str:
+    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."
@@ -92,10 +97,9 @@ class RouterProxy(BaseAgentProxy):
         # Get the top result
         top_result = results[0]
         if isinstance(top_result.result, Agent):
-            # Agent route - delegate to the agent
+            # Agent route - delegate to the agent, passing along kwargs
             agent = top_result.result
-
-            return await agent._llm.generate_str(message)
+            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"
@@ -113,15 +117,54 @@ class ChainProxy(BaseAgentProxy):
         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"""
-        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
-
-
+        """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()

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()

mcp_agent/resources/examples/data-analysis/fastagent.config.yaml

@@ -20,3 +20,22 @@ mcp:
         - 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"]

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

@@ -0,0 +1,190 @@
+import asyncio
+from mcp_agent.core.fastagent import FastAgent
+
+agents = FastAgent(name="Enhanced Researcher")
+
+
+@agents.agent(
+    name="ResearchPlanner",
+    model="sonnet",  # Using a more capable model for planning
+    instruction="""
+You are a strategic research planner. Your job is to:
+1. Break down complex research questions into specific sub-questions
+2. Identify the key information sources needed to answer each sub-question
+3. Outline a structured research plan
+
+When given a research topic:
+- Analyze what is being asked and identify the core components
+- Define 3-5 specific sub-questions that need to be answered
+- For each sub-question, suggest specific search queries and information sources
+- Prioritize the most important areas to investigate first
+- Include suggestions for data visualization or analysis if appropriate
+
+Your output should be a clear, structured research plan that the Researcher can follow.
+""",
+    servers=["brave"],
+)
+@agents.agent(
+    name="Researcher",
+    model="sonnet",  # Using a more capable model for deep research
+    instruction="""
+You are an expert research assistant with access to multiple resources:
+- Brave Search for initial exploration and discovering sources
+- Website fetching to read and extract information directly from webpages
+- Python interpreter for data analysis and visualization
+- Filesystem tools to save and organize your findings
+
+RESEARCH METHODOLOGY:
+1. First understand the research plan provided
+2. For each sub-question, use search tools to find multiple relevant sources
+3. Go beyond surface-level information by:
+   - Consulting primary sources when possible
+   - Cross-referencing information across multiple sources
+   - Using the fetch tool to access complete articles rather than just search snippets
+   - Analyzing data with Python when numerical evidence is needed
+   - Creating visualizations when they help clarify complex information
+
+CRITICAL INFORMATION ASSESSMENT:
+- Evaluate the credibility of each source (consider recency, authority, potential bias)
+- Look for consensus across multiple sources
+- Highlight any contradictions or areas of debate in the research
+- Clearly state limitations in the available information
+
+DOCUMENTATION:
+- Save important information, data, and visualizations to files
+- Always create a comprehensive bibliography with links to all sources
+- Include specific citation details (author, date, publication) when available
+- Note which specific information came from which source
+
+FINAL RESPONSE:
+- Structure your findings logically with clear headings
+- Synthesize the information rather than just listing facts
+- Directly address each sub-question from the research plan
+- Use data and visualizations to support key points
+- End with a concise executive summary of your findings
+- Include a "Methodology" section explaining how you conducted your research
+""",
+    servers=["brave", "interpreter", "filesystem", "fetch"],
+    use_history=True,
+)
+@agents.agent(
+    name="FactChecker",
+    instruction="""
+You are a meticulous fact-checker and critical evaluator of research. Your responsibilities are to:
+
+1. Verify factual claims by cross-checking with authoritative sources
+2. Identify any unsupported assertions or logical fallacies
+3. Detect potential biases or limitations in the research methodology
+4. Ensure proper representation of diverse perspectives on controversial topics
+5. Evaluate the quality, reliability, and currency of cited sources
+
+When reviewing research:
+- Flag any claims that lack sufficient evidence or citation
+- Identify information that seems outdated or contradicts current consensus
+- Check for oversimplifications of complex topics
+- Ensure numerical data and statistics are accurately represented
+- Verify that quotations are accurate and in proper context
+- Look for any gaps in the research or important perspectives that were omitted
+
+Your feedback should be specific, actionable, and structured to help improve accuracy and comprehensiveness.
+""",
+    servers=["brave", "fetch"],
+)
+@agents.agent(
+    name="Evaluator",
+    model="sonnet",
+    instruction="""
+You are a senior research quality evaluator with expertise in academic and professional research standards.
+
+COMPREHENSIVE EVALUATION CRITERIA:
+1. Research Methodology
+   - Has the researcher followed a structured approach?
+   - Were appropriate research methods applied?
+   - Is there evidence of strategic information gathering?
+
+2. Source Quality & Diversity
+   - Are sources authoritative, current, and relevant?
+   - Is there appropriate diversity of sources?
+   - Were primary sources consulted when appropriate?
+
+3. Information Depth
+   - Does the research go beyond surface-level information?
+   - Is there evidence of in-depth analysis?
+   - Has the researcher explored multiple aspects of the topic?
+
+4. Critical Analysis
+   - Has information been critically evaluated rather than simply reported?
+   - Are limitations and uncertainties acknowledged?
+   - Are multiple perspectives considered on controversial topics?
+
+5. Data & Evidence
+   - Is quantitative data properly analyzed and presented?
+   - Are visualizations clear, accurate, and informative?
+   - Is qualitative information presented with appropriate context?
+
+6. Documentation & Attribution
+   - Are all sources properly cited with complete reference information?
+   - Is it clear which information came from which source?
+   - Is the bibliography comprehensive and well-formatted?
+
+7. Structure & Communication
+   - Is the research presented in a logical, well-organized manner?
+   - Are findings communicated clearly and precisely?
+   - Is the level of technical language appropriate for the intended audience?
+
+8. Alignment with Previous Feedback
+   - Has the researcher addressed specific feedback from previous evaluations?
+   - Have requested improvements been successfully implemented?
+
+For each criterion, provide:
+- A detailed RATING (EXCELLENT, GOOD, FAIR, or POOR)
+- Specific examples from the research that justify your rating
+- Clear, actionable suggestions for improvement
+
+Your evaluation should conclude with:
+- An OVERALL RATING that reflects the research quality
+- A concise summary of the research's major strengths
+- A prioritized list of the most important areas for improvement
+
+The researcher should be able to understand exactly why they received their rating and what specific steps they can take to improve.
+""",
+)
+@agents.chain(
+    name="ResearchProcess",
+    sequence=["ResearchPlanner", "Researcher", "FactChecker"],
+    instruction="A comprehensive research workflow that plans, executes, and verifies research",
+    cumulative=True,
+)
+@agents.evaluator_optimizer(
+    generator="ResearchProcess",
+    evaluator="Evaluator",
+    max_refinements=3,
+    min_rating="EXCELLENT",
+    name="EnhancedResearcher",
+)
+async def main():
+    async with agents.run() as agent:
+        # Start with a warm-up to set expectations and explain the research approach
+        await agent.Researcher.send(
+            """I'm an enhanced research assistant trained to conduct thorough, evidence-based research. 
+            I'll approach your question by:
+            1. Creating a structured research plan
+            2. Gathering information from multiple authoritative sources
+            3. Analyzing data and creating visualizations when helpful
+            4. Fact-checking and verifying all information
+            5. Providing a comprehensive, well-documented answer
+
+            What would you like me to research for you today?"""
+        )
+
+        # Start the main research workflow
+        await agent.prompt("EnhancedResearcher")
+
+        print(
+            "\nWould you like to ask follow-up questions to the Researcher? (Type 'STOP' to end)"
+        )
+        await agent.prompt("Researcher", default="STOP")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_agent/workflows/evaluator_optimizer/evaluator_optimizer.py

@@ -127,6 +127,7 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         self.max_refinements = max_refinements
 
         # Determine generator's history setting before super().__init__
+
         if isinstance(generator, Agent):
             self.generator_use_history = generator.config.use_history
         elif isinstance(generator, AugmentedLLM):
@@ -140,6 +141,11 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
                     "use_history",
                     getattr(generator.default_request_params, "use_history", False),
                 )
+        # Handle ChainProxy with type checking
+        elif hasattr(generator, "_sequence") and hasattr(generator, "_agent_proxies"):
+            # This is how we detect a ChainProxy without directly importing it
+            # For ChainProxy, we'll default use_history to False
+            self.generator_use_history = False
         else:
             raise ValueError(f"Unsupported optimizer type: {type(generator)}")
 
@@ -152,6 +158,7 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
         self._llm = PassthroughLLM(name=f"{self.name}_passthrough", context=context)
 
         # Set up the generator
+
         if isinstance(generator, Agent):
             if not llm_factory:
                 raise ValueError("llm_factory is required when using an Agent")
@@ -171,6 +178,13 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
                     else None
                 )  # Fallback to generator's
             )
+        elif hasattr(generator, "_sequence") and hasattr(generator, "_agent_proxies"):
+            # For ChainProxy, use it directly for generation
+            self.generator_llm = generator
+            self.aggregator = None
+            self.instruction = (
+                instruction or f"Chain of agents: {', '.join(generator._sequence)}"
+            )
 
         elif isinstance(generator, AugmentedLLM):
             self.generator_llm = generator
@@ -252,7 +266,7 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
             if isinstance(self.evaluator, Agent):
                 await stack.enter_async_context(self.evaluator)
 
-            # Initial generation
+            # Initial generation - pass parameters to any type of generator
             response = await self.generator_llm.generate_str(
                 message=message,
                 request_params=params,  # Pass params which may override use_history
@@ -321,6 +335,7 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
                     use_history=self.generator_use_history,  # Use the generator's history setting
                 )
 
+                # Pass parameters to any type of generator
                 response = await self.generator_llm.generate_str(
                     message=refinement_prompt,
                     request_params=params,  # Pass params which may override use_history

mcp_agent/workflows/llm/augmented_llm_anthropic.py

@@ -332,15 +332,21 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
         final_text: List[str] = []
 
+        # Process all responses and collect all text content
         for response in responses:
+            # Extract text content from each message
+            message_text = ""
             for content in response.content:
                 if content.type == "text":
-                    final_text.append(content.text)
-        #             elif content.type == "tool_use":
-        #                 final_text.append(
-        #                     f"[Calling tool {content.name} with args {content.input}]"
-        #                 )
-        # TODO -- check whether this should be reinstated - OpenAI doesn't return this....
+                    # Extract text from text blocks
+                    message_text += content.text
+
+            # Only append non-empty text
+            if message_text:
+                final_text.append(message_text)
+
+        # TODO -- make tool detail inclusion behaviour configurable
+        # Join all collected text
         return "\n".join(final_text)
 
     async def generate_structured(

mcp_agent/workflows/llm/enhanced_passthrough.py

@@ -0,0 +1,70 @@
+# src/mcp_agent/workflows/llm/enhanced_passthrough.py
+
+
+import datetime
+from typing import List, Optional, Union
+from mcp_agent.core.simulator_registry import SimulatorRegistry
+from mcp_agent.workflows.llm.augmented_llm import (
+    AugmentedLLM,
+    MessageParamT,
+    RequestParams,
+)
+
+
+class EnhancedPassthroughLLM(AugmentedLLM):
+    """Enhanced passthrough LLM for testing parameter handling and workflows"""
+
+    def __init__(self, name: str = "Simulator", context=None, **kwargs):
+        super().__init__(name=name, context=context, **kwargs)
+        self.simulation_mode = kwargs.get("simulation_mode", "passthrough")
+        self.request_log = []
+        self.last_request_params = None
+
+        # Register this instance with the registry
+        SimulatorRegistry.register(self.name, self)
+
+    async def generate_str(
+        self,
+        message: Union[str, MessageParamT, List[MessageParamT]],
+        request_params: Optional[RequestParams] = None,
+    ) -> str:
+        """Capture parameters and log the request"""
+        # Store for assertion testing
+        self.last_request_params = request_params
+
+        # Log the request
+        self.request_log.append(
+            {
+                "timestamp": datetime.now().isoformat(),
+                "message": str(message),
+                "request_params": request_params.model_dump()
+                if request_params
+                else None,
+            }
+        )
+
+        # Display for debugging
+        self.show_user_message(str(message), model="simulator", chat_turn=0)
+
+        # Simulate response
+        result = f"[SIMULATOR] Response to: {message}"
+        await self.show_assistant_message(result, title="SIMULATOR")
+
+        return result
+
+    # Other generate methods with similar parameter capture
+
+    def get_parameter_usage_report(self):
+        """Generate report of parameter usage"""
+        param_usage = {}
+
+        for req in self.request_log:
+            params = req.get("request_params", {})
+            if params:
+                for key, value in params.items():
+                    if key not in param_usage:
+                        param_usage[key] = {"count": 0, "values": set()}
+                    param_usage[key]["count"] += 1
+                    param_usage[key]["values"].add(str(value))
+
+        return {"total_requests": len(self.request_log), "parameter_usage": param_usage}

mcp_agent/workflows/llm/model_factory.py

@@ -7,6 +7,7 @@ from mcp_agent.core.exceptions import ModelConfigError
 from mcp_agent.workflows.llm.augmented_llm_anthropic import AnthropicAugmentedLLM
 from mcp_agent.workflows.llm.augmented_llm_openai import OpenAIAugmentedLLM
 from mcp_agent.workflows.llm.augmented_llm import RequestParams
+from mcp_agent.workflows.llm.enhanced_passthrough import EnhancedPassthroughLLM
 
 # Type alias for LLM classes
 LLMClass = Union[Type[AnthropicAugmentedLLM], Type[OpenAIAugmentedLLM]]
@@ -17,6 +18,7 @@ class Provider(Enum):
 
     ANTHROPIC = auto()
     OPENAI = auto()
+    SIMULATOR = auto()
 
 
 class ReasoningEffort(Enum):
@@ -91,6 +93,7 @@ class ModelFactory:
     PROVIDER_CLASSES: Dict[Provider, LLMClass] = {
         Provider.ANTHROPIC: AnthropicAugmentedLLM,
         Provider.OPENAI: OpenAIAugmentedLLM,
+        Provider.SIMULATOR: EnhancedPassthroughLLM,
     }
 
     @classmethod