mcp-use 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

mcp_use/config.py

@@ -43,9 +43,9 @@ def create_connector_from_config(server_config: dict[str, Any]) -> BaseConnector
     # HTTP connector
     elif "url" in server_config:
         return HttpConnector(
-            url=server_config["url"],
+            base_url=server_config["url"],
             headers=server_config.get("headers", None),
-            auth=server_config.get("auth", None),
+            auth_token=server_config.get("auth_token", None),
         )
 
     # WebSocket connector
@@ -53,7 +53,7 @@ def create_connector_from_config(server_config: dict[str, Any]) -> BaseConnector
         return WebSocketConnector(
             url=server_config["ws_url"],
             headers=server_config.get("headers", None),
-            auth=server_config.get("auth", None),
+            auth_token=server_config.get("auth_token", None),
         )
 
     raise ValueError("Cannot determine connector type from config")

mcp_use/connectors/base.py

@@ -8,8 +8,12 @@ must implement.
 from abc import ABC, abstractmethod
 from typing import Any
 
+from mcp import ClientSession
 from mcp.types import CallToolResult, Tool
 
+from ..logging import logger
+from ..task_managers import ConnectionManager
+
 
 class BaseConnector(ABC):
     """Base class for MCP connectors.
@@ -17,43 +21,119 @@ class BaseConnector(ABC):
     This class defines the interface that all MCP connectors must implement.
     """
 
+    def __init__(self):
+        """Initialize base connector with common attributes."""
+        self.client: ClientSession | None = None
+        self._connection_manager: ConnectionManager | None = None
+        self._tools: list[Tool] | None = None
+        self._connected = False
+
     @abstractmethod
     async def connect(self) -> None:
         """Establish a connection to the MCP implementation."""
         pass
 
-    @abstractmethod
     async def disconnect(self) -> None:
         """Close the connection to the MCP implementation."""
-        pass
+        if not self._connected:
+            logger.debug("Not connected to MCP implementation")
+            return
+
+        logger.info("Disconnecting from MCP implementation")
+        await self._cleanup_resources()
+        self._connected = False
+        logger.info("Disconnected from MCP implementation")
+
+    async def _cleanup_resources(self) -> None:
+        """Clean up all resources associated with this connector."""
+        errors = []
+
+        # First close the client session
+        if self.client:
+            try:
+                logger.debug("Closing client session")
+                await self.client.__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
+
+        # Then stop the connection manager
+        if self._connection_manager:
+            try:
+                logger.debug("Stopping connection manager")
+                await self._connection_manager.stop()
+            except Exception as e:
+                error_msg = f"Error stopping connection manager: {e}"
+                logger.warning(error_msg)
+                errors.append(error_msg)
+            finally:
+                self._connection_manager = None
+
+        # Reset tools
+        self._tools = None
+
+        if errors:
+            logger.warning(f"Encountered {len(errors)} errors during resource cleanup")
 
-    @abstractmethod
     async def initialize(self) -> dict[str, Any]:
         """Initialize the MCP session and return session information."""
-        pass
+        if not self.client:
+            raise RuntimeError("MCP client is not connected")
+
+        logger.info("Initializing MCP session")
+
+        # Initialize the session
+        result = await self.client.initialize()
+
+        # Get available tools
+        tools_result = await self.client.list_tools()
+        self._tools = tools_result.tools
+
+        logger.info(f"MCP session initialized with {len(self._tools)} tools")
+
+        return result
 
     @property
-    @abstractmethod
     def tools(self) -> list[Tool]:
         """Get the list of available tools."""
-        pass
+        if not self._tools:
+            raise RuntimeError("MCP client is not initialized")
+        return self._tools
 
-    @abstractmethod
     async def call_tool(self, name: str, arguments: dict[str, Any]) -> CallToolResult:
         """Call an MCP tool with the given arguments."""
-        pass
+        if not self.client:
+            raise RuntimeError("MCP client is not connected")
+
+        logger.debug(f"Calling tool '{name}' with arguments: {arguments}")
+        result = await self.client.call_tool(name, arguments)
+        return result
 
-    @abstractmethod
     async def list_resources(self) -> list[dict[str, Any]]:
         """List all available resources from the MCP implementation."""
