review: t27 PeerMixin->ClientPeerMixin; t28 malformed-initialize regression test

t27: rename PeerMixin/Peer -> ClientPeerMixin/ClientPeer (the contents are
exactly the spec ServerRequest set, server->client; sibling
TypedServerRequestMixin already encodes direction). Fix the stale module/
class docstring claiming Connection mixes it in (it does not).

t28: re-cover the deleted tests/issues/test_malformed_input.py regression
on the new path - initialize with params=None returns INVALID_PARAMS and
the runner keeps serving.

t13: keep `notify` (asymmetry justified; layer-consistent).
t29: deletion safe (interaction test_progress.py + dispatcher units cover it).

Author: maxisbey

src/mcp/server/context.py

@@ -11,7 +11,7 @@
 from mcp.shared.context import BaseContext
 from mcp.shared.dispatcher import DispatchContext
 from mcp.shared.message import CloseSSEStreamCallback
-from mcp.shared.peer import Meta, PeerMixin
+from mcp.shared.peer import ClientPeerMixin, Meta
 from mcp.shared.transport_context import TransportContext
 from mcp.types import LoggingLevel, RequestId, RequestParamsMeta
 
@@ -41,11 +41,11 @@ class ServerRequestContext(Generic[LifespanContextT, RequestT]):
 LifespanT = TypeVar("LifespanT", default=Any, covariant=True)
 
 
-class Context(BaseContext[TransportContext], PeerMixin, TypedServerRequestMixin, Generic[LifespanT]):
+class Context(BaseContext[TransportContext], ClientPeerMixin, TypedServerRequestMixin, Generic[LifespanT]):
     """Server-side per-request context.
 
     Composes `BaseContext` (forwards to `DispatchContext`, satisfies `Outbound`),
-    `PeerMixin` (kwarg-style `sample`/`elicit_*`/`list_roots`/`ping`),
+    `ClientPeerMixin` (kwarg-style `sample`/`elicit_*`/`list_roots`/`ping`),
     and `TypedServerRequestMixin` (typed `send_request(req) -> Result`). Adds
     `lifespan` and `connection`.
 

src/mcp/shared/context.py

@@ -4,7 +4,7 @@
 back-channel (`send_raw_request`/`notify`), progress reporting, and the cancel
 event. Adds `meta` (the inbound request's `_meta` field).
 
-Satisfies `Outbound`, so `PeerMixin` works on it (the server-side `Context`
+Satisfies `Outbound`, so `ClientPeerMixin` works on it (the server-side `Context`
 mixes that in directly). Shared between client and server: the server's
 `Context` extends this with `lifespan`/`connection`; `ClientContext` is just an
 alias.

src/mcp/shared/dispatcher.py

@@ -80,7 +80,7 @@ class Outbound(Protocol):
     """Anything that can send requests and notifications to the peer.
 
     Both `Dispatcher` (top-level outbound) and `DispatchContext` (back-channel
-    during an inbound request) extend this. The MCP type layer (`PeerMixin`,
+    during an inbound request) extend this. The MCP type layer (`ClientPeerMixin`,
     `Connection`, `Context`) builds typed `send_request` / convenience methods
     on top of this raw channel.
     """

src/mcp/shared/peer.py

@@ -1,9 +1,9 @@
 """Typed MCP request sugar over an `Outbound`.
 
-`PeerMixin` defines the server-to-client request methods (sampling, elicitation,
-roots, ping) once. Any class that satisfies `Outbound` (i.e. has
+`ClientPeerMixin` defines the server-to-client request methods (sampling,
+elicitation, roots, ping) once. Any class that satisfies `Outbound` (i.e. has
 `send_raw_request` and `notify`) can mix it in and get the typed methods for
-free - `Context`, `Connection`, `Client`, or the bare `Peer` wrapper below.
+free - `Context`, or the bare `ClientPeer` wrapper below.
 
 The mixin does no capability gating: it builds the params, calls
 `self.send_raw_request(method, params)`, and parses the result into the typed
@@ -32,7 +32,7 @@
     ToolChoice,
 )
 
-__all__ = ["Meta", "Peer", "PeerMixin"]
+__all__ = ["ClientPeer", "ClientPeerMixin", "Meta"]
 
 Meta = dict[str, Any]
 """Type alias for the `_meta` field carried on request/notification params."""
@@ -41,7 +41,7 @@
 def dump_params(model: BaseModel | None, meta: Meta | None = None) -> dict[str, Any] | None:
     """Serialize a params model to a wire dict, merging `meta` into `_meta`.
 
-    Shared by `PeerMixin`, `Connection`, and `TypedServerRequestMixin` so every
+    Shared by `ClientPeerMixin`, `Connection`, and `TypedServerRequestMixin` so every
     typed convenience method gets the same `_meta` handling. `meta` keys take
     precedence over any `_meta` already present on the model.
     """
