mcp-gee-sweet 0.9.2.dev233__tar.gz → 0.9.2.dev236__tar.gz

{mcp_gee_sweet-0.9.2.dev233 → mcp_gee_sweet-0.9.2.dev236}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mcp-gee-sweet
-Version: 0.9.2.dev233
+Version: 0.9.2.dev236
 Summary: MCP server for Google Workspace — Sheets, Drive, Docs (HTML or Markdown), and Calendar.
 Project-URL: Homepage, https://github.com/khuisman/mcp-gee-sweet
 Project-URL: Bug Tracker, https://github.com/khuisman/mcp-gee-sweet/issues

{mcp_gee_sweet-0.9.2.dev233 → mcp_gee_sweet-0.9.2.dev236}/docs/design/sse-consent-off-event-loop.md

@@ -60,7 +60,7 @@ Patching mcp's transport instead was rejected: it means carrying a copy of `conn
 | Stray callback request | | degrades in 0.08s (`MismatchingStateError`) |
 | Missing-scope token, client POSTs `initialize` on the endpoint event, then SIGTERM | n/a (no endpoint before the raise) | before §5: 25 of 25 hang. After: 0 of 25, POST `202`; a real `sse_client` initializes and gets the missing-scopes message as the tool error |
 
-An `Exception in ASGI application ... Expected ASGI message 'http.response.body'` traceback at shutdown appears on `develop` too, for any SSE stream open at SIGTERM, so it's unrelated to this change.
+An `Exception in ASGI application ... Expected ASGI message 'http.response.body'` traceback at shutdown appeared on `develop` too, for any SSE stream open at SIGTERM, so it was unrelated to this change. #868 fixed it with `SingleResponseGuard` (`sse_shutdown.py`).
 
 ## Not changed
 

{mcp_gee_sweet-0.9.2.dev233 → mcp_gee_sweet-0.9.2.dev236}/docs/qa/tests/infra.md

