Active Streamable HTTP sessions are not terminated during shutdown #2150

Activity

1. by22Jy

   added a commit that references this issue on Feb 28, 2026

   fix: gracefully terminate active SSE connections during shutdown

   ...

   This issue will close once commit c417f56 is merged into the 'main' branch.

   c417f56
2. maxisbey

   added

   bugSomething isn't workingSomething isn't working

   P2Moderate issues affecting some users, edge cases, potentially valuable featureModerate issues affecting some users, edge cases, potentially valuable feature

   ready for workEnough information for someone to start working onEnough information for someone to start working on

   on Mar 5, 2026
3. weiguangli-io commented on Mar 9, 2026

   

   weiguangli-io

   on Mar 9, 2026

   More actions

   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.
4. weiguangli-io

   added a commit that references this issue on Mar 9, 2026

   fix: terminate active StreamableHTTP sessions during shutdown (modelc…

   ...

   43e5a9d
5. Hackerchen716 commented on May 29, 2026

   

   Hackerchen716

   on May 29, 2026

   More actions

   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.
6. shivamsingh-007 commented on Jul 12, 2026

   

   shivamsingh-007

   on Jul 12, 2026

   Last edited by shivamsingh-007

   More actions

   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.
7. baiyuxi930826

   added 2 commits that reference this issue on Jul 18, 2026

   style: satisfy markdownlint on modelcontextprotocol#2150 notes

   ...

   60e6030

   test(server): cover terminate cleanup of orphaned request streams

   ...

   a6976e1