review: address trivial-directive threads + t02/t15/t19

t01: direct_dispatcher locals left/right -> client/server
t03: migration.md drop "(workaround)", add_request_handler is the supported path
t06+07: Server.middleware comment rewritten + TODO (was stale post-swap)
t09: delete stale ServerRegistry section header
t11: drop Connection.client_info/.client_capabilities properties
     (no readers; v1 only exposed client_params; check_capability reads through)
t12: send_raw_request docstrings point at CallOptions keys
t14+26: drop dump_params from peer.__all__
t20+02: resumption_token/on_resumption_token annotated client-side/SHTTP-only,
     and as 2025-11-25-and-earlier (resumption removed in next protocol rev)
t24: _route_notification docstring (correlation rationale)
t15+19: drop unneeded `from __future__ import annotations` from
     server/context.py and server/session.py (no cycle, no forward refs)

t05+08 answered (no code change): HandlerEntry.handler Any is required storage
erasure; correlation enforced at add_request_handler.

Author: maxisbey

docs/migration.md

@@ -428,7 +428,7 @@ async def my_tool(x: int, ctx: Context) -> str:
 
 The internal layers (`ToolManager.call_tool`, `Tool.run`, `Prompt.render`, `ResourceTemplate.create_resource`, etc.) now require `context` as a positional argument.
 
-### Registering lowlevel handlers on `MCPServer` (workaround)
+### Registering lowlevel handlers from `MCPServer`
 
 `MCPServer` does not expose public APIs for `subscribe_resource`, `unsubscribe_resource`, or `set_logging_level` handlers. In v1, the workaround was to reach into the private lowlevel server and use its decorator methods:
 
