Revert sleep(0) approach — coverage was racy

The sleep(0) between terminate() and cancel_scope.cancel() was
non-deterministic: sometimes the event loop ran exception handlers
(covering the pragmas), sometimes the cancel won the race (leaving
lines uncovered). This caused strict-no-cover to flip between
"wrongly marked" and "missing coverage" across CI runs.

Revert to the simple, deterministic approach:
- Restore all original pragma: no cover annotations
- Add pragma: no cover for the ClosedResourceError/_terminated path
  in the message router, which is unreachable with request-scoped
  task groups (Cancelled always wins over ClosedResourceError)

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

Author: wiggzz

src/mcp/server/streamable_http.py

@@ -619,14 +619,14 @@ async def sse_writer():  # pragma: lax no cover
                         # Then send the message to be processed by the server
                         session_message = self._create_session_message(message, request, request_id, protocol_version)
                         await writer.send(session_message)
-                except Exception:
+                except Exception:  # pragma: no cover
                     logger.exception("SSE response error")
                     await sse_stream_writer.aclose()
                     await self._clean_up_memory_streams(request_id)
                 finally:
                     await sse_stream_reader.aclose()
 
-        except Exception as err:
+        except Exception as err:  # pragma: no cover
             logger.exception("Error handling POST request")
             response = self._create_error_response(
                 f"Error handling POST request: {err}",
@@ -809,7 +809,7 @@ async def _validate_request_headers(self, request: Request, send: Send) -> bool:
 
     async def _validate_session(self, request: Request, send: Send) -> bool:
         """Validate the session ID in the request."""
-        if not self.mcp_session_id:
+        if not self.mcp_session_id:  # pragma: no cover
             # If we're not using session IDs, return True
             return True
 
@@ -1018,7 +1018,7 @@ async def message_router():
                                 might reconnect and replay."""
                             )
                 except anyio.ClosedResourceError:
-                    if self._terminated:
+                    if self._terminated:  # pragma: no cover
                         logger.debug("Read stream closed by client")
                     else:
                         logger.exception("Unexpected closure of read stream in message router")

src/mcp/server/streamable_http_manager.py

@@ -178,7 +178,7 @@ async def run_stateless_server(*, task_status: TaskStatus[None] = anyio.TASK_STA
                         self.app.create_initialization_options(),
                         stateless=True,
                     )
-                except Exception:
+                except Exception:  # pragma: no cover
                     logger.exception("Stateless session crashed")
 
         # Use a request-scoped task group instead of the global one.
@@ -193,9 +193,6 @@ async def run_request_handler(*, task_status: TaskStatus[None] = anyio.TASK_STAT
                 await http_transport.handle_request(scope, receive, send)
                 # Terminate the transport after the request is handled
                 await http_transport.terminate()
-                # Yield one scheduling step so other tasks (e.g. the message
-                # router) can observe the closed streams before we cancel.
-                await anyio.sleep(0)
                 # Cancel the request-scoped task group to stop the server task
                 request_tg.cancel_scope.cancel()
 

src/mcp/shared/session.py

@@ -423,7 +423,7 @@ async def _receive_loop(self) -> None:
                     try:
                         await stream.send(JSONRPCError(jsonrpc="2.0", id=id, error=error))
                         await stream.aclose()
-                    except Exception:
+                    except Exception:  # pragma: no cover
                         # Stream might already be closed
                         pass
                 self._response_streams.clear()