mcp-use 1.3.4__tar.gz → 1.3.5__tar.gz

{mcp_use-1.3.4 → mcp_use-1.3.5}/.github/release-drafter.yml

@@ -1,5 +1,5 @@
-name-template: 'v$RESOLVED_VERSION 🌈'
-tag-template: 'v$RESOLVED_VERSION'
+name-template: 'Release v$RESOLVED_VERSION 🌈'
+tag-template: 'Releasev$RESOLVED_VERSION'
 categories:
   - title: '🚀 Features'
     labels:

{mcp_use-1.3.4 → mcp_use-1.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-use
-Version: 1.3.4
+Version: 1.3.5
 Summary: MCP Library for LLMs
 Author-email: Pietro Zullo <pietro.zullo@gmail.com>
 License: MIT

{mcp_use-1.3.4 → mcp_use-1.3.5}/mcp_use/client.py

@@ -189,9 +189,7 @@ class MCPClient:
 
         # Create sessions for all servers
         for name in servers:
-            session = await self.create_session(name, auto_initialize)
-            if auto_initialize:
-                await session.initialize()
+            await self.create_session(name, auto_initialize)
 
         return self.sessions
 

{mcp_use-1.3.4 → mcp_use-1.3.5}/mcp_use/connectors/base.py

@@ -31,6 +31,7 @@ class BaseConnector(ABC):
         self._resources: list[Resource] | None = None
         self._prompts: list[Prompt] | None = None
         self._connected = False
+        self._initialized = False  # Track if client_session.initialize() has been called
         self.auto_reconnect = True  # Whether to automatically reconnect on connection loss (not configurable for now)
 
     @abstractmethod
@@ -87,6 +88,7 @@ class BaseConnector(ABC):
         self._tools = None
         self._resources = None
         self._prompts = None
+        self._initialized = False  # Reset initialization flag
 
         if errors:
             logger.warning(f"Encountered {len(errors)} errors during resource cleanup")
@@ -96,38 +98,40 @@ class BaseConnector(ABC):
         if not self.client_session:
             raise RuntimeError("MCP client is not connected")
 
-        logger.debug("Initializing MCP session")
+        # Check if already initialized
+        if self._initialized:
+            return {"status": "already_initialized"}
 
         # Initialize the session
         result = await self.client_session.initialize()
+        self._initialized = True  # Mark as initialized
 
         server_capabilities = result.capabilities
 
         if server_capabilities.tools:
-            # Get available tools
-            tools_result = await self.list_tools()
-            self._tools = tools_result or []
+            # Get available tools directly from client session
+            tools_result = await self.client_session.list_tools()
+            self._tools = tools_result.tools if tools_result else []
         else:
             self._tools = []
 
         if server_capabilities.resources:
-            # Get available resources
-            resources_result = await self.list_resources()
-            self._resources = resources_result or []
+            # Get available resources directly from client session
+            resources_result = await self.client_session.list_resources()
+            self._resources = resources_result.resources if resources_result else []
         else:
             self._resources = []
 
         if server_capabilities.prompts:
-            # Get available prompts
-            prompts_result = await self.list_prompts()
-            self._prompts = prompts_result or []
+            # Get available prompts directly from client session
+            prompts_result = await self.client_session.list_prompts()
+            self._prompts = prompts_result.prompts if prompts_result else []
         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"
+            "{len(self._resources)} resources, and {len(self._prompts)} prompts"
         )
 
         return result

{mcp_use-1.3.4 → mcp_use-1.3.5}/mcp_use/connectors/http.py

@@ -81,12 +81,37 @@ class HttpConnector(BaseConnector):
 
             try:
                 # Try to initialize - this is where streamable HTTP vs SSE difference should show up
-                await test_client.initialize()
+                result = await test_client.initialize()
 
                 # If we get here, streamable HTTP works
 
                 self.client_session = test_client
                 self.transport_type = "streamable HTTP"
+                self._initialized = True  # Mark as initialized since we just called initialize()
+
+                # Populate tools, resources, and prompts since we've initialized
+                server_capabilities = result.capabilities
+
+                if server_capabilities.tools:
+                    # Get available tools directly from client session
+                    tools_result = await self.client_session.list_tools()
+                    self._tools = tools_result.tools if tools_result else []
+                else:
+                    self._tools = []
+
+                if server_capabilities.resources:
+                    # Get available resources directly from client session
+                    resources_result = await self.client_session.list_resources()
+                    self._resources = resources_result.resources if resources_result else []
+                else:
+                    self._resources = []
+
+                if server_capabilities.prompts:
+                    # Get available prompts directly from client session
+                    prompts_result = await self.client_session.list_prompts()
+                    self._prompts = prompts_result.prompts if prompts_result else []
+                else:
+                    self._prompts = []
 
             except Exception as init_error:
                 # Clean up the test client

