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

mcp_agent/core/fastagent.py

@@ -10,291 +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,
-    CircularDependencyError,
-    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"
-    CHAIN = "chain"
+# 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 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
-
-    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
-
-
-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, ChainProxy):
-                agent_types[name] = "Chain"
-            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 result
-                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.
@@ -318,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,
@@ -350,7 +132,7 @@ class FastAgent(ContextDependent):
             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(
@@ -397,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:
         """
@@ -638,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] = [],
@@ -651,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",
@@ -665,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,
@@ -726,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="",
@@ -758,6 +576,7 @@ class FastAgent(ContextDependent):
             model=model,
             use_history=use_history,
             request_params=request_params,
+            include_request=include_request,
         )
         return decorator
 
@@ -848,6 +667,7 @@ class FastAgent(ContextDependent):
         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.
@@ -860,6 +680,7 @@ class FastAgent(ContextDependent):
             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
@@ -884,6 +705,37 @@ class FastAgent(ContextDependent):
             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
 
@@ -920,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
@@ -1049,17 +924,17 @@ class FastAgent(ContextDependent):
                 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:
@@ -1073,15 +948,26 @@ class FastAgent(ContextDependent):
                                 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 ""
+                            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)
@@ -1104,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:
@@ -1337,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
@@ -1354,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):
@@ -1364,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
                 )
@@ -1395,6 +1296,30 @@ class FastAgent(ContextDependent):
 
                 # 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:
@@ -1481,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)