mcp-use 1.2.13__py3-none-any.whl → 1.3.1__py3-none-any.whl

mcp_use/connectors/base.py

@@ -24,18 +24,25 @@ class BaseConnector(ABC):
 
     def __init__(self):
         """Initialize base connector with common attributes."""
-        self.client: ClientSession | None = None
+        self.client_session: ClientSession | None = None
         self._connection_manager: ConnectionManager | None = None
         self._tools: list[Tool] | None = None
         self._resources: list[Resource] | None = None
         self._prompts: list[Prompt] | None = None
         self._connected = False
+        self.auto_reconnect = True  # Whether to automatically reconnect on connection loss (not configurable for now), may be made configurable through the connector_config
 
     @abstractmethod
     async def connect(self) -> None:
         """Establish a connection to the MCP implementation."""
         pass
 
+    @property
+    @abstractmethod
+    def public_identifier(self) -> str:
+        """Get the identifier for the connector."""
+        pass
+
     async def disconnect(self) -> None:
         """Close the connection to the MCP implementation."""
         if not self._connected:
@@ -52,16 +59,16 @@ class BaseConnector(ABC):
         errors = []
 
         # First close the client session
-        if self.client:
+        if self.client_session:
             try:
                 logger.debug("Closing client session")
-                await self.client.__aexit__(None, None, None)
+                await self.client_session.__aexit__(None, None, None)
             except Exception as e:
                 error_msg = f"Error closing client session: {e}"
                 logger.warning(error_msg)
                 errors.append(error_msg)
             finally:
-                self.client = None
+                self.client_session = None
 
         # Then stop the connection manager
         if self._connection_manager:
@@ -85,13 +92,13 @@ class BaseConnector(ABC):
 
     async def initialize(self) -> dict[str, Any]:
         """Initialize the MCP session and return session information."""
-        if not self.client:
+        if not self.client_session:
             raise RuntimeError("MCP client is not connected")
 
         logger.debug("Initializing MCP session")
 
         # Initialize the session
-        result = await self.client.initialize()
+        result = await self.client_session.initialize()
 
         server_capabilities = result.capabilities
 
@@ -116,11 +123,7 @@ class BaseConnector(ABC):
         else:
             self._prompts = []
 
-        logger.debug(
-            f"MCP session initialized with {len(self._tools)} tools, "
-            f"{len(self._resources)} resources, "
-            f"and {len(self._prompts)} prompts"
-        )
+        logger.debug(f"MCP session initialized with {len(self._tools)} tools, " f"{len(self._resources)} resources, " f"and {len(self._prompts)} prompts")
 
         return result
 
@@ -145,24 +148,121 @@ class BaseConnector(ABC):
             raise RuntimeError("MCP client is not initialized")
         return self._prompts
 
