refactor: follow Outbound.send_raw_request rename in PeerMixin/BaseContext

PeerMixin methods and Peer/BaseContext now call/expose send_raw_request.
The typed send_request lands on Connection/Context in the next commit.

Author: maxisbey

src/mcp/shared/context.py

@@ -1,7 +1,7 @@
 """`BaseContext` — the user-facing per-request context.
 
 Composition over a `DispatchContext`: forwards the transport metadata, the
-back-channel (`send_request`/`notify`), progress reporting, and the cancel
+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`
@@ -56,7 +56,7 @@ def meta(self) -> RequestParamsMeta | None:
         """The inbound request's ``_meta`` field, if present."""
         return self._meta
 
-    async def send_request(
+    async def send_raw_request(
         self,
         method: str,
         params: Mapping[str, Any] | None,
@@ -68,7 +68,7 @@ async def send_request(
             MCPError: The peer responded with an error.
             NoBackChannelError: ``can_send_request`` is ``False``.
         """
-        return await self._dctx.send_request(method, params, opts)
+        return await self._dctx.send_raw_request(method, params, opts)
 
     async def notify(self, method: str, params: Mapping[str, Any] | None) -> None:
         """Send a notification to the peer on the back-channel."""

src/mcp/shared/peer.py

@@ -1,13 +1,13 @@
 """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 `send_request`
+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.
 
 The mixin does no capability gating: it builds the params, calls
-``self.send_request(method, params)``, and parses the result into the typed
-model. Gating (and `NoBackChannelError`) is the host's `send_request`'s job.
+``self.send_raw_request(method, params)``, and parses the result into the typed
+model. Gating (and `NoBackChannelError`) is the host's `send_raw_request`'s job.
 """
 
 from collections.abc import Mapping
@@ -43,7 +43,7 @@ class PeerMixin:
     """Typed server-to-client request methods.
 
     Each method constrains ``self`` to `Outbound` so the mixin can be applied
-    to anything with ``send_request``/``notify`` — pyright checks the host
+    to anything with ``send_raw_request``/``notify`` — pyright checks the host
     class structurally at the call site.
     """
 
@@ -113,7 +113,7 @@ async def sample(
             tools=tools,
             tool_choice=tool_choice,
         )
-        result = await self.send_request("sampling/createMessage", _dump(params), opts)
+        result = await self.send_raw_request("sampling/createMessage", _dump(params), opts)
         if tools is not None:
             return CreateMessageResultWithTools.model_validate(result)
         return CreateMessageResult.model_validate(result)
@@ -131,7 +131,7 @@ async def elicit_form(
             NoBackChannelError: No back-channel for server-initiated requests.
         """
         params = ElicitRequestFormParams(message=message, requested_schema=requested_schema)
-        result = await self.send_request("elicitation/create", _dump(params), opts)
+        result = await self.send_raw_request("elicitation/create", _dump(params), opts)
         return ElicitResult.model_validate(result)
 
     async def elicit_url(
@@ -148,7 +148,7 @@ async def elicit_url(
             NoBackChannelError: No back-channel for server-initiated requests.
         """
         params = ElicitRequestURLParams(message=message, url=url, elicitation_id=elicitation_id)
-        result = await self.send_request("elicitation/create", _dump(params), opts)
+        result = await self.send_raw_request("elicitation/create", _dump(params), opts)
         return ElicitResult.model_validate(result)
 
     async def list_roots(self: Outbound, opts: CallOptions | None = None) -> ListRootsResult:
@@ -158,7 +158,7 @@ async def list_roots(self: Outbound, opts: CallOptions | None = None) -> ListRoo
             MCPError: The peer responded with an error.
             NoBackChannelError: No back-channel for server-initiated requests.
         """
-        result = await self.send_request("roots/list", None, opts)
+        result = await self.send_raw_request("roots/list", None, opts)
         return ListRootsResult.model_validate(result)
 
     async def ping(self: Outbound, opts: CallOptions | None = None) -> None:
@@ -168,7 +168,7 @@ async def ping(self: Outbound, opts: CallOptions | None = None) -> None:
             MCPError: The peer responded with an error.
             NoBackChannelError: No back-channel for server-initiated requests.
         """
-        await self.send_request("ping", None, opts)
+        await self.send_raw_request("ping", None, opts)
 
 
 class Peer(PeerMixin):
@@ -182,13 +182,13 @@ class Peer(PeerMixin):
     def __init__(self, outbound: Outbound) -> None:
         self._outbound = outbound
 
-    async def send_request(
+    async def send_raw_request(
         self,
         method: str,
         params: Mapping[str, Any] | None,
         opts: CallOptions | None = None,
     ) -> dict[str, Any]:
-        return await self._outbound.send_request(method, params, opts)
+        return await self._outbound.send_raw_request(method, params, opts)
 
     async def notify(self, method: str, params: Mapping[str, Any] | None) -> None:
         await self._outbound.notify(method, params)

tests/shared/test_context.py

@@ -1,7 +1,7 @@
 """Tests for `BaseContext`.
 
 `BaseContext` is composition over a `DispatchContext` — it forwards
-``transport``/``cancel_requested``/``send_request``/``notify``/``progress``
+``transport``/``cancel_requested``/``send_raw_request``/``notify``/``progress``
 and adds ``meta``. It must satisfy `Outbound` so `PeerMixin` works on it.
 """
 
@@ -33,7 +33,7 @@ async def server_on_request(ctx: DCtx, method: str, params: Mapping[str, Any] |
 
     async with running_pair(direct_pair, server_on_request=server_on_request) as (client, *_):
         with anyio.fail_after(5):
-            await client.send_request("t", None)
+            await client.send_raw_request("t", None)
     bctx = captured[0]
     assert bctx.transport.kind == "direct"
     assert isinstance(bctx.cancel_requested, anyio.Event)
@@ -42,13 +42,13 @@ async def server_on_request(ctx: DCtx, method: str, params: Mapping[str, Any] |
 
 
 @pytest.mark.anyio
-async def test_base_context_send_request_and_notify_forward_to_dispatch_context():
+async def test_base_context_send_raw_request_and_notify_forward_to_dispatch_context():
     crec = Recorder()
     c_req, c_notify = echo_handlers(crec)
 
     async def server_on_request(ctx: DCtx, method: str, params: Mapping[str, Any] | None) -> dict[str, Any]:
         bctx = BaseContext(ctx)
-        sample = await bctx.send_request("sampling/createMessage", {"x": 1})
+        sample = await bctx.send_raw_request("sampling/createMessage", {"x": 1})
         await bctx.notify("notifications/message", {"level": "info"})
         return {"sample": sample}
 
@@ -59,7 +59,7 @@ async def server_on_request(ctx: DCtx, method: str, params: Mapping[str, Any] |
         client_on_notify=c_notify,
     ) as (client, *_):
         with anyio.fail_after(5):
-            result = await client.send_request("tools/call", None)
+            result = await client.send_raw_request("tools/call", None)
             await crec.notified.wait()
     assert crec.requests == [("sampling/createMessage", {"x": 1})]
     assert crec.notifications == [("notifications/message", {"level": "info"})]
@@ -80,7 +80,7 @@ async def server_on_request(ctx: DCtx, method: str, params: Mapping[str, Any] |
 
     async with running_pair(direct_pair, server_on_request=server_on_request) as (client, *_):
         with anyio.fail_after(5):
-            await client.send_request("t", None, {"on_progress": on_progress})
+            await client.send_raw_request("t", None, {"on_progress": on_progress})
     assert received == [(0.5, 1.0, "halfway")]
 
 
@@ -99,7 +99,7 @@ async def server_on_request(ctx: DCtx, method: str, params: Mapping[str, Any] |
         direct_pair, server_on_request=server_on_request, client_on_request=c_req, client_on_notify=c_notify
     ) as (client, *_):
         with anyio.fail_after(5):
-            await client.send_request("t", None)
+            await client.send_raw_request("t", None)
     assert crec.requests == [("ping", None)]
 
 
@@ -112,4 +112,4 @@ async def server_on_request(ctx: DCtx, method: str, params: Mapping[str, Any] |
 
     async with running_pair(direct_pair, server_on_request=server_on_request) as (client, *_):
         with anyio.fail_after(5):
-            await client.send_request("t", None)
+            await client.send_raw_request("t", None)