Stop answering cancelled requests

When a peer sent notifications/cancelled for an in-flight request, the
dispatcher interrupted the handler and then answered the request anyway
with a synthesized JSON-RPC error, {"code": 0, "message": "Request
cancelled"} - a v1 carry-over pinned as a spec divergence. The
2026-07-28 transport rules say a cancelled request MUST NOT be answered,
and code 0 is not a valid JSON-RPC error code, so a cancelled request now
settles with no response at all: no result if the handler runs to
completion, no error if it fails. Both seats change (the server for
cancelled client requests, the client for cancelled server-initiated
ones).

The error frame had been doing a second job on the 2025-era streamable
HTTP wire, where each request's POST stays open until its response
arrives: it was what let the POST complete. So the dispatcher now tells
the transport when a request settles unanswered (an
on_request_unanswered hook on the inbound message metadata), and the
transport ends that request's stream on it - an empty 202 in
JSON-response mode, a cleanly-ended event stream in SSE mode - instead
of parking the POST until the session ends.

For the same reason the client transport now releases an abandoned
request's own POST at every protocol era, not just 2026-07-28: with no
response coming, a stream left open would sit parked, or - against an
event-store server - resume via Last-Event-ID for an answer that will
never exist. At 2025 the cancellation frame is still POSTed; only the
lingering stream goes away.

The built-in client's abandon and timeout paths never waited on that
error frame, so they are unaffected; a caller that hand-sends
notifications/cancelled while still awaiting a call now waits rather
than receiving the code-0 error, which docs/migration.md notes.

Author: maxisbey

docs/migration.md

@@ -1388,6 +1388,14 @@ The method and the raw inbound params are `ctx.method` and `ctx.params` (`params
 
 Previously it also re-raised exceptions yielded by the transport onto the read stream (e.g. JSON parse errors). Those are now debug-logged and dropped regardless of `raise_exceptions`. If you relied on `run()` exiting on a transport-level parse error, that no longer happens.
 
+### Cancelled requests are no longer answered
+
+In v1, when the peer sent `notifications/cancelled` for an in-flight request, the receiving side interrupted the handler and answered the request anyway with a JSON-RPC error, `{"code": 0, "message": "Request cancelled"}`. The 2026-07-28 spec says a server MUST NOT send any further messages for a cancelled request, and the sender is expected to stop waiting once it cancels, so that error response has been removed: a cancelled request now produces no response at all - no result, and no error, even if the handler runs to completion or fails afterwards. This applies to both seats (the server for cancelled client requests, and the client for cancelled server-initiated requests such as sampling or elicitation).
+
+On the 2025-era streamable HTTP wire, the cancelled request's HTTP exchange still ends rather than staying open: JSON-response mode answers the POST with an empty `202 Accepted`, SSE mode ends the event stream without a response event, and the client tears down the abandoned request's own POST.
+
+Nothing changes for callers of the built-in client: abandoning a call (cancelling the awaiting task, or a per-request timeout) never waited for that response. If you send `notifications/cancelled` by hand while still awaiting the call, the call no longer resolves with the code-0 error; stop awaiting it yourself, or use a per-request timeout.
+
 ### `Server.run()` no longer takes a `stateless` flag
 
 The `stateless: bool` parameter on the lowlevel `Server.run()` has been removed. Stateless serving is now a property of how the connection is constructed (the streamable-HTTP manager builds a born-ready `Connection` per request), not a flag the loop driver inspects.
@@ -1711,7 +1719,7 @@ except MCPError as e:
 
 Behavior changes:
 
-- **Callbacks and notifications now run concurrently.** In v1 the receive loop processed one inbound message at a time, so callbacks ran inline and in order. Now each delivery starts in arrival order but runs as its own task. Server-initiated request callbacks (`sampling`, `elicitation`, `roots`) no longer block other traffic, may themselves send requests without deadlocking, and are interrupted if the server sends `notifications/cancelled` (the request is then answered with an error). Notification callbacks (`logging_callback`, `progress_callback`, `message_handler`) may interleave, and a `progress_callback` may run after the request it reports on has returned; there is no built-in bound on concurrent deliveries. Transport-level errors reach `message_handler` the same way, and a `message_handler` that raises is logged rather than fatal to the session. Callbacks that need strict sequencing must coordinate themselves.
+- **Callbacks and notifications now run concurrently.** In v1 the receive loop processed one inbound message at a time, so callbacks ran inline and in order. Now each delivery starts in arrival order but runs as its own task. Server-initiated request callbacks (`sampling`, `elicitation`, `roots`) no longer block other traffic, may themselves send requests without deadlocking, and are interrupted if the server sends `notifications/cancelled` (no response is sent for the cancelled request). Notification callbacks (`logging_callback`, `progress_callback`, `message_handler`) may interleave, and a `progress_callback` may run after the request it reports on has returned; there is no built-in bound on concurrent deliveries. Transport-level errors reach `message_handler` the same way, and a `message_handler` that raises is logged rather than fatal to the session. Callbacks that need strict sequencing must coordinate themselves.
 - **Timeouts**: a timed-out or abandoned request is now followed by `notifications/cancelled`, so the server stops the handler instead of leaving it running.
 - **A raising request callback** is answered with `code=0` and the exception text; v1 flattened every callback exception to `INVALID_PARAMS`. For a specific error response, return `ErrorData` (unchanged) or raise `MCPError`. One carve-out: pydantic's `ValidationError` is still answered with `INVALID_PARAMS`, as in v1.
 - **`send_request` before entering the context manager** raises `RuntimeError` immediately; v1 wrote to the transport and hung until the timeout. After the connection has closed it raises `MCPError` (`CONNECTION_CLOSED`) instead. `send_notification` before entry still works.

src/mcp/client/streamable_http.py

@@ -102,12 +102,12 @@ def __init__(self, url: str) -> None:
         # scheduling is arbitrary). Reused on outbound HTTP that carries no
         # per-message header (transport-internal GET/DELETE, and dispatcher-written
         # response/error POSTs that bypass the session's stamp), and consulted by
-        # `_consume_modern_cancellation`. Cleared when an `initialize` message is
+        # `_apply_outbound_cancellation`. Cleared when an `initialize` message is
         # dequeued so a probe-stamped value cannot leak onto the handshake.
         self._protocol_version_header: str | None = None
         # Every request's POST runs inside one of these so an outbound
-        # `notifications/cancelled` at 2026 can abort it; see
-        # `_consume_modern_cancellation`. Keys are verbatim-typed ("1" is not 1).
+        # `notifications/cancelled` can abort it; see
+        # `_apply_outbound_cancellation`. Keys are verbatim-typed ("1" is not 1).
         self._in_flight_posts: dict[RequestId, _InFlightPost] = {}
 
     def _prepare_headers(self) -> dict[str, str]:
@@ -268,32 +268,28 @@ async def _handle_resumption_request(self, ctx: RequestContext) -> None:
                     await event_source.response.aclose()
                     break
 
-    def _consume_modern_cancellation(self, session_message: SessionMessage) -> bool:
-        """Translate an outbound `notifications/cancelled` at 2026; True means "do not POST".
-
-        The 2026 wire defines no client-to-server notifications over streamable
-        HTTP: closing a request's response stream IS its cancellation signal.
-        The dispatcher still emits the courtesy frame as its abandon signal
-        (every outbound cancel names one of our own request ids - the spec
-        forbids cancelling a request the sender did not issue), so this
-        transport translates it: when the named request's POST is in flight,
-        that POST's own recorded era decides - abort-and-swallow at 2026, POST
-        the frame below it (where the frame is the signal and a disconnect
-        explicitly is not). With no POST to consult, the cached negotiated
-        version decides; at 2026 the frame is swallowed even unmatched, so a
-        late cancel racing the response cannot leak onto the wire.
+    def _apply_outbound_cancellation(self, session_message: SessionMessage) -> bool:
+        """Apply an outbound `notifications/cancelled` to this transport; True means "do not POST".
+
+        The dispatcher emits the frame as its abandon signal (it only ever names
+        one of our own request ids), so the named request's in-flight POST is
+        aborted at every era: its caller is gone and the stream must not linger
+        or resume. The POST's recorded era only decides whether the frame is also
+        POSTed - at 2026 the abort IS the cancellation signal and there are no
+        client-to-server notifications (swallow); at 2025 the frame is the signal,
+        so it is POSTed too. With no POST to consult, the cached negotiated version
+        decides; at 2026 the frame is swallowed even unmatched, so a late cancel
+        racing the response cannot leak onto the wire.
         """
         message = session_message.message
         if not (isinstance(message, JSONRPCNotification) and message.method == "notifications/cancelled"):
             return False
         request_id = cancelled_request_id_from_params(message.params)
         post = self._in_flight_posts.get(request_id) if request_id is not None else None
         if post is not None:
-            if not post.modern:
-                return False
             logger.debug("aborting in-flight POST for cancelled request %r", request_id)
             post.scope.cancel()
-            return True
+            return post.modern
         return self._protocol_version_header in MODERN_PROTOCOL_VERSIONS
 
     async def _run_request_post(
@@ -302,7 +298,7 @@ async def _run_request_post(
         post: _InFlightPost,
         request_id: RequestId,
     ) -> None:
-        """Run one request's POST inside its abort scope (see `_consume_modern_cancellation`)."""
+        """Run one request's POST inside its abort scope (see `_apply_outbound_cancellation`)."""
         try:
             with post.scope:
                 await post_fn()
@@ -548,7 +544,7 @@ async def post_writer(
 
                 async def _handle_message(session_message: SessionMessage) -> None:
                     message = session_message.message
-                    if self._consume_modern_cancellation(session_message):
+                    if self._apply_outbound_cancellation(session_message):
                         return
                     metadata = (
                         session_message.metadata

src/mcp/server/streamable_http.py

@@ -262,7 +262,10 @@ def _create_session_message(
         The close_sse_stream callbacks are only provided when the client supports
         resumability (protocol version >= 2025-11-25). Old clients can't resume if
         the stream is closed early because they didn't receive a priming event.
+        Every request carries `on_request_unanswered`, which ends its stream
+        when the request settles without a response.
         """
+        end_stream = partial(self._end_request_stream, request_id)
         # Only provide close callbacks when client supports resumability
         if self._event_store and is_version_at_least(protocol_version, "2025-11-25"):
 
@@ -276,9 +279,10 @@ async def close_standalone_stream_callback() -> None:
                 request_context=request,
                 close_sse_stream=close_stream_callback,
                 close_standalone_sse_stream=close_standalone_stream_callback,
+                on_request_unanswered=end_stream,
             )
         else:
-            metadata = ServerMessageMetadata(request_context=request)
+            metadata = ServerMessageMetadata(request_context=request, on_request_unanswered=end_stream)
 
         return SessionMessage(message, metadata=metadata)
 
@@ -390,6 +394,16 @@ def _create_event_data(self, event_message: EventMessage) -> SSEEvent:
 
         return event_data
 
+    async def _end_request_stream(self, request_id: RequestId) -> None:
+        """End a request's stream when it settled without a response (e.g. cancelled).
+
+        Only the send side, so the reader finishes as a normal end-of-stream: JSON
+        mode answers the POST with 202, SSE mode ends the event stream. Already
+        gone if `close_sse_stream()` polling or session teardown released it first.
+        """
+        if streams := self._request_streams.get(request_id):  # pragma: no branch
+            await streams[0].aclose()
+
     async def _clean_up_memory_streams(self, request_id: RequestId) -> None:
         """Clean up memory streams for a given request ID."""
         if request_id in self._request_streams:  # pragma: no branch
@@ -555,7 +569,10 @@ async def _handle_post_request(self, scope: Scope, request: Request, receive: Re
                 )
                 request_stream_reader = self._request_streams[request_id][1]
                 # Process the message
-                metadata = ServerMessageMetadata(request_context=request)
+                metadata = ServerMessageMetadata(
+                    request_context=request,
+                    on_request_unanswered=partial(self._end_request_stream, request_id),
+                )
                 session_message = SessionMessage(message, metadata=metadata)
                 await writer.send(session_message)
                 try:
@@ -573,19 +590,15 @@ async def _handle_post_request(self, scope: Scope, request: Request, receive: Re
                         else:  # pragma: no cover
                             logger.debug(f"received: {event_message.message.method}")
 
-                    # At this point we should have a response
                     if response_message:
                         # Create JSON response
                         response = self._create_json_response(response_message)
-                        await response(scope, receive, send)
-                    else:  # pragma: no cover
-                        # This shouldn't happen in normal operation
-                        logger.error("No response message received before stream closed")
-                        response = self._create_error_response(
-                            "Error processing request: No response received",
-                            HTTPStatus.INTERNAL_SERVER_ERROR,
-                        )
-                        await response(scope, receive, send)
+                    else:
+                        # The stream ended without a response: the request settled
+                        # unanswered (e.g. it was cancelled). End the POST with
+                        # an empty 202 Accepted rather than leaving it open.
+                        response = self._create_json_response(None, HTTPStatus.ACCEPTED)
+                    await response(scope, receive, send)
                 except Exception:  # pragma: no cover
                     logger.exception("Error processing JSON response")
                     response = self._create_error_response(

src/mcp/shared/jsonrpc_dispatcher.py

@@ -80,7 +80,9 @@
 
 PeerCancelMode = Literal["interrupt", "signal"]
 """How `notifications/cancelled` is applied: `"interrupt"` (default) cancels
-the handler's scope; `"signal"` only sets `ctx.cancel_requested`."""
+the handler's scope; `"signal"` only sets `ctx.cancel_requested` and lets the
+handler run to completion. Either way the cancelled request is never
+answered - the handler's eventual result or error is dropped, not written."""
 
 
 def handler_exception_to_error_data(exc: BaseException) -> ErrorData | None:
@@ -696,7 +698,10 @@ async def _handle_request(
     ) -> None:
         """Run `on_request` for one inbound request and write its response.
 
-        The single exception-to-wire boundary: handler exceptions become `JSONRPCError` here.
+        The single exception-to-wire boundary: handler exceptions become
+        `JSONRPCError` here. A request the peer cancelled is never answered
+        (spec: MUST NOT send further messages for it) - it settles unanswered
+        instead, and `_settle_unanswered` tells the transport.
         """
         answer_write_started = False
         try:
@@ -711,27 +716,25 @@ async def _handle_request(
                     key = coerce_request_id(req.id)
                     if (entry := self._in_flight.get(key)) is not None and entry.dctx is dctx:
                         del self._in_flight[key]
-                # A write interrupted by cancellation may still have delivered
-                # (a memory-stream send can hand its item to the receiver and
-                # still raise), so a started answer write counts as sent below:
-                # peers drop late responses, while a second answer for one id
-                # would break JSON-RPC.
-                answer_write_started = True
-                await self._write_result(req.id, result)
-            if scope.cancelled_caught:
-                # anyio absorbs the scope's own cancel at __exit__, and
-                # `cancelled_caught` (unlike `cancel_called`) guarantees the
-                # result write above did not happen - no double response.
-                # TODO(L38): spec says SHOULD NOT respond after cancel;
-                # the existing server always has, so match that for now.
-                answer_write_started = True
-                await self._write_error(req.id, ErrorData(code=0, message="Request cancelled"))
+                if not dctx.cancel_requested.is_set():
+                    # A write interrupted by cancellation may still have delivered
+                    # (a memory-stream send can hand its item to the receiver and
+                    # still raise), so a started answer write counts as sent below:
+                    # peers drop late responses, while a second answer for one id
+                    # would break JSON-RPC.
+                    answer_write_started = True
+                    await self._write_result(req.id, result)
+            # Reached unanswered: the handler saw the cancel (any mode), or the
+            # scope absorbed the interrupt at __exit__.
+            if not answer_write_started:
+                await self._settle_unanswered(dctx)
         except anyio.get_cancelled_exc_class():
             # Shutdown: answer the request so the peer isn't left waiting - unless
             # an answer write already started (it may have reached the transport;
-            # prefer possibly-zero answers over possibly-two). The shielded helper
-            # is needed because bare awaits re-raise here.
-            if not answer_write_started:
+            # prefer possibly-zero answers over possibly-two), or the peer already
+            # cancelled it and stopped waiting. The shielded helper is needed
+            # because bare awaits re-raise here.
+            if not answer_write_started and not dctx.cancel_requested.is_set():
                 await self._final_write(
                     partial(self._write_error, req.id, ErrorData(code=CONNECTION_CLOSED, message="Connection closed")),
                     shield=True,
@@ -741,15 +744,19 @@ async def _handle_request(
             raise
         except Exception as e:
             error = handler_exception_to_error_data(e)
-            if error is not None:
-                await self._write_error(req.id, error)
-            else:
+            unmapped = error is None
+            if unmapped:
                 logger.exception("handler for %r raised", req.method)
                 # TODO(L58): code=0 pins existing-server compat; JSON-RPC says
                 # INTERNAL_ERROR. Revisit per the suite's divergence entry.
-                await self._write_error(req.id, ErrorData(code=0, message=str(e)))
-                if self._raise_handler_exceptions:
-                    raise
+                error = ErrorData(code=0, message=str(e))
+            # A cancel silences only the wire; the failure stays as visible as before.
+            if dctx.cancel_requested.is_set():
+                await self._settle_unanswered(dctx)
+            else:
+                await self._write_error(req.id, error)
+            if unmapped and self._raise_handler_exceptions:
+                raise
         # No `_in_flight` pop here: the inner finally covers every path, and a late pop could evict a reused id.
 
     def _allocate_id(self) -> int:
@@ -771,6 +778,16 @@ async def _write_error(self, request_id: RequestId, error: ErrorData) -> None:
         except (anyio.BrokenResourceError, anyio.ClosedResourceError):
             logger.debug("dropped error for %r: write stream closed", request_id)
 
+    async def _settle_unanswered(self, dctx: _JSONRPCDispatchContext[TransportT]) -> None:
+        """Run the transport's `on_request_unanswered` hook: this request settled with no response.
+
+        A shared-channel wire (stdio) has none; legacy streamable HTTP uses it
+        to complete the request's still-open POST.
+        """
+        metadata = dctx.message_metadata
+        if isinstance(metadata, ServerMessageMetadata) and metadata.on_request_unanswered is not None:
+            await metadata.on_request_unanswered()
+
     async def _final_write(
         self,
         write: Callable[[], Awaitable[None]],