-    async def call_tool(self, name: str, arguments: dict[str, Any]) -> CallToolResult:
-        """Call an MCP tool with the given arguments."""
-        if not self.client:
+    @property
+    def is_connected(self) -> bool:
+        """Check if the connector is actually connected and the connection is alive.
+
+        This property checks not only the connected flag but also verifies that
+        the underlying connection manager and streams are still active.
+
+        Returns:
+            True if the connector is connected and the connection is alive, False otherwise.
+        """
+
+        # Check if we have a client session
+        if not self.client_session:
+            # Update the connected flag since we don't have a client session
+            self._connected = False
+            return False
+
+        # First check the basic connected flag
+        if not self._connected:
+            return False
+
+        # Check if we have a connection manager and if its task is still running
+        if self._connection_manager:
+            try:
+                # Check if the connection manager task is done (indicates disconnection)
+                if hasattr(self._connection_manager, "_task") and self._connection_manager._task:
+                    if self._connection_manager._task.done():
+                        logger.debug("Connection manager task is done, marking as disconnected")
+                        self._connected = False
+                        return False
+
+                # For HTTP-based connectors, also check if streams are still open
+                # Use the get_streams method to get the current connection
+                streams = self._connection_manager.get_streams()
+                if streams:
+                    # Connection should be a tuple of (read_stream, write_stream)
+                    if isinstance(streams, tuple) and len(streams) == 2:
+                        read_stream, write_stream = streams
+                        # Check if streams are closed using getattr with default value
+                        if getattr(read_stream, "_closed", False):
+                            logger.debug("Read stream is closed, marking as disconnected")
+                            self._connected = False
+                            return False
+                        if getattr(write_stream, "_closed", False):
+                            logger.debug("Write stream is closed, marking as disconnected")
+                            self._connected = False
+                            return False
+
+            except Exception as e:
+                # If we can't check the connection state, assume disconnected for safety
+                logger.debug(f"Error checking connection state: {e}, marking as disconnected")
+                self._connected = False
+                return False
+
+        return True
+
+    async def _ensure_connected(self) -> None:
+        """Ensure the connector is connected, reconnecting if necessary.
+
+        Raises:
+            RuntimeError: If connection cannot be established and auto_reconnect is False.
+        """
+        if not self.client_session:
             raise RuntimeError("MCP client is not connected")
 
+        if not self.is_connected:
+            if self.auto_reconnect:
+                logger.debug("Connection lost, attempting to reconnect...")
+                try:
+                    await self.connect()
+                    logger.debug("Reconnection successful")
+                except Exception as e:
+                    raise RuntimeError(f"Failed to reconnect to MCP server: {e}") from e
+            else:
+                raise RuntimeError("Connection to MCP server has been lost. " "Auto-reconnection is disabled. Please reconnect manually.")
+
+    async def call_tool(self, name: str, arguments: dict[str, Any]) -> CallToolResult:
+        """Call an MCP tool with automatic reconnection handling.
+
+        Args:
+            name: The name of the tool to call.
+            arguments: The arguments to pass to the tool.
+
+        Returns:
+            The result of the tool call.
+
+        Raises:
+            RuntimeError: If the connection is lost and cannot be reestablished.
+        """
+
+        # Ensure we're connected
+        await self._ensure_connected()
+
         logger.debug(f"Calling tool '{name}' with arguments: {arguments}")
-        result = await self.client.call_tool(name, arguments)
-        logger.debug(f"Tool '{name}' called with result: {result}")
-        return result
+        try:
+            result = await self.client_session.call_tool(name, arguments)
+            logger.debug(f"Tool '{name}' called with result: {result}")
+            return result
+        except Exception as e:
+            # Check if the error might be due to connection loss
+            if not self.is_connected:
+                raise RuntimeError(f"Tool call '{name}' failed due to connection loss: {e}") from e
+            else:
+                # Re-raise the original error if it's not connection-related
+                raise
 
     async def list_tools(self) -> list[Tool]:
         """List all available tools from the MCP implementation."""
-        if not self.client:
-            raise RuntimeError("MCP client is not connected")
+
+        # Ensure we're connected
+        await self._ensure_connected()
 
         logger.debug("Listing tools")
         try:
-            result = await self.client.list_tools()
+            result = await self.client_session.list_tools()
             return result.tools
         except McpError as e:
             logger.error(f"Error listing tools: {e}")
@@ -170,12 +270,12 @@ class BaseConnector(ABC):
 
     async def list_resources(self) -> list[Resource]:
         """List all available resources from the MCP implementation."""
-        if not self.client:
-            raise RuntimeError("MCP client is not connected")
+        # Ensure we're connected
+        await self._ensure_connected()
 
         logger.debug("Listing resources")
         try:
-            result = await self.client.list_resources()
+            result = await self.client_session.list_resources()
             return result.resources
         except McpError as e:
             logger.error(f"Error listing resources: {e}")
@@ -183,41 +283,39 @@ class BaseConnector(ABC):
 
     async def read_resource(self, uri: str) -> ReadResourceResult:
         """Read a resource by URI."""
