mcp-use 1.3.2__tar.gz → 1.3.3__tar.gz

{mcp_use-1.3.2 → mcp_use-1.3.3}/.github/workflows/publish.yml

@@ -2,9 +2,8 @@ name: Release
 
 on:
   workflow_run:
-    workflows: ["Python Tests"]
-    branches:
-      - main
+    workflows: ["Python Tests", "Transports"]
+    branches: [main]
     types:
       - completed
 
@@ -15,9 +14,8 @@ permissions:
 
 jobs:
   check-version-and-publish:
-    # Only proceed if the referenced workflow completed successfully
-    if: ${{ github.event.workflow_run.conclusion == 'success' }}
     runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
     steps:
       - uses: actions/checkout@v3
         with:
@@ -73,6 +71,7 @@ jobs:
           draft: false
           prerelease: false
           generateReleaseNotes: false
+          omitBodyDuringUpdate: true
 
       - name: Publish to PyPI
         if: steps.check-version.outputs.is_new_version == 'true'

{mcp_use-1.3.2 → mcp_use-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-use
-Version: 1.3.2
+Version: 1.3.3
 Summary: MCP Library for LLMs
 Author-email: Pietro Zullo <pietro.zullo@gmail.com>
 License: MIT
@@ -34,7 +34,8 @@ Provides-Extra: anthropic
 Requires-Dist: langchain-anthropic; extra == 'anthropic'
 Provides-Extra: dev
 Requires-Dist: black>=23.9.0; extra == 'dev'
-Requires-Dist: fastmcp; extra == 'dev'
+Requires-Dist: fastapi; extra == 'dev'
+Requires-Dist: fastmcp==2.8.0; extra == 'dev'
 Requires-Dist: isort>=5.12.0; extra == 'dev'
 Requires-Dist: mypy>=1.5.0; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'

{mcp_use-1.3.2 → mcp_use-1.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcp-use"
-version = "1.3.2"
+version = "1.3.3"
 description = "MCP Library for LLMs"
 authors = [
     {name = "Pietro Zullo", email = "pietro.zullo@gmail.com"}
@@ -46,7 +46,8 @@ dev = [
     "isort>=5.12.0",
     "mypy>=1.5.0",
     "ruff>=0.1.0",
-    "fastmcp",
+    "fastmcp==2.8.0",
+    "fastapi",
 ]
 anthropic = [
     "langchain_anthropic",

{mcp_use-1.3.2 → mcp_use-1.3.3}/tests/integration/transports/sse/test_connection_state_tracking.py

@@ -53,48 +53,13 @@ async def timeout_server_process():
     print("Timeout test server cleanup complete")
 
 
-@pytest.fixture
-async def long_timeout_server_process():
-    """Start a server that closes connections after 30+ seconds to match issue reproduction steps"""
-    server_path = Path(__file__).parent.parent.parent / "servers_for_testing" / "long_timeout_test_server.py"
-
-    print(f"Starting long timeout test server: python {server_path}")
-
-    # Start the server process
-    process = subprocess.Popen(
-        ["python", str(server_path)],
-        cwd=str(server_path.parent),
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
-        text=True,
-    )
-
-    # Give the server time to start
-    await asyncio.sleep(2)
-    server_url = "http://127.0.0.1:8082"
-    yield server_url
-
-    # Cleanup
-    print("Cleaning up long timeout test server process")
-    if process.poll() is None:
-        process.terminate()
-        try:
-            process.wait(timeout=10)
-        except subprocess.TimeoutExpired:
-            print("Process didn't terminate gracefully, killing it")
-            process.kill()
-            process.wait()
-
-    print("Long timeout test server cleanup complete")
-
-
 @pytest.mark.asyncio
-async def test_github_issue_120_fixed_behavior(long_timeout_server_process):
+async def test_github_issue_120_fixed_behavior(timeout_server_process):
     """Test that GitHub issue #120 is fixed: connection state properly tracked and auto-reconnection works"""
-    server_url = long_timeout_server_process
+    server_url = timeout_server_process
 
-    # Step 1: Create an HttpConnector with SSE endpoint configuration with auto_connect enabled
-    config = {"mcpServers": {"fixTest": {"url": f"{server_url}/sse", "auto_connect": True}}}
+    # Step 1: Create an HttpConnector with SSE endpoint configuration
+    config = {"mcpServers": {"fixTest": {"url": f"{server_url}/sse"}}}
 
     client = MCPClient(config=config)
     try:
@@ -121,11 +86,11 @@ async def test_github_issue_120_fixed_behavior(long_timeout_server_process):
         print("✓ Tool call succeeded while connected")
 
         # Step 3: Wait for 30+ seconds for the server to close the SSE connection due to inactivity
-        print("Waiting for server timeout (35 seconds)...")
-        await asyncio.sleep(35)
+        print("Waiting for server timeout (10 seconds)...")
+        await asyncio.sleep(10)
 
         # Step 4: Check connection state - should now properly detect disconnection
-        print(f"Connection state after 35 second timeout: {session.is_connected}")
+        print(f"Connection state after 10 second timeout: {session.is_connected}")
 
         # With the fix, is_connected should properly detect the disconnection
         # But since auto_connect is enabled, it might auto-reconnect on the next call
@@ -164,12 +129,12 @@ async def test_github_issue_120_fixed_behavior(long_timeout_server_process):
 
 
 @pytest.mark.asyncio
-async def test_github_issue_120_auto_connect_disabled(long_timeout_server_process):
-    """Test GitHub issue #120 fix with auto_connect disabled - should provide clear error messages"""
-    server_url = long_timeout_server_process
+async def test_github_issue_120_manual_connection(timeout_server_process):
+    """Test GitHub issue #120 fix with manual connection - should provide clear error messages"""
+    server_url = timeout_server_process
 
-    # Create connector with auto_connect disabled
-    config = {"mcpServers": {"noAutoTest": {"url": f"{server_url}/sse", "auto_connect": False}}}
+    # Create connector and test manual connection behavior
+    config = {"mcpServers": {"noAutoTest": {"url": f"{server_url}/sse"}}}
 
     client = MCPClient(config=config)
     try:
@@ -188,7 +153,7 @@ async def test_github_issue_120_auto_connect_disabled(long_timeout_server_proces
         assert len(tools) > 0, "Should have at least one tool"
         test_tool = tools[0]
 
-        print(f"Initial connection established (auto_connect=False), testing tool: {test_tool.name}")
+        print(f"Initial connection established (manual connection), testing tool: {test_tool.name}")
         print(f"is_connected: {session.is_connected}")
 
         # Verify tool works initially
@@ -197,14 +162,14 @@ async def test_github_issue_120_auto_connect_disabled(long_timeout_server_proces
         print("✓ Tool call succeeded while connected")
 
         # Wait for server timeout
-        print("Waiting for server timeout (35 seconds) with auto_connect=False...")
-        await asyncio.sleep(35)
+        print("Waiting for server timeout (10 seconds)...")
+        await asyncio.sleep(10)
 
         # Check connection state after timeout
-        print(f"Connection state after 35 second timeout (auto_connect=False): {session.is_connected}")
+        print(f"Connection state after 10 second timeout: {session.is_connected}")
 
-        # Attempt to call a tool - should fail with clear error message since auto_connect is disabled
-        print("Attempting tool call after timeout (auto_connect=False)...")
+        # Attempt to call a tool - should either auto-reconnect or fail with clear error message
+        print("Attempting tool call after timeout...")
         try:
             result2 = await session.connector.call_tool(test_tool.name, {})
             # If this succeeds, the connection may still be active or there's an issue
@@ -219,77 +184,15 @@ async def test_github_issue_120_auto_connect_disabled(long_timeout_server_proces
 
             # With the fix, we should get a clear error message about connection loss
             assert error_msg != "", "Error message should not be empty (GitHub Issue #120 fixed)"
-            assert "connection" in error_msg.lower() and (
-                "lost" in error_msg.lower() or "manual" in error_msg.lower()
-            ), "Error message should clearly indicate connection loss and need for manual reconnection"
-            print("✓ Clear error message provided for connection loss with auto_connect disabled")
+            assert "connection" in error_msg.lower(), "Error message should mention connection issues"
+            print("✓ Clear error message provided for connection loss")
         except Exception as e:
             error_msg = str(e)
             print(f"Tool call failed with exception: {type(e).__name__}: '{error_msg}'")
             # Any error should have a clear message
             assert error_msg != "", "Error message should not be empty"
 
-        print("✓ GitHub Issue #120 fix verified with auto_connect=False - clear error messages")
-
-    finally:
-        await client.close_all_sessions()
-
-
-@pytest.mark.asyncio
-async def test_connection_state_after_server_timeout(timeout_server_process):
-    """Test that connection state is properly tracked when server closes connection due to timeout"""
-    server_url = timeout_server_process
-    config = {"mcpServers": {"timeoutTest": {"url": f"{server_url}/sse", "auto_connect": True}}}
-
-    client = MCPClient(config=config)
-    try:
-        # Establish initial connection
-        await client.create_all_sessions()
-        session = client.get_session("timeoutTest")
-
-        assert session is not None, "Session should be created"
-        await session.initialize()
-        assert session.is_connected, "Session should be connected after initialize"
-
-        # Get a tool to call later
-        tools = session.connector.tools
-        assert len(tools) > 0, "Should have at least one tool"
-        test_tool = tools[0]
-
-        print(f"Initial connection established, testing tool: {test_tool.name}")
-
-        # Call tool successfully while connected
-        result1 = await session.connector.call_tool(test_tool.name, {})
-        assert result1 is not None, "Tool call should succeed while connected"
-        print("✓ Tool call succeeded while connected")
-
-        # Wait for server timeout (server should close connection after 5 seconds)
-        print("Waiting for server timeout...")
-        await asyncio.sleep(8)
-
-        # After the fix, check connection state behavior
-        print(f"Connection state after timeout: {session.is_connected}")
-
-        # Try to call tool after timeout
-        try:
-            result2 = await session.connector.call_tool(test_tool.name, {})
-            if result2 is not None:
-                print("✓ Tool call succeeded - auto-reconnection worked")
-            else:
-                print("⚠ Tool call returned None")
-        except RuntimeError as e:
-            error_msg = str(e)
-            print(f"Tool call failed with clear error: {error_msg}")
-
-            # Check that we get a clear error message (not empty)
-            assert error_msg != "", "Error message should not be empty (GitHub Issue #120 fixed)"
-            print("✓ Clear error message provided instead of empty error")
-        except Exception as e:
-            error_msg = str(e)
-            print(f"Tool call failed with exception: {type(e).__name__}: {error_msg}")
-            assert error_msg != "", "Error message should not be empty"
-
-        print("✓ Connection state properly tracked after server timeout")
+        print("✓ GitHub Issue #120 fix verified - clear error messages")
 
     finally:
         await client.close_all_sessions()
@@ -299,14 +202,7 @@ async def test_connection_state_after_server_timeout(timeout_server_process):
 async def test_connection_manager_task_detection(timeout_server_process):
     """Test that connection manager task completion is properly detected"""
     server_url = timeout_server_process
-    config = {
-        "mcpServers": {
-            "timeoutTest": {
-                "url": f"{server_url}/sse",
-                "auto_connect": False,  # Disable auto_connect to test state detection
-            }
-        }
-    }
+    config = {"mcpServers": {"timeoutTest": {"url": f"{server_url}/sse"}}}
 
     client = MCPClient(config=config)
     try:
@@ -351,7 +247,7 @@ async def test_connection_manager_task_detection(timeout_server_process):
 async def test_multiple_reconnection_attempts(timeout_server_process):
     """Test that auto-reconnection works multiple times"""
     server_url = timeout_server_process
-    config = {"mcpServers": {"timeoutTest": {"url": f"{server_url}/sse", "auto_connect": True}}}
+    config = {"mcpServers": {"timeoutTest": {"url": f"{server_url}/sse"}}}
 
     client = MCPClient(config=config)
     try:

mcp_use-1.3.2/tests/integration/servers_for_testing/long_timeout_test_server.py

@@ -1,171 +0,0 @@
-"""
-Long Timeout Test Server for GitHub Issue #120
-
-This server specifically tests the connection state tracking issue by:
-1. Accepting SSE connections
-2. Closing them after 30+ seconds to simulate real server-side timeouts
-3. Providing basic MCP tools to test functionality
-4. Matching the exact reproduction steps from the GitHub issue
-"""
-
-import asyncio
-import json
-import time
-from datetime import datetime
-from typing import Any
-
-from fastmcp import FastMCP
-
-# Create FastMCP server instance
-mcp = FastMCP(name="LongTimeoutTestServer")
-
-# Track connection times for timeout logic
-connection_times: dict[str, float] = {}
-
-
-@mcp.tool()
-def ping() -> dict[str, Any]:
-    """Simple ping tool for testing connectivity"""
-    return {"message": "pong", "timestamp": datetime.now().isoformat(), "server": "LongTimeoutTestServer"}
-
-
-@mcp.tool()
-def get_server_info() -> dict[str, Any]:
-    """Get server information"""
-    return {
-        "name": "LongTimeoutTestServer",
-        "purpose": "Testing connection timeouts for issue #120 with 30+ seconds",
-        "timeout_seconds": 30,
-        "timestamp": datetime.now().isoformat(),
-    }
-
-
-@mcp.tool()
-def echo(message: str) -> dict[str, Any]:
-    """Echo a message back"""
-    return {"original_message": message, "echo": f"Server received: {message}", "timestamp": datetime.now().isoformat()}
-
-
-@mcp.resource("test://server/status")
-def server_status_resource() -> str:
-    """Server status as a resource"""
-    status = {"status": "running", "active_connections": len(connection_times), "timestamp": datetime.now().isoformat()}
-    return json.dumps(status, indent=2)
-
-
-@mcp.prompt()
-def test_prompt() -> str:
-    """A simple test prompt"""
-    return f"""This is a test prompt from LongTimeoutTestServer.
-
-Current time: {datetime.now().isoformat()}
-Server purpose: Testing connection timeouts for GitHub issue #120 with 30+ second timeout
-
-Please use this server to test:
-1. Connection establishment
-2. Tool calls while connected
-3. Connection state after 30+ second server timeout
-4. Auto-reconnection behavior after long timeouts
-"""
-
-
-# Custom SSE endpoint with 30+ second timeout logic
-@mcp.custom_route("/sse", methods=["GET"])
-async def custom_sse_endpoint(request):
-    """Custom SSE endpoint that closes connections after 30+ seconds to match issue #120"""
-    import uuid
-
-    from fastapi.responses import StreamingResponse
-
-    # Generate unique connection ID
-    connection_id = str(uuid.uuid4())
-    connection_times[connection_id] = time.time()
-
-    print(f"New SSE connection: {connection_id}")
-
-    async def event_generator():
-        try:
-            # Send initial connection event
-            yield f"data: {json.dumps({'type': 'connection', 'id': connection_id, 'status': 'connected'})}\n\n"
-
-            start_time = time.time()
-            timeout_seconds = 30  # Close connection after 30 seconds to match issue reproduction
-
-            heartbeat_count = 0
-            while True:
-                current_time = time.time()
-
-                # Check if we should timeout
-                if current_time - start_time > timeout_seconds:
-                    print(f"Timing out connection {connection_id} after {timeout_seconds} seconds")
-                    # Send timeout event before closing
-                    timeout_event = {
-                        "type": "timeout",
-                        "id": connection_id,
-                        "message": "Connection timed out after 30 seconds",
-                    }
-                    yield f"data: {json.dumps(timeout_event)}\n\n"
-                    break
-
-                # Send periodic heartbeat every 5 seconds
-                if heartbeat_count % 5 == 0:
-                    heartbeat_event = {
-                        "type": "heartbeat",
-                        "timestamp": datetime.now().isoformat(),
-                        "elapsed": int(current_time - start_time),
-                    }
-                    yield f"data: {json.dumps(heartbeat_event)}\n\n"
-
-                await asyncio.sleep(1)
-                heartbeat_count += 1
-
-        except Exception as e:
-            print(f"Error in SSE connection {connection_id}: {e}")
-            # This should simulate the "peer closed connection without sending complete message body" error
-        finally:
-            # Clean up connection tracking
-            if connection_id in connection_times:
-                del connection_times[connection_id]
-            print(
-                f"Connection {connection_id} closed - "
-                "this should trigger the disconnection logs mentioned in issue #120"
-            )
-
-    return StreamingResponse(
-        event_generator(),
-        media_type="text/event-stream",
-        headers={"Cache-Control": "no-cache", "Connection": "keep-alive", "Access-Control-Allow-Origin": "*"},
-    )
-
-
-@mcp.custom_route("/health", methods=["GET"])
-async def health_check(request) -> dict:
-    """Health check endpoint"""
-    return {
-        "status": "healthy",
-        "timestamp": datetime.now().isoformat(),
-        "active_connections": len(connection_times),
-        "timeout_seconds": 30,
-    }
-
-
-if __name__ == "__main__":
-    print("🚀 Starting Long Timeout Test Server for GitHub Issue #120...")
-    print("⏰ Connection timeout: 30 seconds (matches issue reproduction steps)")
-    print("📡 Server features:")
-    print("   - Automatic connection timeout after 30 seconds")
-    print("   - Basic MCP tools for testing")
-    print("   - Connection state tracking")
-    print("   - Simulates 'peer closed connection' errors")
-    print("\n💡 Available endpoints:")
-    print("   - SSE endpoint: http://localhost:8082/sse")
-    print("   - Health check: http://localhost:8082/health")
-    print("\n💡 This server is designed to test:")
-    print("   - Connection state tracking after 30+ second timeout")
-    print("   - Auto-reconnection behavior after long timeouts")
-    print("   - Error handling for disconnected sessions with empty error messages")
-    print("   - Exact reproduction of GitHub Issue #120 steps")
-    print("⚡ Starting server on port 8082...")
-
-    # Run the FastMCP server with SSE transport
-    mcp.run(transport="sse", host="0.0.0.0", port=8082, log_level="info")