Active Streamable HTTP sessions are not terminated during shutdown

[emmahoggan]

Initial Checks

• I confirm that I'm using the latest version of MCP Python SDK
• I confirm that I searched for my issue in https://github.com/modelcontextprotocol/python-sdk/issues before opening this issue

Description

Context

This is primarily a repost of this fastmcp issue as it seems to actually be a bug in the mcp python sdk and I want to make sure we've got visibility over here.

When shutting down a FastMCP server (CTRL+C) while clients have active streaming connections, Uvicorn logs:

ERROR: ASGI callable returned without completing response.

The error occurs because StreamableHTTPSessionManager cancels the task group without first gracefully terminating active SSE/streaming connections.

Expected behavior would be the active connections being closed with a proper http response before the rest of shutdown.

Example Code

from fastmcp import FastMCP

mcp = FastMCP("Test Server")

@mcp.tool
def hello() -> str:
  return "Hello, World!"

if __name__ == "__main__":
  mcp.run(transport="streamable-http", port=8000)

Python & MCP Python SDK

Python 3.12
MCP Python SDK 1.26.0

[weiguangli-io]

Root Cause Analysis

The issue is in StreamableHTTPSessionManager.run() (src/mcp/server/streamable_http_manager.py, lines 129-137). On shutdown, the finally block does:

tg.cancel_scope.cancel()
self._task_group = None
self._server_instances.clear()

This abruptly cancels all tasks in the task group without first gracefully terminating active sessions. The EventSourceResponse coroutines (running inside the cancelled tasks) are killed mid-stream before they can send a proper HTTP response completion, which triggers Uvicorn's ASGI callable returned without completing response error.

There are actually two compounding problems:

1. run() never calls terminate() on active transports before cancelling the task group. It just clears the dict.

2. terminate() itself doesn't close _sse_stream_writers. It only closes _request_streams via _clean_up_memory_streams(), but the SSE stream writers (which keep EventSourceResponse alive) are stored separately in self._sse_stream_writers and are never touched during terminate(). Closing the request streams alone doesn't cause the SSE response to complete gracefully — the EventSourceResponse keeps waiting on its sse_stream_reader.

Proposed Fix

File: src/mcp/server/streamable_http_manager.py — In the run() method's finally block, iterate over all active transports and call terminate() on each before cancelling the task group:

finally:
    logger.info("StreamableHTTP session manager shutting down")
    # Gracefully terminate all active sessions before cancelling tasks
    for transport in list(self._server_instances.values()):
        try:
            await transport.terminate()
        except Exception:
            logger.debug("Error terminating transport during shutdown")
    tg.cancel_scope.cancel()
    self._task_group = None
    self._server_instances.clear()

File: src/mcp/server/streamable_http.py — In terminate(), also close all _sse_stream_writers so that active EventSourceResponse instances complete gracefully:

async def terminate(self) -> None:
    if self._terminated:
        return
    self._terminated = True
    logger.info(f"Terminating session: {self.mcp_session_id}")

    # Close all SSE stream writers to allow EventSourceResponse to complete
    for writer in list(self._sse_stream_writers.values()):
        writer.close()
    self._sse_stream_writers.clear()

    # Close all request streams
    request_stream_keys = list(self._request_streams.keys())
    for key in request_stream_keys:
        await self._clean_up_memory_streams(key)
    self._request_streams.clear()
    # ... rest of stream cleanup

Edge Cases

• Timing: terminate() must complete before tg.cancel_scope.cancel() — if it's done concurrently within the cancelled scope, the terminate calls themselves get cancelled. Using anyio.move_on_after() as a safety net around each terminate call could help avoid a hung shutdown.
• Stateless mode: Not affected since stateless transports are terminated per-request already (line 211).
• Concurrent requests: A request arriving during the shutdown window (after terminate starts but before cancel) could hit a partially-terminated transport. The existing self._terminated check at the top of handle_request() (line 389) should handle this, returning 404.
• close() vs aclose(): The _sse_stream_writers use MemoryObjectSendStream — calling .close() (sync) is sufficient and avoids awaiting inside the shutdown path, which is more robust.

[Hackerchen716]

I would like to work on this. I plan to keep the scope focused on graceful shutdown for active Streamable HTTP sessions: make transport termination close SSE stream writers, have the session manager terminate active transports before cancelling the task group, and add regression coverage for shutdown cleanup behavior. I will avoid changing stateless request handling or the normal request path beyond the shutdown cleanup path.

[shivamsingh-007]

I'd like to work on this. My plan: (1) make erminate() in streamable_http.py close _sse_stream_writers so EventSourceResponse completes gracefully, (2) have the session manager in streamable_http_manager.py terminate active transports before cancelling the task group on shutdown. Kept scoped to the shutdown cleanup path — no changes to stateless or normal request handling. Let me know if that sounds right.