fast-agent-mcp 0.1.9__tar.gz → 0.1.10__tar.gz

{fast_agent_mcp-0.1.9 → fast_agent_mcp-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.1.9
+Version: 0.1.10
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>, Sarmad Qadri <sarmad@lastmileai.dev>
 License:                                  Apache License
@@ -259,9 +259,10 @@ The simple declarative syntax lets you concentrate on composing your Prompts and
 
 Evaluate how different models handle Agent and MCP Server calling tasks, then build multi-model workflows using the best provider for each task.
 
-`fast-agent` is now multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints (for supported models), via Prompts and MCP Tool Call results.
+`fast-agent` is now multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints (for supported models), via Prompts, Resources and MCP Tool Call results.
 
-> [!TIP] > `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site.
+> [!TIP]
+> `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site.
 
 ### Agent Application Development
 

{fast_agent_mcp-0.1.9 → fast_agent_mcp-0.1.10}/README.md

@@ -16,9 +16,10 @@ The simple declarative syntax lets you concentrate on composing your Prompts and
 
 Evaluate how different models handle Agent and MCP Server calling tasks, then build multi-model workflows using the best provider for each task.
 
-`fast-agent` is now multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints (for supported models), via Prompts and MCP Tool Call results.
+`fast-agent` is now multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints (for supported models), via Prompts, Resources and MCP Tool Call results.
 
-> [!TIP] > `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site.
+> [!TIP]
+> `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site.
 
 ### Agent Application Development
 

{fast_agent_mcp-0.1.9 → fast_agent_mcp-0.1.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.1.9"
+version = "0.1.10"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }

{fast_agent_mcp-0.1.9 → fast_agent_mcp-0.1.10}/src/mcp_agent/agents/agent.py

@@ -9,7 +9,10 @@ from mcp.types import (
     ListToolsResult,
     TextContent,
     Tool,
+    EmbeddedResource,
+    ReadResourceResult,
 )
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 from mcp_agent.core.exceptions import PromptExitError
 from mcp_agent.mcp.mcp_aggregator import MCPAggregator
@@ -320,6 +323,11 @@ class Agent(MCPAggregator):
                 ],
             )
 
+    async def read_resource(
+        self, server_name: str, resource_name: str
+    ) -> ReadResourceResult:
+        return None
+
     async def apply_prompt(
         self, prompt_name: str, arguments: dict[str, str] = None
     ) -> str:
@@ -359,3 +367,107 @@ class Agent(MCPAggregator):
         # The LLM will automatically generate a response if needed
         result = await self._llm.apply_prompt_template(prompt_result, display_name)
         return result
+
+    async def get_resource(self, server_name: str, resource_name: str):
+        """
+        Get a resource directly from an MCP server by name.
+
+        Args:
+            server_name: Name of the MCP server to retrieve the resource from
+            resource_name: Name of the resource to retrieve
+
+        Returns:
+            The resource object from the MCP server
+
+        Raises:
+            ValueError: If the server doesn't exist or the resource couldn't be found
+        """
+        if not self.initialized:
+            await self.initialize()
+
+        # Get the specified server connection
+        server = self.get_server(server_name)
+        if not server:
+            raise ValueError(f"Server '{server_name}' not found or not connected")
+
+        # Request the resource directly from the server
+        try:
+            resource_result = await server.get_resource(resource_name)
+            return resource_result
+        except Exception as e:
+            self.logger.error(
+                f"Error retrieving resource '{resource_name}' from server '{server_name}': {str(e)}"
+            )
+            raise ValueError(
+                f"Failed to retrieve resource '{resource_name}' from server '{server_name}': {str(e)}"
+            )
+
+    async def get_embedded_resources(
+        self, server_name: str, resource_name: str
+    ) -> List[EmbeddedResource]:
+        """
+        Get a resource from an MCP server and return it as a list of embedded resources ready for use in prompts.
+
+        Args:
+            server_name: Name of the MCP server to retrieve the resource from
+            resource_name: Name or URI of the resource to retrieve
+
+        Returns:
+            List of EmbeddedResource objects ready to use in a PromptMessageMultipart
+
+        Raises:
+            ValueError: If the server doesn't exist or the resource couldn't be found
+        """
+        # Get the raw resource result
+        result: ReadResourceResult = await super().get_resource(
+            server_name, resource_name
+        )
+
+        # Convert each resource content to an EmbeddedResource
+        embedded_resources: List[EmbeddedResource] = []
+        for resource_content in result.contents:
+            embedded_resource = EmbeddedResource(
+                type="resource", resource=resource_content, annotations=None
+            )
+            embedded_resources.append(embedded_resource)
+
+        return embedded_resources
+
+    async def with_resource(
+        self,
+        prompt_content: Union[str, PromptMessageMultipart],
+        server_name: str,
+        resource_name: str,
+    ) -> str:
+        """
+        Create a prompt with the given content and resource, then send it to the agent.
+
+        Args:
+            prompt_content: Either a string message or an existing PromptMessageMultipart
+            server_name: Name of the MCP server to retrieve the resource from
+            resource_name: Name or URI of the resource to retrieve
+
+        Returns:
+            The agent's response as a string
+        """
+        # Get the embedded resources
+        embedded_resources: List[EmbeddedResource] = await self.get_embedded_resources(
+            server_name, resource_name
+        )
+
+        # Create or update the prompt message
+        prompt: PromptMessageMultipart
+        if isinstance(prompt_content, str):
+            # Create a new prompt with the text and resources
+            content = [TextContent(type="text", text=prompt_content)]
+            content.extend(embedded_resources)
+            prompt = PromptMessageMultipart(role="user", content=content)
+        elif isinstance(prompt_content, PromptMessageMultipart):
+            # Add resources to the existing prompt
+            prompt = prompt_content
+            prompt.content.extend(embedded_resources)
+        else:
+            raise TypeError("prompt_content must be a string or PromptMessageMultipart")
+
+        # Send the prompt to the agent and return the response
+        return await self._llm.generate_prompt(prompt, None)

{fast_agent_mcp-0.1.9 → fast_agent_mcp-0.1.10}/src/mcp_agent/context.py

@@ -24,7 +24,6 @@ from mcp_agent.executor.executor import Executor
 from mcp_agent.executor.decorator_registry import (
     DecoratorRegistry,
     register_asyncio_decorators,
-    register_temporal_decorators,
 )
 from mcp_agent.executor.task_registry import ActivityRegistry
 from mcp_agent.executor.executor import AsyncioExecutor
@@ -194,7 +193,6 @@ async def initialize_context(
 
     context.decorator_registry = DecoratorRegistry()
     register_asyncio_decorators(context.decorator_registry)
-    register_temporal_decorators(context.decorator_registry)
 
     # Store the tracer in context if needed
     context.tracer = trace.get_tracer(config.otel.service_name)

{fast_agent_mcp-0.1.9 → fast_agent_mcp-0.1.10}/src/mcp_agent/core/factory.py

@@ -172,16 +172,17 @@ async def create_agents_by_type(
             if agent_type == AgentType.BASIC:
                 # Get the agent name for special handling
                 agent_name = agent_data["config"].name
-                agent = Agent(config=config, context=app_instance.context)
-
-                # Set up LLM with proper configuration
-                async with agent:
-                    llm_factory = model_factory_func(
-                        model=config.model,
-                        request_params=config.default_request_params,
-                    )
-                    agent._llm = await agent.attach_llm(llm_factory)
+                agent = Agent(
+                    config=config,
+                    context=app_instance.context,
+                )
+                await agent.initialize()
 
+                llm_factory = model_factory_func(
+                    model=config.model,
+                    request_params=config.default_request_params,
+                )
+                agent._llm = await agent.attach_llm(llm_factory)
                 # Store the agent
                 instance = agent
 
@@ -222,16 +223,16 @@ async def create_agents_by_type(
                     default_request_params=base_params,
                 )
                 planner_agent = Agent(
-                    config=planner_config, context=app_instance.context
+                    config=planner_config,
+                    context=app_instance.context,
                 )
                 planner_factory = model_factory_func(
                     model=config.model,
                     request_params=config.default_request_params,
                 )
 
-                async with planner_agent:
-                    planner = await planner_agent.attach_llm(planner_factory)
-
+                planner = await planner_agent.attach_llm(planner_factory)
+                await planner.initialize()
                 # Create the orchestrator with pre-configured planner
                 instance = Orchestrator(
                     name=config.name,

{fast_agent_mcp-0.1.9 → fast_agent_mcp-0.1.10}/src/mcp_agent/core/fastagent.py

@@ -16,7 +16,6 @@ from contextlib import asynccontextmanager
 from functools import partial
 
 from mcp_agent.app import MCPApp
-from mcp_agent.context_dependent import ContextDependent
 from mcp_agent.config import Settings
 
 from mcp_agent.core.agent_app import AgentApp
@@ -64,7 +63,7 @@ from mcp_agent.mcp_server import AgentMCPServer
 T = TypeVar("T")  # For the wrapper classes
 
 
-class FastAgent(ContextDependent):
+class FastAgent:
     """
     A decorator-based interface for MCP Agent applications.
     Provides a simplified way to create and manage agents using decorators.
@@ -320,6 +319,7 @@ class FastAgent(ContextDependent):
         """
         active_agents = {}
         had_error = False
+        await self.app.initialize()
 
         # Handle quiet mode by disabling logger settings after initialization
         quiet_mode = hasattr(self, "args") and self.args.quiet

{fast_agent_mcp-0.1.9 → fast_agent_mcp-0.1.10}/src/mcp_agent/core/proxies.py

@@ -8,6 +8,7 @@ from typing import List, Optional, Dict, Union, TYPE_CHECKING
 from mcp_agent.agents.agent import Agent
 from mcp_agent.app import MCPApp
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from mcp.types import EmbeddedResource
 
 # Handle circular imports
 if TYPE_CHECKING:
@@ -129,6 +130,43 @@ class LLMAgentProxy(BaseAgentProxy):
         """
         return await self._agent.apply_prompt(prompt_name, arguments)
 
+    # Add the new methods
+    async def get_embedded_resources(
+        self, server_name: str, resource_name: str
+    ) -> List[EmbeddedResource]:
+        """
+        Get a resource from an MCP server and return it as a list of embedded resources ready for use in prompts.
+
+        Args:
+            server_name: Name of the MCP server to retrieve the resource from
+            resource_name: Name or URI of the resource to retrieve
+
+        Returns:
+            List of EmbeddedResource objects ready to use in a PromptMessageMultipart
+        """
+        return await self._agent.get_embedded_resources(server_name, resource_name)
+
+    async def with_resource(
+        self,
+        prompt_content: Union[str, PromptMessageMultipart],
+        server_name: str,
+        resource_name: str,
+    ) -> str:
+        """
+        Create a prompt with the given content and resource, then send it to the agent.
+
+        Args:
+            prompt_content: Either a string message or an existing PromptMessageMultipart
+            server_name: Name of the MCP server to retrieve the resource from
+            resource_name: Name or URI of the resource to retrieve
+
+        Returns:
+            The agent's response as a string
+        """
+        return await self._agent.with_resource(
+            prompt_content, server_name, resource_name
+        )
+
 
 class WorkflowProxy(BaseAgentProxy):
     """Proxy for workflow types that implement generate_str() directly"""

{fast_agent_mcp-0.1.9 → fast_agent_mcp-0.1.10}/src/mcp_agent/logging/listeners.py

@@ -177,10 +177,7 @@ class BatchingListener(FilteredListener):
 
         if self._flush_task and not self._flush_task.done():
             self._flush_task.cancel()
-            try:
-                await self._flush_task
-            except asyncio.CancelledError:
-                pass
+            await self._flush_task
             self._flush_task = None
         await self.flush()
 
@@ -193,8 +190,8 @@ class BatchingListener(FilteredListener):
                     )
                 except asyncio.TimeoutError:
                     await self.flush()
-        except asyncio.CancelledError:
-            pass
+        # except asyncio.CancelledError:
+        #     break
         finally:
             await self.flush()  # Final flush
 

fast_agent_mcp-0.1.10/src/mcp_agent/mcp/mcp_agent_client_session.py

@@ -0,0 +1,118 @@
+"""
+A derived client session for the MCP Agent framework.
+It adds logging and supports sampling requests.
+"""
+
+from typing import Optional
+
+from mcp import ClientSession
+from mcp.shared.session import (
+    ReceiveResultT,
+    ReceiveNotificationT,
+    RequestId,
+    SendNotificationT,
+    SendRequestT,
+    SendResultT,
+)
+from mcp.types import (
+    ErrorData,
+    ListRootsResult,
+    Root,
+)
+from pydantic import AnyUrl
+
+from mcp_agent.config import MCPServerSettings
+from mcp_agent.context_dependent import ContextDependent
+from mcp_agent.logging.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+async def list_roots(ctx: ClientSession) -> ListRootsResult:
+    """List roots callback that will be called by the MCP library."""
+
+    roots = []
+    if (
+        hasattr(ctx, "session")
+        and hasattr(ctx.session, "server_config")
+        and ctx.session.server_config
+        and hasattr(ctx.session.server_config, "roots")
+        and ctx.session.server_config.roots
+    ):
+        roots = [
+            Root(uri=AnyUrl(root.uri), name=root.name)
+            for root in ctx.session.server_config.roots
+        ]
+    return ListRootsResult(roots=roots or [])
+
+
+class MCPAgentClientSession(ClientSession, ContextDependent):
+    """
+    MCP Agent framework acts as a client to the servers providing tools/resources/prompts for the agent workloads.
+    This is a simple client session for those server connections, and supports
+        - handling sampling requests
+        - notifications
+        - MCP root configuration
+
+    Developers can extend this class to add more custom functionality as needed
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs, list_roots_callback=list_roots)
+        self.server_config: Optional[MCPServerSettings] = None
+
+    async def send_request(
+        self,
+        request: SendRequestT,
+        result_type: type[ReceiveResultT],
+    ) -> ReceiveResultT:
+        logger.debug("send_request: request=", data=request.model_dump())
+        try:
+            result = await super().send_request(request, result_type)
+            logger.debug("send_request: response=", data=result.model_dump())
+            return result
+        except Exception as e:
+            logger.error(f"send_request failed: {str(e)}")
+            raise
+
+    async def send_notification(self, notification: SendNotificationT) -> None:
+        logger.debug("send_notification:", data=notification.model_dump())
+        try:
+            return await super().send_notification(notification)
+        except Exception as e:
+            logger.error("send_notification failed", data=e)
+            raise
+
+    async def _send_response(
+        self, request_id: RequestId, response: SendResultT | ErrorData
+    ) -> None:
+        logger.debug(
+            f"send_response: request_id={request_id}, response=",
+            data=response.model_dump(),
+        )
+        return await super()._send_response(request_id, response)
+
+    async def _received_notification(self, notification: ReceiveNotificationT) -> None:
+        """
+        Can be overridden by subclasses to handle a notification without needing
+        to listen on the message stream.
+        """
+        logger.info(
+            "_received_notification: notification=",
+            data=notification.model_dump(),
+        )
+        return await super()._received_notification(notification)
+
+    async def send_progress_notification(
+        self, progress_token: str | int, progress: float, total: float | None = None
+    ) -> None:
+        """
+        Sends a progress notification for a request that is currently being
+        processed.
+        """
+        logger.debug(
+            "send_progress_notification: progress_token={progress_token}, progress={progress}, total={total}"
+        )
+        return await super().send_progress_notification(
+            progress_token=progress_token, progress=progress, total=total
+        )

{fast_agent_mcp-0.1.9 → fast_agent_mcp-0.1.10}/src/mcp_agent/mcp/mcp_aggregator.py

@@ -8,8 +8,8 @@ from typing import (
     Callable,
     TypeVar,
 )
-from mcp import GetPromptResult
-from pydantic import BaseModel, ConfigDict
+from mcp import GetPromptResult, ReadResourceResult
+from pydantic import AnyUrl, BaseModel, ConfigDict
 from mcp.client.session import ClientSession
 from mcp.server.lowlevel.server import Server
 from mcp.server.stdio import stdio_server
@@ -210,6 +210,7 @@ class MCPAggregator(ContextDependent):
                         "agent_name": self.agent_name,
                     },
                 )
