refactor: rename Outbound.send_request to send_raw_request

The dispatcher-layer raw channel is now `send_raw_request(method, params) ->
dict`. This frees the `send_request` name for the typed surface
(`send_request(req: Request) -> Result`) that Connection/Context/Client add
in later PRs.

Mechanical rename across Outbound, Dispatcher, DispatchContext,
DirectDispatcher, _DirectDispatchContext, and all tests. `can_send_request`
(the transport capability flag) is unchanged — it names the capability, not
the method.

Author: maxisbey

src/mcp/shared/direct_dispatcher.py

@@ -40,7 +40,7 @@ class _DirectDispatchContext:
     """`DispatchContext` for an inbound request on a `DirectDispatcher`.
 
     The back-channel callables target the *originating* side, so a handler's
-    `send_request` reaches the peer that made the inbound request.
+    `send_raw_request` reaches the peer that made the inbound request.
     """
 
     transport: TransportContext
@@ -52,7 +52,7 @@ class _DirectDispatchContext:
     async def notify(self, method: str, params: Mapping[str, Any] | None) -> None:
         await self._back_notify(method, params)
 
-    async def send_request(
+    async def send_raw_request(
         self,
         method: str,
         params: Mapping[str, Any] | None,
@@ -71,7 +71,7 @@ class DirectDispatcher:
     """A `Dispatcher` that calls a peer's handlers directly, in-process.
 
     Two instances are wired together with `create_direct_dispatcher_pair`; each
-    holds a reference to the other. `send_request` on one awaits the peer's
+    holds a reference to the other. `send_raw_request` on one awaits the peer's
     `on_request`. `run` parks until `close` is called.
     """
 
@@ -86,7 +86,7 @@ def __init__(self, transport_ctx: TransportContext):
     def connect_to(self, peer: DirectDispatcher) -> None:
         self._peer = peer
 
-    async def send_request(
+    async def send_raw_request(
         self,
         method: str,
         params: Mapping[str, Any] | None,

src/mcp/shared/dispatcher.py

@@ -2,7 +2,7 @@
 
 A Dispatcher turns a duplex message channel into two things:
 
-* an outbound API: ``send_request(method, params)`` and ``notify(method, params)``
+* an outbound API: ``send_raw_request(method, params)`` and ``notify(method, params)``
 * an inbound pump: ``run(on_request, on_notify)`` that drives the receive loop
   and invokes the supplied handlers for each incoming request/notification
 
@@ -44,7 +44,7 @@ async def __call__(self, progress: float, total: float | None, message: str | No
 
 
 class CallOptions(TypedDict, total=False):
-    """Per-call options for `Outbound.send_request`.
+    """Per-call options for `Outbound.send_raw_request`.
 
     All keys are optional. Dispatchers ignore keys they do not understand.
     """
@@ -67,17 +67,18 @@ 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. `PeerMixin` wraps an `Outbound` to
-    provide typed MCP request/notification methods.
+    during an inbound request) extend this. The MCP type layer (`PeerMixin`,
+    `Connection`, `Context`) builds typed ``send_request`` / convenience methods
+    on top of this raw channel.
     """
 
-    async def send_request(
+    async def send_raw_request(
         self,
         method: str,
         params: Mapping[str, Any] | None,
         opts: CallOptions | None = None,
     ) -> dict[str, Any]:
-        """Send a request and await its result.
+        """Send a request and await its raw result dict.
 
         Raises:
             MCPError: If the peer responded with an error, or the handler
@@ -96,7 +97,7 @@ class DispatchContext(Outbound, Protocol[TransportT_co]):
 
     Carries the transport metadata for the inbound message and provides the
     back-channel for sending requests/notifications to the peer while handling
-    it. `send_request` raises `NoBackChannelError` if
+    it. `send_raw_request` raises `NoBackChannelError` if
     ``transport.can_send_request`` is ``False``.
     """
 

src/mcp/shared/exceptions.py

@@ -46,7 +46,7 @@ class NoBackChannelError(MCPError):
 
     Stateless HTTP and JSON-response-mode HTTP have no channel for the server to
     push requests (sampling, elicitation, roots/list) to the client. This is
-    raised by `DispatchContext.send_request` when `transport.can_send_request`
+    raised by `DispatchContext.send_raw_request` when `transport.can_send_request`
     is ``False``, and serializes to an ``INVALID_REQUEST`` error response.
     """
 

src/mcp/shared/transport_context.py

@@ -26,5 +26,5 @@ class TransportContext:
 
     ``False`` for stateless HTTP and HTTP with JSON response mode; ``True`` for
     stdio, SSE, and stateful streamable HTTP. When ``False``,
-    `DispatchContext.send_request` raises `NoBackChannelError`.
+    `DispatchContext.send_raw_request` raises `NoBackChannelError`.
     """

tests/shared/test_dispatcher.py

@@ -67,44 +67,44 @@ async def running_pair(
 
 
 @pytest.mark.anyio
-async def test_send_request_returns_result_from_peer_on_request():
+async def test_send_raw_request_returns_result_from_peer_on_request():
     async with running_pair() as (client, _server, _crec, srec):
         with anyio.fail_after(5):
-            result = await client.send_request("tools/list", {"cursor": "abc"})
+            result = await client.send_raw_request("tools/list", {"cursor": "abc"})
     assert result == {"echoed": "tools/list", "params": {"cursor": "abc"}}
     assert srec.requests == [("tools/list", {"cursor": "abc"})]
 
 
 @pytest.mark.anyio
-async def test_send_request_reraises_mcperror_from_handler_unchanged():
+async def test_send_raw_request_reraises_mcperror_from_handler_unchanged():
     async def on_request(
         ctx: DispatchContext[TransportContext], method: str, params: Mapping[str, Any] | None
     ) -> dict[str, Any]:
         raise MCPError(code=INVALID_PARAMS, message="bad cursor")
 
     async with running_pair(server_on_request=on_request) as (client, *_):
         with anyio.fail_after(5), pytest.raises(MCPError) as exc:
-            await client.send_request("tools/list", {})
+            await client.send_raw_request("tools/list", {})
     assert exc.value.error.code == INVALID_PARAMS
     assert exc.value.error.message == "bad cursor"
 
 
 @pytest.mark.anyio
-async def test_send_request_wraps_non_mcperror_exception_as_internal_error():
+async def test_send_raw_request_wraps_non_mcperror_exception_as_internal_error():
     async def on_request(
         ctx: DispatchContext[TransportContext], method: str, params: Mapping[str, Any] | None
     ) -> dict[str, Any]:
         raise ValueError("oops")
 
     async with running_pair(server_on_request=on_request) as (client, *_):
         with anyio.fail_after(5), pytest.raises(MCPError) as exc:
-            await client.send_request("tools/list", {})
+            await client.send_raw_request("tools/list", {})
     assert exc.value.error.code == INTERNAL_ERROR
     assert isinstance(exc.value.__cause__, ValueError)
 
 
 @pytest.mark.anyio
-async def test_send_request_with_timeout_raises_mcperror_request_timeout():
+async def test_send_raw_request_with_timeout_raises_mcperror_request_timeout():
     async def on_request(
         ctx: DispatchContext[TransportContext], method: str, params: Mapping[str, Any] | None
     ) -> dict[str, Any]:
@@ -113,7 +113,7 @@ async def on_request(
 
     async with running_pair(server_on_request=on_request) as (client, *_):
         with anyio.fail_after(5), pytest.raises(MCPError) as exc:
-            await client.send_request("slow", None, {"timeout": 0})
+            await client.send_raw_request("slow", None, {"timeout": 0})
     assert exc.value.error.code == REQUEST_TIMEOUT
 
 
@@ -127,32 +127,32 @@ async def test_notify_invokes_peer_on_notify():
 
 
 @pytest.mark.anyio
-async def test_ctx_send_request_round_trips_to_calling_side():
-    """A handler's ctx.send_request reaches the side that made the inbound request."""
+async def test_ctx_send_raw_request_round_trips_to_calling_side():
+    """A handler's ctx.send_raw_request reaches the side that made the inbound request."""
 
     async def server_on_request(
         ctx: DispatchContext[TransportContext], method: str, params: Mapping[str, Any] | None
     ) -> dict[str, Any]:
-        sample = await ctx.send_request("sampling/createMessage", {"prompt": "hi"})
+        sample = await ctx.send_raw_request("sampling/createMessage", {"prompt": "hi"})
         return {"sampled": sample}
 
     async with running_pair(server_on_request=server_on_request) as (client, _server, crec, _srec):
         with anyio.fail_after(5):
-            result = await client.send_request("tools/call", None)
+            result = await client.send_raw_request("tools/call", None)
     assert crec.requests == [("sampling/createMessage", {"prompt": "hi"})]
     assert result == {"sampled": {"echoed": "sampling/createMessage", "params": {"prompt": "hi"}}}
 
 
 @pytest.mark.anyio
-async def test_ctx_send_request_raises_nobackchannelerror_when_transport_disallows():
+async def test_ctx_send_raw_request_raises_nobackchannelerror_when_transport_disallows():
     async def server_on_request(
         ctx: DispatchContext[TransportContext], method: str, params: Mapping[str, Any] | None
     ) -> dict[str, Any]:
-        return await ctx.send_request("sampling/createMessage", None)
+        return await ctx.send_raw_request("sampling/createMessage", None)
 
     async with running_pair(server_on_request=server_on_request, can_send_request=False) as (client, *_):
         with anyio.fail_after(5), pytest.raises(NoBackChannelError) as exc:
-            await client.send_request("tools/call", None)
+            await client.send_raw_request("tools/call", None)
     assert exc.value.method == "sampling/createMessage"
     assert exc.value.error.code == INVALID_REQUEST
 
@@ -167,7 +167,7 @@ async def server_on_request(
 
     async with running_pair(server_on_request=server_on_request) as (client, _server, crec, _srec):
         with anyio.fail_after(5):
-            await client.send_request("tools/call", None)
+            await client.send_raw_request("tools/call", None)
             await crec.notified.wait()
     assert crec.notifications == [("notifications/message", {"level": "info"})]
 
@@ -187,12 +187,12 @@ async def on_progress(progress: float, total: float | None, message: str | None)
 
     async with running_pair(server_on_request=server_on_request) as (client, *_):
         with anyio.fail_after(5):
-            await client.send_request("tools/call", None, {"on_progress": on_progress})
+            await client.send_raw_request("tools/call", None, {"on_progress": on_progress})
     assert received == [(0.5, 1.0, "halfway")]
 
 
 @pytest.mark.anyio
-async def test_send_request_issued_before_peer_run_blocks_until_peer_ready():
+async def test_send_raw_request_issued_before_peer_run_blocks_until_peer_ready():
     client, server = create_direct_dispatcher_pair()
     s_req, s_notify = echo_handlers(Recorder())
     c_req, c_notify = echo_handlers(Recorder())
@@ -205,7 +205,7 @@ async def late_start():
         tg.start_soon(client.run, c_req, c_notify)
         tg.start_soon(late_start)
         with anyio.fail_after(5):
-            result = await client.send_request("ping", None)
+            result = await client.send_raw_request("ping", None)
         assert result == {"echoed": "ping", "params": {}}
         client.close()
         server.close()
@@ -221,15 +221,15 @@ async def server_on_request(
 
     async with running_pair(server_on_request=server_on_request) as (client, *_):
         with anyio.fail_after(5):
-            result = await client.send_request("tools/call", None)
+            result = await client.send_raw_request("tools/call", None)
     assert result == {"ok": True}
 
 
 @pytest.mark.anyio
-async def test_send_request_and_notify_raise_runtimeerror_when_no_peer_connected():
+async def test_send_raw_request_and_notify_raise_runtimeerror_when_no_peer_connected():
     d = DirectDispatcher(TransportContext(kind="direct", can_send_request=True))
     with pytest.raises(RuntimeError, match="no peer"):
-        await d.send_request("ping", None)
+        await d.send_raw_request("ping", None)
     with pytest.raises(RuntimeError, match="no peer"):
         await d.notify("ping", None)