@@ -52,7 +52,7 @@ def dump_params(model: BaseModel | None, meta: Meta | None = None) -> dict[str,
     return out
 
 
-class PeerMixin:
+class ClientPeerMixin:
     """Typed server-to-client request methods.
 
     Each method constrains `self` to `Outbound` so the mixin can be applied
@@ -193,11 +193,11 @@ async def ping(self: Outbound, *, meta: Meta | None = None, opts: CallOptions |
         await self.send_raw_request("ping", dump_params(None, meta), opts)
 
 
-class Peer(PeerMixin):
-    """Standalone wrapper that gives any `Outbound` the `PeerMixin` sugar.
+class ClientPeer(ClientPeerMixin):
+    """Standalone wrapper that gives any `Outbound` the `ClientPeerMixin` sugar.
 
-    `Context` and `Connection` mix `PeerMixin` in directly; use `Peer` when
-    you have a bare dispatcher (or any `Outbound`) and want the typed methods
+    `Context` mixes `ClientPeerMixin` in directly; use `ClientPeer` when you
+    have a bare dispatcher (or any `Outbound`) and want the typed methods
     without writing your own host class.
     """
 

tests/server/test_runner.py

@@ -207,6 +207,18 @@ async def test_runner_rejects_snake_case_initialize_params(server: SrvT):
     assert exc.value.error.code == INVALID_PARAMS
 
 
+@pytest.mark.anyio
+async def test_runner_initialize_with_absent_params_returns_invalid_params_and_stays_alive(server: SrvT):
+    """Re-covers what the old `tests/issues/test_malformed_input.py` pinned: a
+    malformed `initialize` is rejected and the runner keeps serving."""
+    async with connected_runner(server, initialized=False) as (client, _):
+        with pytest.raises(MCPError) as exc:
+            await client.send_raw_request("initialize", None)
+        assert exc.value.error.code == INVALID_PARAMS
+        result = await client.send_raw_request("initialize", _initialize_params())
+    assert result["serverInfo"]["name"] == "test-server"
+
+
 @pytest.mark.anyio
 async def test_runner_rejects_snake_case_params_for_custom_handler(server: SrvT):
     """Custom-method handlers (which skip the spec-method gate) still validate

tests/server/test_server_context.py

@@ -1,7 +1,7 @@
 """Tests for the server-side `Context`.
 
 `Context` composes `BaseContext` (forwarding to a `DispatchContext`) with
-`PeerMixin` (typed sample/elicit/roots/ping) plus `lifespan` and `connection`.
+`ClientPeerMixin` (typed sample/elicit/roots/ping) plus `lifespan` and `connection`.
 End-to-end tested over `DirectDispatcher`.
 """
 

tests/shared/test_context.py

@@ -2,7 +2,7 @@
 
 `BaseContext` is composition over a `DispatchContext` - it forwards
 `transport`/`cancel_requested`/`send_raw_request`/`notify`/`progress`
-and adds `meta`. It must satisfy `Outbound` so `PeerMixin` works on it.
+and adds `meta`. It must satisfy `Outbound` so `ClientPeerMixin` works on it.
 """
 
 from collections.abc import Mapping
@@ -13,7 +13,7 @@
 
 from mcp.shared.context import BaseContext
 from mcp.shared.dispatcher import DispatchContext
-from mcp.shared.peer import Peer
+from mcp.shared.peer import ClientPeer
 from mcp.shared.transport_context import TransportContext
 
 from .conftest import direct_pair, jsonrpc_pair
@@ -104,11 +104,11 @@ async def server_on_request(ctx: DCtx, method: str, params: Mapping[str, Any] |
 
 @pytest.mark.anyio
 async def test_base_context_satisfies_outbound_so_peer_mixin_works():
-    """Wrapping a BaseContext in Peer proves it satisfies Outbound structurally."""
+    """Wrapping a BaseContext in ClientPeer proves it satisfies Outbound structurally."""
 
     async def server_on_request(ctx: DCtx, method: str, params: Mapping[str, Any] | None) -> dict[str, Any]:
         bctx = BaseContext(ctx)
-        await Peer(bctx).ping()
+        await ClientPeer(bctx).ping()
         return {}
 
     crec = Recorder()

tests/shared/test_peer.py

@@ -1,6 +1,6 @@
-"""Tests for `PeerMixin` and `Peer`.
+"""Tests for `ClientPeerMixin` and `ClientPeer`.
 
-Each PeerMixin method is tested by wrapping a `DirectDispatcher` in `Peer`,
+Each ClientPeerMixin method is tested by wrapping a `DirectDispatcher` in `ClientPeer`,
 calling the typed method, and asserting (a) the right method+params went out
 and (b) the return value is the typed result model.
 """
@@ -12,7 +12,7 @@
 import pytest
 
 from mcp.shared.dispatcher import DispatchContext
-from mcp.shared.peer import Peer, dump_params
+from mcp.shared.peer import ClientPeer, dump_params
 from mcp.shared.transport_context import TransportContext
 from mcp.types import (
     CreateMessageResult,
@@ -44,7 +44,7 @@ async def on_request(self, ctx: DCtx, method: str, params: Mapping[str, Any] | N
 async def test_peer_sample_sends_create_message_and_returns_typed_result():
     rec = _Recorder({"role": "assistant", "content": {"type": "text", "text": "hi"}, "model": "m"})
     async with running_pair(direct_pair, server_on_request=rec.on_request) as (client, *_):
-        peer = Peer(client)
+        peer = ClientPeer(client)
         with anyio.fail_after(5):
             result = await peer.sample(
                 [SamplingMessage(role="user", content=TextContent(type="text", text="hello"))],
@@ -64,7 +64,7 @@ async def test_peer_sample_validates_result_alias_only():
     snake = {"role": "assistant", "content": {"type": "text", "text": "x"}, "model": "m", "stop_reason": "endTurn"}
     rec = _Recorder(snake)
     async with running_pair(direct_pair, server_on_request=rec.on_request) as (client, *_):
-        peer = Peer(client)
+        peer = ClientPeer(client)
         with anyio.fail_after(5):
             result = await peer.sample(
                 [SamplingMessage(role="user", content=TextContent(type="text", text="q"))], max_tokens=1
@@ -77,7 +77,7 @@ async def test_peer_sample_validates_result_alias_only():
 async def test_peer_sample_with_tools_returns_with_tools_result():
     rec = _Recorder({"role": "assistant", "content": [{"type": "text", "text": "x"}], "model": "m"})
     async with running_pair(direct_pair, server_on_request=rec.on_request) as (client, *_):
-        peer = Peer(client)
+        peer = ClientPeer(client)
         with anyio.fail_after(5):
             result = await peer.sample(
                 [SamplingMessage(role="user", content=TextContent(type="text", text="q"))],
@@ -94,7 +94,7 @@ async def test_peer_sample_with_tools_returns_with_tools_result():
 async def test_peer_elicit_form_sends_elicitation_create_with_form_params():
     rec = _Recorder({"action": "accept", "content": {"name": "Max"}})
     async with running_pair(direct_pair, server_on_request=rec.on_request) as (client, *_):
-        peer = Peer(client)
+        peer = ClientPeer(client)
         with anyio.fail_after(5):
             result = await peer.elicit_form("Your name?", requested_schema={"type": "object", "properties": {}})
         method, params = rec.seen[0]
@@ -108,7 +108,7 @@ async def test_peer_elicit_form_sends_elicitation_create_with_form_params():
 async def test_peer_elicit_url_sends_elicitation_create_with_url_params():
     rec = _Recorder({"action": "accept"})
     async with running_pair(direct_pair, server_on_request=rec.on_request) as (client, *_):
-        peer = Peer(client)
+        peer = ClientPeer(client)
         with anyio.fail_after(5):
             result = await peer.elicit_url("Auth needed", url="https://example.com/auth", elicitation_id="e1")
         method, params = rec.seen[0]
@@ -122,7 +122,7 @@ async def test_peer_elicit_url_sends_elicitation_create_with_url_params():
 async def test_peer_list_roots_sends_roots_list_and_returns_typed_result():
     rec = _Recorder({"roots": [{"uri": "file:///workspace"}]})
     async with running_pair(direct_pair, server_on_request=rec.on_request) as (client, *_):
-        peer = Peer(client)
+        peer = ClientPeer(client)
         with anyio.fail_after(5):
             result = await peer.list_roots()
         method, _ = rec.seen[0]
@@ -136,7 +136,7 @@ async def test_peer_list_roots_sends_roots_list_and_returns_typed_result():
 async def test_peer_list_roots_with_meta_sends_meta_in_params():
     rec = _Recorder({"roots": []})
     async with running_pair(direct_pair, server_on_request=rec.on_request) as (client, *_):
-        peer = Peer(client)
+        peer = ClientPeer(client)
         with anyio.fail_after(5):
             await peer.list_roots(meta={"traceId": "t1"})
         method, params = rec.seen[0]
@@ -164,15 +164,15 @@ async def send_raw_request(
         async def notify(self, method: str, params: Mapping[str, Any] | None) -> None:
             sent.append((method, params))
 
-    await Peer(_Out()).notify("n", {"x": 1})
+    await ClientPeer(_Out()).notify("n", {"x": 1})
     assert sent == [("n", {"x": 1})]
 
 
 @pytest.mark.anyio
 async def test_peer_ping_sends_ping_and_returns_none():
     rec = _Recorder({})
     async with running_pair(direct_pair, server_on_request=rec.on_request) as (client, *_):
-        peer = Peer(client)
+        peer = ClientPeer(client)
         with anyio.fail_after(5):
             result = await peer.ping()
         method, _ = rec.seen[0]