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

mcp_agent/core/fastagent.py

@@ -10,266 +10,57 @@ from typing import (
     Callable,
     TypeVar,
     Any,
-    Union,
-    TypeAlias,
     Literal,
 )
-from enum import Enum
 import yaml
 import argparse
 from contextlib import asynccontextmanager
 
-from mcp_agent.core.exceptions import (
-    AgentConfigError,
-    ModelConfigError,
-    PromptExitError,
-    ServerConfigError,
-    ProviderKeyError,
-    ServerInitializationError,
-)
-
 from mcp_agent.app import MCPApp
 from mcp_agent.agents.agent import Agent, AgentConfig
 from mcp_agent.context_dependent import ContextDependent
+from mcp_agent.config import Settings
 from mcp_agent.event_progress import ProgressAction
-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,
     QualityRating,
 )
-from mcp_agent.workflows.router.router_llm import LLMRouter
-from mcp_agent.config import Settings
-from rich import print
-from mcp_agent.progress_display import progress_display
-from mcp_agent.workflows.llm.model_factory import ModelFactory
 from mcp_agent.workflows.llm.augmented_llm import AugmentedLLM, RequestParams
+from mcp_agent.workflows.llm.model_factory import ModelFactory
+from mcp_agent.workflows.orchestrator.orchestrator import Orchestrator
+from mcp_agent.workflows.parallel.parallel_llm import ParallelLLM
+from mcp_agent.workflows.router.router_llm import LLMRouter
 
-# TODO -- resintate once Windows&Python 3.13 platform issues are fixed
-# import readline  # noqa: F401
-
-# Type aliases for better readability
-WorkflowType: TypeAlias = Union[
-    Orchestrator, ParallelLLM, EvaluatorOptimizerLLM, LLMRouter
-]
-AgentOrWorkflow: TypeAlias = Union[Agent, WorkflowType]
-ProxyDict: TypeAlias = Dict[str, "BaseAgentProxy"]
-
-
-class AgentType(Enum):
-    """Enumeration of supported agent types."""
+from mcp_agent.core.agent_app import AgentApp
+from mcp_agent.core.agent_types import AgentType
+from mcp_agent.core.agent_utils import unwrap_proxy, get_agent_instances, log_agent_load
+from mcp_agent.core.error_handling import handle_error
+from mcp_agent.core.proxies import (
+    BaseAgentProxy,
+    LLMAgentProxy,
+    WorkflowProxy,
+    RouterProxy,
+    ChainProxy,
+)
+from mcp_agent.core.types import AgentOrWorkflow, ProxyDict
+from mcp_agent.core.exceptions import (
+    AgentConfigError,
+    CircularDependencyError,
+    ModelConfigError,
+    PromptExitError,
+    ServerConfigError,
+    ProviderKeyError,
+    ServerInitializationError,
+)
 
-    BASIC = "agent"
-    ORCHESTRATOR = "orchestrator"
-    PARALLEL = "parallel"
-    EVALUATOR_OPTIMIZER = "evaluator_optimizer"
-    ROUTER = "router"
+# TODO -- reinstate once Windows&Python 3.13 platform issues are fixed
+# import readline  # noqa: F401
 
+from rich import print
 
 T = TypeVar("T")  # For the wrapper classes
 
 
