Sweep: route report_progress through DispatchContext.progress; bump LATEST_PROTOCOL_VERSION; orphan cleanup

- Context.report_progress now delegates to DispatchContext.progress() via
  ServerSession.report_progress (was: token-gated send_notification, which
  only worked under JSONRPCDispatcher). Progress now reaches the client on
  the in-process modern path; 4 progress-notification xfails flip to pass.
  ServerSession's request_outbound is typed DispatchContext (it always was
  one at runtime).
- LATEST_PROTOCOL_VERSION bumped to '2026-07-28' (the newest revision the
  SDK supports). Handshake-outcome assertions and mock-InitializeResult
  fixtures switched to HANDSHAKE_PROTOCOL_VERSIONS[-1]. migration.md entry.
- ServerMessageMetadata.protocol_version deleted (no readers, no writers).
- ClientSession.send_progress_notification and Client.send_progress_notification
  deprecated (client-to-server progress is server-to-client only at 2026-07-28).
- Mcp-Name TODO re-anchored on _make_modern_stamp.

Author: maxisbey

docs/migration.md

@@ -776,6 +776,8 @@ async def my_tool(ctx: Context[MyLifespanState]) -> str: ...
 
 `SUPPORTED_PROTOCOL_VERSIONS` is deprecated — it's now the union of `HANDSHAKE_PROTOCOL_VERSIONS` (initialize-handshake versions) and `MODERN_PROTOCOL_VERSIONS` (per-request-envelope versions). If you were using it to mean "versions the initialize handshake accepts", switch to `HANDSHAKE_PROTOCOL_VERSIONS`.
 
+`LATEST_PROTOCOL_VERSION` now reflects the newest protocol revision the SDK supports (`2026-07-28`). Code that used it to mean "the version `.initialize()` offers" should switch to `HANDSHAKE_PROTOCOL_VERSIONS[-1]`.
+
 ### `ProgressContext` and `progress()` context manager removed
 
 The `mcp.shared.progress` module (`ProgressContext`, `Progress`, and the `progress()` context manager) has been removed. This module had no real-world adoption — all users send progress notifications via `Context.report_progress()` or `session.send_progress_notification()` directly.
@@ -1301,6 +1303,12 @@ warnings.filterwarnings("ignore", category=MCPDeprecationWarning)
 
 No migration is required during the deprecation window. New code should avoid building on these features, since they may be removed in a future spec version.
 
+### Client-to-server progress deprecated (2026-07-28)
+
+The 2026-07-28 spec restricts `notifications/progress` to the server-to-client direction only — `ProgressNotification` is no longer in `ClientNotification`. `Client.send_progress_notification()` and `ClientSession.send_progress_notification()` now carry `typing_extensions.deprecated` and emit `mcp.MCPDeprecationWarning` at runtime. They continue to work against servers negotiating 2025-11-25 or earlier.
+
+On the server side, prefer the new dispatcher-agnostic `ServerSession.report_progress(progress, total, message)` (and `Context.report_progress()` on `MCPServer`) over the raw `ServerSession.send_progress_notification(progress_token, …)`. `report_progress` encapsulates the "no-op when the caller did not request progress" rule and works on every dispatcher; the raw token-taking form remains for handlers that read `_meta.progressToken` directly.
+
 ## Bug Fixes
 
 ### OAuth metadata URLs no longer gain a trailing slash

pyproject.toml

@@ -217,6 +217,9 @@ filterwarnings = [
     # them internally (e.g. `ctx.debug` -> `log` -> `send_log_message`), so the
     # advisory warning is silenced. Tests asserting it opt back in with pytest.warns.
     "ignore:.*is deprecated as of 2026-07-28 \\(SEP-2577\\).:mcp.MCPDeprecationWarning",
+    # 2026-07-28 restricts progress to server->client; the client send path is
+    # advisory-deprecated and a handful of tests still exercise it.
+    "ignore:Client-to-server progress is deprecated as of 2026-07-28.*:mcp.MCPDeprecationWarning",
 ]
 
 [tool.markdown.lint]