-        pass
+        if not self.client:
+            raise RuntimeError("MCP client is not connected")
+
+        logger.debug("Listing resources")
+        resources = await self.client.list_resources()
+        return resources
 
-    @abstractmethod
     async def read_resource(self, uri: str) -> tuple[bytes, str]:
         """Read a resource by URI."""
-        pass
+        if not self.client:
+            raise RuntimeError("MCP client is not connected")
+
+        logger.debug(f"Reading resource: {uri}")
+        resource = await self.client.read_resource(uri)
+        return resource.content, resource.mimeType
 
-    @abstractmethod
     async def request(self, method: str, params: dict[str, Any] | None = None) -> Any:
         """Send a raw request to the MCP implementation."""
-        pass
+        if not self.client:
+            raise RuntimeError("MCP client is not connected")
+
+        logger.debug(f"Sending request: {method} with params: {params}")
+        return await self.client.request({"method": method, "params": params or {}})

mcp_use/connectors/http.py

@@ -2,23 +2,20 @@
 HTTP connector for MCP implementations.
 
 This module provides a connector for communicating with MCP implementations
-through HTTP APIs.
+through HTTP APIs with SSE for transport.
 """
 
-from typing import Any
-
-import aiohttp
-from mcp.types import Tool
+from mcp import ClientSession
 
 from ..logging import logger
-from ..task_managers import ConnectionManager, HttpConnectionManager
+from ..task_managers import SseConnectionManager
 from .base import BaseConnector
 
 
 class HttpConnector(BaseConnector):
-    """Connector for MCP implementations using HTTP transport.
+    """Connector for MCP implementations using HTTP transport with SSE.
 
-    This connector uses HTTP requests to communicate with remote MCP implementations,
+    This connector uses HTTP/SSE to communicate with remote MCP implementations,
     using a connection manager to handle the proper lifecycle management.
     """
 
@@ -27,6 +24,8 @@ class HttpConnector(BaseConnector):
         base_url: str,
         auth_token: str | None = None,
         headers: dict[str, str] | None = None,
+        timeout: float = 5,
+        sse_read_timeout: float = 60 * 5,
     ):
         """Initialize a new HTTP connector.
 
@@ -34,17 +33,17 @@ class HttpConnector(BaseConnector):
             base_url: The base URL of the MCP HTTP API.
             auth_token: Optional authentication token.
             headers: Optional additional headers.
+            timeout: Timeout for HTTP operations in seconds.
+            sse_read_timeout: Timeout for SSE read operations in seconds.
         """
+        super().__init__()
         self.base_url = base_url.rstrip("/")
         self.auth_token = auth_token
         self.headers = headers or {}
         if auth_token:
             self.headers["Authorization"] = f"Bearer {auth_token}"
-
-        self.session: aiohttp.ClientSession | None = None
-        self._connection_manager: ConnectionManager | None = None
-        self._tools: list[Tool] | None = None
-        self._connected = False
+        self.timeout = timeout
+        self.sse_read_timeout = sse_read_timeout
 
     async def connect(self) -> None:
         """Establish a connection to the MCP implementation."""
@@ -52,159 +51,32 @@ class HttpConnector(BaseConnector):
             logger.debug("Already connected to MCP implementation")
             return
 
-        logger.info(f"Connecting to MCP implementation via HTTP: {self.base_url}")
+        logger.info(f"Connecting to MCP implementation via HTTP/SSE: {self.base_url}")
         try:
+            # Create the SSE connection URL
+            sse_url = f"{self.base_url}/sse"
+
             # Create and start the connection manager
-            self._connection_manager = HttpConnectionManager(self.base_url, self.headers)
-            self.session = await self._connection_manager.start()
+            self._connection_manager = SseConnectionManager(
+                sse_url, self.headers, self.timeout, self.sse_read_timeout
+            )
+            read_stream, write_stream = await self._connection_manager.start()
+
+            # 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.info(f"Successfully connected to MCP implementation via HTTP: {self.base_url}")
+            logger.info(
+                f"Successfully connected to MCP implementation via HTTP/SSE: {self.base_url}"
+            )
 
         except Exception as e:
-            logger.error(f"Failed to connect to MCP implementation via HTTP: {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
-
-    async def disconnect(self) -> None:
-        """Close the connection to the MCP implementation."""
-        if not self._connected:
-            logger.debug("Not connected to MCP implementation")
-            return
-
-        logger.info("Disconnecting from MCP implementation")
-        await self._cleanup_resources()
-        self._connected = False
-        logger.info("Disconnected from MCP implementation")
-
-    async def _cleanup_resources(self) -> None:
-        """Clean up all resources associated with this connector."""
-        errors = []
-
-        # Stop the connection manager
-        if self._connection_manager:
-            try:
-                logger.debug("Stopping connection manager")
-                await self._connection_manager.stop()
-            except Exception as e:
-                error_msg = f"Error stopping connection manager: {e}"
-                logger.warning(error_msg)
-                errors.append(error_msg)
-            finally:
-                self._connection_manager = None
-                self.session = None
-
-        # Reset tools
-        self._tools = None
-
-        if errors:
-            logger.warning(f"Encountered {len(errors)} errors during resource cleanup")
-
-    async def _request(self, method: str, endpoint: str, data: dict[str, Any] | None = None) -> Any:
-        """Send an HTTP request to the MCP API.
-
-        Args:
-            method: The HTTP method (GET, POST, etc.).
-            endpoint: The API endpoint path.
-            data: Optional request data.
-
-        Returns:
-            The parsed JSON response.
-        """
-        if not self.session:
-            raise RuntimeError("HTTP session is not connected")
-
-        url = f"{self.base_url}/{endpoint.lstrip('/')}"
-        logger.debug(f"Sending {method} request to {url}")
-
-        if method.upper() == "GET" and data:
-            # For GET requests, convert data to query parameters
-            async with self.session.get(url, params=data) as response:
-                response.raise_for_status()
-                return await response.json()
-        else:
-            # For other methods, send data as JSON body
-            async with self.session.request(method, url, json=data) as response:
-                response.raise_for_status()
-                return await response.json()
-
-    async def initialize(self) -> dict[str, Any]:
-        """Initialize the MCP session and return session information."""
-        logger.info("Initializing MCP session")
-
-        # Initialize the session
-        result = await self._request("POST", "initialize")
-
-        # Get available tools
-        tools_result = await self.list_tools()
-        self._tools = [Tool(**tool) for tool in tools_result]
-
-        logger.info(f"MCP session initialized with {len(self._tools)} tools")
-        return result
-
-    async def list_tools(self) -> list[dict[str, Any]]:
-        """List all available tools from the MCP implementation."""
-        logger.debug("Listing tools")
-        result = await self._request("GET", "tools")
-        return result.get("tools", [])
-
-    @property
-    def tools(self) -> list[Tool]:
-        """Get the list of available tools."""
-        if not self._tools:
-            raise RuntimeError("MCP client is not initialized")
-        return self._tools
-
-    async def call_tool(self, name: str, arguments: dict[str, Any]) -> Any:
-        """Call an MCP tool with the given arguments."""
-        logger.debug(f"Calling tool '{name}' with arguments: {arguments}")
-        return await self._request("POST", f"tools/{name}", arguments)
-
-    async def list_resources(self) -> list[dict[str, Any]]:
-        """List all available resources from the MCP implementation."""
-        logger.debug("Listing resources")
-        result = await self._request("GET", "resources")
-        return result
-
-    async def read_resource(self, uri: str) -> tuple[bytes, str]:
-        """Read a resource by URI."""
-        logger.debug(f"Reading resource: {uri}")
-
-        # For resources, we may need to handle binary data
-        if not self.session:
-            raise RuntimeError("HTTP session is not connected")
-
-        url = f"{self.base_url}/resources/read"
-
-        async with self.session.get(url, params={"uri": uri}) as response:
-            response.raise_for_status()
-
-            # Check if this is a JSON response or binary data
-            content_type = response.headers.get("Content-Type", "")
-            if "application/json" in content_type:
-                data = await response.json()
-                content = data.get("content", b"")
-                mime_type = data.get("mimeType", "")
-
-                # If content is base64 encoded, decode it
-                if isinstance(content, str):
-                    import base64
-
-                    content = base64.b64decode(content)
-
-                return content, mime_type
-            else:
-                # Assume binary response
-                content = await response.read()
-                return content, content_type
-
-    async def request(self, method: str, params: dict[str, Any] | None = None) -> Any:
-        """Send a raw request to the MCP implementation."""
-        logger.debug(f"Sending request: {method} with params: {params}")
-        # For custom methods, we'll use the RPC-style endpoint
-        return await self._request("POST", "rpc", {"method": method, "params": params or {}})

mcp_use/connectors/stdio.py

@@ -6,13 +6,11 @@ through the standard input/output streams.
 """
 
 import sys
-from typing import Any
 
 from mcp import ClientSession, StdioServerParameters
-from mcp.types import CallToolResult, Tool
 
 from ..logging import logger
-from ..task_managers import ConnectionManager, StdioConnectionManager
+from ..task_managers import StdioConnectionManager
 from .base import BaseConnector
 
 
@@ -39,14 +37,11 @@ class StdioConnector(BaseConnector):
             env: Optional environment variables.
             errlog: Stream to write error output to.
         """
+        super().__init__()
         self.command = command
         self.args = args or []  # Ensure args is never None
         self.env = env
         self.errlog = errlog
-        self.client: ClientSession | None = None
-        self._connection_manager: ConnectionManager | None = None
-        self._tools: list[Tool] | None = None
-        self._connected = False
 
     async def connect(self) -> None:
         """Establish a connection to the MCP implementation."""
@@ -81,108 +76,3 @@ class StdioConnector(BaseConnector):
 
             # Re-raise the original exception
             raise
-
-    async def disconnect(self) -> None:
-        """Close the connection to the MCP implementation."""
-        if not self._connected:
-            logger.debug("Not connected to MCP implementation")
-            return
-
-        logger.info("Disconnecting from MCP implementation")
-        await self._cleanup_resources()
-        self._connected = False
-        logger.info("Disconnected from MCP implementation")
-
-    async def _cleanup_resources(self) -> None:
-        """Clean up all resources associated with this connector."""
-        errors = []
-
-        # First close the client session
-        if self.client:
-            try:
-                logger.debug("Closing client session")
-                await self.client.__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
-
-        # Then stop the connection manager
-        if self._connection_manager:
-            try:
-                logger.debug("Stopping connection manager")
-                await self._connection_manager.stop()
-            except Exception as e:
-                error_msg = f"Error stopping connection manager: {e}"
-                logger.warning(error_msg)
-                errors.append(error_msg)
-            finally:
-                self._connection_manager = None
-
-        # Reset tools
-        self._tools = None
-
-        if errors:
-            logger.warning(f"Encountered {len(errors)} errors during resource cleanup")
-
-    async def initialize(self) -> dict[str, Any]:
-        """Initialize the MCP session and return session information."""
-        if not self.client:
-            raise RuntimeError("MCP client is not connected")
-
-        logger.info("Initializing MCP session")
-
-        # Initialize the session
-        result = await self.client.initialize()
-
-        # Get available tools
-        tools_result = await self.client.list_tools()
-        self._tools = tools_result.tools
-
-        logger.info(f"MCP session initialized with {len(self._tools)} tools")
-
-        return result
-
-    @property
-    def tools(self) -> list[Tool]:
-        """Get the list of available tools."""
-        if not self._tools:
-            raise RuntimeError("MCP client is not initialized")
-        return self._tools
-
-    async def call_tool(self, name: str, arguments: dict[str, Any]) -> CallToolResult:
-        """Call an MCP tool with the given arguments."""
-        if not self.client:
-            raise RuntimeError("MCP client is not connected")
-
-        logger.debug(f"Calling tool '{name}' with arguments: {arguments}")
-        result = await self.client.call_tool(name, arguments)
-        return result
-
-    async def list_resources(self) -> list[dict[str, Any]]:
-        """List all available resources from the MCP implementation."""
-        if not self.client:
-            raise RuntimeError("MCP client is not connected")
-
-        logger.debug("Listing resources")
-        resources = await self.client.list_resources()
-        return resources
-
-    async def read_resource(self, uri: str) -> tuple[bytes, str]:
-        """Read a resource by URI."""
-        if not self.client:
-            raise RuntimeError("MCP client is not connected")
-
-        logger.debug(f"Reading resource: {uri}")
-        resource = await self.client.read_resource(uri)
-        return resource.content, resource.mimeType
-
-    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")
-
-        logger.debug(f"Sending request: {method} with params: {params}")
-        return await self.client.request({"method": method, "params": params or {}})

mcp_use/task_managers/__init__.py

@@ -6,7 +6,7 @@ through different transport mechanisms.
 """
 
 from .base import ConnectionManager
-from .http import HttpConnectionManager
+from .sse import SseConnectionManager
 from .stdio import StdioConnectionManager
 from .websocket import WebSocketConnectionManager
 
@@ -15,4 +15,5 @@ __all__ = [
     "HttpConnectionManager",
     "StdioConnectionManager",
     "WebSocketConnectionManager",
+    "SseConnectionManager",
 ]

mcp_use/task_managers/sse.py

@@ -0,0 +1,82 @@
+"""
+SSE connection management for MCP implementations.
+
+This module provides a connection manager for SSE-based MCP connections
+that ensures proper task isolation and resource cleanup.
+"""
+
+from typing import Any
+
+from mcp.client.sse import sse_client
+
+from ..logging import logger
+from .base import ConnectionManager
+
+
+class SseConnectionManager(ConnectionManager[tuple[Any, Any]]):
+    """Connection manager for SSE-based MCP connections.
+
+    This class handles the proper task isolation for sse_client context managers
+    to prevent the "cancel scope in different task" error. It runs the sse_client
+    in a dedicated task and manages its lifecycle.
+    """
+
+    def __init__(
+        self,
+        url: str,
+        headers: dict[str, str] | None = None,
+        timeout: float = 5,
+        sse_read_timeout: float = 60 * 5,
+    ):
+        """Initialize a new SSE connection manager.
+
+        Args:
+            url: The SSE endpoint URL
+            headers: Optional HTTP headers
+            timeout: Timeout for HTTP operations in seconds
+            sse_read_timeout: Timeout for SSE read operations in seconds
+        """
+        super().__init__()
+        self.url = url
+        self.headers = headers or {}
+        self.timeout = timeout
+        self.sse_read_timeout = sse_read_timeout
+        self._sse_ctx = None
+
+    async def _establish_connection(self) -> tuple[Any, Any]:
+        """Establish an SSE connection.
+
+        Returns:
+            A tuple of (read_stream, write_stream)
+
+        Raises:
+            Exception: If connection cannot be established.
+        """
+        # Create the context manager
+        self._sse_ctx = sse_client(
+            url=self.url,
+            headers=self.headers,
+            timeout=self.timeout,
+            sse_read_timeout=self.sse_read_timeout,
+        )
+
+        # Enter the context manager
+        read_stream, write_stream = await self._sse_ctx.__aenter__()
+
+        # Return the streams
+        return (read_stream, write_stream)
+
+    async def _close_connection(self, connection: tuple[Any, Any]) -> None:
+        """Close the SSE connection.
+
+        Args:
+            connection: The connection to close (ignored, we use the context manager)
+        """
+        if self._sse_ctx:
+            # Exit the context manager
+            try:
+                await self._sse_ctx.__aexit__(None, None, None)
+            except Exception as e:
+                logger.warning(f"Error closing SSE context: {e}")
+            finally:
+                self._sse_ctx = None

mcp_use/task_managers/websocket.py

@@ -5,13 +5,13 @@ This module provides a connection manager for WebSocket-based MCP connections.
 """
 
 import websockets
-from websockets.client import WebSocketClientProtocol
+from websockets.client import ClientConnection
 
 from ..logging import logger
 from .base import ConnectionManager
 
 
-class WebSocketConnectionManager(ConnectionManager[WebSocketClientProtocol]):
+class WebSocketConnectionManager(ConnectionManager[ClientConnection]):
     """Connection manager for WebSocket-based MCP connections.
 
     This class handles the lifecycle of WebSocket connections, ensuring proper
@@ -33,7 +33,7 @@ class WebSocketConnectionManager(ConnectionManager[WebSocketClientProtocol]):
         self.url = url
         self.headers = headers or {}
 
-    async def _establish_connection(self) -> WebSocketClientProtocol:
+    async def _establish_connection(self) -> ClientConnection:
         """Establish a WebSocket connection.
 
         Returns:
@@ -50,7 +50,7 @@ class WebSocketConnectionManager(ConnectionManager[WebSocketClientProtocol]):
             logger.error(f"Failed to connect to WebSocket: {e}")
             raise
 
-    async def _close_connection(self, connection: WebSocketClientProtocol) -> None:
+    async def _close_connection(self, connection: ClientConnection) -> None:
         """Close the WebSocket connection.
 
         Args:

{mcp_use-1.0.0.dist-info → mcp_use-1.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-use
-Version: 1.0.0
+Version: 1.0.1
 Summary: MCP Library for LLMs
 Author-email: Pietro Zullo <pietro.zullo@gmail.com>
 License: MIT
@@ -38,7 +38,7 @@ Requires-Dist: openai>=1.10.0; extra == 'openai'
 Description-Content-Type: text/markdown
 
 <picture>
-  <img alt="" src="./static/mcpusegrass.png"  width="full">
+  <img alt="" src="./static/image.jpg"  width="full">
 </picture>
 
 <h1 align="center">Open Source MCP CLient Library </h1>
@@ -47,6 +47,7 @@ Description-Content-Type: text/markdown
 [![PyPI Downloads](https://img.shields.io/pypi/dm/mcp_use.svg)](https://pypi.org/project/mcp_use/)
 [![PyPI Version](https://img.shields.io/pypi/v/mcp_use.svg)](https://pypi.org/project/mcp_use/)
 [![Python Versions](https://img.shields.io/pypi/pyversions/mcp_use.svg)](https://pypi.org/project/mcp_use/)
+[![Documentation](https://img.shields.io/badge/docs-mcp--use.io-blue)](https://docs.mcp-use.io)
 [![License](https://img.shields.io/github/license/pietrozullo/mcp-use)](https://github.com/pietrozullo/mcp-use/blob/main/LICENSE)
 [![Code style: Ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
 [![GitHub stars](https://img.shields.io/github/stars/pietrozullo/mcp-use?style=social)](https://github.com/pietrozullo/mcp-use/stargazers)

{mcp_use-1.0.0.dist-info → mcp_use-1.0.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 mcp_use/__init__.py,sha256=PSoxLAu1GPjfIDPcZiJyI3k66MMS3lcfx5kERUgFb1o,723
 mcp_use/client.py,sha256=0rvlJBwvPD19sjDRtXfnp15-F1VHJlXWxLQNt9cHwPA,8275
-mcp_use/config.py,sha256=D9LuCuT1mFUSBiO2DUGa5Pnd-yjNcvM9u_v11N5UmK8,1624
+mcp_use/config.py,sha256=O9V4pa-shZ2mPokRTrd7KZQ2GpuTcYBGUslefl1fosw,1653
 mcp_use/logging.py,sha256=2-hSB7ZWcHEx_OFHNg8GIbSGCZx3MW4mZGGWxi2Ew3E,2690
 mcp_use/session.py,sha256=Z4EZTUnQUX0QyGMzkJIrMRTX4SDk6qQUoBld408LIJE,3449
 mcp_use/agents/__init__.py,sha256=ukchMTqCOID6ikvLmJ-6sldWTVFIzztGQo4BX6QeQr8,312
@@ -9,16 +9,16 @@ mcp_use/agents/langchain_agent.py,sha256=q6zIb9J9fc15HRGDjPAhmPdM_8UOqQToy8ESeyr
 mcp_use/agents/mcpagent.py,sha256=lTRutdT1QIMiTbMSKfSbqlqNq_Y6uDPfkjAzJAKb6H0,12727
 mcp_use/agents/prompts/default.py,sha256=tnwt9vOiVBhdpu-lIHhwEJo3rvE6EobPfUgS9JURBzg,941
 mcp_use/connectors/__init__.py,sha256=jnd-7pPPJMb0UNJ6aD9lInj5Tlamc8lA_mFyG8RWJpo,385
-mcp_use/connectors/base.py,sha256=caUaTfsODUOik8JF9mPtcZDyZhoIz2X12I_BhAfZK10,1616
-mcp_use/connectors/http.py,sha256=KqVf0HXouFoeQ_bBUr6KQifiUjTo7K6EOCRkqVpFx4Q,7763
-mcp_use/connectors/stdio.py,sha256=aEeZ-OZS6yknFPEy-YpwvwFILGIaAsA48uB1I4j8wog,6752
+mcp_use/connectors/base.py,sha256=TCLVNJdt6qrflmphgXOZhD6xPKQQegbGqe5REmcLYg0,4813
+mcp_use/connectors/http.py,sha256=vNrVOjO_7SLJv_G6Gio3moRu11omKY6nM3_34yUMpew,2839
+mcp_use/connectors/stdio.py,sha256=36yEY7hbFXgM7zju5BtLJl4cKAZNCXVRrTaU6YOttBI,2606
 mcp_use/connectors/websocket.py,sha256=4xqxl9UncrfU6NitvKfB80Hk2g7o0Gc0G5sm6sY3RAk,9534
-mcp_use/task_managers/__init__.py,sha256=6VVe5ceSxXmQvBpjH-6aFud5dRJMNA6pu0qpAnfxpIA,460
+mcp_use/task_managers/__init__.py,sha256=4dgW5N61iiPLpwjU2rrn_uqrL8mmDJFDaF9Lukzk65A,486
 mcp_use/task_managers/base.py,sha256=ksNdxTwq8N-zqymxVoKGnWXq9iqkLYC61uB91o6Mh-4,4888
-mcp_use/task_managers/http.py,sha256=XhrF73RGRnVctBVW2FlFrFTJR2pIGXhtNvfJFiW0Olw,1881
+mcp_use/task_managers/sse.py,sha256=WysmjwqRI3meXMZY_F4y9tSBMvSiUZfTJQfitM5l6jQ,2529
 mcp_use/task_managers/stdio.py,sha256=DEISpXv4mo3d5a-WT8lkWbrXJwUh7QW0nMT_IM3fHGg,2269
-mcp_use/task_managers/websocket.py,sha256=SVgTLFogiynb48eyi6ZioWIKLLWiVBCNE59rXi6GrCM,1943
-mcp_use-1.0.0.dist-info/METADATA,sha256=SutQOwdz5oeqwsqGZJEgALeYG3evLZ8pNabca1lJppw,10113
-mcp_use-1.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_use-1.0.0.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
-mcp_use-1.0.0.dist-info/RECORD,,
+mcp_use/task_managers/websocket.py,sha256=ZbCqdGgzCRtsXzRGFws-f2OzH8cPAkN4sJNDwEpRmCc,1915
+mcp_use-1.0.1.dist-info/METADATA,sha256=BZm7Zn7K33DKE2fLzRgDPl-oTpQRAuKW3ssxNkpEsxA,10203
+mcp_use-1.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_use-1.0.1.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
+mcp_use-1.0.1.dist-info/RECORD,,

mcp_use/task_managers/http.py

@@ -1,62 +0,0 @@
-"""
-HTTP connection management for MCP implementations.
-
-This module provides a connection manager for HTTP-based MCP connections.
-"""
-
-import aiohttp
-
-from ..logging import logger
-from .base import ConnectionManager
-
-
-class HttpConnectionManager(ConnectionManager[aiohttp.ClientSession]):
-    """Connection manager for HTTP-based MCP connections.
-
-    This class handles the lifecycle of HTTP client sessions, ensuring proper
-    connection establishment and cleanup.
-    """
-
-    def __init__(
-        self,
-        base_url: str,
-        headers: dict[str, str] | None = None,
-    ):
-        """Initialize a new HTTP connection manager.
-
-        Args:
-            base_url: The base URL for HTTP requests
-            headers: Optional headers to include in all HTTP requests
-        """
-        super().__init__()
-        self.base_url = base_url.rstrip("/")
-        self.headers = headers or {}
-
-    async def _establish_connection(self) -> aiohttp.ClientSession:
-        """Establish an HTTP client session.
-
-        Returns:
-            The established HTTP client session
-
-        Raises:
-            Exception: If session cannot be established
-        """
-        logger.debug(f"Creating HTTP client session for: {self.base_url}")
-        try:
-            session = aiohttp.ClientSession(headers=self.headers)
-            return session
-        except Exception as e:
-            logger.error(f"Failed to create HTTP client session: {e}")
-            raise
-
-    async def _close_connection(self, connection: aiohttp.ClientSession) -> None:
-        """Close the HTTP client session.
-
-        Args:
-            connection: The HTTP client session to close
-        """
-        try:
-            logger.debug("Closing HTTP client session")
-            await connection.close()
-        except Exception as e:
-            logger.warning(f"Error closing HTTP client session: {e}")