fast-agent-mcp 0.2.57__py3-none-any.whl → 0.3.0__py3-none-any.whl

{mcp_agent → fast_agent}/core/direct_factory.py

@@ -3,49 +3,79 @@ Direct factory functions for creating agent and workflow instances without proxi
 Implements type-safe factories with improved error handling.
 """
 
-from typing import Any, Callable, Dict, Optional, Protocol, TypeVar
+from typing import Any, Dict, Optional, Protocol, TypeVar
 
-from mcp_agent.agents.agent import Agent, AgentConfig
-from mcp_agent.agents.workflow.evaluator_optimizer import (
+from fast_agent.agents.agent_types import AgentConfig, AgentType
+from fast_agent.agents.llm_agent import LlmAgent
+from fast_agent.agents.mcp_agent import McpAgent
+from fast_agent.agents.workflow.evaluator_optimizer import (
     EvaluatorOptimizerAgent,
     QualityRating,
 )
-from mcp_agent.agents.workflow.iterative_planner import IterativePlanner
-from mcp_agent.agents.workflow.orchestrator_agent import OrchestratorAgent
-from mcp_agent.agents.workflow.parallel_agent import ParallelAgent
-from mcp_agent.agents.workflow.router_agent import RouterAgent
-from mcp_agent.app import MCPApp
-from mcp_agent.core.agent_types import AgentType
-from mcp_agent.core.exceptions import AgentConfigError
-from mcp_agent.core.validation import get_dependencies_groups
-from mcp_agent.event_progress import ProgressAction
-from mcp_agent.llm.augmented_llm import RequestParams
-from mcp_agent.llm.model_factory import ModelFactory
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.interfaces import AgentProtocol
+from fast_agent.agents.workflow.iterative_planner import IterativePlanner
+from fast_agent.agents.workflow.parallel_agent import ParallelAgent
+from fast_agent.agents.workflow.router_agent import RouterAgent
+from fast_agent.core import Core
+from fast_agent.core.exceptions import AgentConfigError
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.core.validation import get_dependencies_groups
+from fast_agent.event_progress import ProgressAction
+from fast_agent.interfaces import (
+    AgentProtocol,
+    LLMFactoryProtocol,
+    ModelFactoryFunctionProtocol,
+)
+from fast_agent.llm.model_factory import ModelFactory
+from fast_agent.mcp.ui_agent import McpAgentWithUI
+from fast_agent.types import RequestParams
 
 # Type aliases for improved readability and IDE support
 AgentDict = Dict[str, AgentProtocol]
 AgentConfigDict = Dict[str, Dict[str, Any]]
 T = TypeVar("T")  # For generic types
 
-# Type for model factory functions
-ModelFactoryFn = Callable[[Optional[str], Optional[RequestParams]], Callable[[], Any]]
-
 
 logger = get_logger(__name__)
 
 
+def _create_agent_with_ui_if_needed(
+    agent_class: type,
+    config: Any,
+    context: Any,
+) -> Any:
+    """
+    Create an agent with UI support if MCP UI mode is enabled.
+
+    Args:
+        agent_class: The agent class to potentially enhance with UI
+        config: Agent configuration
+        context: Application context
+
+    Returns:
+        Either a UI-enhanced agent instance or the original agent instance
+    """
+    # Check UI mode from settings
+    settings = context.config if hasattr(context, "config") else None
+    ui_mode = getattr(settings, "mcp_ui_mode", "auto") if settings else "auto"
+
+    if ui_mode != "disabled" and agent_class == McpAgent:
+        # Use the UI-enhanced agent class instead of the base class
+        return McpAgentWithUI(config=config, context=context, ui_mode=ui_mode)
+    else:
+        # Create the original agent instance
+        return agent_class(config=config, context=context)
+
+
 class AgentCreatorProtocol(Protocol):
     """Protocol for agent creator functions."""
 
     async def __call__(
         self,
-        app_instance: MCPApp,
+        app_instance: Core,
         agents_dict: AgentConfigDict,
         agent_type: AgentType,
         active_agents: Optional[AgentDict] = None,
-        model_factory_func: Optional[ModelFactoryFn] = None,
+        model_factory_func: Optional[ModelFactoryFunctionProtocol] = None,
         **kwargs: Any,
     ) -> AgentDict: ...
 
@@ -56,7 +86,7 @@ def get_model_factory(
     request_params: Optional[RequestParams] = None,
     default_model: Optional[str] = None,
     cli_model: Optional[str] = None,
-) -> Callable:
+) -> LLMFactoryProtocol:
     """
     Get model factory using specified or default model.
     Model string is parsed by ModelFactory to determine provider and reasoning effort.
