Always stamp serverInfo; drop the include_server_info opt-out

The spec's opt-out language ("unless specifically configured not to do
so") is already expressible at the layer that owns response envelopes:
a middleware that strips the key from the results it passes along. A
dedicated constructor flag duplicated that mechanism, so it is removed;
neither the go nor the typescript SDK shipped one. The interaction
matrix now pins a server version and strips the stamp at comparison
sites (tests/_stamp.unstamped) instead of running a non-default config.

Also from review:

- server_info_stamp returns a deep copy per access: the cached dump's
  nested values (icons) previously aliased into every stamped response,
  so mutating one response's stamp corrupted all later ones.
- The claimed-shape sieve bypass is now modern-only: a resultType
  outside the core vocabulary on a legacy session fails the per-version
  surface (INTERNAL_ERROR) instead of leaking a shape legacy clients
  cannot resolve.
- The validated params argument of Extension.intercept_tool_call is
  documented as authoritative: a context rewrite through call_next
  adjusts what the handler observes, not which tool call runs (pinned
  by test).

Author: maxisbey

docs/advanced/low-level-server.md

@@ -107,7 +107,7 @@ Call it and the result carries both representations:
 }
 ```
 
-The `_meta` block is the server's identity stamp: the SDK adds it to every 2026-era result, with the `version` taken from the constructor or the installed package. Pass `include_server_info=False` to the server to turn it off.
+The `_meta` block is the server's identity stamp: the SDK adds it to every 2026-era result, with the `version` taken from the constructor or the installed package. A server that must not identify itself can strip the key with a middleware, which owns the results it returns.
 
 The server never compares the two fields. This SDK's `Client` does: return `structured_content` that doesn't satisfy the `output_schema` you declared and `call_tool` raises a `RuntimeError` that starts with `Invalid structured content returned by tool search_books` and goes on to quote the `jsonschema` failure. Promising a schema is cheap; keeping it is on you. The whole ladder of return types and schemas is in **[Structured Output](../servers/structured-output.md)**.
 

docs/migration.md

@@ -481,13 +481,14 @@ What changed in the SDK:
 
 - `DiscoverResult` no longer has a `server_info` field. Read or write identity
   through result `_meta`; the key is exported as `mcp_types.SERVER_INFO_META_KEY`.
-- Servers stamp `serverInfo` into every 2026-era result's `_meta` by default,
-  built from the constructor identity fields (`name`, `version`, `title`, and
-  so on). Pass `include_server_info=False` to `Server(...)` or `MCPServer(...)`
-  to turn it off. A `serverInfo` value your handler already set in `_meta` is
-  never overwritten. Handshake-era responses are unchanged, and notifications
-  and error responses are never stamped. A middleware that answers a request
-  itself (without `call_next`) owns its result envelope, stamp included.
+- Servers stamp `serverInfo` into every 2026-era result's `_meta`, built from
+  the constructor identity fields (`name`, `version`, `title`, and so on). A
+  `serverInfo` value your handler already set in `_meta` is never overwritten.
+  Handshake-era responses are unchanged, and notifications and error responses
+  are never stamped. A middleware that answers a request itself (without
+  `call_next`) owns its result envelope, stamp included; a server that must
+  not identify itself can strip the key the same way, with a middleware that
+  removes it from the results it passes along.
 - `client.server_info` and `session.server_info` are `Implementation | None`
   on 2026-era connections: identity is optional on the wire, so a server that
   does not stamp it reads as `None`. Handshake-era connections still always

docs/whats-new.md

@@ -197,7 +197,7 @@ At 2026-07-28 the standalone HTTP GET stream and `resources/subscribe` are repla
 
 ### The rest, quickly
 
-* **Identity is optional, per-message metadata.** The request-side `clientInfo` `_meta` key is optional (the required pair is `protocolVersion` + `clientCapabilities`), and `serverInfo` moved out of the `server/discover` result body: servers stamp it into every 2026-era result's `_meta` instead (since `2.0.0b3`; [spec #3002](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/3002)). The SDK stamps by default and `include_server_info=False` turns it off; `client.server_info` is `None` when a server chooses not to identify itself. The **[Migration Guide](migration.md#server-identity-moved-from-the-serverdiscover-result-body-to-result-_meta)** has the details.
+* **Identity is optional, per-message metadata.** The request-side `clientInfo` `_meta` key is optional (the required pair is `protocolVersion` + `clientCapabilities`), and `serverInfo` moved out of the `server/discover` result body: servers stamp it into every 2026-era result's `_meta` instead (since `2.0.0b3`; [spec #3002](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/3002)). The SDK always stamps; `client.server_info` is `None` when a server does not identify itself (for example, a middleware stripped the key). The **[Migration Guide](migration.md#server-identity-moved-from-the-serverdiscover-result-body-to-result-_meta)** has the details.
 * **Requests are routable without parsing bodies.** Modern HTTP requests carry `Mcp-Method` (and, for the three tool-ish calls, `Mcp-Name`); a tool input-schema property annotated with `x-mcp-header` is mirrored into an `Mcp-Param-*` header and cross-checked by the server ([SEP-2243](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2243)). Gateways and rate limiters can route on headers alone; the **[Migration Guide](migration.md#servers-validate-mcp-param-headers-against-the-request-body-sep-2243)** has the rules.
 * **Results carry cache hints.** List and read results declare `ttlMs` and `cacheScope` ([SEP-2549](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2549)); you set them per method with `cache_hints=`, and `Client` honors them with a built-in response cache. A server that sends no hints (every pre-2026 server) sees identical, uncached traffic. **[Caching hints](client/caching.md)**.
 * **Extensions are first class.** Servers and clients declare optional capability bundles under reverse-DNS identifiers ([SEP-2133](https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2133)); the built-in `Apps` extension (MCP Apps) is the reference. **[Extensions](advanced/extensions.md)** and **[MCP Apps](advanced/apps.md)**.

src/mcp/server/context.py

@@ -116,8 +116,11 @@ async def log(self, level: LoggingLevel, data: Any, logger: str | None = None, *
 all three to a result dict."""
 
 CallNext = Callable[["ServerRequestContext[Any, Any]"], Awaitable[HandlerResult]]
-"""Invokes the rest of the chain. Pass the `ctx` through; rewrite `method` or
-`params` with `dataclasses.replace(ctx, ...)` to alter what the handler sees."""
+"""Invokes the rest of the chain with the given context. What a context
+rewrite (`dataclasses.replace(ctx, ...)`) can alter depends on the tier:
+`ServerMiddleware` runs before params validation, so its rewrites change what
+the handler is invoked with; an `Extension` interceptor runs after, so its
+rewrites change only what the handler observes on `ctx`."""
 
 _MwLifespanT = TypeVar("_MwLifespanT")
 

src/mcp/server/extension.py

@@ -147,7 +147,11 @@ async def intercept_tool_call(
         `call_next(ctx)` runs the rest of the chain and the real handler, and
         returns the handler's domain result. Interceptors run at the handler
         layer: whatever they return is serialized like any handler result,
-        including the 2026-era `serverInfo` `_meta` stamp.
+        including the 2026-era `serverInfo` `_meta` stamp. The `params` this
+        interceptor received is what the wrapped handler is invoked with -
+        passing a rewritten context through `call_next` adjusts what the
+        handler observes on `ctx`, not the tool invocation. Wire-level request
+        rewriting belongs to `Server.middleware`, above params validation.
         """
         return await call_next(ctx)
 

src/mcp/server/lowlevel/server.py

@@ -36,6 +36,7 @@ async def main():
 
 from __future__ import annotations
 
+import copy
 import logging
 import warnings
 from collections.abc import AsyncIterator, Awaitable, Callable, Mapping
@@ -147,7 +148,6 @@ def __init__(
         website_url: str | None = None,
         icons: list[types.Icon] | None = None,
         cache_hints: Mapping[CacheableMethod, CacheHint] | None = None,
-        include_server_info: bool = True,
         lifespan: Callable[
             [Server[LifespanResultT]],
             AbstractAsyncContextManager[LifespanResultT],
@@ -231,7 +231,6 @@ def __init__(
         website_url: str | None = None,
         icons: list[types.Icon] | None = None,
         cache_hints: Mapping[CacheableMethod, CacheHint] | None = None,
-        include_server_info: bool = True,
         lifespan: Callable[
             [Server[LifespanResultT]],
             AbstractAsyncContextManager[LifespanResultT],
@@ -324,7 +323,6 @@ def __init__(
         website_url: str | None = None,
         icons: list[types.Icon] | None = None,
         cache_hints: Mapping[CacheableMethod, CacheHint] | None = None,
-        include_server_info: bool = True,
         lifespan: Callable[
             [Server[LifespanResultT]],
             AbstractAsyncContextManager[LifespanResultT],
@@ -432,10 +430,6 @@ def __init__(
         self.instructions = instructions
         self.website_url = website_url
         self.icons = icons
-        # Spec 2026-07-28: servers SHOULD stamp `serverInfo` into every result's
-        # `_meta` "unless specifically configured not to do so" - this is that
-        # configuration. Consumed at the single stamping site in `ServerRunner`.
-        self.include_server_info = include_server_info
         # 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)
@@ -657,13 +651,21 @@ def server_info(self) -> types.Implementation:
         )
 
     @cached_property
+    def _server_info_stamp_source(self) -> dict[str, Any]:
+        # Identity is fixed at construction, so the dump is computed once per
+        # server instead of per request. Never handed out directly: nested
+        # values (`icons`) would alias the cache into stamped responses.
+        return self.server_info.model_dump(by_alias=True, mode="json", exclude_none=True)
+
+    @property
     def server_info_stamp(self) -> dict[str, Any]:
-        """The wire dump of `server_info`, computed once per server.
+        """A fresh wire dump of `server_info`; callers own the returned dict.
 
-        Identity is fixed at construction, so the per-result `_meta` stamping
-        site (`ServerRunner`) reads this instead of re-dumping per request.
+        Each access materializes a deep copy of the once-per-server dump, so
+        a caller mutating a stamped response can never corrupt the identity
+        stamped into later responses.
         """
-        return self.server_info.model_dump(by_alias=True, mode="json", exclude_none=True)
+        return copy.deepcopy(self._server_info_stamp_source)
 
     async def _handle_discover(
         self, ctx: ServerRequestContext[LifespanResultT], params: types.RequestParams | None

src/mcp/server/mcpserver/server.py

@@ -183,7 +183,6 @@ def __init__(
         resource_security: ResourceSecurity = DEFAULT_RESOURCE_SECURITY,
         request_state_security: RequestStateSecurity | None = None,
         cache_hints: Mapping[CacheableMethod, CacheHint] | None = None,
-        include_server_info: bool = True,
         subscriptions: SubscriptionBus | None = None,
     ):
         self._resource_security = resource_security
@@ -217,7 +216,6 @@ def __init__(
             icons=icons,
             version=version,
             cache_hints=cache_hints,
-            include_server_info=include_server_info,
             on_list_tools=self._handle_list_tools,
             on_call_tool=self._handle_call_tool,
             on_list_resources=self._handle_list_resources,

src/mcp/server/runner.py

@@ -354,14 +354,21 @@ def _serialize(self, method: str, version: str, result: HandlerResult) -> dict[s
                 # Hint keys first so wire keys the handler set win, matching `apply_cache_hint` precedence.
                 result = {"ttlMs": hint.ttl_ms, "cacheScope": hint.scope, **result}
         dumped = _dump_result(result)
-        # An extension `resultType` (outside the core vocabulary) marks a claimed
-        # shape owned by the extension that defined it: the per-version surface
-        # doesn't describe it, so the sieve applies to core results only.
+        # A modern-era extension `resultType` (outside the core vocabulary) marks
+        # a claimed shape owned by the extension that defined it: the per-version
+        # surface doesn't describe it, so the sieve applies to core results only.
+        # Legacy connections sieve everything - claimed shapes are 2026-era
+        # vocabulary and cannot be delivered on a legacy wire (mirrors the
+        # client-side ResultClaim rule).
         # TODO(L56): reject extension resultType values unless the corresponding
         # extension is in this request's _meta clientCapabilities.extensions; the
         # explicit MUST-reject is client-side (basic/index.mdx ResultType), this enforces it proactively.
         result_type = dumped.get("resultType")
-        core_shape = not isinstance(result_type, str) or result_type in CORE_RESULT_TYPES
+        core_shape = (
+            version not in MODERN_PROTOCOL_VERSIONS
+            or not isinstance(result_type, str)
+            or result_type in CORE_RESULT_TYPES
+        )
         if method in _methods.SPEC_CLIENT_METHODS and core_shape:
             try:
                 dumped = _methods.serialize_server_result(method, version, dumped)
@@ -379,17 +386,18 @@ def _stamp_server_info(self, version: str, result: dict[str, Any]) -> dict[str,
         to own, and handshake-era results are never stamped. `result` is
         pipeline-owned (`_dump_result` copies dicts; the spec-method sieve
         re-dumps), but `_meta` may still be the handler's object, so the stamp
-        replaces it rather than writing into it.
+        replaces it rather than writing into it. `server_info_stamp` is a
+        fresh dict per access, so the response never aliases server state.
         """
-        if not self.server.include_server_info or version not in MODERN_PROTOCOL_VERSIONS:
+        if version not in MODERN_PROTOCOL_VERSIONS:
             return result
         raw_meta = result.get("_meta")
         if raw_meta is None:
-            result["_meta"] = {SERVER_INFO_META_KEY: dict(self.server.server_info_stamp)}
+            result["_meta"] = {SERVER_INFO_META_KEY: self.server.server_info_stamp}
         elif isinstance(raw_meta, dict):
             meta = cast("dict[str, Any]", raw_meta)
             if meta.get(SERVER_INFO_META_KEY) is None:
-                result["_meta"] = {**meta, SERVER_INFO_META_KEY: dict(self.server.server_info_stamp)}
+                result["_meta"] = {**meta, SERVER_INFO_META_KEY: self.server.server_info_stamp}
         return result
 
     @staticmethod

tests/_stamp.py

@@ -0,0 +1,32 @@
+"""Shared helper: drop the 2026-era serverInfo `_meta` stamp from a result.
+
+Servers stamp `io.modelcontextprotocol/serverInfo` into every 2026-era
+result's `_meta` and never into handshake-era ones, and the stamp's `version`
+defaults to the installed package version. Suites that share one expected
+payload across eras (the interaction matrix) or that construct servers
+without a pinned version strip the stamp before exact comparison. Stamp
+semantics themselves have dedicated coverage in tests/server/test_runner.py.
+"""
+
+from typing import Any, TypeVar
+
+from mcp_types import SERVER_INFO_META_KEY, Result
+
+R = TypeVar("R", bound=Result)
+
+
+def unstamped(result: R) -> R:
+    """Remove the serverInfo stamp in place if present, asserting its shape.
+
+    Present-versus-absent is era-dependent and belongs to the runner tests;
+    this only guarantees that when a stamp exists it is a well-formed
+    identity object, then returns the result for inline use in comparisons.
+    """
+    meta = result.meta
+    if meta is not None and SERVER_INFO_META_KEY in meta:
+        stamp: Any = meta.pop(SERVER_INFO_META_KEY)
+        assert isinstance(stamp, dict)
+        assert "name" in stamp and "version" in stamp
+        if not meta:
+            result.meta = None
+    return result