-        if not self.client:
+        if not self.client_session:
             raise RuntimeError("MCP client is not connected")
 
         logger.debug(f"Reading resource: {uri}")
-        result = await self.client.read_resource(uri)
+        result = await self.client_session.read_resource(uri)
         return result
 
     async def list_prompts(self) -> list[Prompt]:
         """List all available prompts from the MCP implementation."""
-        if not self.client:
-            raise RuntimeError("MCP client is not connected")
+        # Ensure we're connected
+        await self._ensure_connected()
 
         logger.debug("Listing prompts")
         try:
-            result = await self.client.list_prompts()
+            result = await self.client_session.list_prompts()
             return result.prompts
         except McpError as e:
             logger.error(f"Error listing prompts: {e}")
             return []
 
-    async def get_prompt(
-        self, name: str, arguments: dict[str, Any] | None = None
-    ) -> GetPromptResult:
+    async def get_prompt(self, name: str, arguments: dict[str, Any] | None = None) -> GetPromptResult:
         """Get a prompt by name."""
-        if not self.client:
-            raise RuntimeError("MCP client is not connected")
+        # Ensure we're connected
+        await self._ensure_connected()
 
         logger.debug(f"Getting prompt: {name}")
-        result = await self.client.get_prompt(name, arguments)
+        result = await self.client_session.get_prompt(name, arguments)
         return result
 
     async def request(self, method: str, params: dict[str, Any] | None = None) -> Any:
         """Send a raw request to the MCP implementation."""
-        if not self.client:
-            raise RuntimeError("MCP client is not connected")
+        # Ensure we're connected
+        await self._ensure_connected()
 
         logger.debug(f"Sending request: {method} with params: {params}")
-        return await self.client.request({"method": method, "params": params or {}})
+        return await self.client_session.request({"method": method, "params": params or {}})

mcp_use/connectors/http.py

@@ -2,20 +2,21 @@
 HTTP connector for MCP implementations.
 
 This module provides a connector for communicating with MCP implementations
-through HTTP APIs with SSE for transport.
+through HTTP APIs with SSE or Streamable HTTP for transport.
 """
 
+import httpx
 from mcp import ClientSession
 
 from ..logging import logger
-from ..task_managers import SseConnectionManager
+from ..task_managers import ConnectionManager, SseConnectionManager, StreamableHttpConnectionManager
 from .base import BaseConnector
 
 
 class HttpConnector(BaseConnector):
-    """Connector for MCP implementations using HTTP transport with SSE.
+    """Connector for MCP implementations using HTTP transport with SSE or streamable HTTP.
 
-    This connector uses HTTP/SSE to communicate with remote MCP implementations,
+    This connector uses HTTP/SSE or streamable HTTP to communicate with remote MCP implementations,
     using a connection manager to handle the proper lifecycle management.
     """
 
@@ -45,38 +46,115 @@ class HttpConnector(BaseConnector):
         self.timeout = timeout
         self.sse_read_timeout = sse_read_timeout
 
+    async def _setup_client(self, connection_manager: ConnectionManager) -> None:
+        """Set up the client session with the provided connection manager."""
+
+        self._connection_manager = connection_manager
+        read_stream, write_stream = await self._connection_manager.start()
+        self.client_session = ClientSession(read_stream, write_stream, sampling_callback=None)
+        await self.client_session.__aenter__()
+
     async def connect(self) -> None:
         """Establish a connection to the MCP implementation."""
         if self._connected:
             logger.debug("Already connected to MCP implementation")
             return
 
-        logger.debug(f"Connecting to MCP implementation via HTTP/SSE: {self.base_url}")
-        try:
-            # Create the SSE connection URL
-            sse_url = f"{self.base_url}"
-
-            # Create and start the connection manager
-            self._connection_manager = SseConnectionManager(
-                sse_url, self.headers, self.timeout, self.sse_read_timeout
-            )
-            read_stream, write_stream = await self._connection_manager.start()
+        # Try streamable HTTP first (new transport), fall back to SSE (old transport)
+        # This implements backwards compatibility per MCP specification
+        self.transport_type = None
+        connection_manager = None
 