@@ -89,15 +119,15 @@ def get_model_factory(
         request_params = RequestParams(model=model_spec)
 
     # Let model factory handle the model string parsing and setup
-    return ModelFactory.create_factory(model_spec, request_params=request_params)
+    return ModelFactory.create_factory(model_spec)
 
 
 async def create_agents_by_type(
-    app_instance: MCPApp,
+    app_instance: Core,
     agents_dict: AgentConfigDict,
     agent_type: AgentType,
+    model_factory_func: ModelFactoryFunctionProtocol,
     active_agents: Optional[AgentDict] = None,
-    model_factory_func: Optional[ModelFactoryFn] = None,
     **kwargs: Any,
 ) -> AgentDict:
     """
@@ -117,11 +147,6 @@ async def create_agents_by_type(
     if active_agents is None:
         active_agents = {}
 
-    if model_factory_func is None:
-        # Default factory that just returns the inputs - should be overridden
-        def model_factory_func(model=None, request_params=None):
-            return lambda: None
-
     # Create a dictionary to store the initialized agents
     result_agents: AgentDict = {}
 
@@ -143,11 +168,13 @@ async def create_agents_by_type(
             # Type-specific initialization based on the Enum type
             # Note: Above we compared string values from config, here we compare Enum objects directly
             if agent_type == AgentType.BASIC:
-                # Create a basic agent
-                agent = Agent(
-                    config=config,
-                    context=app_instance.context,
+                # Create agent with UI support if needed
+                agent = _create_agent_with_ui_if_needed(
+                    McpAgent,
+                    config,
+                    app_instance.context,
                 )
+
                 await agent.initialize()
 
                 # Attach LLM to the agent
@@ -160,15 +187,21 @@ async def create_agents_by_type(
                 result_agents[name] = agent
 
             elif agent_type == AgentType.CUSTOM:
-                # Get the class to instantiate
-                cls = agent_data["agent_class"]
-                # Create the custom agent
-                agent = cls(
-                    config=config,
-                    context=app_instance.context,
+                # Get the class to instantiate (support legacy 'agent_class' and new 'cls')
+                cls = agent_data.get("agent_class") or agent_data.get("cls")
+                if cls is None:
+                    raise AgentConfigError(
+                        f"Custom agent '{name}' missing class reference ('agent_class' or 'cls')"
+                    )
+
+                # Create agent with UI support if needed
+                agent = _create_agent_with_ui_if_needed(
+                    cls,
+                    config,
+                    app_instance.context,
                 )
-                await agent.initialize()
 
+                await agent.initialize()
                 # Attach LLM to the agent
                 llm_factory = model_factory_func(model=config.model)
                 await agent.attach_llm(
@@ -195,23 +228,13 @@ async def create_agents_by_type(
                     agent = active_agents[agent_name]
                     child_agents.append(agent)
 
-                if AgentType.ORCHESTRATOR == agent_type:
-                    # Create the orchestrator
-                    orchestrator = OrchestratorAgent(
-                        config=config,
-                        context=app_instance.context,
-                        agents=child_agents,
-                        plan_iterations=agent_data.get("plan_iterations", 5),
-                        plan_type=agent_data.get("plan_type", "full"),
-                    )
-                else:
-                    orchestrator = IterativePlanner(
-                        config=config,
-                        context=app_instance.context,
-                        agents=child_agents,
-                        plan_iterations=agent_data.get("plan_iterations", 5),
-                        plan_type=agent_data.get("plan_type", "full"),
-                    )
+                orchestrator = IterativePlanner(
+                    config=config,
+                    context=app_instance.context,
+                    agents=child_agents,
+                    plan_iterations=agent_data.get("plan_iterations", 5),
+                    plan_type=agent_data.get("plan_type", "full"),
+                )
 
                 # Initialize the orchestrator
                 await orchestrator.initialize()
@@ -219,7 +242,6 @@ async def create_agents_by_type(
                 # Attach LLM to the orchestrator
                 llm_factory = model_factory_func(model=config.model)
 
-                #                print("************", config.default_request_params.instruction)
                 await orchestrator.attach_llm(
                     llm_factory,
                     request_params=config.default_request_params,
@@ -304,7 +326,7 @@ async def create_agents_by_type(
                         raise AgentConfigError(f"Chain agent {agent_name} not found")
                     chain_agents.append(active_agents[agent_name])
 
-                from mcp_agent.agents.workflow.chain_agent import ChainAgent
+                from fast_agent.agents.workflow.chain_agent import ChainAgent
 
                 # Get the cumulative parameter
                 cumulative = agent_data.get("cumulative", False)
@@ -358,9 +380,9 @@ async def create_agents_by_type(
 
 
 async def create_agents_in_dependency_order(
-    app_instance: MCPApp,
+    app_instance: Core,
     agents_dict: AgentConfigDict,
-    model_factory_func: ModelFactoryFn,
+    model_factory_func: ModelFactoryFunctionProtocol,
     allow_cycles: bool = False,
 ) -> AgentDict:
     """
@@ -394,8 +416,8 @@ async def create_agents_in_dependency_order(
                     if agents_dict[name]["type"] == AgentType.BASIC.value
                 },
                 AgentType.BASIC,
-                active_agents,
                 model_factory_func,
+                active_agents,
             )
             active_agents.update(basic_agents)
 