-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) -> str:
-        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) -> str:
-        return await self._agent._llm.generate_str(message)
-
-
-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) -> str:
-        return await self._workflow.generate_str(message)
-
-
-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) -> str:
-        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
-            agent = top_result.result
-
-            return await agent._llm.generate_str(message)
-        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 AgentApp:
-    """Main application wrapper"""
-
-    def __init__(self, app: MCPApp, agents: ProxyDict):
-        self._app = app
-        self._agents = agents
-        # Optional: set default agent for direct calls
-        self._default = next(iter(agents)) if agents else None
-
-    async def send(self, agent_name: str, message: Optional[str]) -> str:
-        """Core message sending"""
-        if agent_name not in self._agents:
-            raise ValueError(f"No agent named '{agent_name}'")
-
-        if not message or "" == message:
-            return await self.prompt(agent_name)
-
-        proxy = self._agents[agent_name]
-        return await proxy.generate_str(message)
-
-    async def prompt(self, agent_name: Optional[str] = None, default: str = "") -> str:
-        """
-        Interactive prompt for sending messages with advanced features.
-
-        Args:
-            agent_name: Optional target agent name (uses default if not specified)
-            default: Default message to use when user presses enter
-        """
-        from .enhanced_prompt import get_enhanced_input, handle_special_commands
-
-        agent = agent_name or self._default
-
-        if agent not in self._agents:
-            raise ValueError(f"No agent named '{agent}'")
-
-        # Pass all available agent names for auto-completion
-        available_agents = list(self._agents.keys())
-
-        # Create agent_types dictionary mapping agent names to their types
-        agent_types = {}
-        for name, proxy in self._agents.items():
-            # Determine agent type based on the proxy type
-            if isinstance(proxy, LLMAgentProxy):
-                # Convert AgentType.BASIC.value ("agent") to "Agent"
-                agent_types[name] = "Agent"
-            elif isinstance(proxy, RouterProxy):
-                agent_types[name] = "Router"
-            elif isinstance(proxy, WorkflowProxy):
-                # For workflow proxies, check the workflow type
-                workflow = proxy._workflow
-                if isinstance(workflow, Orchestrator):
-                    agent_types[name] = "Orchestrator"
-                elif isinstance(workflow, ParallelLLM):
-                    agent_types[name] = "Parallel"
-                elif isinstance(workflow, EvaluatorOptimizerLLM):
-                    agent_types[name] = "Evaluator"
-                else:
-                    agent_types[name] = "Workflow"
-
-        result = ""
-        while True:
-            with progress_display.paused():
-                # Use the enhanced input method with advanced features
-                user_input = await get_enhanced_input(
-                    agent_name=agent,
-                    default=default,
-                    show_default=(default != ""),
-                    show_stop_hint=True,
-                    multiline=False,  # Default to single-line mode
-                    available_agent_names=available_agents,
-                    syntax=None,  # Can enable syntax highlighting for code input
-                    agent_types=agent_types,  # Pass agent types for display
-                )
-
-                # Handle special commands
-                command_result = await handle_special_commands(user_input, self)
-
-                # Check if we should switch agents
-                if (
-                    isinstance(command_result, dict)
-                    and "switch_agent" in command_result
-                ):
-                    agent = command_result["switch_agent"]
-                    continue
-
-                # Skip further processing if command was handled
-                if command_result:
-                    continue
-
-                if user_input.upper() == "STOP":
-                    return
-                if user_input == "":
-                    continue
-
-            result = await self.send(agent, user_input)
-
-        return result
-
-    def __getattr__(self, name: str) -> AgentProxy:
-        """Support: agent.researcher"""
-        if name not in self._agents:
-            raise AttributeError(f"No agent named '{name}'")
-        return AgentProxy(self, name)
-
-    def __getitem__(self, name: str) -> AgentProxy:
-        """Support: agent['researcher']"""
-        if name not in self._agents:
-            raise KeyError(f"No agent named '{name}'")
-        return AgentProxy(self, name)
-
-    async def __call__(
-        self, message: Optional[str] = "", agent_name: Optional[str] = None
-    ) -> str:
-        """Support: agent('message')"""
-        target = agent_name or self._default
-        if not target:
-            raise ValueError("No default agent available")
-        return await self.send(target, message)
-
-
 class FastAgent(ContextDependent):
     """
     A decorator-based interface for MCP Agent applications.
@@ -293,11 +84,27 @@ class FastAgent(ContextDependent):
             "--model",
             help="Override the default model for all agents. Precedence is default < config_file < command line < constructor",
         )
+        parser.add_argument(
+            "--agent",
+            help="Specify the agent to send a message to (used with --message)",
+        )
+        parser.add_argument(
+            "-m", "--message",
+            help="Message to send to the specified agent (requires --agent)",
+        )
+        parser.add_argument(
+            "--quiet", action="store_true",
+            help="Disable progress display, tool and message logging for cleaner output",
+        )
         self.args = parser.parse_args()
+        
+        # Quiet mode will be handled in _load_config()
 
         self.name = name
         self.config_path = config_path
         self._load_config()
+        
+        # Create the MCPApp with the config
         self.app = MCPApp(
             name=name,
             settings=Settings(**self.config) if hasattr(self, "config") else None,
@@ -323,8 +130,9 @@ class FastAgent(ContextDependent):
         if agent_type not in [
             AgentType.PARALLEL.value,
             AgentType.EVALUATOR_OPTIMIZER.value,
+            AgentType.CHAIN.value,
         ]:
-            self._log_agent_load(name)
+            log_agent_load(self.app, name)
         if agent_type == AgentType.BASIC.value:
             if not isinstance(instance, Agent):
                 raise TypeError(
@@ -355,6 +163,10 @@ class FastAgent(ContextDependent):
                     f"Expected LLMRouter instance for {name}, got {type(instance)}"
                 )
             return RouterProxy(self.app, name, instance)
+        elif agent_type == AgentType.CHAIN.value:
+            # Chain proxy is directly returned from _create_agents_by_type
+            # No need for type checking as it's already a ChainProxy
+            return instance
         else:
             raise ValueError(f"Unknown agent type: {agent_type}")
 
@@ -367,7 +179,7 @@ class FastAgent(ContextDependent):
         """Load configuration from YAML file, properly handling without dotenv processing"""
         if self.config_path:
             with open(self.config_path) as f:
-                self.config = yaml.safe_load(f)
+                self.config = yaml.safe_load(f) or {}
 
     def _validate_server_references(self) -> None:
         """