@@ -442,7 +442,7 @@ async def handle_set_logging_level(level: str) -> None:
 mcp._mcp_server.subscribe_resource()(handle_subscribe)  # pyright: ignore[reportPrivateUsage]
 ```
 
-In v2, the lowlevel `Server` no longer has decorator methods (handlers are constructor-only), so the equivalent workaround is `add_request_handler`:
+In v2, the lowlevel `Server` supports arbitrary request handlers directly via `add_request_handler` (the decorator methods are gone; handlers are otherwise constructor-only). From `MCPServer`, access it via `_lowlevel_server`:
 
 **After (v2):**
 

src/mcp/server/connection.py

@@ -24,7 +24,7 @@
 from mcp.shared.dispatcher import CallOptions, Outbound
 from mcp.shared.exceptions import NoBackChannelError
 from mcp.shared.peer import Meta, dump_params
-from mcp.types import ClientCapabilities, Implementation, InitializeRequestParams, LoggingLevel
+from mcp.types import ClientCapabilities, InitializeRequestParams, LoggingLevel
 
 __all__ = ["Connection"]
 
@@ -72,16 +72,6 @@ def __init__(self, outbound: Outbound, *, has_standalone_channel: bool, session_
         raised by callbacks are logged and swallowed; they never propagate
         out of `ServerRunner.run()`."""
 
-    @property
-    def client_info(self) -> Implementation | None:
-        """The client's `Implementation` from `initialize`; `None` before initialization."""
-        return self.client_params.client_info if self.client_params is not None else None
-
-    @property
-    def client_capabilities(self) -> ClientCapabilities | None:
-        """The client's `ClientCapabilities` from `initialize`; `None` before initialization."""
-        return self.client_params.capabilities if self.client_params is not None else None
-
     async def send_raw_request(
         self,
         method: str,
@@ -92,7 +82,8 @@ async def send_raw_request(
 
         Low-level `Outbound` channel. Prefer the typed `send_request` (from
         `TypedServerRequestMixin`) or the convenience methods below; use this
-        directly only for off-spec messages.
+        directly only for off-spec messages. `opts` carries per-call `timeout`
+        / `on_progress` / resumption hints; see `CallOptions`.
 
         Raises:
             MCPError: The peer responded with an error.
@@ -151,9 +142,9 @@ def check_capability(self, capability: ClientCapabilities) -> bool:
         """
         # TODO: redesign - mirrors v1 ServerSession.check_client_capability
         # verbatim for parity.
-        if self.client_capabilities is None:
+        if self.client_params is None:
             return False
-        have = self.client_capabilities
+        have = self.client_params.capabilities
         if capability.roots is not None:
             if have.roots is None:
                 return False

src/mcp/server/context.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from collections.abc import Awaitable, Callable, Mapping
 from dataclasses import dataclass
 from typing import Any, Generic, Protocol

src/mcp/server/lowlevel/server.py

@@ -215,8 +215,11 @@ def __init__(
         self._request_handlers: dict[str, HandlerEntry[LifespanResultT]] = {}
         self._notification_handlers: dict[str, HandlerEntry[LifespanResultT]] = {}
         self._session_manager: StreamableHTTPSessionManager | None = None
-        # Context-tier middleware consumed by `ServerRunner`. Additive; the
-        # existing `run()` path ignores it.
+        # Context-tier middleware: wraps each request handler with
+        # `(ctx, method, params, call_next)`. Applied in `ServerRunner._on_request`.
+        # TODO(maxisbey): provisional - signature and semantics change with the
+        # Context/middleware rework (covariant `Context[L]`, outbound seam) before
+        # v2 final.
         self.middleware: list[ServerMiddleware[LifespanResultT]] = []
         logger.debug("Initializing server %r", name)
 
@@ -272,8 +275,6 @@ def add_notification_handler(
         """
         self._notification_handlers[method] = HandlerEntry(params_type, handler)
 
-    # --- ServerRegistry protocol (consumed by ServerRunner) ------------------
-
     def get_request_handler(self, method: str) -> HandlerEntry[LifespanResultT] | None:
         """Return the registered entry for a request method, or `None`."""
         return self._request_handlers.get(method)

src/mcp/server/session.py

@@ -9,22 +9,18 @@
 used to live here are now owned by `JSONRPCDispatcher` and `ServerRunner`.
 """
 
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, TypeVar, overload
+from typing import Any, TypeVar, overload
 
 from pydantic import AnyUrl, BaseModel
 
 from mcp import types
+from mcp.server.connection import Connection
 from mcp.server.validation import validate_sampling_tools, validate_tool_use_result_messages
 from mcp.shared.dispatcher import CallOptions, ProgressFnT
 from mcp.shared.exceptions import StatelessModeNotSupported
 from mcp.shared.jsonrpc_dispatcher import JSONRPCDispatcher
 from mcp.shared.message import MessageMetadata, ServerMessageMetadata
 
-if TYPE_CHECKING:
-    from mcp.server.connection import Connection
-
 __all__ = ["ServerSession"]
 
 ResultT = TypeVar("ResultT", bound=BaseModel)

src/mcp/shared/direct_dispatcher.py

@@ -186,12 +186,12 @@ def create_direct_dispatcher_pair(
         headers: Sets `TransportContext.headers` on both sides.
 
     Returns:
-        A `(left, right)` pair. Conventionally `left` is the client side
-        and `right` is the server side, but the wiring is symmetric.
+        A `(client, server)` pair. The wiring is symmetric, so the roles
+        are conventional only.
     """
     ctx = TransportContext(kind=DIRECT_TRANSPORT_KIND, can_send_request=can_send_request, headers=headers)
-    left = DirectDispatcher(ctx)
-    right = DirectDispatcher(ctx)
-    left.connect_to(right)
-    right.connect_to(left)
-    return left, right
+    client = DirectDispatcher(ctx)
+    server = DirectDispatcher(ctx)
+    client.connect_to(server)
+    server.connect_to(client)
+    return client, server

src/mcp/shared/dispatcher.py

@@ -59,10 +59,20 @@ class CallOptions(TypedDict, total=False):
     """Receive `notifications/progress` updates for this request."""
 
     resumption_token: str
-    """Opaque token to resume a previously interrupted request (transport-dependent)."""
+    """Opaque token to resume a previously interrupted request.
+
+    Client-side, streamable-HTTP only. Ignored by server dispatchers and other
+    transports. Supports protocol version 2025-11-25 and earlier; SSE-stream
+    resumption is removed in the next protocol revision.
+    """
 
     on_resumption_token: Callable[[str], Awaitable[None]]
-    """Receive a resumption token when the transport issues one."""
+    """Receive a resumption token when the transport issues one for this request.
+
+    Client-side, streamable-HTTP only. Ignored by server dispatchers and other
+    transports. Supports protocol version 2025-11-25 and earlier; SSE-stream
+    resumption is removed in the next protocol revision.
+    """
 
 
 @runtime_checkable
@@ -83,6 +93,9 @@ async def send_raw_request(
     ) -> dict[str, Any]:
         """Send a request and await its raw result dict.
 
+        `opts` carries per-call `timeout` / `on_progress` / resumption hints;
+        see `CallOptions`.
+
         Raises:
             MCPError: If the peer responded with an error, or the handler
                 raised. Implementations normalize all handler exceptions to

src/mcp/shared/jsonrpc_dispatcher.py

@@ -504,6 +504,13 @@ def _dispatch_notification(
         on_notify: OnNotify,
         sender_ctx: contextvars.Context | None,
     ) -> None:
+        """Route one inbound notification.
+
+        `notifications/cancelled` and `notifications/progress` are intercepted
+        here because they correlate against JSON-RPC request IDs - the
+        `_in_flight` / `_pending` tables this layer owns - so no higher layer
+        can act on them. See the module docstring for the design rationale.
+        """
         if msg.method == "notifications/cancelled":
             match msg.params:
                 case {"requestId": str() | int() as rid} if (in_flight := self._in_flight.get(rid)) is not None:

src/mcp/shared/peer.py

@@ -32,7 +32,7 @@
     ToolChoice,
 )
 
-__all__ = ["Meta", "Peer", "PeerMixin", "dump_params"]
+__all__ = ["Meta", "Peer", "PeerMixin"]
 
 Meta = dict[str, Any]
 """Type alias for the `_meta` field carried on request/notification params."""

tests/server/test_connection.py

@@ -235,16 +235,6 @@ def test_check_capability_per_field_branches(have: ClientCapabilities, want: Cli
     assert conn.check_capability(want) is expected
 
 
-def test_connection_client_info_and_capabilities_derive_from_client_params():
-    conn = Connection(StubOutbound(), has_standalone_channel=True)
-    assert conn.client_info is None
-    assert conn.client_capabilities is None
-    caps = ClientCapabilities(sampling=SamplingCapability())
-    conn.client_params = _client_params(caps)
-    assert conn.client_info is not None and conn.client_info.name == "t"
-    assert conn.client_capabilities == caps
-
-
 def test_connection_check_capability_true_when_client_declares_it():
     conn = Connection(StubOutbound(), has_standalone_channel=True)
     conn.client_params = _client_params(