{mcp_use-1.3.4 → mcp_use-1.3.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcp-use"
-version = "1.3.4"
+version = "1.3.5"
 description = "MCP Library for LLMs"
 authors = [
     {name = "Pietro Zullo", email = "pietro.zullo@gmail.com"}

{mcp_use-1.3.4 → mcp_use-1.3.5}/tests/unit/test_client.py

@@ -456,10 +456,9 @@ class TestMCPClientSessionManagement:
         assert mock_create_connector.call_count == 2
         assert mock_session_class.call_count == 2
 
-        # In the implementation, initialize is called twice for each session:
-        # Once in create_session and once in the explicit initialize call
-        assert mock_session1.initialize.call_count == 2
-        assert mock_session2.initialize.call_count == 2
+        # Initialize is called once per session during create_session
+        assert mock_session1.initialize.call_count == 1
+        assert mock_session2.initialize.call_count == 1
 
         # Verify state changes
         assert len(client.sessions) == 2

{mcp_use-1.3.4 → mcp_use-1.3.5}/tests/unit/test_http_connector.py

@@ -128,7 +128,17 @@ class TestHttpConnectorConnection(IsolatedAsyncioTestCase):
                 mock_instance.initialize.side_effect = McpError(ErrorData(code=1, message="Connection closed"))
             else:
                 # Second call (SSE) - succeeds
-                mock_instance.initialize.return_value = EmptyResult()
+                mock_init_result = MagicMock()
+                mock_init_result.capabilities = MagicMock(tools=True, resources=True, prompts=True)
+                mock_instance.initialize.return_value = mock_init_result
+
+            # Add mocks for list_tools, list_resources, and list_prompts since HttpConnector calls these
+            mock_instance.list_tools = AsyncMock()
+            mock_instance.list_tools.return_value = MagicMock(tools=[MagicMock(spec=Tool)])
+            mock_instance.list_resources = AsyncMock()
+            mock_instance.list_resources.return_value = MagicMock(resources=[MagicMock(spec=Resource)])
+            mock_instance.list_prompts = AsyncMock()
+            mock_instance.list_prompts.return_value = MagicMock(prompts=[MagicMock(spec=Prompt)])
 
             return mock_instance
 
@@ -163,7 +173,18 @@ class TestHttpConnectorConnection(IsolatedAsyncioTestCase):
         mock_client_session_instance = MagicMock()
         mock_client_session_instance.__aenter__ = AsyncMock()
         mock_client_session_instance.initialize = AsyncMock()
-        mock_client_session_instance.initialize.return_value = EmptyResult()  # Success
+        mock_init_result = MagicMock()
+        mock_init_result.capabilities = MagicMock(tools=True, resources=True, prompts=True)
+        mock_client_session_instance.initialize.return_value = mock_init_result
+
+        # Add mocks for list_tools, list_resources, and list_prompts since HttpConnector calls these
+        mock_client_session_instance.list_tools = AsyncMock()
+        mock_client_session_instance.list_tools.return_value = MagicMock(tools=[MagicMock(spec=Tool)])
+        mock_client_session_instance.list_resources = AsyncMock()
+        mock_client_session_instance.list_resources.return_value = MagicMock(resources=[MagicMock(spec=Resource)])
+        mock_client_session_instance.list_prompts = AsyncMock()
+        mock_client_session_instance.list_prompts.return_value = MagicMock(prompts=[MagicMock(spec=Prompt)])
+
         mock_client_session_class.return_value = mock_client_session_instance
 
         # Test connect with streamable HTTP
@@ -178,10 +199,19 @@ class TestHttpConnectorConnection(IsolatedAsyncioTestCase):
         mock_client_session_instance.__aenter__.assert_called_once()
         mock_client_session_instance.initialize.assert_called_once()
 
+        # Verify tools/resources/prompts were populated during connect
+        mock_client_session_instance.list_tools.assert_called_once()
+        mock_client_session_instance.list_resources.assert_called_once()
+        mock_client_session_instance.list_prompts.assert_called_once()
+
         # Verify final state
         self.assertEqual(self.connector.client_session, mock_client_session_instance)
         self.assertEqual(self.connector._connection_manager, mock_cm_instance)
         self.assertTrue(self.connector._connected)
+        self.assertTrue(self.connector._initialized)
+        self.assertEqual(len(self.connector._tools), 1)
+        self.assertEqual(len(self.connector._resources), 1)
+        self.assertEqual(len(self.connector._prompts), 1)
 
     @patch("mcp_use.connectors.http.StreamableHttpConnectionManager")
     async def test_sse_connect_already_connected(self, mock_cm_class, _):
@@ -300,7 +330,7 @@ class TestHttpConnectorOperations(IsolatedAsyncioTestCase):
         mock_init_result.capabilities = MagicMock(tools=True, resources=True, prompts=True)
         self.connector.client_session.initialize.return_value = mock_init_result
 
-        # Setup mocks for list_tools, list_resources, and list_prompts
+        # Setup mocks for client session methods directly (not connector wrapper methods)
         self.connector.client_session.list_tools.return_value = MagicMock(tools=[MagicMock(spec=Tool)])
         self.connector.client_session.list_resources.return_value = MagicMock(resources=[MagicMock(spec=Resource)])
         self.connector.client_session.list_prompts.return_value = MagicMock(prompts=[MagicMock(spec=Prompt)])
@@ -308,7 +338,7 @@ class TestHttpConnectorOperations(IsolatedAsyncioTestCase):
         # Initialize
         result_session_info = await self.connector.initialize()
 
-        # Verify calls
+        # Verify calls to client session methods directly
         self.connector.client_session.initialize.assert_called_once()
         self.connector.client_session.list_tools.assert_called_once()
         self.connector.client_session.list_resources.assert_called_once()