@@ -461,6 +273,15 @@ class FastAgent(ContextDependent):
                         f"Evaluator-Optimizer '{name}' references non-existent components: {', '.join(missing)}"
                     )
 
+            elif agent_type == AgentType.CHAIN.value:
+                # Check that all agents in the sequence exist
+                sequence = agent_data.get("sequence", agent_data.get("agents", []))
+                missing = [a for a in sequence if a not in available_components]
+                if missing:
+                    raise AgentConfigError(
+                        f"Chain '{name}' references non-existent agents: {', '.join(missing)}"
+                    )
+
     def _get_model_factory(
         self,
         model: Optional[str] = None,
@@ -599,6 +420,7 @@ class FastAgent(ContextDependent):
     def agent(
         self,
         name: str = "Agent",
+        instruction_or_kwarg: str = None,
         *,
         instruction: str = "You are a helpful agent.",
         servers: List[str] = [],
@@ -612,13 +434,26 @@ class FastAgent(ContextDependent):
 
         Args:
             name: Name of the agent
-            instruction: Base instruction for the agent
+            instruction_or_kwarg: Optional positional parameter for instruction
+            instruction: Base instruction for the agent (keyword arg)
             servers: List of server names the agent should connect to
             model: Model specification string (highest precedence)
             use_history: Whether to maintain conversation history
             request_params: Additional request parameters for the LLM
             human_input: Whether to enable human input capabilities
+
+        The instruction can be provided either as a second positional argument
+        or as a keyword argument. Positional argument takes precedence when both are provided.
+
+        Usage:
+            @fast.agent("agent_name", "Your instruction here")  # Using positional arg
+            @fast.agent("agent_name", instruction="Your instruction here")  # Using keyword arg
         """
+        # Use positional argument if provided, otherwise use keyword argument
+        final_instruction = (
+            instruction_or_kwarg if instruction_or_kwarg is not None else instruction
+        )
+
         decorator = self._create_decorator(
             AgentType.BASIC,
             default_name="Agent",
@@ -626,7 +461,7 @@ class FastAgent(ContextDependent):
             default_use_history=True,
         )(
             name=name,
-            instruction=instruction,
+            instruction=final_instruction,
             servers=servers,
             model=model,
             use_history=use_history,
@@ -687,25 +522,47 @@ class FastAgent(ContextDependent):
     def parallel(
         self,
         name: str,
-        fan_in: str,
         fan_out: List[str],
+        fan_in: Optional[str] = None,
         instruction: str = "",
         model: str | None = None,
         use_history: bool = True,
         request_params: Optional[Dict] = None,
+        include_request: bool = True,
     ) -> Callable:
         """
         Decorator to create and register a parallel executing agent.
 
         Args:
             name: Name of the parallel executing agent
-            fan_in: Name of collecting agent
             fan_out: List of parallel execution agents
+            fan_in: Optional name of collecting agent. If not provided, a passthrough agent 
+                    will be created automatically with the name "{name}_fan_in"
             instruction: Optional instruction for the parallel agent
             model: Model specification string
             use_history: Whether to maintain conversation history
             request_params: Additional request parameters for the LLM
+            include_request: Whether to include the original request in the fan-in message
         """
+        # If fan_in is not provided, create a passthrough agent with a derived name
+        if fan_in is None:
+            passthrough_name = f"{name}_fan_in"
+            
+            # Register the passthrough agent directly in self.agents
+            self.agents[passthrough_name] = {
+                "config": AgentConfig(
+                    name=passthrough_name,
+                    instruction=f"Passthrough fan-in for {name}",
+                    servers=[],
+                    use_history=use_history,
+                ),
+                "type": AgentType.BASIC.value,  # Using BASIC type since we're just attaching a PassthroughLLM
+                "func": lambda x: x,  # Simple passthrough function (never actually called)
+            }
+            
+            # Use this passthrough as the fan-in
+            fan_in = passthrough_name
+        
         decorator = self._create_decorator(
             AgentType.PARALLEL,
             default_instruction="",
@@ -719,6 +576,7 @@ class FastAgent(ContextDependent):
             model=model,
             use_history=use_history,
             request_params=request_params,
+            include_request=include_request,
         )
         return decorator
 
@@ -799,6 +657,88 @@ class FastAgent(ContextDependent):
         )
         return decorator
 
+    def chain(
+        self,
+        name: str = "Chain",
+        *,
+        sequence: List[str] = None,
+        agents: List[str] = None,  # Alias for sequence
+        instruction: str = None,
+        model: str | None = None,
+        use_history: bool = True,
+        request_params: Optional[Dict] = None,
+        continue_with_final: bool = True,
+    ) -> Callable:
+        """
+        Decorator to create and register a chain of agents.
+
+        Args:
+            name: Name of the chain
+            sequence: List of agent names in order of execution (preferred name)
+            agents: Alias for sequence (backwards compatibility)
+            instruction: Optional custom instruction for the chain (if none provided, will autogenerate based on sequence)
+            model: Model specification string (not used directly in chain)
+            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)
+        """
+        # Support both parameter names
+        agent_sequence = sequence or agents
+        if agent_sequence is None:
+            raise ValueError("Either 'sequence' or 'agents' parameter must be provided")
+
+        # 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)}"
+
+        decorator = self._create_decorator(
+            AgentType.CHAIN,
+            default_name="Chain",
+            default_instruction=instruction,
+            default_use_history=True,
+            wrapper_needed=True,
+        )(
+            name=name,
+            sequence=agent_sequence,
+            instruction=instruction,
+            model=model,
+            use_history=use_history,
+            request_params=request_params,
+            continue_with_final=continue_with_final,
+        )
+        return decorator
+        
+    def passthrough(
+        self,
+        name: str = "Passthrough",
+        use_history: bool = True,
+        **kwargs
+    ) -> Callable:
+        """
+        Decorator to create and register a passthrough agent.
+        A passthrough agent simply returns any input message without modification.
+        
+        This is useful for parallel workflows where no fan-in aggregation is needed
+        (the fan-in agent can be a passthrough that simply returns the combined outputs).
+
+        Args:
+            name: Name of the passthrough agent
+            use_history: Whether to maintain conversation history
+            **kwargs: Additional parameters (ignored, for compatibility)
+        """
+        decorator = self._create_decorator(
+            AgentType.BASIC,  # Using BASIC agent type since we'll use a regular agent with PassthroughLLM
+            default_name="Passthrough",
+            default_instruction="Passthrough agent that returns input without modification",
+            default_use_history=use_history,
+            wrapper_needed=True,
+        )(
+            name=name,
+            use_history=use_history,
+        )
+        return decorator
+
     async def _create_agents_by_type(
         self,
         agent_app: MCPApp,
@@ -832,19 +772,42 @@ class FastAgent(ContextDependent):
 
                 # Type-specific initialization
                 if agent_type == AgentType.BASIC:
-                    # Create basic agent with configuration
-                    agent = Agent(config=config, context=agent_app.context)
-
-                    # Set up LLM with proper configuration
-                    async with agent:
-                        llm_factory = self._get_model_factory(
-                            model=config.model,
-                            request_params=config.default_request_params,
-                        )
-                        agent._llm = await agent.attach_llm(llm_factory)
-
-                    # Store the agent
-                    instance = agent
+                    # Get the agent name for special handling
+                    agent_name = agent_data["config"].name
+                    
+                    # Check if this is an agent that should use the PassthroughLLM
+                    if agent_name.endswith("_fan_in") or agent_name.startswith("passthrough"):
+                        # Import here to avoid circular imports
+                        from mcp_agent.workflows.llm.augmented_llm import PassthroughLLM
+                        
+                        # Create basic agent with configuration
+                        agent = Agent(config=config, context=agent_app.context)
+                        
+                        # Set up a PassthroughLLM directly
+                        async with agent:
+                            agent._llm = PassthroughLLM(
+                                name=f"{config.name}_llm",
+                                context=agent_app.context,
+                                agent=agent,
+                                default_request_params=config.default_request_params,
+                            )
+                            
+                        # Store the agent
+                        instance = agent
+                    else:
+                        # Standard basic agent with LLM
+                        agent = Agent(config=config, context=agent_app.context)
+    
+                        # Set up LLM with proper configuration
+                        async with agent:
+                            llm_factory = self._get_model_factory(
+                                model=config.model,
+                                request_params=config.default_request_params,
+                            )
+                            agent._llm = await agent.attach_llm(llm_factory)
+    
+                        # Store the agent
+                        instance = agent
 
                 elif agent_type == AgentType.ORCHESTRATOR:
                     # Get base params configured with model settings
@@ -958,6 +921,54 @@ class FastAgent(ContextDependent):
                         verb=ProgressAction.ROUTING,  # Set verb for progress display
                     )
 
+                elif agent_type == AgentType.CHAIN:
+                    # Get the sequence from either parameter
+                    sequence = agent_data.get("sequence", agent_data.get("agents", []))
+
+                    # Auto-generate instruction if not provided or if it's just the default
+                    default_instruction = f"Chain of agents: {', '.join(sequence)}"
+
+                    # If user provided a custom instruction, use that
+                    # Otherwise, generate a description based on the sequence and their servers
+                    if config.instruction == default_instruction:
+                        # Get all agent names in the sequence
+                        agent_names = []
+                        all_servers = set()
+
+                        # Collect information about the agents and their servers
+                        for agent_name in sequence:
+                            if agent_name in active_agents:
+                                agent_proxy = active_agents[agent_name]
+                                if hasattr(agent_proxy, "_agent"):
+                                    # For LLMAgentProxy
+                                    agent_instance = agent_proxy._agent
+                                    agent_names.append(agent_name)
+                                    if hasattr(agent_instance, "server_names"):
+                                        all_servers.update(agent_instance.server_names)
+                                elif hasattr(agent_proxy, "_workflow"):
+                                    # For WorkflowProxy
+                                    agent_names.append(agent_name)
+
+                        # Generate a better description
+                        if agent_names:
+                            server_part = (
+                                f" with access to servers: {', '.join(sorted(all_servers))}"
+                                if all_servers
+                                else ""
+                            )
+                            config.instruction = f"Sequence of agents: {', '.join(agent_names)}{server_part}."
+
+                    # Create a ChainProxy without needing a new instance
+                    # Just pass the agent proxies and sequence
+                    instance = ChainProxy(self.app, name, sequence, active_agents)
+                    # Set continue_with_final behavior from configuration
+                    instance._continue_with_final = agent_data.get(
+                        "continue_with_final", True
+                    )
+
+                # We removed the AgentType.PASSTHROUGH case
+                # Passthrough agents are now created as BASIC agents with a special LLM
+
                 elif agent_type == AgentType.PARALLEL:
                     # Get fan-out agents (could be basic agents or other parallels)
                     fan_out_agents = self._get_agent_instances(
@@ -979,6 +990,7 @@ class FastAgent(ContextDependent):
                         context=agent_app.context,
                         llm_factory=llm_factory,
                         default_request_params=config.default_request_params,
+                        include_request=agent_data.get("include_request", True),
                     )
 
                 else:
@@ -1037,16 +1049,18 @@ class FastAgent(ContextDependent):
             agent_app, AgentType.EVALUATOR_OPTIMIZER, active_agents
         )
 
-    def _get_parallel_dependencies(
-        self, name: str, visited: set, path: set
+    def _get_dependencies(
+        self, name: str, visited: set, path: set, agent_type: AgentType = None
     ) -> List[str]:
         """
-        Get dependencies for a parallel agent in topological order.
+        Get dependencies for an agent in topological order.
+        Works for both Parallel and Chain workflows.
 
         Args:
-            name: Name of the parallel agent
+            name: Name of the agent
             visited: Set of already visited agents
             path: Current path for cycle detection
+            agent_type: Optional type filter (e.g., only check Parallel or Chain)
 
         Returns:
             List of agent names in dependency order
@@ -1056,7 +1070,7 @@ class FastAgent(ContextDependent):
         """
         if name in path:
             path_str = " -> ".join(path)
-            raise ValueError(f"Circular dependency detected: {path_str} -> {name}")
+            raise CircularDependencyError(f"Path: {path_str} -> {name}")
 
         if name in visited:
             return []
@@ -1065,15 +1079,26 @@ class FastAgent(ContextDependent):
             return []
 
         config = self.agents[name]
-        if config["type"] != AgentType.PARALLEL.value:
+
+        # Skip if not the requested type (when filtering)
+        if agent_type and config["type"] != agent_type.value:
             return []
 
         path.add(name)
         deps = []
 
-        # Get dependencies from fan-out agents
-        for fan_out in config["fan_out"]:
-            deps.extend(self._get_parallel_dependencies(fan_out, visited, path))
+        # Handle dependencies based on agent type
+        if config["type"] == AgentType.PARALLEL.value:
+            # Get dependencies from fan-out agents
+            for fan_out in config["fan_out"]:
+                deps.extend(self._get_dependencies(fan_out, visited, path, agent_type))
+        elif config["type"] == AgentType.CHAIN.value:
+            # Get dependencies from sequence agents
+            sequence = config.get("sequence", config.get("agents", []))
+            for agent_name in sequence:
+                deps.extend(
+                    self._get_dependencies(agent_name, visited, path, agent_type)
+                )
 
         # Add this agent after its dependencies
         deps.append(name)
@@ -1082,54 +1107,95 @@ class FastAgent(ContextDependent):
 
         return deps
 
-    async def _create_parallel_agents(
-        self, agent_app: MCPApp, active_agents: ProxyDict
+    def _get_parallel_dependencies(
+        self, name: str, visited: set, path: set
+    ) -> List[str]:
+        """
+        Get dependencies for a parallel agent in topological order.
+        Legacy function that calls the more general _get_dependencies.
+
+        Args:
+            name: Name of the parallel agent
+            visited: Set of already visited agents
+            path: Current path for cycle detection
+
+        Returns:
+            List of agent names in dependency order
+
+        Raises:
+            ValueError: If circular dependency detected
+        """
+        return self._get_dependencies(name, visited, path, AgentType.PARALLEL)
+
+    async def _create_agents_in_dependency_order(
+        self, agent_app: MCPApp, active_agents: ProxyDict, agent_type: AgentType
     ) -> ProxyDict:
         """
-        Create parallel execution agents in dependency order.
+        Create agents in dependency order to avoid circular references.
+        Works for both Parallel and Chain workflows.
 
         Args:
             agent_app: The main application instance
             active_agents: Dictionary of already created agents/proxies
+            agent_type: Type of agents to create (AgentType.PARALLEL or AgentType.CHAIN)
 
         Returns:
-            Dictionary of initialized parallel agents
+            Dictionary of initialized agents
         """
-        parallel_agents = {}
+        result_agents = {}
         visited = set()
 
-        # Get all parallel agents
-        parallel_names = [
+        # Get all agents of the specified type
+        agent_names = [
             name
             for name, agent_data in self.agents.items()
-            if agent_data["type"] == AgentType.PARALLEL.value
+            if agent_data["type"] == agent_type.value
         ]
 
         # Create agents in dependency order
-        for name in parallel_names:
+        for name in agent_names:
             # Get ordered dependencies if not already processed
             if name not in visited:
                 try:
-                    ordered_agents = self._get_parallel_dependencies(
-                        name, visited, set()
+                    ordered_agents = self._get_dependencies(
+                        name, visited, set(), agent_type
                     )
                 except ValueError as e:
-                    raise ValueError(f"Error creating parallel agent {name}: {str(e)}")
+                    raise ValueError(
+                        f"Error creating {agent_type.name.lower()} agent {name}: {str(e)}"
+                    )
 
                 # Create each agent in order
                 for agent_name in ordered_agents:
-                    if agent_name not in parallel_agents:
-                        # Create one parallel agent at a time using the generic method
+                    if agent_name not in result_agents:
+                        # Create one agent at a time using the generic method
                         agent_result = await self._create_agents_by_type(
                             agent_app,
-                            AgentType.PARALLEL,
+                            agent_type,
                             active_agents,
                             agent_name=agent_name,
                         )
                         if agent_name in agent_result:
-                            parallel_agents[agent_name] = agent_result[agent_name]
+                            result_agents[agent_name] = agent_result[agent_name]
 
-        return parallel_agents
+        return result_agents
+
+    async def _create_parallel_agents(
+        self, agent_app: MCPApp, active_agents: ProxyDict
+    ) -> ProxyDict:
+        """
+        Create parallel execution agents in dependency order.
+
+        Args:
+            agent_app: The main application instance
+            active_agents: Dictionary of already created agents/proxies
+
+        Returns:
+            Dictionary of initialized parallel agents
+        """
+        return await self._create_agents_in_dependency_order(
+            agent_app, active_agents, AgentType.PARALLEL
+        )
 
     async def _create_routers(
         self, agent_app: MCPApp, active_agents: ProxyDict
@@ -1158,9 +1224,7 @@ class FastAgent(ContextDependent):
         Returns:
             The underlying Agent or workflow instance
         """
-        if isinstance(proxy, LLMAgentProxy):
-            return proxy._agent
-        return proxy._workflow
+        return unwrap_proxy(proxy)
 
     def _get_agent_instances(
         self, agent_names: List[str], active_agents: ProxyDict
@@ -1175,7 +1239,7 @@ class FastAgent(ContextDependent):
         Returns:
             List of unwrapped agent/workflow instances
         """
-        return [self._unwrap_proxy(active_agents[name]) for name in agent_names]
+        return get_agent_instances(agent_names, active_agents)
 
     @asynccontextmanager
     async def run(self):
@@ -1185,14 +1249,30 @@ class FastAgent(ContextDependent):
         """
         active_agents = {}
         had_error = False
+        
+        # Handle quiet mode by disabling logger settings after initialization
+        quiet_mode = hasattr(self, "args") and self.args.quiet
+        
         try:
             async with self.app.run() as agent_app:
+                # Apply quiet mode directly to the context's config if needed
+                if quiet_mode and hasattr(agent_app.context, "config") and hasattr(agent_app.context.config, "logger"):
+                    # Apply after initialization but before agents are created
+                    agent_app.context.config.logger.progress_display = False
+                    agent_app.context.config.logger.show_chat = False
+                    agent_app.context.config.logger.show_tools = False
+                    
+                    # Directly disable the progress display singleton
+                    from mcp_agent.progress_display import progress_display
+                    progress_display.stop()  # This will stop and hide the display
+                
                 # Pre-flight validation
                 self._validate_server_references()
                 self._validate_workflow_references()
 
                 # Create all types of agents in dependency order
                 active_agents = await self._create_basic_agents(agent_app)
+
                 orchestrators = await self._create_orchestrators(
                     agent_app, active_agents
                 )
@@ -1203,15 +1283,43 @@ class FastAgent(ContextDependent):
                     agent_app, active_agents
                 )
                 routers = await self._create_routers(agent_app, active_agents)
+                chains = await self._create_agents_in_dependency_order(
+                    agent_app, active_agents, AgentType.CHAIN
+                )
 
                 # Merge all agents into active_agents
                 active_agents.update(orchestrators)
                 active_agents.update(parallel_agents)
                 active_agents.update(evaluator_optimizers)
                 active_agents.update(routers)
+                active_agents.update(chains)
 
                 # Create wrapper with all agents
                 wrapper = AgentApp(agent_app, active_agents)
+                
+                # Handle direct message sending if --agent and --message are provided
+                if self.args.agent and self.args.message:
+                    agent_name = self.args.agent
+                    message = self.args.message
+                    
+                    if agent_name not in active_agents:
+                        available_agents = ", ".join(active_agents.keys())
+                        print(f"\n\nError: Agent '{agent_name}' not found. Available agents: {available_agents}")
+                        raise SystemExit(1)
+                    
+                    try:
+                        # Get response
+                        response = await wrapper[agent_name].send(message)
+                        
+                        # Only print the response in quiet mode
+                        if self.args.quiet:
+                            print(f"{response}")
+                        
+                        raise SystemExit(0)
+                    except Exception as e:
+                        print(f"\n\nError sending message to agent '{agent_name}': {str(e)}")
+                        raise SystemExit(1)
+                
                 yield wrapper
 
         except ServerConfigError as e:
@@ -1259,6 +1367,15 @@ class FastAgent(ContextDependent):
             )
             raise SystemExit(1)
 
+        except CircularDependencyError as e:
+            had_error = True
+            self._handle_error(
+                e,
+                "Circular Dependency Detected",
+                "Check your agent configuration for circular dependencies.",
+            )
+            raise SystemExit(1)
+
         except PromptExitError as e:
             had_error = True
             self._handle_error(
@@ -1289,19 +1406,8 @@ class FastAgent(ContextDependent):
             error_type: Type of error to display
             suggestion: Optional suggestion message to display
         """
-        print(f"\n[bold red]{error_type}:")
-        print(getattr(e, "message", str(e)))
-        if hasattr(e, "details") and e.details:
-            print("\nDetails:")
-            print(e.details)
-        if suggestion:
-            print(f"\n{suggestion}")
+        handle_error(e, error_type, suggestion)
 
     def _log_agent_load(self, agent_name: str) -> None:
-        self.app._logger.info(
-            f"Loaded {agent_name}",
-            data={
-                "progress_action": ProgressAction.LOADED,
-                "agent_name": agent_name,
-            },
-        )
+        # Using the imported function
+        log_agent_load(self.app, agent_name)