Remove the Posture setting; always serve both protocol eras

Delete the Posture enum, its export, and the posture= constructor
parameter on Server and MCPServer. The lowlevel Server is a registry
of handlers and carries no serving configuration; a server offers both
the 2025 handshake era and the 2026 per-request era on every transport,
and each stream connection's era is decided by the client's opening
message, as the default already did.

_StreamConnection no longer takes a starting era; it starts undecided
and pins on the first era-distinctive message. The streamable-HTTP
manager's header routing is unchanged: streams it has already routed
to the handshake era are entered born-legacy through the transport-
internal serve_legacy_stream, so the legacy leg keeps refusing
enveloped requests with -32600 exactly as before.

The MODERN_ONLY / LEGACY_ONLY tests and doc sections go with it, and
the streamable-HTTP orphan test file is renamed now that its posture
half is gone.

Author: maxisbey

docs/advanced/low-level-server.md

@@ -223,10 +223,7 @@ async with server.lifespan() as state, anyio.create_task_group() as tg:
 
 The lifespan is entered **outside** the task group on purpose: on the way out the task group joins the still-running connection tasks first and only then does the lifespan tear down, so the shared pool outlives every connection using it (the other order tears the pool down while connections are still being served).
 
-Two things about the shared-`Server` shape that the single-connection rungs never surface:
-
-* Which protocol eras a server offers is `Server(posture=...)` (`Posture.DUAL` by default, `Posture.MODERN_ONLY`, `Posture.LEGACY_ONLY`); it rides along on the server object, so none of these drivers takes a posture argument you could forget.
-* The cross-connection listen behaviour called out under `serve_listener` above applies to any shared `Server`, including this rung; the per-connection-`Server` recipe there is how you sidestep it.
+One thing about the shared-`Server` shape that the single-connection rungs never surface: the cross-connection listen behaviour called out under `serve_listener` above applies to any shared `Server`, including this rung; the per-connection-`Server` recipe there is how you sidestep it.
 
 An `MCPServer` reaches every one of these through `mcp.lowlevel_server`, and `mcp.close_subscriptions()` (or `Server.close_subscriptions()` down here) ends the open listen streams gracefully from the server's side.
 

docs/migration.md

@@ -1363,17 +1363,7 @@ The concrete dispatcher's `inline_methods=` constructor keyword is also gone: th
 
 `server/discover` no longer pins the connection to the modern era: it is a probe, answered with modern semantics, and the era is decided by the first non-probe message. A client whose discover probe was answered can therefore still fall back to `initialize` on the same connection, and `subscriptions/listen` is now served over stdio and every other duplex stream (previously refused with `-32601`).
 
