fast-agent-mcp 0.2.58__py3-none-any.whl → 0.3.1__py3-none-any.whl

{mcp_agent → fast_agent}/core/agent_app.py

@@ -2,18 +2,17 @@
 Direct AgentApp implementation for interacting with agents without proxies.
 """
 
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Mapping, Optional, Union
 
 from deprecated import deprecated
 from mcp.types import GetPromptResult, PromptMessage
 from rich import print as rich_print
 
-from mcp_agent.agents.agent import Agent
-from mcp_agent.core.agent_types import AgentType
-from mcp_agent.core.interactive_prompt import InteractivePrompt
-from mcp_agent.core.request_params import RequestParams
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-from mcp_agent.progress_display import progress_display
+from fast_agent.agents.agent_types import AgentType
+from fast_agent.interfaces import AgentProtocol
+from fast_agent.types import PromptMessageExtended, RequestParams
+from fast_agent.ui.interactive_prompt import InteractivePrompt
+from fast_agent.ui.progress_display import progress_display
 
 
 class AgentApp:
@@ -28,7 +27,7 @@ class AgentApp:
     calls to the default agent (the first agent in the container).
     """
 
-    def __init__(self, agents: Dict[str, Agent]) -> None:
+    def __init__(self, agents: Dict[str, AgentProtocol]) -> None:
         """
         Initialize the DirectAgentApp.
 
@@ -37,13 +36,13 @@ class AgentApp:
         """
         self._agents = agents
 
-    def __getitem__(self, key: str) -> Agent:
+    def __getitem__(self, key: str) -> AgentProtocol:
         """Allow access to agents using dictionary syntax."""
         if key not in self._agents:
             raise KeyError(f"Agent '{key}' not found")
         return self._agents[key]
 
-    def __getattr__(self, name: str) -> Agent:
+    def __getattr__(self, name: str) -> AgentProtocol:
         """Allow access to agents using attribute syntax."""
         if name in self._agents:
             return self._agents[name]