@@ -409,8 +431,8 @@ async def create_agents_in_dependency_order(
                     if agents_dict[name]["type"] == AgentType.CUSTOM.value
                 },
                 AgentType.CUSTOM,
-                active_agents,
                 model_factory_func,
+                active_agents,
             )
             active_agents.update(basic_agents)
 
@@ -424,8 +446,8 @@ async def create_agents_in_dependency_order(
                     if agents_dict[name]["type"] == AgentType.PARALLEL.value
                 },
                 AgentType.PARALLEL,
-                active_agents,
                 model_factory_func,
+                active_agents,
             )
             active_agents.update(parallel_agents)
 
@@ -439,8 +461,8 @@ async def create_agents_in_dependency_order(
                     if agents_dict[name]["type"] == AgentType.ROUTER.value
                 },
                 AgentType.ROUTER,
-                active_agents,
                 model_factory_func,
+                active_agents,
             )
             active_agents.update(router_agents)
 
@@ -454,8 +476,8 @@ async def create_agents_in_dependency_order(
                     if agents_dict[name]["type"] == AgentType.CHAIN.value
                 },
                 AgentType.CHAIN,
-                active_agents,
                 model_factory_func,
+                active_agents,
             )
             active_agents.update(chain_agents)
 
@@ -469,8 +491,8 @@ async def create_agents_in_dependency_order(
                     if agents_dict[name]["type"] == AgentType.EVALUATOR_OPTIMIZER.value
                 },
                 AgentType.EVALUATOR_OPTIMIZER,
-                active_agents,
                 model_factory_func,
+                active_agents,
             )
             active_agents.update(evaluator_agents)
 
@@ -483,8 +505,8 @@ async def create_agents_in_dependency_order(
                     if agents_dict[name]["type"] == AgentType.ORCHESTRATOR.value
                 },
                 AgentType.ORCHESTRATOR,
-                active_agents,
                 model_factory_func,
+                active_agents,
             )
             active_agents.update(orchestrator_agents)
 
@@ -498,8 +520,8 @@ async def create_agents_in_dependency_order(
                     if agents_dict[name]["type"] == AgentType.ITERATIVE_PLANNER.value
                 },
                 AgentType.ITERATIVE_PLANNER,
-                active_agents,
                 model_factory_func,
+                active_agents,
             )
             active_agents.update(orchestrator2_agents)
 