src/mcp/client/client.py

@@ -239,6 +239,10 @@ async def send_ping(self, *, meta: RequestParamsMeta | None = None) -> EmptyResu
         """Send a ping request to the server."""
         return await self.session.send_ping(meta=meta)
 
+    @deprecated(
+        "Client-to-server progress is deprecated as of 2026-07-28; progress is server-to-client only.",
+        category=MCPDeprecationWarning,
+    )
     async def send_progress_notification(
         self,
         progress_token: str | int,
@@ -247,7 +251,7 @@ async def send_progress_notification(
         message: str | None = None,
     ) -> None:
         """Send a progress notification to the server."""
-        await self.session.send_progress_notification(
+        await self.session.send_progress_notification(  # pyright: ignore[reportDeprecated]
             progress_token=progress_token,
             progress=progress,
             total=total,

src/mcp/client/session.py

@@ -72,6 +72,7 @@ def stamp(data: dict[str, Any], opts: CallOptions) -> None:
         headers = opts.setdefault("headers", {})
         headers[MCP_PROTOCOL_VERSION_HEADER] = protocol_version
         headers[MCP_METHOD_HEADER] = data["method"]
+        # TODO: also emit Mcp-Name for prompts/get (params.name) and resources/read (params.uri)
         if data["method"] == "tools/call" and isinstance(name := params.get("name"), str):
             headers[MCP_NAME_HEADER] = encode_header_value(name)
 
@@ -451,6 +452,10 @@ async def send_ping(self, *, meta: RequestParamsMeta | None = None) -> types.Emp
         """Send a ping request."""
         return await self.send_request(types.PingRequest(params=types.RequestParams(_meta=meta)), types.EmptyResult)
 
+    @deprecated(
+        "Client-to-server progress is deprecated as of 2026-07-28; progress is server-to-client only.",
+        category=MCPDeprecationWarning,
+    )
     async def send_progress_notification(
         self,
         progress_token: str | int,

src/mcp/server/mcpserver/context.py

@@ -94,18 +94,7 @@ async def report_progress(self, progress: float, total: float | None = None, mes
             total: Optional total value (e.g., 100)
             message: Optional message (e.g., "Starting render...")
         """
-        progress_token = self.request_context.meta.get("progress_token") if self.request_context.meta else None
-
-        if progress_token is None:
-            return
-
-        await self.request_context.session.send_progress_notification(
-            progress_token=progress_token,
-            progress=progress,
-            total=total,
-            message=message,
-            related_request_id=self.request_id,
-        )
+        await self.request_context.session.report_progress(progress, total, message)
 
     async def read_resource(self, uri: str | AnyUrl) -> Iterable[ReadResourceContents]:
         """Read a resource by URI.

src/mcp/server/session.py

@@ -14,7 +14,7 @@
 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, Outbound, ProgressFnT
+from mcp.shared.dispatcher import CallOptions, DispatchContext, ProgressFnT
 from mcp.shared.exceptions import MCPDeprecationWarning
 from mcp.shared.message import ServerMessageMetadata
 from mcp.types import methods as _methods
@@ -36,7 +36,7 @@ class ServerSession:
     never crosses the `Outbound` Protocol.
     """
 
-    def __init__(self, request_outbound: Outbound, connection: Connection) -> None:
+    def __init__(self, request_outbound: DispatchContext[Any], connection: Connection) -> None:
         self._request_outbound = request_outbound
         self._connection = connection
 
@@ -353,6 +353,16 @@ async def send_ping(self) -> types.EmptyResult:
             types.EmptyResult,
         )
 
+    async def report_progress(self, progress: float, total: float | None = None, message: str | None = None) -> None:
+        """Report progress for the inbound request this session is scoped to.
+
+        A no-op when the caller did not request progress. Dispatcher-agnostic:
+        on JSON-RPC the held `DispatchContext` emits ``notifications/progress``
+        against the caller's token; on the in-process direct dispatcher it
+        invokes the caller's callback directly.
+        """
+        await self._request_outbound.progress(progress, total, message)
+
     async def send_progress_notification(
         self,
         progress_token: str | int,

src/mcp/shared/message.py

@@ -37,9 +37,6 @@ class ServerMessageMetadata:
     # transports, None for stdio). Typed as Any because the server layer is
     # transport-agnostic.
     request_context: Any = None
-    # Per-message protocol version observed by the transport (e.g. the
-    # validated MCP-Protocol-Version header).
-    protocol_version: str | None = None
     # Callback to close SSE stream for the current request without terminating
     close_sse_stream: CloseSSEStreamCallback | None = None
     # Callback to close the standalone GET SSE stream (for unsolicited notifications)

src/mcp/types/_types.py

@@ -22,7 +22,7 @@
 
 from mcp.types.jsonrpc import RequestId
 
-LATEST_PROTOCOL_VERSION: Final[str] = "2025-11-25"
+LATEST_PROTOCOL_VERSION: Final[str] = "2026-07-28"
 """The newest protocol version this SDK can negotiate.
 
 See https://modelcontextprotocol.io/specification/latest.

tests/client/test_client.py

@@ -17,6 +17,7 @@
 from mcp.client.streamable_http import streamable_http_client
 from mcp.server import Server, ServerRequestContext
 from mcp.server.mcpserver import MCPServer
+from mcp.shared.version import HANDSHAKE_PROTOCOL_VERSIONS
 from mcp.types import (
     CallToolResult,
     EmptyResult,
@@ -118,7 +119,7 @@ async def test_client_is_initialized(app: MCPServer):
 async def test_client_initialize_result_exposes_negotiated_protocol_version(app: MCPServer):
     """The negotiated protocol version is readable after initialization."""
     async with Client(app) as client:
-        assert client.initialize_result.protocol_version == types.LATEST_PROTOCOL_VERSION
+        assert client.initialize_result.protocol_version == HANDSHAKE_PROTOCOL_VERSIONS[-1]
 
 
 async def test_client_with_simple_server(simple_server: Server):
@@ -241,7 +242,7 @@ async def handle_progress(ctx: ServerRequestContext, params: types.ProgressNotif
     server = Server(name="test_server", on_progress=handle_progress)
 
     async with Client(server) as client:
-        await client.send_progress_notification(progress_token="token123", progress=50.0)
+        await client.send_progress_notification(progress_token="token123", progress=50.0)  # pyright: ignore[reportDeprecated]
         await event.wait()
         assert received_from_client == snapshot({"progress_token": "token123", "progress": 50.0})
 

tests/client/test_session.py

@@ -23,7 +23,6 @@
     CONNECTION_CLOSED,
     INTERNAL_ERROR,
     INVALID_PARAMS,
-    LATEST_PROTOCOL_VERSION,
     METHOD_NOT_FOUND,
     PROTOCOL_VERSION_META_KEY,
     REQUEST_TIMEOUT,
@@ -88,7 +87,7 @@ async def mock_server():
         assert isinstance(request, InitializeRequest)
 
         result = InitializeResult(
-            protocol_version=LATEST_PROTOCOL_VERSION,
+            protocol_version=HANDSHAKE_PROTOCOL_VERSIONS[-1],
             capabilities=ServerCapabilities(
                 logging=None,
                 resources=None,
@@ -141,7 +140,7 @@ async def message_handler(  # pragma: no cover
 
     # Assert the result
     assert isinstance(result, InitializeResult)
-    assert result.protocol_version == LATEST_PROTOCOL_VERSION
+    assert result.protocol_version == HANDSHAKE_PROTOCOL_VERSIONS[-1]
     assert isinstance(result.capabilities, ServerCapabilities)
     assert result.server_info == Implementation(name="mock-server", version="0.1.0")
     assert result.instructions == "The server instructions."
@@ -172,7 +171,7 @@ async def mock_server():
         received_client_info = request.params.client_info
 
         result = InitializeResult(
-            protocol_version=LATEST_PROTOCOL_VERSION,
+            protocol_version=HANDSHAKE_PROTOCOL_VERSIONS[-1],
             capabilities=ServerCapabilities(),
             server_info=Implementation(name="mock-server", version="0.1.0"),
         )
@@ -229,7 +228,7 @@ async def mock_server():
         received_client_info = request.params.client_info
 
         result = InitializeResult(
-            protocol_version=LATEST_PROTOCOL_VERSION,
+            protocol_version=HANDSHAKE_PROTOCOL_VERSIONS[-1],
             capabilities=ServerCapabilities(),
             server_info=Implementation(name="mock-server", version="0.1.0"),
         )
@@ -278,8 +277,8 @@ async def mock_server():
         )
         assert isinstance(request, InitializeRequest)
 
-        # Verify client sent the latest protocol version
-        assert request.params.protocol_version == LATEST_PROTOCOL_VERSION
+        # Verify client offers the newest handshake protocol version
+        assert request.params.protocol_version == HANDSHAKE_PROTOCOL_VERSIONS[-1]
 
         # Server responds with a supported older version
         result = InitializeResult(
@@ -387,7 +386,7 @@ async def mock_server():
         received_capabilities = request.params.capabilities
 
         result = InitializeResult(
-            protocol_version=LATEST_PROTOCOL_VERSION,
+            protocol_version=HANDSHAKE_PROTOCOL_VERSIONS[-1],
             capabilities=ServerCapabilities(),
             server_info=Implementation(name="mock-server", version="0.1.0"),
         )
@@ -458,7 +457,7 @@ async def mock_server():
         received_capabilities = request.params.capabilities
 
         result = InitializeResult(
-            protocol_version=LATEST_PROTOCOL_VERSION,
+            protocol_version=HANDSHAKE_PROTOCOL_VERSIONS[-1],
             capabilities=ServerCapabilities(),
             server_info=Implementation(name="mock-server", version="0.1.0"),
         )
@@ -537,7 +536,7 @@ async def mock_server():
         received_capabilities = request.params.capabilities
 
         result = InitializeResult(
-            protocol_version=LATEST_PROTOCOL_VERSION,
+            protocol_version=HANDSHAKE_PROTOCOL_VERSIONS[-1],
             capabilities=ServerCapabilities(),
             server_info=Implementation(name="mock-server", version="0.1.0"),
         )
@@ -605,7 +604,7 @@ async def mock_server():
         assert isinstance(request, InitializeRequest)
 
         result = InitializeResult(
-            protocol_version=LATEST_PROTOCOL_VERSION,
+            protocol_version=HANDSHAKE_PROTOCOL_VERSIONS[-1],
             capabilities=expected_capabilities,
             server_info=expected_server_info,
             instructions=expected_instructions,
@@ -644,7 +643,7 @@ async def mock_server():
         assert result.server_info == expected_server_info
         assert result.capabilities == expected_capabilities
         assert result.instructions == expected_instructions
-        assert result.protocol_version == LATEST_PROTOCOL_VERSION
+        assert result.protocol_version == HANDSHAKE_PROTOCOL_VERSIONS[-1]
 
 
 @pytest.mark.anyio
@@ -667,7 +666,7 @@ async def mock_server():
         assert isinstance(request, InitializeRequest)
 
         result = InitializeResult(
-            protocol_version=LATEST_PROTOCOL_VERSION,
+            protocol_version=HANDSHAKE_PROTOCOL_VERSIONS[-1],
             capabilities=ServerCapabilities(),
             server_info=Implementation(name="mock-server", version="0.1.0"),
         )
@@ -1348,7 +1347,7 @@ async def send_raw_request(
             self.calls.append((method, opts or {}))
             if method == "initialize":
                 return InitializeResult(
-                    protocol_version=LATEST_PROTOCOL_VERSION,
+                    protocol_version=HANDSHAKE_PROTOCOL_VERSIONS[-1],
                     capabilities=ServerCapabilities(),
                     server_info=Implementation(name="mock-server", version="0.1.0"),
                 ).model_dump(by_alias=True, mode="json", exclude_none=True)