@@ -51,7 +50,7 @@ class AgentApp:
 
     async def __call__(
         self,
-        message: Union[str, PromptMessage, PromptMessageMultipart] | None = None,
+        message: Union[str, PromptMessage, PromptMessageExtended] | None = None,
         agent_name: str | None = None,
         default_prompt: str = "",
         request_params: RequestParams | None = None,
@@ -62,9 +61,9 @@ class AgentApp:
 
         Args:
             message: Message content in various formats:
-                - String: Converted to a user PromptMessageMultipart
-                - PromptMessage: Converted to PromptMessageMultipart
-                - PromptMessageMultipart: Used directly
+                - String: Converted to a user PromptMessageExtended
+                - PromptMessage: Converted to PromptMessageExtended
+                - PromptMessageExtended: Used directly
             agent_name: Optional name of the agent to send to (defaults to first agent)
             default_prompt: Default message to use in interactive prompt mode
             request_params: Optional request parameters including MCP metadata
@@ -75,11 +74,13 @@ class AgentApp:
         if message:
             return await self._agent(agent_name).send(message, request_params)
 
-        return await self.interactive(agent_name=agent_name, default_prompt=default_prompt, request_params=request_params)
+        return await self.interactive(
+            agent_name=agent_name, default_prompt=default_prompt, request_params=request_params
+        )
 
     async def send(
         self,
-        message: Union[str, PromptMessage, PromptMessageMultipart],
+        message: Union[str, PromptMessage, PromptMessageExtended],
         agent_name: Optional[str] = None,
         request_params: RequestParams | None = None,
     ) -> str:
@@ -88,9 +89,9 @@ class AgentApp:
 
         Args:
             message: Message content in various formats:
-                - String: Converted to a user PromptMessageMultipart
-                - PromptMessage: Converted to PromptMessageMultipart
-                - PromptMessageMultipart: Used directly
+                - String: Converted to a user PromptMessageExtended
+                - PromptMessage: Converted to PromptMessageExtended
+                - PromptMessageExtended: Used directly
             agent_name: Optional name of the agent to send to
             request_params: Optional request parameters including MCP metadata
 
@@ -99,7 +100,7 @@ class AgentApp:
         """
         return await self._agent(agent_name).send(message, request_params)
 
-    def _agent(self, agent_name: str | None) -> Agent:
+    def _agent(self, agent_name: str | None) -> AgentProtocol:
         if agent_name:
             if agent_name not in self._agents:
                 raise ValueError(f"Agent '{agent_name}' not found")
@@ -134,7 +135,7 @@ class AgentApp:
             prompt, arguments, as_template=as_template
         )
 
-    async def list_prompts(self, server_name: str | None = None, agent_name: str | None = None):
+    async def list_prompts(self, namespace: str | None = None, agent_name: str | None = None):
         """
         List available prompts for an agent.
 
@@ -148,10 +149,10 @@ class AgentApp:
         if not agent_name:
             results = {}
             for agent in self._agents.values():
-                curr_prompts = await agent.list_prompts(server_name=server_name)
+                curr_prompts = await agent.list_prompts(namespace=namespace)
                 results.update(curr_prompts)
             return results
-        return await self._agent(agent_name).list_prompts(server_name=server_name)
+        return await self._agent(agent_name).list_prompts(namespace=namespace)
 
     async def get_prompt(
         self,
@@ -173,12 +174,12 @@ class AgentApp:
             GetPromptResult containing the prompt information
         """
         return await self._agent(agent_name).get_prompt(
-            prompt_name=prompt_name, arguments=arguments, server_name=server_name
+            prompt_name=prompt_name, arguments=arguments, namespace=server_name
         )
 
     async def with_resource(
         self,
-        prompt_content: Union[str, PromptMessage, PromptMessageMultipart],
+        prompt_content: Union[str, PromptMessage, PromptMessageExtended],
         resource_uri: str,
         server_name: str | None = None,
         agent_name: str | None = None,
@@ -187,7 +188,7 @@ class AgentApp:
         Send a message with an attached MCP resource.
 
         Args:
-            prompt_content: Content in various formats (String, PromptMessage, or PromptMessageMultipart)
+            prompt_content: Content in various formats (String, PromptMessage, or PromptMessageExtended)
             resource_uri: URI of the resource to retrieve
             server_name: Optional name of the MCP server to retrieve the resource from
             agent_name: Name of the agent to use
@@ -196,14 +197,14 @@ class AgentApp:
             The agent's response as a string
         """
         return await self._agent(agent_name).with_resource(
-            prompt_content=prompt_content, resource_uri=resource_uri, server_name=server_name
+            prompt_content=prompt_content, resource_uri=resource_uri, namespace=server_name
         )
 
     async def list_resources(
         self,
         server_name: str | None = None,
         agent_name: str | None = None,
-    ) -> Dict[str, List[str]]:
+    ) -> Mapping[str, List[str]]:
         """
         List available resources from one or all servers.
 
@@ -214,7 +215,7 @@ class AgentApp:
         Returns:
             Dictionary mapping server names to lists of resource URIs
         """
-        return await self._agent(agent_name).list_resources(server_name=server_name)
+        return await self._agent(agent_name).list_resources(namespace=server_name)
 
     async def get_resource(
         self,
@@ -234,20 +235,22 @@ class AgentApp:
             ReadResourceResult object containing the resource content
         """
         return await self._agent(agent_name).get_resource(
-            resource_uri=resource_uri, server_name=server_name
+            resource_uri=resource_uri, namespace=server_name
         )
 
     @deprecated
     async def prompt(
-        self, 
-        agent_name: str | None = None, 
+        self,
+        agent_name: str | None = None,
         default_prompt: str = "",
-        request_params: RequestParams | None = None
+        request_params: RequestParams | None = None,
     ) -> str:
         """
         Deprecated - use interactive() instead.
         """
-        return await self.interactive(agent_name=agent_name, default_prompt=default_prompt, request_params=request_params)
+        return await self.interactive(
+            agent_name=agent_name, default_prompt=default_prompt, request_params=request_params
+        )
 
     async def interactive(
         self,
@@ -279,7 +282,7 @@ class AgentApp:
             target_name = None
             for agent in self._agents.values():
                 if agent.config.default:
-                    target_name = agent.config.name
+                    target_name = agent.name
                     break
 
             if not target_name:
@@ -303,7 +306,7 @@ class AgentApp:
             if pretty_print_parallel:
                 agent = self._agents.get(agent_name)
                 if agent and agent.agent_type == AgentType.PARALLEL:
-                    from mcp_agent.ui.console_display import ConsoleDisplay
+                    from fast_agent.ui.console_display import ConsoleDisplay
 
                     display = ConsoleDisplay(config=None)
                     display.show_parallel_results(agent)

fast_agent/core/core_app.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import asyncio
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, Optional, TypeVar
+
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.event_progress import ProgressAction
+
+if TYPE_CHECKING:
+    # Only imported for type checking to avoid circular imports at runtime
+    from fast_agent.config import Settings
+    from fast_agent.context import Context
+    from fast_agent.core.executor.workflow_signal import SignalWaitCallback
+
+R = TypeVar("R")
+
+
+class Core:
+    """
+    fast-agent core. handles application settings, config and context management.
+    """
+
+    def __init__(
+        self,
+        name: str = "fast-agent",
+        settings: Optional[Settings] | str = None,
+        signal_notification: Optional[SignalWaitCallback] = None,
+    ) -> None:
+        """
+        Initialize the core.
+        Args:
+            name:
+            settings: If unspecified, the settings are loaded from fastagent.config.yaml.
+                If this is a string, it is treated as the path to the config file to load.
+            signal_notification: Callback for getting notified on workflow signals/events.
+        """
+        self.name = name
+
+        # We use these to initialize the context in initialize()
+        self._config_or_path = settings
+        self._signal_notification = signal_notification
+
+        self._logger = None
+        # Use forward reference for type to avoid runtime import
+        self._context: Optional["Context"] = None
+        self._initialized = False
+
+    @property
+    def context(self) -> "Context":
+        if self._context is None:
+            raise RuntimeError(
+                "Core not initialized, please call initialize() first, or use async with app.run()."
+            )
+        return self._context
+
+    @property
+    def config(self):
+        return self.context.config
+
+    @property
+    def server_registry(self):
+        return self.context.server_registry
+
+    @property
+    def logger(self):
+        if self._logger is None:
+            self._logger = get_logger(f"fast_agent.{self.name}")
+        return self._logger
+
+    async def initialize(self) -> None:
+        """Initialize the fast-agent core. Sets up context (and therefore logging and loading settings)."""
+        if self._initialized:
+            return
+
+        # Import here to avoid circular imports during module initialization
+        from fast_agent import context as _context_mod
+
+        self._context = await _context_mod.initialize_context(
+            self._config_or_path, store_globally=True
+        )
+
+        # Set the properties that were passed in the constructor
+        self._context.signal_notification = self._signal_notification
+        # Note: upstream_session support removed for now
+
+        self._initialized = True
+        self.logger.info(
+            "fast-agent initialized",
+            data={
+                "progress_action": "Running",
+                "target": self.name or "mcp_application",
+                "agent_name": self.name or "fast-agent core",
+            },
+        )
+
+    async def cleanup(self) -> None:
+        """Cleanup application resources."""
+        if not self._initialized:
+            return
+
+        self.logger.info(
+            "fast-agent cleanup",
+            data={
+                "progress_action": ProgressAction.FINISHED,
+                "target": self.name or "fast-agent",
+                "agent_name": self.name or "fast-agent core",
+            },
+        )
+        try:
+            # Import here to avoid circular imports during module initialization
+            from fast_agent import context as _context_mod
+
+            await _context_mod.cleanup_context()
+        except asyncio.CancelledError:
+            self.logger.debug("Cleanup cancelled error during shutdown")
+
+        self._context = None
+        self._initialized = False
+
+    @asynccontextmanager
+    async def run(self):
+        """
+        Use core for context management
+
+        Example:
+            async with core.run() as running_app:
+                # App is initialized here
+                pass
+        """
+        await self.initialize()
+        try:
+            yield self
+        finally:
+            await self.cleanup()

{mcp_agent → fast_agent}/core/direct_decorators.py

@@ -4,7 +4,6 @@ These decorators provide type-safe function signatures and IDE support
 for creating agents in the DirectFastAgent framework.
 """
 
-import inspect
 from functools import wraps
 from pathlib import Path
 from typing import (
@@ -17,27 +16,25 @@ from typing import (
     ParamSpec,
     Protocol,
     TypeVar,
-    Union,
     cast,
 )
 
 from mcp.client.session import ElicitationFnT
 from pydantic import AnyUrl
 
-from mcp_agent.agents.agent import AgentConfig
-from mcp_agent.agents.workflow.iterative_planner import ITERATIVE_PLAN_SYSTEM_PROMPT_TEMPLATE
-from mcp_agent.agents.workflow.router_agent import (
+from fast_agent.agents.agent_types import AgentConfig, AgentType
+from fast_agent.agents.workflow.iterative_planner import ITERATIVE_PLAN_SYSTEM_PROMPT_TEMPLATE
+from fast_agent.agents.workflow.router_agent import (
     ROUTING_SYSTEM_INSTRUCTION,
 )
-from mcp_agent.core.agent_types import AgentType
-from mcp_agent.core.request_params import RequestParams
+from fast_agent.types import RequestParams
 
 # Type variables for the decorated function
 P = ParamSpec("P")  # Parameters
-R = TypeVar("R")  # Return type
+R = TypeVar("R", covariant=True)  # Return type
 
 # Type for agent functions - can be either async or sync
-AgentCallable = Callable[P, Union[Awaitable[R], R]]
+AgentCallable = Callable[P, Awaitable[R]]
 
 
 # Protocol for decorated agent functions
@@ -47,7 +44,7 @@ class DecoratedAgentProtocol(Protocol[P, R]):
     _agent_type: AgentType
     _agent_config: AgentConfig
 
-    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> Union[Awaitable[R], R]: ...
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> Awaitable[R]: ...
 
 
 # Protocol for orchestrator functions
@@ -207,21 +204,10 @@ def _decorator_impl(
     """
 
     def decorator(func: AgentCallable[P, R]) -> DecoratedAgentProtocol[P, R]:
-        is_async = inspect.iscoroutinefunction(func)
-
-        # Handle both async and sync functions consistently
-        if is_async:
-
-            @wraps(func)
-            async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-                # Call the original function
-                return await func(*args, **kwargs)
-        else:
-
-            @wraps(func)
-            def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-                # Call the original function
-                return func(*args, **kwargs)
+        @wraps(func)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> Awaitable[R]:
+            # Call the original function
+            return func(*args, **kwargs)
 
         # Create agent configuration
         config = AgentConfig(
@@ -597,7 +583,7 @@ def chain(
     """
     # Validate sequence is not empty
     if not sequence:
-        from mcp_agent.core.exceptions import AgentConfigError
+        from fast_agent.core.exceptions import AgentConfigError
 
         raise AgentConfigError(f"Chain '{name}' requires at least one agent in the sequence")