-A stray leading notification (for example a client's `notifications/roots/list_changed`) no longer decides the era: only `initialize` (or a bare pre-handshake request) opens the legacy era, only `notifications/initialized` opens it among notifications, and any other early notification is ignored, so a 2026 client is never pinned to the legacy era by a courtesy frame it sent first. A legacy-committed connection also now refuses a request that carries the modern envelope with `-32600` instead of processing it under legacy semantics, and `initialize` is answered `-32022` (naming the modern versions the server serves) whenever it reaches the modern side, on every transport.
-
-The new `posture` constructor parameter on `Server` and `MCPServer` narrows which eras a server offers, on stream transports and streamable HTTP alike:
-
-```python
-from mcp.server import Posture, Server
-
-server = Server("app", posture=Posture.MODERN_ONLY)  # or Posture.LEGACY_ONLY; Posture.DUAL is the default
-```
-
-A `MODERN_ONLY` server answers a 2025 handshake with `-32022` and its supported versions (on stdio and streamable HTTP); a `LEGACY_ONLY` server refuses envelope-bearing requests in legacy vocabulary and never enters the modern era. Posture is the one place a server restricts its eras; the walkthrough is in [Serving one era only](run/legacy-clients.md#serving-one-era-only).
+A stray leading notification (for example a client's `notifications/roots/list_changed`) no longer decides the era: only `initialize` (or a bare pre-handshake request) opens the legacy era, only `notifications/initialized` opens it among notifications, and any other early notification is ignored, so a 2026 client is never pinned to the legacy era by a courtesy frame it sent first. A legacy-committed connection also now refuses a request that carries the modern envelope with `-32600` instead of processing it under legacy semantics, and `initialize` is answered `-32022` (naming the modern versions the server serves) whenever it reaches the modern side, on every transport. Every server offers both eras on every transport; there is no era switch on `Server` or `MCPServer`.
 
 At stdin EOF a stdio server now winds down gracefully: it gives in-flight requests a short bounded window to finish, ends every open `subscriptions/listen` stream with its empty `SubscriptionsListenResult` (the spec's graceful closure), and then writes nothing further onto a stdout nobody reads. In particular, an in-flight request no longer receives a `CONNECTION_CLOSED` error at EOF, since the peer that would read it is gone.
 

docs/run/legacy-clients.md

@@ -9,14 +9,11 @@ The SDK routes every request by its `MCP-Protocol-Version` header. A request nam
 So a legacy client is not something you build *for*. It is something that connects *to* the server you already wrote. You configure nothing.
 
 !!! note
-    Nothing on the transport, literally. There is no `legacy=` option and no version
-    allowlist on `streamable_http_app()`, `run()`, or the session manager; by default both
-    eras are always on, and the version header routes each request to the right one. The one
-    place a server can restrict eras is its own posture:
-    `MCPServer(name, posture=Posture.LEGACY_ONLY)` (or `MODERN_ONLY`) is a constructor
-    property every transport honours (see **[Serving one era only](#serving-one-era-only)**),
-    and the default `DUAL` is this page's assumption. The nearest thing to a per-request
-    switch in the HTTP signature is `stateless_http`, and it is most of this page.
+    Nothing on the transport, and nothing on the server either. There is no `legacy=` option
+    and no version allowlist on `MCPServer`, `Server`, `streamable_http_app()`, `run()`, or the
+    session manager; both eras are always on, and the version header routes each request to
+    the right one. The nearest thing to a per-request switch in the HTTP signature is
+    `stateless_http`, and it is most of this page.
 
 ## One handler, both eras
 
@@ -114,25 +111,9 @@ Over HTTP, neither call reaches the other era's clients. To tell everyone, call
 
 Two lines, no `if`, no version check, and you are done. That is the entire list of things a handler does differently because a legacy client exists.
 
-## Serving one era only
-
-Everything above assumes the default: your server offers both eras. That default is a constructor property called the server's **posture**, and it is the one place you narrow it:
-
-```python
-from mcp.server import Posture
-from mcp.server.mcpserver import MCPServer
-
-mcp = MCPServer("Bookshop", posture=Posture.MODERN_ONLY)
-```
-
-`Posture.DUAL` is the default and the whole rest of this page. `Posture.MODERN_ONLY` retires the handshake era: a pre-2026 client's `initialize` is answered with a `-32022` error naming the modern versions the server does speak, so a well-behaved client learns to go modern rather than being silently dropped. `Posture.LEGACY_ONLY` is the mirror image, a server that speaks only the `initialize` handshake and refuses requests carrying the modern envelope. The low-level `Server` takes the same argument.
-
-Posture lives on the server object, not on any driver, so `run()`, `streamable_http_app()`, and the stream drivers all honour the same declaration and there is no per-transport switch to keep in step. Reach for it deliberately: `MODERN_ONLY` turns away every deployed pre-2026 client, and `LEGACY_ONLY` turns away 2026 ones, so `DUAL` is what you want unless you know exactly who connects.
-
 ## Recap
 
-* One `streamable_http_app()` serves both protocol eras. The SDK routes each request by its `MCP-Protocol-Version` header; there is nothing to configure on the transport and no per-request era knob to look for.
-* The one era switch is the server's posture: `MCPServer(name, posture=Posture.MODERN_ONLY)` or `LEGACY_ONLY`, a constructor property every transport honours. The default `DUAL` is what this whole page assumes.
+* One `streamable_http_app()` (and one stdio server) serves both protocol eras, always. The SDK routes each request by its `MCP-Protocol-Version` header, and a stream connection's era is decided by the client's opening message; there is nothing to configure on the transport or the server and no era switch to look for.
 * A legacy client costs you a session: an in-process `Mcp-Session-Id` record with no distributed store behind it. More than one worker means **sticky routing**, or the wrong worker answers `404 Session not found`. **[Deploy & scale](deploy.md)** has the multi-worker story.
 * `stateless_http=True` is the one knob, and it is **legacy-leg-only**. It buys free load balancing for legacy clients at the price of both server-to-client channels on that leg: server-initiated requests raise `NoBackChannelError` (a top-level error at the client, not an `is_error` result), and notifications are dropped.
 * A `2026-07-28` connection is sessionless either way. `stateless_http` never touches it.

docs/whats-new.md

@@ -153,7 +153,7 @@ Each of these is a section in the **[Migration Guide](migration.md)**:
 
 ## The protocol: 2025-11-25 to 2026-07-28
 
-v2 implements the 2026-07-28 revision, and it serves **both** revisions at once: the same `streamable_http_app()` (and the same stdio server) answers a 2025-era client's `initialize` and a 2026-era client's requests with nothing to configure, no flag to flip, and no separate deployment. Serving the new revision does not strand a client on the old one. If you want to serve only one revision, that is a single constructor property, `Server(posture=...)` / `MCPServer(posture=...)`, honoured by every transport; see [Serving one era only](run/legacy-clients.md#serving-one-era-only). What follows is what the new revision itself changes.
+v2 implements the 2026-07-28 revision, and it serves **both** revisions at once: the same `streamable_http_app()` (and the same stdio server) answers a 2025-era client's `initialize` and a 2026-era client's requests with nothing to configure, no flag to flip, and no separate deployment. Serving the new revision does not strand a client on the old one. What follows is what the new revision itself changes.
 
 ### No handshake, no session
 

src/mcp/server/__init__.py

@@ -3,7 +3,7 @@
 from .lowlevel import NotificationOptions, Server
 from .mcpserver import MCPServer
 from .models import InitializationOptions
-from .serving import Posture, serve_listener, serve_stream
+from .serving import serve_listener, serve_stream
 
 __all__ = [
     "CacheHint",
@@ -12,7 +12,6 @@
     "MCPServer",
     "NotificationOptions",
     "InitializationOptions",
-    "Posture",
     "serve_listener",
     "serve_stream",
 ]

src/mcp/server/lowlevel/server.py

@@ -58,7 +58,7 @@ async def main():
 from mcp.server.caching import CacheableMethod, CacheHint, validate_cache_hints
 from mcp.server.context import HandlerResult, ServerMiddleware, ServerRequestContext
 from mcp.server.models import InitializationOptions
-from mcp.server.serving import Posture, serve_stream
+from mcp.server.serving import serve_stream
 from mcp.server.streamable_http import EventStore
 from mcp.server.streamable_http_manager import (
     DEFAULT_MAX_REQUEST_BODY_SIZE,
@@ -143,7 +143,6 @@ def __init__(
         website_url: str | None = None,
         icons: list[types.Icon] | None = None,
         cache_hints: Mapping[CacheableMethod, CacheHint] | None = None,
-        posture: Posture = Posture.DUAL,
         lifespan: Callable[
             [Server[LifespanResultT]],
             AbstractAsyncContextManager[LifespanResultT],
@@ -227,7 +226,6 @@ def __init__(
         website_url: str | None = None,
         icons: list[types.Icon] | None = None,
         cache_hints: Mapping[CacheableMethod, CacheHint] | None = None,
-        posture: Posture = Posture.DUAL,
         lifespan: Callable[
             [Server[LifespanResultT]],
             AbstractAsyncContextManager[LifespanResultT],
@@ -320,7 +318,6 @@ def __init__(
         website_url: str | None = None,
         icons: list[types.Icon] | None = None,
         cache_hints: Mapping[CacheableMethod, CacheHint] | None = None,
-        posture: Posture = Posture.DUAL,
         lifespan: Callable[
             [Server[LifespanResultT]],
             AbstractAsyncContextManager[LifespanResultT],
@@ -428,8 +425,6 @@ def __init__(
         self.instructions = instructions
         self.website_url = website_url
         self.icons = icons
-        # Which protocol eras this server offers, on every transport.
-        self.posture: Posture = posture
         # Per-method `ttl_ms`/`cache_scope` fills, applied by `ServerRunner`
         # after the handler returns; fields the handler set explicitly win.
         self.cache_hints: dict[str, CacheHint] = validate_cache_hints(cache_hints)
@@ -716,8 +711,8 @@ async def run(
         """Serve one connection over a duplex message stream until the read side closes.
 
         Enters the server's lifespan, lets the client's opening message pick
-        the connection's protocol era (subject to `self.posture`), and serves
-        that era until EOF; `initialization_options` defaults to
+        the connection's protocol era, and serves that era until EOF;
+        `initialization_options` defaults to
         `create_initialization_options()`. For a socket host use `serve_listener`;
         for connections sharing a lifespan, `serve_stream(..., lifespan_state=)`.
         """

src/mcp/server/mcpserver/server.py

@@ -84,7 +84,6 @@
 from mcp.server.mcpserver.utilities.context_injection import find_context_parameter
 from mcp.server.mcpserver.utilities.logging import configure_logging, get_logger
 from mcp.server.request_state import RequestStateBoundary, RequestStateSecurity
-from mcp.server.serving import Posture
 from mcp.server.sse import SseServerTransport
 from mcp.server.stdio import stdio_server
 from mcp.server.streamable_http import EventStore
@@ -185,7 +184,6 @@ def __init__(
         request_state_security: RequestStateSecurity | None = None,
         cache_hints: Mapping[CacheableMethod, CacheHint] | None = None,
         subscriptions: SubscriptionBus | None = None,
-        posture: Posture = Posture.DUAL,
     ):
         self._resource_security = resource_security
         self.settings = Settings(
@@ -219,7 +217,6 @@ def __init__(
             icons=icons,
             version=version,
             cache_hints=cache_hints,
-            posture=posture,
             on_list_tools=self._handle_list_tools,
             on_call_tool=self._handle_call_tool,
             on_list_resources=self._handle_list_resources,

src/mcp/server/serving.py

@@ -1,16 +1,14 @@
 """Serving a `Server` over a duplex message stream (stdio, SSE, custom sockets).
 
-`serve_stream` is the driver for stream transports. The client's opening
-messages decide the connection's protocol era, in receive order, among those
-`Server(posture=)` offers, and that era serves every later message; `Posture`
-names which eras a server offers at all.
+`serve_stream` is the driver for stream transports. A server offers both
+protocol eras on every connection; the client's opening messages decide the
+connection's era, in receive order, and that era serves every later message.
 """
 
 from __future__ import annotations
 
 import logging
 from collections.abc import Awaitable, Mapping
-from enum import Enum
 from typing import TYPE_CHECKING, Any, Generic, Literal
 
 import anyio
@@ -34,7 +32,7 @@
 if TYPE_CHECKING:
     from mcp.server.lowlevel.server import Server
 
-__all__ = ["Posture", "serve_listener", "serve_stream"]
+__all__ = ["serve_listener", "serve_stream"]
 
 logger = logging.getLogger(__name__)
 
@@ -47,19 +45,6 @@
 """The one notification that completes a legacy handshake and so opens the legacy era."""
 
 
-class Posture(Enum):
-    """Which protocol eras a server offers on a connection; `DUAL` lets the opening message decide."""
-
-    DUAL = "dual"
-    """Both eras: the legacy `initialize` handshake and the modern per-request envelope."""
-
-    LEGACY_ONLY = "legacy-only"
-    """Only the legacy `initialize` handshake era."""
-
-    MODERN_ONLY = "modern-only"
-    """Only the modern per-request-envelope era (2026-07-28+)."""
-
-
 class _Unset:
     """Sentinel type for an omitted `lifespan_state` (`None` is a valid state)."""
 
@@ -159,8 +144,8 @@ async def _ignore_stray_notification() -> None:
 class _StreamConnection(Generic[LifespanT]):
     """One duplex stream connection: admits every message and routes it to the connection's era.
 
-    `_era` starts from the server's posture and, under `DUAL`, is decided once, in
-    receive order, by the first era-distinctive message the dispatcher admits.
+    `_era` starts undecided and is decided once, in receive order, by the first
+    era-distinctive message the dispatcher admits.
     """
 
     def __init__(
@@ -169,7 +154,6 @@ def __init__(
         read_stream: ReadStream[SessionMessage | Exception],
         write_stream: WriteStream[SessionMessage],
         *,
-        posture: Posture,
         lifespan_state: LifespanT,
         init_options: InitializationOptions | None,
         session_id: str | None,
@@ -188,13 +172,7 @@ def __init__(
             ServerRunner(server, loop_connection, lifespan_state, init_options=init_options)
         )
         self._modern: _ModernEra[LifespanT] = _ModernEra(server, lifespan_state, NotifyOnlyOutbound(self._dispatcher))
-        # Posture is consumed here, once: which eras exist for this connection.
-        starting_era: dict[Posture, _LegacyEra[LifespanT] | _ModernEra[LifespanT] | None] = {
-            Posture.DUAL: None,
-            Posture.LEGACY_ONLY: self._legacy,
-            Posture.MODERN_ONLY: self._modern,
-        }
-        self._era: _LegacyEra[LifespanT] | _ModernEra[LifespanT] | None = starting_era[posture]
+        self._era: _LegacyEra[LifespanT] | _ModernEra[LifespanT] | None = None
 
     def _transport_context(self, _metadata: MessageMetadata) -> TransportContext:
         # Admission has already decided this frame's era; only the legacy era
@@ -239,6 +217,11 @@ def _admit_notification(self, method: str, params: Mapping[str, Any] | None) ->
             self._era = self._legacy
         return False
 
+    def open_legacy_era(self) -> None:
+        """Open the legacy era before any message: the transport routed this stream to
+        the handshake era ahead of its first frame (streamable HTTP's stateful sessions)."""
+        self._era = self._legacy
+
     def _on_request(
         self, dctx: DispatchContext[TransportContext], method: str, params: Mapping[str, Any] | None
     ) -> Awaitable[dict[str, Any]]:
@@ -274,8 +257,8 @@ async def serve_stream(
     """Serve `server` over a duplex message stream until the read side closes.
 
     The driver for stream transports: the client's opening messages decide the
-    connection's era among those `server.posture` offers. Enters
-    `server.lifespan()` unless `lifespan_state` is given.
+    connection's era. Enters `server.lifespan()` unless `lifespan_state` is
+    given.
 
     Args:
         initialization_options: The legacy handshake's `InitializeResult`
@@ -301,7 +284,6 @@ async def serve_stream(
         server,
         read_stream,
         write_stream,
-        posture=server.posture,
         lifespan_state=lifespan_state,
         init_options=initialization_options,
         session_id=None,
@@ -327,12 +309,12 @@ async def serve_legacy_stream(
         server,
         read_stream,
         write_stream,
-        posture=Posture.LEGACY_ONLY,
         lifespan_state=lifespan_state,
         init_options=None,
         session_id=session_id,
         raise_exceptions=False,
     )
+    connection.open_legacy_era()
     await connection.run()