Fix handle sse disconnect event to free read_stream_writers[session_id]

examples/servers/simple-prompt/mcp_simple_prompt/server.py

@@ -90,6 +90,7 @@ async def get_prompt(
     if transport == "sse":
         from mcp.server.sse import SseServerTransport
         from starlette.applications import Starlette
+        from starlette.responses import Response
         from starlette.routing import Mount, Route
 
         sse = SseServerTransport("/messages/")
@@ -101,6 +102,7 @@ async def handle_sse(request):
                 await app.run(
                     streams[0], streams[1], app.create_initialization_options()
                 )
+            return Response("MCP SSE")
 
         starlette_app = Starlette(
             debug=True,

examples/servers/simple-resource/mcp_simple_resource/server.py

@@ -46,6 +46,7 @@ async def read_resource(uri: FileUrl) -> str | bytes:
     if transport == "sse":
         from mcp.server.sse import SseServerTransport
         from starlette.applications import Starlette
+        from starlette.responses import Response
         from starlette.routing import Mount, Route
 
         sse = SseServerTransport("/messages/")
@@ -57,6 +58,7 @@ async def handle_sse(request):
                 await app.run(
                     streams[0], streams[1], app.create_initialization_options()
                 )
+            return Response("MCP SSE")
 
         starlette_app = Starlette(
             debug=True,

examples/servers/simple-tool/mcp_simple_tool/server.py

@@ -60,6 +60,7 @@ async def list_tools() -> list[types.Tool]:
     if transport == "sse":
         from mcp.server.sse import SseServerTransport
         from starlette.applications import Starlette
+        from starlette.responses import Response
         from starlette.routing import Mount, Route
 
         sse = SseServerTransport("/messages/")
@@ -71,6 +72,7 @@ async def handle_sse(request):
                 await app.run(
                     streams[0], streams[1], app.create_initialization_options()
                 )
+            return Response("MCP SSE")
 
         starlette_app = Starlette(
             debug=True,

pyproject.toml

@@ -30,6 +30,7 @@ dependencies = [
     "sse-starlette>=1.6.1",
     "pydantic-settings>=2.5.2",
     "uvicorn>=0.23.1",
+    "typer>=0.12.4",
 ]
 
 [project.optional-dependencies]
@@ -48,6 +49,7 @@ dev-dependencies = [
     "trio>=0.26.2",
     "pytest-flakefinder>=1.1.0",
     "pytest-xdist>=3.6.1",
+    "sse-starlette>=2.3.4",
 ]
 
 [build-system]

src/mcp/server/fastmcp/server.py

@@ -476,6 +476,7 @@ async def run_stdio_async(self) -> None:
     async def run_sse_async(self) -> None:
         """Run the server using SSE transport."""
         from starlette.applications import Starlette
+        from starlette.responses import Response
         from starlette.routing import Mount, Route
 
         sse = SseServerTransport("/messages/")
@@ -489,6 +490,7 @@ async def handle_sse(request):
                     streams[1],
                     self._mcp_server.create_initialization_options(),
                 )
+            return Response("OK")
 
         starlette_app = Starlette(
             debug=self.settings.debug,

src/mcp/server/sse.py

@@ -6,6 +6,8 @@
 Example usage:
 ```
     # Create an SSE transport at an endpoint
+    from starlette.responses import Response
+
     sse = SseServerTransport("/messages/")
 
     # Create Starlette routes for SSE and message handling
@@ -22,6 +24,7 @@ async def handle_sse(request):
             await app.run(
                 streams[0], streams[1], app.create_initialization_options()
             )
+        return Response("MCP SSE")
 
     # Create and run Starlette app
     starlette_app = Starlette(routes=routes)
@@ -43,7 +46,7 @@ async def handle_sse(request):
 from sse_starlette import EventSourceResponse
 from starlette.requests import Request
 from starlette.responses import Response
-from starlette.types import Receive, Scope, Send
+from starlette.types import Message, Receive, Scope, Send
 
 import mcp.types as types
 
@@ -120,9 +123,19 @@ async def sse_writer():
                         }
                     )
 
+        async def handle_see_disconnect(message: Message) -> None:
+            logger.debug(f"Disconnect sse {session_id}")
+            del self._read_stream_writers[session_id]
+            await read_stream.aclose()
+            await read_stream_writer.aclose()
+            await write_stream.aclose()
+            await write_stream_reader.aclose()
+
         async with anyio.create_task_group() as tg:
             response = EventSourceResponse(
-                content=sse_stream_reader, data_sender_callable=sse_writer
+                content=sse_stream_reader,
+                data_sender_callable=sse_writer,
+                client_close_handler_callable=handle_see_disconnect,
             )
             logger.debug("Starting SSE response task")
             tg.start_soon(response, scope, receive, send)

tests/server/test_sse_disconnect.py

@@ -0,0 +1,54 @@
+import asyncio
+from uuid import UUID
+
+import pytest
+from starlette.types import Message, Scope
+
+from mcp.server.sse import SseServerTransport
+
+
+@pytest.mark.anyio
+async def test_sse_disconnect_handle():
+    transport = SseServerTransport(endpoint="/sse")
+    # Create a minimal ASGI scope for an HTTP GET request
+    scope: Scope = {
+        "type": "http",
+        "method": "GET",
+        "path": "/sse",
+        "headers": [],
+    }
+    send_disconnect = False
+
+    # Dummy receive and send functions
+    async def receive() -> dict:
+        nonlocal send_disconnect
+        if not send_disconnect:
+            send_disconnect = True
+            return {"type": "http.request"}
+        else:
+            return {"type": "http.disconnect"}
+
+    async def send(message: Message) -> None:
+        await asyncio.sleep(0)
+
+    # Run the connect_sse context manager
+    async with transport.connect_sse(scope, receive, send) as (
+        read_stream,
+        write_stream,
+    ):
+        # Assert that streams are provided
+        assert read_stream is not None
+        assert write_stream is not None
+
+        # There should be exactly one session
+        assert len(transport._read_stream_writers) == 1
+        # Check that the session key is a UUID
+        session_id = next(iter(transport._read_stream_writers.keys()))
+        assert isinstance(session_id, UUID)
+
+        # Check that the writer is still open
+        writer = transport._read_stream_writers[session_id]
+        assert writer is not None
+
+    # After context exits, session should be cleaned up
+    assert len(transport._read_stream_writers) == 0

tests/shared/test_sse.py

@@ -80,16 +80,19 @@ async def handle_call_tool(name: str, args: dict) -> list[TextContent]:
 # Test fixtures
 def make_server_app() -> Starlette:
     """Create test Starlette app with SSE transport"""
+    from starlette.responses import Response
+
     sse = SseServerTransport("/messages/")
     server = ServerTest()
 
-    async def handle_sse(request: Request) -> None:
+    async def handle_sse(request: Request) -> Response:
         async with sse.connect_sse(
             request.scope, request.receive, request._send
         ) as streams:
             await server.run(
                 streams[0], streams[1], server.create_initialization_options()
             )
+        return Response("MCP SSE")
 
     app = Starlette(
         routes=[