@@ -509,8 +531,8 @@ async def create_agents_in_dependency_order(
 async def _create_default_fan_in_agent(
     fan_in_name: str,
     context,
-    model_factory_func: ModelFactoryFn,
-) -> Agent:
+    model_factory_func: ModelFactoryFunctionProtocol,
+) -> AgentProtocol:
     """
     Create a default fan-in agent for parallel workflows when none is specified.
 
@@ -530,7 +552,7 @@ async def _create_default_fan_in_agent(
     )
 
     # Create and initialize the default agent
-    fan_in_agent = Agent(
+    fan_in_agent = LlmAgent(
         config=default_config,
         context=context,
     )

{mcp_agent → fast_agent/core}/executor/executor.py

@@ -19,17 +19,17 @@ from typing import (
 
 from pydantic import BaseModel, ConfigDict
 
-from mcp_agent.context_dependent import ContextDependent
-from mcp_agent.executor.workflow_signal import (
+from fast_agent.context_dependent import ContextDependent
+from fast_agent.core.executor.workflow_signal import (
     AsyncioSignalHandler,
     Signal,
     SignalHandler,
     SignalValueT,
 )
-from mcp_agent.logging.logger import get_logger
+from fast_agent.core.logging.logger import get_logger
 
 if TYPE_CHECKING:
-    from mcp_agent.context import Context
+    from fast_agent.context import Context
 
 logger = get_logger(__name__)
 
@@ -221,7 +221,6 @@ class AsyncioExecutor(Executor):
 
                     return result
             except Exception as e:
-                # TODO: saqadri - adding logging or other error handling here
                 return e
 
         if self._activity_semaphore:

{mcp_agent → fast_agent}/core/fastagent.py

@@ -15,40 +15,40 @@ from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, TypeVar
 import yaml
 from opentelemetry import trace
 
-from mcp_agent import config
-from mcp_agent.app import MCPApp
-from mcp_agent.context import Context
-from mcp_agent.core.agent_app import AgentApp
-from mcp_agent.core.direct_decorators import (
+from fast_agent import config
+from fast_agent.context import Context
+from fast_agent.core import Core
+from fast_agent.core.agent_app import AgentApp
+from fast_agent.core.direct_decorators import (
     agent as agent_decorator,
 )
-from mcp_agent.core.direct_decorators import (
+from fast_agent.core.direct_decorators import (
     chain as chain_decorator,
 )
-from mcp_agent.core.direct_decorators import (
+from fast_agent.core.direct_decorators import (
     custom as custom_decorator,
 )
-from mcp_agent.core.direct_decorators import (
+from fast_agent.core.direct_decorators import (
     evaluator_optimizer as evaluator_optimizer_decorator,
 )
-from mcp_agent.core.direct_decorators import (
+from fast_agent.core.direct_decorators import (
     iterative_planner as orchestrator2_decorator,
 )
-from mcp_agent.core.direct_decorators import (
+from fast_agent.core.direct_decorators import (
     orchestrator as orchestrator_decorator,
 )
-from mcp_agent.core.direct_decorators import (
+from fast_agent.core.direct_decorators import (
     parallel as parallel_decorator,
 )
-from mcp_agent.core.direct_decorators import (
+from fast_agent.core.direct_decorators import (
     router as router_decorator,
 )
-from mcp_agent.core.direct_factory import (
+from fast_agent.core.direct_factory import (
     create_agents_in_dependency_order,
     get_model_factory,
 )
-from mcp_agent.core.error_handling import handle_error
-from mcp_agent.core.exceptions import (
+from fast_agent.core.error_handling import handle_error
+from fast_agent.core.exceptions import (
     AgentConfigError,
     CircularDependencyError,
     ModelConfigError,
@@ -57,18 +57,18 @@ from mcp_agent.core.exceptions import (
     ServerConfigError,
     ServerInitializationError,
 )
-from mcp_agent.core.usage_display import display_usage_report
-from mcp_agent.core.validation import (
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.core.validation import (
     validate_provider_keys_post_creation,
     validate_server_references,
     validate_workflow_references,
 )
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.prompts.prompt_load import load_prompt_multipart
+from fast_agent.mcp.prompts.prompt_load import load_prompt_multipart
+from fast_agent.ui.usage_display import display_usage_report
 
 if TYPE_CHECKING:
-    from mcp_agent.agents.agent import Agent
-    from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+    from fast_agent.interfaces import AgentProtocol
+    from fast_agent.types import PromptMessageExtended
 
 F = TypeVar("F", bound=Callable[..., Any])  # For decorated functions
 logger = get_logger(__name__)
@@ -87,7 +87,7 @@ class FastAgent:
         ignore_unknown_args: bool = False,
         parse_cli_args: bool = True,
         quiet: bool = False,  # Add quiet parameter
-        **kwargs
+        **kwargs,
     ) -> None:
         """
         Initialize the fast-agent application.