@@ -1026,7 +1026,7 @@ Start `uv run mcp-gee-sweet --transport sse` with `AUTH_METHOD=oauth`, `TOKEN_PA
 - 5: the stderr file has `Starting without Google access: ... the server shut down before the browser consent completed`
 - 5: `lsof -i :<port>` and `lsof -i :<cb>` are both empty afterward
 
-An `Exception in ASGI application ... Expected ASGI message 'http.response.body', but got 'http.response.start'` traceback during shutdown isn't a failure of this case: any SSE stream open at SIGTERM produces it, with or without a consent wait (pre-existing, seen on `develop` before #833).
+An `Exception in ASGI application ... Expected ASGI message 'http.response.body', but got 'http.response.start'` traceback during shutdown isn't a failure of this case. Any SSE stream open at SIGTERM used to produce it, with or without a consent wait (pre-existing, seen on `develop` before #833). Fixed in #868, which TC-I47 covers.
 
 **Cleanup:** if the server is still running, SIGKILL its process group and record the case as failed.
 
@@ -1128,3 +1128,33 @@ Live `mcp-gee-sweet-sky` server, OAuth, mcp 2.3.0. 1: `Error executing tool list
 
 **Result (2026-10-04, PR #905 round 2 @ 42ab5e6, Sky) ✅ PASS**
 Live `mcp-gee-sweet-sky` server, mcp 2.3.0: steps 1 and 2 return the same `HttpError 404 ... Requested entity was not found.` text as round 1. Extra check over a stdio subprocess with the same credentials (`DEBUG_LEVEL=INFO`): the server logs `WARNING mcp_gee_sweet.server Reporting HttpError to the client: ...` with the full traceback through `execute_in_thread`, and the access line is `"TOOL list_sheets" 500`.
+
+---
+
+### TC-I47: SIGTERM with an SSE stream open shuts down without an ASGI traceback (issue #868) ⚠️ local-filesystem
+
+**Background:** on SIGTERM, sse_starlette cancels an open SSE stream without sending its closing chunk, and mcp's `/sse` endpoint then returns an empty `Response()` on the same connection. uvicorn rejected that second response with `Exception in ASGI application ... RuntimeError: Expected ASGI message 'http.response.body', but got 'http.response.start'` on every shutdown with a stream open, and the client saw a truncated chunked stream. `SingleResponseGuard` (`sse_shutdown.py`) now closes the cut-off stream and drops the late second response, but only once `AppStatus.should_exit` is set. Before shutdown it passes everything through, so uvicorn still reports a genuine double response, and after an ordinary client disconnect uvicorn no-ops mcp's late `Response()` itself. `main()` serves the guarded app for plain `--transport sse` as well as `--reload`, since `mcp.run(transport="sse")` builds its own unguarded app. It launches it the way mcp's `run_sse_async()` does (`anyio.run(uvicorn.Server(config).serve)`), not with `uvicorn.run()`, which would pick uvloop when installed.
+
+**Setup:** none beyond a checkout of this branch. No Google credentials are needed: the case only needs an idle, fully started SSE connection.
+
+**Action**
+Start `uv run mcp-gee-sweet --transport sse` with `HOST=127.0.0.1`, `PORT=<free port>`, `AUTH_METHOD=oauth`, `CREDENTIALS_PATH=<nonexistent>`, `TOKEN_PATH=<nonexistent>`, `DEBUG_LEVEL=DEBUG`, `PYTHONUNBUFFERED=1`, stdout and stderr to one file.
+1. Open `GET http://127.0.0.1:<port>/sse` (e.g. Python `urllib.request.urlopen`) and read the first line (`event: endpoint`). Wait 3 seconds
+2. Send the server process `SIGTERM` (not SIGKILL) and time its exit. Then read the rest of the SSE response to EOF
+3. Repeat steps 1–2 two more times against a fresh server, then once more with `--reload` added to the command line
+4. Start a fresh server the same way; with the `mcp` SDK's `sse_client` + `ClientSession`, `initialize` and `list_tools`, close the session, then SIGTERM the server
+
+**Checks**
+- 2, 3: the log has no `Exception in ASGI application`, no `RuntimeError: Expected ASGI message`, and no `ASGI callable returned without completing response`. (The setup's nonexistent `CREDENTIALS_PATH` logs a `DEBUG ... Auth failure detail` traceback ending in `RuntimeError: '<path>' not found` at connection time; that's the expected degraded start, not a failure.) With `DEBUG_LEVEL=DEBUG` it has `DEBUG mcp_gee_sweet.sse_shutdown Dropping a second response on /sse during shutdown (#868)`
+- 2, 3: the server exits within a few seconds of SIGTERM, and `lsof -i :<port>` is empty afterwards
+- 2, 3: reading the SSE response to the end ends with a clean EOF, not an `IncompleteRead` (before this fix the chunked stream was never terminated)
+- 4: `initialize` and `list_tools` succeed (the guard doesn't touch a normal session), and the log has no traceback other than the expected `Auth failure detail` one
+- 4: the log has no `Dropping a second response` line at all. The session's stream closed before SIGTERM, so the guard has nothing to drop, and it acts only during shutdown (round 1 found it acting on an ordinary client disconnect). Don't check the line's order against uvicorn's `Shutting down` instead: in steps 2–3 the two are logged in either order during a real shutdown.
+
+**Cleanup:** SIGKILL any server still running (and record the case as failed).
+
+**Result (2026-10-05, PR #911 round 1 @ d6ba1ec, Sky) ✅ PASS**
+uvicorn 0.47.0, run through `uv run` (so the parent's exit code is uv's 143 after forwarding SIGTERM; `--reload` exits 0). Steps 2–3 (three plain runs plus one `--reload`): every log has the `Dropping a second response on /sse (#868)` line and none of the three error strings. The server exits 0.2–0.8s after SIGTERM, the SSE response reads to a clean EOF, and the port is free afterwards. Baseline: the same driver against an `origin/develop` export logs `Exception in ASGI application ... RuntimeError: Expected ASGI message 'http.response.body', but got 'http.response.start'`, and the client gets `IncompleteRead(64 bytes read)`. Step 4: `initialize` and `list_tools` (139 tools) succeed, with no ASGI error. But the log shows `Dropping a second response on /sse (#868)` right after the client closed its session, about 1s *before* SIGTERM. So the guard also handles mcp's late `Response()` after an ordinary client disconnect, not only at shutdown (see the round-1 PR comment). Side check: `--transport streamable-http` with an open `GET /mcp` stream still logs `ASGI callable returned without completing response.` on SIGTERM, and the client gets `IncompleteRead(0 bytes read)`. That transport isn't in this PR's scope; filed as #917.
+
+**Result (2026-10-05, PR #911 round 2 @ 1f138a5, Sky) ✅ PASS**
+Same drivers as round 1. Steps 2–3 (three plain runs plus one `--reload`): each log has `Dropping a second response on /sse during shutdown (#868)` and none of the three error strings. The server exits 0.2–0.6s after SIGTERM, every SSE response reads to a clean EOF, and the ports are free. The drop line and uvicorn's `Shutting down` were logged in either order across these runs, so I changed step 4's check from an ordering check to an absence check. Step 4: `initialize` and `list_tools` (139 tools) succeed, and the log has no `Dropping` line and no ASGI error. So after an ordinary client disconnect, the late `Response()` now reaches uvicorn, which ignores it without error. Plain `--transport sse` now launches via `anyio.run(uvicorn.Server(config).serve)` and behaves the same as `--reload`.

{mcp_gee_sweet-0.9.2.dev233 → mcp_gee_sweet-0.9.2.dev236}/docs/roadmap.md

@@ -330,7 +330,7 @@ Requires `gmail/v1` client and `https://www.googleapis.com/auth/gmail.modify` sc
 - [ ] TC-DOC80 can no longer trip the response-size cap post-#519 — large-doc fixture is under the raised default; needs a per-case low-cap override — Aziz ([#678](https://github.com/khuisman/mcp-gee-sweet/issues/678))
 - [ ] Define the correctness rubric and own execution for the composite-vs-primitive efficiency benchmark — Aziz ([#584](https://github.com/khuisman/mcp-gee-sweet/issues/584))
 - [ ] QA `.env` has no single source of truth — `setup_team.sh` only copies `.env` into a worktree when absent, so fixture-ID changes never propagate (had to hand-sync 9 copies for #305); also `run.md` vs `setup.md` disagree on `docs/qa/.env` vs repo-root `.env`. Surfaced by PR #677, relates to [#648](https://github.com/khuisman/mcp-gee-sweet/issues/648) ([#679](https://github.com/khuisman/mcp-gee-sweet/issues/679))
-- [ ] `list_files`/`get_file_metadata` docstrings cite a stale `upload_local_file` `modifiedTime` caveat (fixed at the root by PR #472) and carry a broken self-referential contrast — from Bob's `docs/tools.md` docstring sweep; Dev/QA track, batches with #682/#683 ([#681](https://github.com/khuisman/mcp-gee-sweet/issues/681))
+- [x] `list_files`/`get_file_metadata` docstrings cite a stale `upload_local_file` `modifiedTime` caveat (fixed at the root by PR #472) and carry a broken self-referential contrast — from Bob's `docs/tools.md` docstring sweep; Dev/QA track, batches with #682/#683 ([#681](https://github.com/khuisman/mcp-gee-sweet/issues/681)) (PR 898)
 - [ ] `create_doc` family docstrings name only the ~25MP inline-image limit; the ~50MB byte-size limit (#562) is equally enforced, and 3 deferring docstrings inherit the gap — from Bob's `docs/tools.md` docstring sweep ([#682](https://github.com/khuisman/mcp-gee-sweet/issues/682))
 - [ ] `qa(docs)`: no comprehensive fixture exercising every Docs formatting construct in one pass — Aziz, triaged out of `backlog` 2026-09-11 ([#477](https://github.com/khuisman/mcp-gee-sweet/issues/477))
 - [ ] Fact-check and word competitive/benchmark claims once real benchmark numbers exist — routed to Amy, triaged out of `backlog` 2026-09-11 ([#585](https://github.com/khuisman/mcp-gee-sweet/issues/585))

{mcp_gee_sweet-0.9.2.dev233 → mcp_gee_sweet-0.9.2.dev236}/src/mcp_gee_sweet/server.py

@@ -92,6 +92,7 @@ from .auth import (  # noqa: E402
     set_raise_auth_failures,
     spreadsheet_lifespan,
 )
+from .sse_shutdown import SingleResponseGuard  # noqa: E402
 
 
 def _parse_enabled_tools() -> set | None:
@@ -124,8 +125,10 @@ mcp = MCPServer(
 )
 
 # mcp v2 moved host/port from the constructor to call-time kwargs on
-# sse_app()/run_sse_async()/run() itself (confirmed live against mcp==2.0.0, issue #175)
-app = mcp.sse_app(host=_resolved_host)
+# sse_app()/run_sse_async()/run() itself (confirmed live against mcp==2.0.0, issue #175).
+# SingleResponseGuard keeps a SIGTERM with an open SSE stream from logging an ASGI
+# traceback (#868); main() serves this app for every SSE launch so the guard applies.
+app = SingleResponseGuard(mcp.sse_app(host=_resolved_host))
 
 
 _tool_access_logger = logging.getLogger("mcp_gee_sweet.access")
@@ -597,6 +600,18 @@ def main():
         # the connection without Google access instead (PR #867).
         set_raise_auth_failures(True)
         mcp.run(transport=transport)
+    elif transport == "sse":
+        # mcp.run(transport="sse") would build a second, unguarded sse_app, so serve
+        # the guarded module-level app with run_sse_async()'s own launch (#868):
+        # anyio.run on the plain asyncio loop, which #833's auth handoff was built
+        # and QA'd on. uvicorn.run() would pick uvloop whenever it's installed.
+        import anyio
+        import uvicorn
+
+        config = uvicorn.Config(
+            app, host=_resolved_host, port=_resolved_port, log_level=mcp.settings.log_level.lower()
+        )
+        anyio.run(uvicorn.Server(config).serve)
     else:
         # mcp v2 moved host/port from the constructor to call-time kwargs (see the
         # mcp.sse_app() call above) — stdio's own overload doesn't accept them.

mcp_gee_sweet-0.9.2.dev236/src/mcp_gee_sweet/sse_shutdown.py

@@ -0,0 +1,60 @@
+"""ASGI guard for the SSE stream a server shutdown cuts off (#868).
+
+On SIGTERM, sse_starlette's ``EventSourceResponse`` sees ``AppStatus.should_exit``
+and cancels its own task group, so its closing ``http.response.body``
+(``more_body=False``) is never sent: the response is left started but incomplete.
+mcp's ``sse_app`` endpoint then returns an empty ``Response()``, which Starlette
+sends on the same connection, and uvicorn rejects that second
+``http.response.start`` with "Exception in ASGI application". A client disconnect
+doesn't hit this, because uvicorn turns every send after a disconnect into a no-op.
+
+``SingleResponseGuard`` drops that late second response, but only once
+``AppStatus.should_exit`` is set. If the first one is still open, it sends the
+missing closing body first, so the client gets a properly terminated stream
+instead of a truncated one. Before shutdown every message passes through
+untouched, so uvicorn still reports a genuine double response (PR #911 QA round 1).
+"""
+
+import logging
+
+from sse_starlette.sse import AppStatus
+from starlette.types import ASGIApp, Message, Receive, Scope, Send
+
+logger = logging.getLogger(__name__)
+
+
+class SingleResponseGuard:
+    """During shutdown, drop a second ``http.response.start`` on a request that already started one."""
+
+    def __init__(self, app: ASGIApp) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        started = False
+        complete = False
+        discarding = False
+
+        async def guarded_send(message: Message) -> None:
+            nonlocal started, complete, discarding
+            if discarding:
+                return
+            if message["type"] == "http.response.start":
+                if started and AppStatus.should_exit:
+                    discarding = True
+                    logger.debug(
+                        "Dropping a second response on %s during shutdown (#868)", scope.get("path")
+                    )
+                    if not complete:
+                        complete = True
+                        await send({"type": "http.response.body", "body": b"", "more_body": False})
+                    return
+                started = True
+            elif message["type"] == "http.response.body" and not message.get("more_body", False):
+                complete = True
+            await send(message)
+
+        await self.app(scope, receive, guarded_send)

{mcp_gee_sweet-0.9.2.dev233 → mcp_gee_sweet-0.9.2.dev236}/src/mcp_gee_sweet/tools/drive/files.py

@@ -560,10 +560,9 @@ def register(tool):
             starred status, and md5_checksum. md5_checksum is only present for
             binary files — Google Workspace files (Docs, Sheets, Slides, etc.) have
             no fixed byte content and the Drive API omits the field for them, so
-            it's None for those. Use it to detect real content drift (e.g. after
-            sync_folder's upload path, which doesn't stamp modifiedTime the way
-            sync_folder's own upload does) instead of inferring change from
-            modifiedTime alone.
+            it's None for those. Use it to detect real content drift (for example,
+            a local overwrite that preserves mtime) instead of inferring change
+            from modifiedTime alone.
             Results are cached; call refresh_cache(folder_id=folder_id) to invalidate,
             or refresh_cache() to clear all caches.
         """
@@ -774,9 +773,8 @@ def register(tool):
             md5_checksum (like size) is only present for binary files — Google
             Workspace files have no fixed byte content and the Drive API omits it
             for them. Use it to detect real content drift instead of inferring
-            change from modifiedTime alone (e.g. after upload_local_file, which
-            doesn't stamp modifiedTime to match a local file's mtime the way
-            sync_folder does). starred reflects star_file/unstar_file's own effect
+            change from modifiedTime alone (for example, a local overwrite that
+            preserves mtime). starred reflects star_file/unstar_file's own effect
             (#388) — previously there was no way to read a file's starred state
             independently of calling one of those two mutating tools.
         """

{mcp_gee_sweet-0.9.2.dev233 → mcp_gee_sweet-0.9.2.dev236}/tests/test_server.py

@@ -8,7 +8,9 @@ import sys
 from types import SimpleNamespace
 from unittest.mock import MagicMock
 
+import anyio
 import pytest
+import uvicorn
 from google.auth.exceptions import RefreshError
 from googleapiclient import errors as googleapiclient_errors
 from googleapiclient.errors import HttpError
@@ -30,6 +32,7 @@ from mcp_gee_sweet.server import (
     mcp,
     tool,
 )
+from mcp_gee_sweet.sse_shutdown import SingleResponseGuard
 
 
 def _http_error(status: int, message: str) -> HttpError:
@@ -727,11 +730,33 @@ class TestMainAuthAndTransport:
 
     def test_sse_keeps_interactive_consent(self, monkeypatch):
         monkeypatch.setattr(sys, "argv", ["mcp-gee-sweet", "--transport", "sse"])
-        monkeypatch.setattr(mcp, "run", MagicMock())
+        monkeypatch.setattr(anyio, "run", MagicMock())
         main()
         assert auth_module._interactive_consent is True
         assert auth_module._raise_auth_failures is False
 
+    def test_sse_serves_the_guarded_app_like_run_sse_async(self, monkeypatch):
+        # #868: mcp.run(transport="sse") builds its own app without SingleResponseGuard,
+        # so main() serves the guarded app with run_sse_async()'s own launch:
+        # anyio.run(uvicorn.Server(config).serve), not uvicorn.run (which picks uvloop).
+        monkeypatch.setattr(sys, "argv", ["mcp-gee-sweet", "--transport", "sse"])
+        monkeypatch.setattr(server, "_resolved_host", "127.0.0.9")
+        monkeypatch.setattr(server, "_resolved_port", 47123)
+        monkeypatch.setattr(mcp.settings, "log_level", "DEBUG")
+        mcp_run, uvicorn_run, anyio_run = MagicMock(), MagicMock(), MagicMock()
+        monkeypatch.setattr(mcp, "run", mcp_run)
+        monkeypatch.setattr(uvicorn, "run", uvicorn_run)
+        monkeypatch.setattr(anyio, "run", anyio_run)
+        main()
+        mcp_run.assert_not_called()
+        uvicorn_run.assert_not_called()
+        (serve,) = anyio_run.call_args.args
+        assert serve.__func__ is uvicorn.Server.serve
+        config = serve.__self__.config
+        assert isinstance(server.app, SingleResponseGuard)
+        assert config.app is server.app
+        assert (config.host, config.port, config.log_level) == ("127.0.0.9", 47123, "debug")
+
 
 class TestMainLogsVersion:
     """Issue #356: main() logs the running package version at startup so a

mcp_gee_sweet-0.9.2.dev236/tests/test_sse_shutdown.py

@@ -0,0 +1,189 @@
+"""Tests for SingleResponseGuard: a SIGTERM with an open SSE stream (#868)."""
+
+import threading
+
+import anyio
+import pytest
+from mcp.server.mcpserver import MCPServer
+from sse_starlette import sse as sse_starlette_sse
+from sse_starlette.sse import AppStatus
+
+from mcp_gee_sweet.sse_shutdown import SingleResponseGuard
+
+_HTTP_SCOPE = {"type": "http", "method": "GET", "path": "/sse"}
+
+
+class _StrictSend:
+    """Records sends, enforcing the ordering checks of uvicorn's h11 ``send``."""
+
+    def __init__(self):
+        self.messages = []
+        self.started = False
+        self.complete = False
+
+    async def __call__(self, message):
+        if not self.started:
+            if message["type"] != "http.response.start":
+                raise RuntimeError(
+                    f"Expected ASGI message 'http.response.start', but got '{message['type']}'."
+                )
+            self.started = True
+        elif not self.complete:
+            if message["type"] != "http.response.body":
+                raise RuntimeError(
+                    f"Expected ASGI message 'http.response.body', but got '{message['type']}'."
+                )
+            if not message.get("more_body", False):
+                self.complete = True
+        else:
+            raise RuntimeError(
+                f"Unexpected ASGI message '{message['type']}' sent, after response already completed."
+            )
+        self.messages.append(message)
+
+
+async def _never_receive():
+    await anyio.sleep_forever()
+
+
+def _app_sending(*messages):
+    async def app(scope, receive, send):
+        for message in messages:
+            await send(message)
+
+    return app
+
+
+_START = {"type": "http.response.start", "status": 200, "headers": []}
+_CHUNK = {"type": "http.response.body", "body": b"data: x\n\n", "more_body": True}
+_END = {"type": "http.response.body", "body": b"", "more_body": False}
+
+
+class TestSingleResponseGuard:
+    @pytest.fixture
+    def shutting_down(self, monkeypatch):
+        monkeypatch.setattr(AppStatus, "should_exit", True)
+
+    @pytest.fixture(autouse=True)
+    def _not_shutting_down_by_default(self, monkeypatch):
+        monkeypatch.setattr(AppStatus, "should_exit", False)
+
+    @pytest.mark.parametrize("should_exit", [False, True])
+    async def test_a_single_response_passes_through_untouched(self, monkeypatch, should_exit):
+        monkeypatch.setattr(AppStatus, "should_exit", should_exit)
+        send = _StrictSend()
+        await SingleResponseGuard(_app_sending(_START, _CHUNK, _END))(
+            _HTTP_SCOPE, _never_receive, send
+        )
+        assert send.messages == [_START, _CHUNK, _END]
+
+    @pytest.mark.parametrize(
+        "messages",
+        [(_START, _CHUNK, _START, _END), (_START, _END, _START, _END)],
+        ids=["open", "complete"],
+    )
+    async def test_before_shutdown_a_second_response_still_reaches_the_server(self, messages):
+        # PR #911 QA round 1: outside shutdown a double response is a real bug, so
+        # uvicorn must still see (and report) it, and an open stream isn't closed.
+        send = _StrictSend()
+        with pytest.raises(RuntimeError, match=r"'http\.response\.start'"):
+            await SingleResponseGuard(_app_sending(*messages))(_HTTP_SCOPE, _never_receive, send)
+        assert send.messages == list(messages[:2])
+
+    @pytest.mark.usefixtures("shutting_down")
+    async def test_a_second_response_on_an_open_stream_closes_it_and_is_dropped(self):
+        # The #868 shape: the stream is cut off without its closing body, then
+        # mcp's empty Response() starts a second response on the same connection.
+        send = _StrictSend()
+        late_response = ({"type": "http.response.start", "status": 200, "headers": []}, _END)
+        app = _app_sending(_START, _CHUNK, *late_response)
+        await SingleResponseGuard(app)(_HTTP_SCOPE, _never_receive, send)
+        assert send.messages == [_START, _CHUNK, _END]
+        assert send.complete
+
+    @pytest.mark.usefixtures("shutting_down")
+    async def test_a_second_response_after_a_complete_one_is_dropped(self):
+        send = _StrictSend()
+        app = _app_sending(_START, _END, _START, _END)
+        await SingleResponseGuard(app)(_HTTP_SCOPE, _never_receive, send)
+        assert send.messages == [_START, _END]
+
+    @pytest.mark.usefixtures("shutting_down")
+    async def test_other_misuse_still_reaches_the_server(self):
+        # Only a duplicate start is absorbed, even during shutdown; a body after
+        # completion still raises.
+        send = _StrictSend()
+        app = _app_sending(_START, _END, _CHUNK)
+        with pytest.raises(RuntimeError, match="after response already completed"):
+            await SingleResponseGuard(app)(_HTTP_SCOPE, _never_receive, send)
+
+    async def test_non_http_scopes_pass_straight_through(self):
+        seen = []
+
+        async def app(scope, receive, send):
+            seen.append((scope, send))
+
+        def send(message):  # never wrapped, so never awaited
+            raise AssertionError
+
+        scope = {"type": "lifespan"}
+        await SingleResponseGuard(app)(scope, _never_receive, send)
+        assert seen == [(scope, send)]
+
+
+class TestShutdownWithOpenSseStream:
+    """mcp's real sse_app, shut down the way uvicorn's SIGTERM handler does."""
+
+    @pytest.fixture(autouse=True)
+    def _fresh_shutdown_state(self, monkeypatch):
+        monkeypatch.setattr(AppStatus, "should_exit", False)
+        # sse_starlette's shutdown watcher is per thread; don't inherit another test's.
+        monkeypatch.setattr(sse_starlette_sse, "_thread_state", threading.local())
+
+    @staticmethod
+    async def _serve_then_shut_down(app):
+        send = _StrictSend()
+        scope = {
+            "type": "http",
+            "asgi": {"version": "3.0"},
+            "http_version": "1.1",
+            "method": "GET",
+            "scheme": "http",
+            "path": "/sse",
+            "raw_path": b"/sse",
+            "root_path": "",
+            "query_string": b"",
+            "headers": [(b"host", b"127.0.0.1:8000"), (b"accept", b"text/event-stream")],
+            "client": ("127.0.0.1", 50000),
+            "server": ("127.0.0.1", 8000),
+        }
+        errors = []
+
+        async def serve():
+            try:
+                await app(scope, _never_receive, send)
+            except Exception as exc:  # what uvicorn logs as "Exception in ASGI application"
+                errors.append(exc)
+
+        with anyio.fail_after(10):
+            async with anyio.create_task_group() as tg:
+                tg.start_soon(serve)
+                while not send.messages:  # the stream is open once its endpoint event is out
+                    await anyio.sleep(0.01)
+                AppStatus.should_exit = True
+        return send, errors
+
+    async def test_unguarded_app_reproduces_the_traceback(self):
+        # Pins the premise: without the guard, mcp's sse_app hits uvicorn's check.
+        _, errors = await self._serve_then_shut_down(MCPServer("t").sse_app(host="0.0.0.0"))
+        assert len(errors) == 1
+        assert "but got 'http.response.start'" in str(errors[0])
+
+    async def test_guarded_app_shuts_down_cleanly(self):
+        app = SingleResponseGuard(MCPServer("t").sse_app(host="0.0.0.0"))
+        send, errors = await self._serve_then_shut_down(app)
+        assert errors == []
+        starts = [m for m in send.messages if m["type"] == "http.response.start"]
+        assert len(starts) == 1
+        assert send.messages[-1] == _END
+        assert send.complete