Run handle_request in caller context, not as child task

The previous approach ran handle_request inside a child task within the
request-scoped task group. This caused coverage.py on Python 3.11 to
lose track of execution when returning from the task group back to the
caller — the root cause of the false coverage gaps on test assertions.

The fix is simpler: run handle_request directly in the async with body
(like the original code on main), with only run_stateless_server as a
child task. This preserves the request-scoped task group for preventing
task accumulation while keeping the caller's execution context intact.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: wiggzz

src/mcp/server/streamable_http_manager.py

@@ -186,19 +186,12 @@ async def run_stateless_server(*, task_status: TaskStatus[None] = anyio.TASK_STA
         # finishes, preventing zombie tasks from accumulating.
         # See: https://github.com/modelcontextprotocol/python-sdk/issues/1764
         async with anyio.create_task_group() as request_tg:
-
-            async def run_request_handler(*, task_status: TaskStatus[None] = anyio.TASK_STATUS_IGNORED):
-                task_status.started()
-                # Handle the HTTP request and return the response
-                await http_transport.handle_request(scope, receive, send)
-                # Cancel the request-scoped task group to stop the server task.
-                # This ensures the Cancelled exception reaches the server task
-                # before terminate() closes the streams, avoiding a race between
-                # Cancelled and ClosedResourceError in the message router.
-                request_tg.cancel_scope.cancel()
-
             await request_tg.start(run_stateless_server)
-            await request_tg.start(run_request_handler)
+            # Handle the HTTP request directly in the caller's context
+            # (not as a child task) so execution flows back naturally.
+            await http_transport.handle_request(scope, receive, send)
+            # Cancel the request-scoped task group to stop the server task.
+            request_tg.cancel_scope.cancel()
 
         # Terminate after the task group exits — the server task is already
         # cancelled at this point, so this is just cleanup (sets _terminated

tests/server/test_streamable_http_manager.py

@@ -258,19 +258,15 @@ async def mock_receive():
             await manager.handle_request(scope, mock_receive, mock_send)
 
             # Verify transport was created
-            assert len(created_transports) == 1, "Should have created one transport"  # pragma: lax no cover
+            assert len(created_transports) == 1, "Should have created one transport"
 
-            transport = created_transports[0]  # pragma: lax no cover
+            transport = created_transports[0]
 
             # The key assertion - transport should be terminated
-            assert transport._terminated, (
-                "Transport should be terminated after stateless request"
-            )  # pragma: lax no cover
+            assert transport._terminated, "Transport should be terminated after stateless request"
 
             # Verify internal state is cleaned up
-            assert len(transport._request_streams) == 0, (
-                "Transport should have no active request streams"
-            )  # pragma: lax no cover
+            assert len(transport._request_streams) == 0, "Transport should have no active request streams"
 
 
 @pytest.mark.anyio