@@ -201,15 +201,15 @@ class FastAgent:
                 self.config["logger"]["show_tools"] = False
 
             # Create the app with our local settings
-            self.app = MCPApp(
+            self.app = Core(
                 name=name,
                 settings=config.Settings(**self.config) if hasattr(self, "config") else None,
-                **kwargs
+                **kwargs,
             )
 
             # Stop progress display immediately if quiet mode is requested
             if self._programmatic_quiet:
-                from mcp_agent.progress_display import progress_display
+                from fast_agent.ui.progress_display import progress_display
 
                 progress_display.stop()
 
@@ -229,7 +229,7 @@ class FastAgent:
         but without relying on the global cache."""
 
         # Import but make a local copy to avoid affecting the global state
-        from mcp_agent.config import _settings, get_settings
+        from fast_agent.config import _settings, get_settings
 
         # Temporarily clear the global settings to ensure a fresh load
         old_settings = _settings
@@ -266,7 +266,7 @@ class FastAgent:
         Context manager for running the application.
         Initializes all registered agents.
         """
-        active_agents: Dict[str, Agent] = {}
+        active_agents: Dict[str, AgentProtocol] = {}
         had_error = False
         await self.app.initialize()
 
@@ -292,7 +292,7 @@ class FastAgent:
                         self.app.context.config.logger.show_tools = False
 
                         # Directly disable the progress display singleton
-                        from mcp_agent.progress_display import progress_display
+                        from fast_agent.ui.progress_display import progress_display
 
                         progress_display.stop()
 
@@ -342,7 +342,7 @@ class FastAgent:
                                 print("Press Ctrl+C to stop")
 
                             # Create the MCP server
-                            from mcp_agent.mcp_server import AgentMCPServer
+                            from fast_agent.mcp.server import AgentMCPServer
 
                             mcp_server = AgentMCPServer(
                                 agent_app=wrapper,
@@ -397,7 +397,7 @@ class FastAgent:
 
                     if hasattr(self.args, "prompt_file") and self.args.prompt_file:
                         agent_name = self.args.agent
-                        prompt: List[PromptMessageMultipart] = load_prompt_multipart(
+                        prompt: List[PromptMessageExtended] = load_prompt_multipart(
                             Path(self.args.prompt_file)
                         )
                         if agent_name not in active_agents:
@@ -443,14 +443,14 @@ class FastAgent:
             finally:
                 # Ensure progress display is stopped before showing usage summary
                 try:
-                    from mcp_agent.progress_display import progress_display
+                    from fast_agent.ui.progress_display import progress_display
 
                     progress_display.stop()
                 except:  # noqa: E722
                     pass
 
                 # Print usage report before cleanup (show for user exits too)
-                if active_agents and not had_error:
+                if active_agents and not had_error and not quiet_mode:
                     self._print_usage_report(active_agents)
 
                 # Clean up any active agents (always cleanup, even on errors)

fast_agent/core/logging/__init__.py

@@ -0,0 +1,5 @@
+"""Logging module for MCP Agent."""
+
+from fast_agent.core.logging.logger import Logger, LoggingConfig, get_logger
+
+__all__ = ["Logger", "LoggingConfig", "get_logger"]

{mcp_agent → fast_agent/core}/logging/events.py

@@ -129,15 +129,15 @@ class StreamingExclusionFilter(EventFilter):
         # First check if it passes the base filter
         if not super().matches(event):
             return False
-        
+
         # Exclude events with "Streaming progress" message
         if event.message == "Streaming progress":
             return False
-        
+
         # Also check for events with progress_action = STREAMING in data
         if event.data and isinstance(event.data.get("data"), dict):
             event_data = event.data["data"]
             if event_data.get("progress_action") == "Streaming":
                 return False
-        
+
         return True

{mcp_agent → fast_agent/core}/logging/json_serializer.py

@@ -11,7 +11,7 @@ from uuid import UUID
 
 import httpx
 
-from mcp_agent.logging import logger
+from fast_agent.core.logging import logger
 
 
 class JSONSerializer: