fast-agent-mcp 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

mcp_agent/mcp/mcp_agent_client_session.py

@@ -7,7 +7,6 @@ from typing import Optional
 
 from mcp import ClientSession
 from mcp.shared.session import (
-    RequestResponder,
     ReceiveResultT,
     ReceiveNotificationT,
     RequestId,
@@ -16,18 +15,11 @@ from mcp.shared.session import (
     SendResultT,
 )
 from mcp.types import (
-    ClientResult,
-    CreateMessageRequest,
-    CreateMessageResult,
     ErrorData,
-    JSONRPCNotification,
-    JSONRPCRequest,
-    ServerRequest,
-    TextContent,
-    ListRootsRequest,
     ListRootsResult,
     Root,
 )
+from pydantic import AnyUrl
 
 from mcp_agent.config import MCPServerSettings
 from mcp_agent.context_dependent import ContextDependent
@@ -36,6 +28,24 @@ 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.
@@ -48,36 +58,9 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
     """
 
     def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs, list_roots_callback=list_roots)
         self.server_config: Optional[MCPServerSettings] = None
 
-    async def _received_request(
-        self, responder: RequestResponder[ServerRequest, ClientResult]
-    ) -> None:
-        logger.debug("Received request:", data=responder.request.model_dump())
-        request = responder.request.root
-
-        if isinstance(request, CreateMessageRequest):
-            return await self.handle_sampling_request(request, responder)
-        elif isinstance(request, ListRootsRequest):
-            # Handle list_roots request by returning configured roots
-            if hasattr(self, "server_config") and self.server_config.roots:
-                roots = [
-                    Root(
-                        uri=root.server_uri_alias or root.uri,
-                        name=root.name,
-                    )
-                    for root in self.server_config.roots
-                ]
-
-                await responder.respond(ListRootsResult(roots=roots))
-            else:
-                await responder.respond(ListRootsResult(roots=[]))
-            return
-
-        # Handle other requests as usual
-        await super()._received_request(responder)
-
     async def send_request(
         self,
         request: SendRequestT,
@@ -89,7 +72,7 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
             logger.debug("send_request: response=", data=result.model_dump())
             return result
         except Exception as e:
-            logger.error(f"send_request failed: {e}")
+            logger.error(f"send_request failed: {str(e)}")
             raise
 
     async def send_notification(self, notification: SendNotificationT) -> None:
@@ -133,110 +116,3 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
         return await super().send_progress_notification(
             progress_token=progress_token, progress=progress, total=total
         )
-
-    async def _receive_loop(self) -> None:
-        async with (
-            self._read_stream,
-            self._write_stream,
-            self._incoming_message_stream_writer,
-        ):
-            async for message in self._read_stream:
-                if isinstance(message, Exception):
-                    await self._incoming_message_stream_writer.send(message)
-                elif isinstance(message.root, JSONRPCRequest):
-                    validated_request = self._receive_request_type.model_validate(
-                        message.root.model_dump(
-                            by_alias=True, mode="json", exclude_none=True
-                        )
-                    )
-                    responder = RequestResponder(
-                        request_id=message.root.id,
-                        request_meta=validated_request.root.params.meta
-                        if validated_request.root.params
-                        else None,
-                        request=validated_request,
-                        session=self,
-                    )
-
-                    await self._received_request(responder)
-                    if not responder._responded:
-                        await self._incoming_message_stream_writer.send(responder)
-                elif isinstance(message.root, JSONRPCNotification):
-                    notification = self._receive_notification_type.model_validate(
-                        message.root.model_dump(
-                            by_alias=True, mode="json", exclude_none=True
-                        )
-                    )
-
-                    await self._received_notification(notification)
-                    await self._incoming_message_stream_writer.send(notification)
-                else:  # Response or error
-                    stream = self._response_streams.pop(message.root.id, None)
-                    if stream:
-                        await stream.send(message.root)
-                    else:
-                        await self._incoming_message_stream_writer.send(
-                            RuntimeError(
-                                "Received response with an unknown "
-                                f"request ID: {message}"
-                            )
-                        )
-
-    async def handle_sampling_request(
-        self,
-        request: CreateMessageRequest,
-        responder: RequestResponder[ServerRequest, ClientResult],
-    ):
-        logger.info("Handling sampling request: %s", request)
-        config = self.context.config
-        session = self.context.upstream_session
-        if session is None:
-            # TODO: saqadri - consider whether we should be handling the sampling request here as a client
-            logger.warning(
-                "Error: No upstream client available for sampling requests. Request:",
-                data=request,
-            )
-            try:
-                from anthropic import AsyncAnthropic
-
-                client = AsyncAnthropic(api_key=config.anthropic.api_key)
-
-                params = request.params
-                response = await client.messages.create(
-                    model="claude-3-sonnet-20240229",
-                    max_tokens=params.maxTokens,
-                    messages=[
-                        {
-                            "role": m.role,
-                            "content": m.content.text
-                            if hasattr(m.content, "text")
-                            else m.content.data,
-                        }
-                        for m in params.messages
-                    ],
-                    system=getattr(params, "systemPrompt", None),
-                    temperature=getattr(params, "temperature", 0.7),
-                    stop_sequences=getattr(params, "stopSequences", None),
-                )
-
-                await responder.respond(
-                    CreateMessageResult(
-                        model="claude-3-sonnet-20240229",
-                        role="assistant",
-                        content=TextContent(type="text", text=response.content[0].text),
-                    )
-                )
-            except Exception as e:
-                logger.error(f"Error handling sampling request: {e}")
-                await responder.respond(ErrorData(code=-32603, message=str(e)))
-        else:
-            try:
-                # If a session is available, we'll pass-through the sampling request to the upstream client
-                result = await session.send_request(
-                    request=ServerRequest(request), result_type=CreateMessageResult
-                )
-
-                # Pass the result from the upstream client back to the server. We just act as a pass-through client here.
-                await responder.send_result(result)
-            except Exception as e:
-                await responder.send_error(code=-32603, message=str(e))

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
                 )
@@ -370,20 +371,11 @@ class MCPAggregator(ContextDependent):
         Returns:
             Result from the operation or an error result
         """
-        logger.info(
-            f"Requesting {operation_type}",
-            data={
-                "progress_action": ProgressAction.STARTING,
-                f"{operation_type}_name": operation_name,
-                "server_name": server_name,
-                "agent_name": self.agent_name,
-            },
-        )
 
         async def try_execute(client: ClientSession):
             try:
                 method = getattr(client, method_name)
-                return await method(**method_args) if method_args else await method()
+                return await method(**method_args)
             except Exception as e:
                 error_msg = f"Failed to {method_name} '{operation_name}' on server '{server_name}': {e}"
                 logger.error(error_msg)
@@ -469,6 +461,16 @@ class MCPAggregator(ContextDependent):
             logger.error(f"Error: Tool '{name}' not found")
             return CallToolResult(isError=True, message=f"Tool '{name}' not found")
 
+        logger.info(
+            "Requesting tool call",
+            data={
+                "progress_action": ProgressAction.CALLING_TOOL,
+                "tool_name": local_tool_name,
+                "server_name": server_name,
+                "agent_name": self.agent_name,
+            },
+        )
+
         return await self._execute_on_server(
             server_name=server_name,
             operation_type="tool",
@@ -820,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):
     """

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()

mcp_agent/mcp/mime_utils.py

@@ -0,0 +1,69 @@
+# mime_utils.py
+
+import mimetypes
+
+# Initialize mimetypes database
+mimetypes.init()
+
+# Extend with additional types that might be missing
+mimetypes.add_type("text/x-python", ".py")
+mimetypes.add_type("image/webp", ".webp")
+
+# Known text-based MIME types not starting with "text/"
+TEXT_MIME_TYPES = {
+    "application/json",
+    "application/javascript",
+    "application/xml",
+    "application/ld+json",
+    "application/xhtml+xml",
+    "application/x-httpd-php",
+    "application/x-sh",
+    "application/ecmascript",
+    "application/graphql",
+    "application/x-www-form-urlencoded",
+    "application/yaml",
+    "application/toml",
+    "application/x-python-code",
+    "application/vnd.api+json",
+}
+
+# Common text-based MIME type patterns
+TEXT_MIME_PATTERNS = ("+xml", "+json", "+yaml", "+text")
+
+
+def guess_mime_type(file_path: str) -> str:
+    """
+    Guess the MIME type of a file based on its extension.
+    """
+    mime_type, _ = mimetypes.guess_type(file_path)
+    return mime_type or "application/octet-stream"
+
+
+def is_text_mime_type(mime_type: str) -> bool:
+    """Determine if a MIME type represents text content."""
+    if not mime_type:
+        return False
+
+    # Standard text types
+    if mime_type.startswith("text/"):
+        return True
+
+    # Known text types
+    if mime_type in TEXT_MIME_TYPES:
+        return True
+
+    # Common text patterns
+    if any(mime_type.endswith(pattern) for pattern in TEXT_MIME_PATTERNS):
+        return True
+
+    return False
+
+
+def is_binary_content(mime_type: str) -> bool:
+    """Check if content should be treated as binary."""
+    return not is_text_mime_type(mime_type)
+
+
+def is_image_mime_type(mime_type: str) -> bool:
+    """Check if a MIME type represents an image."""
+    return mime_type.startswith("image/") and mime_type != "image/svg+xml"

mcp_agent/mcp/prompt_message_multipart.py

@@ -0,0 +1,64 @@
+from typing import List, Union
+from pydantic import BaseModel
+
+from mcp.types import (
+    PromptMessage,
+    TextContent,
+    ImageContent,
+    EmbeddedResource,
+    Role,
+    GetPromptResult,
+)
+
+
+class PromptMessageMultipart(BaseModel):
+    """
+    Extension of PromptMessage that handles multiple content parts.
+    Internally converts to/from a sequence of standard PromptMessages.
+    """
+
+    role: Role
+    content: List[Union[TextContent, ImageContent, EmbeddedResource]]
+
+    @classmethod
+    def from_prompt_messages(
+        cls, messages: List[PromptMessage]
+    ) -> List["PromptMessageMultipart"]:
+        """Convert a sequence of PromptMessages into PromptMessageMultipart objects."""
+        if not messages:
+            return []
+
+        result = []
+        current_group = None
+        current_role = None
+
+        for msg in messages:
+            if msg.role != current_role:
+                # Role changed, start new message
+                if current_group is not None:
+                    result.append(current_group)
+                current_role = msg.role
+                current_group = cls(role=msg.role, content=[msg.content])
+            else:
+                # Same role, add to current message
+                current_group.content.append(msg.content)
+
+        # Add the last group
+        if current_group is not None:
+            result.append(current_group)
+
+        return result
+
+    def to_prompt_messages(self) -> List[PromptMessage]:
+        """Convert this PromptMessageMultipart to a sequence of standard PromptMessages."""
+        return [
+            PromptMessage(role=self.role, content=content_part)
+            for content_part in self.content
+        ]
+
+    @classmethod
+    def parse_get_prompt_result(
+        cls, result: GetPromptResult
+    ) -> List["PromptMessageMultipart"]:
+        """Parse a GetPromptResult into PromptMessageMultipart objects."""
+        return cls.from_prompt_messages(result.messages)