-            # Create the client session
-            self.client = ClientSession(read_stream, write_stream, sampling_callback=None)
-            await self.client.__aenter__()
-
-            # Mark as connected
-            self._connected = True
-            logger.debug(
-                f"Successfully connected to MCP implementation via HTTP/SSE: {self.base_url}"
+        try:
+            # First, try the new streamable HTTP transport
+            logger.debug(f"Attempting streamable HTTP connection to: {self.base_url}")
+            connection_manager = StreamableHttpConnectionManager(
+                self.base_url, self.headers, self.timeout, self.sse_read_timeout
             )
 
-        except Exception as e:
-            logger.error(f"Failed to connect to MCP implementation via HTTP/SSE: {e}")
-
-            # Clean up any resources if connection failed
-            await self._cleanup_resources()
-
-            # Re-raise the original exception
-            raise
+            # Test if this is a streamable HTTP server by attempting initialization
+            read_stream, write_stream = await connection_manager.start()
+
+            # Test if this actually works by trying to create a client session and initialize it
+            test_client = ClientSession(read_stream, write_stream, sampling_callback=None)
+            await test_client.__aenter__()
+
+            try:
+                # Try to initialize - this is where streamable HTTP vs SSE difference should show up
+                await test_client.initialize()
+
+                # If we get here, streamable HTTP works
+
+                self.client_session = test_client
+                self.transport_type = "streamable HTTP"
+
+            except Exception as init_error:
+                # Clean up the test client
+                try:
+                    await test_client.__aexit__(None, None, None)
+                except Exception:
+                    pass
+                raise init_error
+
+        except Exception as streamable_error:
+            logger.debug(f"Streamable HTTP failed: {streamable_error}")
+
+            # Clean up the failed streamable HTTP connection manager
+            if connection_manager:
+                try:
+                    await connection_manager.close()
+                except Exception:
+                    pass
+
+            # Check if this is a 4xx error that indicates we should try SSE fallback
+            should_fallback = False
+            if isinstance(streamable_error, httpx.HTTPStatusError):
+                if streamable_error.response.status_code in [404, 405]:
+                    should_fallback = True
+            elif "405 Method Not Allowed" in str(streamable_error) or "404 Not Found" in str(
+                streamable_error
+            ):
+                should_fallback = True
+            else:
+                # For other errors, still try fallback but they might indicate
+                # real connectivity issues
+                should_fallback = True
+
+            if should_fallback:
+                try:
+                    # Fall back to the old SSE transport
+                    logger.debug(f"Attempting SSE fallback connection to: {self.base_url}")
+                    connection_manager = SseConnectionManager(
+                        self.base_url, self.headers, self.timeout, self.sse_read_timeout
+                    )
+
+                    read_stream, write_stream = await connection_manager.start()
+
+                    # Create the client session for SSE
+                    self.client_session = ClientSession(
+                        read_stream, write_stream, sampling_callback=None
+                    )
+                    await self.client_session.__aenter__()
+                    self.transport_type = "SSE"
+
+                except Exception as sse_error:
+                    logger.error(
+                        f"Both transport methods failed. Streamable HTTP: {streamable_error}, "
+                        f"SSE: {sse_error}"
+                    )
+                    raise sse_error
+            else:
+                raise streamable_error
+
+        # Store the successful connection manager and mark as connected
+        self._connection_manager = connection_manager
+        self._connected = True
+        logger.debug(
+            f"Successfully connected to MCP implementation via"
+            f" {self.transport_type}: {self.base_url}"
+        )
+
+    @property
+    def public_identifier(self) -> str:
+        """Get the identifier for the connector."""
+        return {"type": self.transport_type, "base_url": self.base_url}