fix: align JSONRPCDispatcher error shapes with existing server

Three pinned wire shapes the interaction suite locks in:

- Peer-cancelled requests are answered with ErrorData(code=0,
  message="Request cancelled"). Spec says SHOULD NOT respond, but the
  existing server always has.
- Unhandled handler exceptions become code=0 (not INTERNAL_ERROR),
  message=str(e). Matches Server._handle_request.
- ValidationError becomes the fixed "Invalid request parameters" /
  data="" shape rather than leaking the pydantic error text.

All three carry TODO(maxisbey) markers; they're compat with current
behavior, not the intended end state.

Author: maxisbey

src/mcp/shared/jsonrpc_dispatcher.py

@@ -43,7 +43,6 @@
 from mcp.shared.transport_context import TransportContext
 from mcp.types import (
     CONNECTION_CLOSED,
-    INTERNAL_ERROR,
     INVALID_PARAMS,
     REQUEST_CANCELLED,
     REQUEST_TIMEOUT,
@@ -524,11 +523,15 @@ async def _handle_request(
                     # `dctx.send_raw_request()` should see `NoBackChannelError`.
                     dctx.close()
                 await self._write_result(req.id, result)
-            # Peer-cancel: `_dispatch_notification` cancelled this scope. anyio
-            # swallows a scope's *own* cancel at __exit__, so the result write
-            # (or the handler) is interrupted and execution lands here without
-            # reaching the `except cancelled` arm below. Spec SHOULD: send no
-            # response - fall through to `finally`.
+            if scope.cancel_called:
+                # Peer-cancel: `_dispatch_notification` cancelled this scope.
+                # anyio swallows a scope's *own* cancel at __exit__, so the
+                # result write (or the handler) is interrupted and execution
+                # lands here rather than the `except cancelled` arm below.
+                # TODO(maxisbey): spec says SHOULD NOT respond after cancel.
+                # The existing server always has and the interaction suite pins
+                # that; revisit once the suite's divergence entry is resolved.
+                await self._write_error(req.id, ErrorData(code=0, message="Request cancelled"))
         except anyio.get_cancelled_exc_class():
             # Outer-cancel: run()'s task group is shutting down. Any bare
             # `await` here re-raises immediately, so shield the courtesy write.
@@ -537,11 +540,20 @@ async def _handle_request(
             raise
         except MCPError as e:
             await self._write_error(req.id, e.error)
-        except ValidationError as e:
-            await self._write_error(req.id, ErrorData(code=INVALID_PARAMS, message=str(e)))
+        except ValidationError:
+            # TODO(maxisbey): data="" is pinned compat with the existing
+            # server (which never leaked pydantic error text onto the wire).
+            # Consider putting the validation detail in `data` once the
+            # interaction suite's divergence entry is resolved.
+            await self._write_error(
+                req.id, ErrorData(code=INVALID_PARAMS, message="Invalid request parameters", data="")
+            )
         except Exception as e:
             logger.exception("handler for %r raised", req.method)
-            await self._write_error(req.id, ErrorData(code=INTERNAL_ERROR, message=str(e)))
+            # TODO(maxisbey): code=0 is pinned compat with the existing
+            # server's `_handle_request`. JSON-RPC says INTERNAL_ERROR
+            # (-32603); revisit once the suite's divergence entry is resolved.
+            await self._write_error(req.id, ErrorData(code=0, message=str(e)))
             if self._raise_handler_exceptions:
                 raise
         finally:

tests/shared/test_jsonrpc_dispatcher.py

@@ -70,22 +70,23 @@ async def call(method: str) -> None:
 
 
 @pytest.mark.anyio
-async def test_handler_raising_exception_sends_internal_error_with_str_message():
-    """Per design: INTERNAL_ERROR carries str(e), not a scrubbed message."""
+async def test_handler_raising_exception_sends_code_zero_with_str_message():
+    """Matches the existing server's `_handle_request`: code=0, message=str(e)."""
 
     async def server_on_request(ctx: DCtx, method: str, params: Mapping[str, Any] | None) -> dict[str, Any]:
         raise RuntimeError("kaboom")
 
     async with running_pair(jsonrpc_pair, server_on_request=server_on_request) as (client, *_):
         with anyio.fail_after(5), pytest.raises(MCPError) as exc:
             await client.send_raw_request("tools/list", None)
-    assert exc.value.error.code == INTERNAL_ERROR
+    assert exc.value.error.code == 0
     assert exc.value.error.message == "kaboom"
     assert exc.value.__cause__ is None  # cause does not survive the wire
 
 
 @pytest.mark.anyio
-async def test_peer_cancel_interrupt_mode_sets_cancel_requested_and_sends_no_response():
+async def test_peer_cancel_interrupt_mode_writes_cancelled_error_response():
+    """Matches the existing server: a peer-cancelled request is answered with code=0."""
     handler_started = anyio.Event()
     handler_exited = anyio.Event()
     seen_ctx: list[DCtx] = []
@@ -99,23 +100,22 @@ async def server_on_request(ctx: DCtx, method: str, params: Mapping[str, Any] |
             handler_exited.set()
         raise NotImplementedError
 
+    seen_error: list[ErrorData] = []
     async with running_pair(jsonrpc_pair, server_on_request=server_on_request) as (client, *_):
         with anyio.fail_after(5):
             async with anyio.create_task_group() as tg:  # pragma: no branch
 
                 async def call_then_record() -> None:
-                    with pytest.raises(MCPError):  # we'll cancel via tg below
+                    with pytest.raises(MCPError) as exc:
                         await client.send_raw_request("slow", None)
+                    seen_error.append(exc.value.error)
 
                 tg.start_soon(call_then_record)
                 await handler_started.wait()
-                # cancel just the handler (peer-cancel), not our caller
                 await client.notify("notifications/cancelled", {"requestId": 1})
                 await handler_exited.wait()
-                # Handler torn down, no response was written; caller is still parked.
-                # Cancel the caller's task to end the test.
-                tg.cancel_scope.cancel()
     assert seen_ctx[0].cancel_requested.is_set()
+    assert seen_error == [ErrorData(code=0, message="Request cancelled")]
 
 
 @pytest.mark.anyio
@@ -266,7 +266,7 @@ async def on_notify(ctx: DCtx, method: str, params: Mapping[str, Any] | None) ->
         sent = s2c_recv.receive_nowait()
         assert isinstance(sent, SessionMessage)
         assert isinstance(sent.message, JSONRPCError)
-        assert sent.message.error.code == INTERNAL_ERROR
+        assert sent.message.error.code == 0
     finally:
         for s in (c2s_send, c2s_recv, s2c_send, s2c_recv):
             s.close()
@@ -408,7 +408,7 @@ async def server_on_request(ctx: DCtx, method: str, params: Mapping[str, Any] |
     async with running_pair(jsonrpc_pair, server_on_request=server_on_request) as (client, *_):
         with anyio.fail_after(5), pytest.raises(MCPError) as exc:
             await client.send_raw_request("t", None)
-    assert exc.value.error.code == INVALID_PARAMS
+    assert exc.value.error == ErrorData(code=INVALID_PARAMS, message="Invalid request parameters", data="")
 
 
 @pytest.mark.anyio