+
                 await self._persistent_connection_manager.get_server(
                     server_name, client_session_factory=MCPAgentClientSession
                 )
@@ -821,6 +822,53 @@ class MCPAggregator(ContextDependent):
         logger.debug(f"Available prompts across servers: {results}")
         return results
 
+    async def get_resource(
+        self, server_name: str, resource_uri: str
+    ) -> ReadResourceResult:
+        """
+        Get a resource directly from an MCP server by URI.
+
+        Args:
+            server_name: Name of the MCP server to retrieve the resource from
+            resource_uri: URI of the resource to retrieve
+
+        Returns:
+            ReadResourceResult object containing the resource content
+
+        Raises:
+            ValueError: If the server doesn't exist or the resource couldn't be found
+        """
+        if not self.initialized:
+            await self.load_servers()
+
+        if server_name not in self.server_names:
+            raise ValueError(f"Server '{server_name}' not found")
+
+        logger.info(
+            "Requesting resource",
+            data={
+                "progress_action": ProgressAction.CALLING_TOOL,
+                "resource_uri": resource_uri,
+                "server_name": server_name,
+                "agent_name": self.agent_name,
+            },
+        )
+
+        try:
+            uri = AnyUrl(resource_uri)
+        except Exception as e:
+            raise ValueError(f"Invalid resource URI: {resource_uri}. Error: {e}")
+
+        # Use the _execute_on_server method to call read_resource on the server
+        return await self._execute_on_server(
+            server_name=server_name,
+            operation_type="resource",
+            operation_name=resource_uri,
+            method_name="read_resource",
+            method_args={"uri": uri},
+            error_factory=lambda msg: ValueError(f"Failed to retrieve resource: {msg}"),
+        )
+
 
 class MCPCompoundServer(Server):
     """

{fast_agent_mcp-0.1.9 → fast_agent_mcp-0.1.10}/src/mcp_agent/mcp/mcp_connection_manager.py

@@ -163,7 +163,6 @@ async def _server_lifecycle_task(server_conn: ServerConnection) -> None:
         async with transport_context as (read_stream, write_stream):
             #      try:
             server_conn.create_session(read_stream, write_stream)
-            #       except FileNotFoundError as e:
 
             async with server_conn.session:
                 await server_conn.initialize_session()

{fast_agent_mcp-0.1.9 → fast_agent_mcp-0.1.10}/src/mcp_agent/mcp/prompts/prompt_server.py

@@ -12,6 +12,8 @@ import logging
 import sys
 from pathlib import Path
 from typing import List, Dict, Optional, Callable, Awaitable, Literal, Any
+from mcp.server.fastmcp.resources import FileResource
+from pydantic import AnyUrl
 
 from mcp_agent.mcp import mime_utils, resource_utils
 
@@ -185,19 +187,19 @@ def create_prompt_handler(
 
 
 # Type for resource handler
-ResourceHandler = Callable[[], Awaitable[str]]
+ResourceHandler = Callable[[], Awaitable[str | bytes]]
 
 
 def create_resource_handler(resource_path: Path, mime_type: str) -> ResourceHandler:
     """Create a resource handler function for the given resource"""
 
-    async def get_resource() -> str:
+    async def get_resource() -> str | bytes:
         is_binary = mime_utils.is_binary_content(mime_type)
 
         if is_binary:
             # For binary files, read in binary mode and base64 encode
             with open(resource_path, "rb") as f:
-                return base64.b64encode(f.read()).decode("utf-8")
+                return f.read()
         else:
             # For text files, read as utf-8 text
             with open(resource_path, "r", encoding="utf-8") as f:
@@ -284,15 +286,14 @@ def register_prompt(file_path: Path):
                         exposed_resources[resource_id] = resource_file
                         mime_type = mime_utils.guess_mime_type(str(resource_file))
 
-                        # Register with the correct resource ID directly with MCP
-                        resource_handler = create_resource_handler(
-                            resource_file, mime_type
+                        mcp.add_resource(
+                            FileResource(
+                                uri=AnyUrl(resource_id),
+                                path=resource_file,
+                                mime_type=mime_type,
+                                is_binary=mime_utils.is_binary_content(mime_type),
+                            )
                         )
-                        mcp.resource(
-                            resource_id,
-                            description=f"Resource from {file_path.name}",
-                            mime_type=mime_type,
-                        )(resource_handler)
 
                         logger.info(
                             f"Registered resource: {resource_id} ({resource_file})"