@@ -17,10 +17,11 @@
 
 import time
 from collections.abc import Iterable, Iterator, Mapping
+from dataclasses import dataclass
 from functools import cache
 from importlib import import_module
 from types import MappingProxyType, ModuleType, UnionType
-from typing import TYPE_CHECKING, Any, Final, Literal, NamedTuple, TypeGuard, TypeVar, cast, get_args
+from typing import TYPE_CHECKING, Any, Final, Literal, TypeGuard, TypeVar, cast, get_args
 
 from pydantic import BaseModel, TypeAdapter
 
@@ -871,8 +872,13 @@ def parse_client_result(
 """Every monolith map, for `warm()`."""
 
 
-class WarmReport(NamedTuple):
-    """What one `warm()` call built (already-built work is skipped and not counted)."""
+@dataclass(frozen=True)
+class WarmReport:
+    """What one `warm()` call built (already-built work is skipped and not counted).
+
+    A frozen dataclass rather than a tuple, so a later field addition does not
+    change how existing fields are read.
+    """
 
     models: int
     """Deferred model classes whose validators this call built."""
@@ -910,7 +916,7 @@ def _warm_adapter(adapter: TypeAdapter[Any]) -> int:
     return 0 if adapter.rebuild() is None else 1
 
 
-def warm(version: str | None = None, *, everything: bool = False) -> WarmReport:
+def warm(version: str | None = None, *, all_versions: bool = False) -> WarmReport:
     """Build the SDK's deferred validators up front, before the first message needs them.
 
     Importing the SDK stays fast because pydantic validators build on first use
@@ -919,21 +925,26 @@ def warm(version: str | None = None, *, everything: bool = False) -> WarmReport:
     startup, calls this from a startup hook; nothing in the SDK calls it, and
     steady-state behaviour is identical either way.
 
-    * `warm()` builds the version-independent set: the monolith `mcp_types`
-      models a session routes through, the JSON-RPC envelopes and the
-      module-level union adapters.
-    * `warm(version)` additionally imports that protocol version's wire
-      package and builds its routing surface (the wire models and the cached
-      adapters a connection at that version routes through).
-    * `warm(everything=True)` does that for every known protocol version.
+    * `warm(version)` is what a host wants: it builds the version-independent
+      set (below) and imports that protocol version's wire package and builds
+      its routing surface (the wire models and the cached adapters a
+      connection at that version routes through), so the first connection at
+      that version builds nothing.
+    * `warm()` builds only the version-independent set: the monolith
+      `mcp_types` models a session routes through, the JSON-RPC envelopes and
+      the module-level union adapters. The first connection still imports and
+      builds its version's routing surface.
+    * `warm(all_versions=True)` warms every known protocol version's routing
+      surface, for a proxy or gateway that serves clients of both eras.
 
     Model classes are completed before the adapters that reference them are
     built, so no schema is generated twice; anything already built is skipped,
     so the call is idempotent and repeat calls are cheap.
 
     Args:
         version: The protocol version whose routing surface to build too.
-        everything: Warm every known protocol version (benchmarks, tests).
+        all_versions: Warm every known protocol version's routing surface
+            (a proxy or gateway serving both eras; benchmarks and tests).
 
     Returns:
         Counts of what this call built and the milliseconds it took.
@@ -943,7 +954,7 @@ def warm(version: str | None = None, *, everything: bool = False) -> WarmReport:
     """
     started = time.perf_counter()
     versions: list[str] = []
-    if everything:
+    if all_versions:
         versions = sorted(KNOWN_PROTOCOL_VERSIONS)
     elif version is not None:
         _check_known_version(version)
 
@@ -5,6 +5,7 @@
 """
 
 import pytest
+from mcp_types import methods
 
 import mcp
 import mcp.server.session
@@ -27,6 +28,11 @@ def test_client_and_server_reexports_are_the_defining_objects():
     assert mcp.ClientSessionGroup is ClientSessionGroup
 
 
+def test_warm_is_the_types_layer_prewarm_helper_itself():
+    """SDK-defined: `mcp.warm` is `mcp_types.methods.warm` - one helper, two spellings."""
+    assert mcp.warm is methods.warm
+
+
 def test_dir_lists_every_export_and_the_bound_submodules():
     """SDK-defined: `dir(mcp)` reports all of `__all__` plus the submodules a bare import binds."""
     listing = set(dir(mcp))
 
@@ -1,5 +1,6 @@
 """Tests for the wire-method maps and two-step parse functions in `mcp_types.methods`."""
 
+import dataclasses
 import importlib.util
 import json
 import os
@@ -1034,7 +1035,7 @@ def test_importing_the_module_builds_no_adapters_and_identical_rows_share_one():
 # --- warm(): the opt-in prewarm helper ---
 
 _WARM_PROBE = """
-import json, sys
+import dataclasses, json, sys
 import pydantic
 import mcp_types
 from mcp_types import methods
@@ -1069,7 +1070,7 @@ def counting_init(self, *a, **k):
     {{"tools": [], "cacheScope": "private", "ttlMs": 0, "resultType": "complete"}},
 )
 mcp_types.jsonrpc_message_adapter.validate_python({{"jsonrpc": "2.0", "id": 1, "method": "ping"}})
-print(json.dumps({{"report": report._asdict() if report else None, "wire": loaded_wire, "built": built}}))
+print(json.dumps({{"report": dataclasses.asdict(report) if report else None, "wire": loaded_wire, "built": built}}))
 """
 
 
@@ -1115,10 +1116,19 @@ def test_warm_is_idempotent_and_gates_unknown_versions():
     """SDK-defined: repeating a `warm()` builds nothing more; an unknown version is a ValueError."""
     baseline = methods.warm()  # the version-independent set (this process may already have built it)
     assert baseline.elapsed_ms >= 0
-    methods.warm(everything=True)
-    again = methods.warm(everything=True)
+    methods.warm(all_versions=True)
+    again = methods.warm(all_versions=True)
     assert (again.models, again.adapters) == (0, 0)
     assert again.elapsed_ms >= 0
     with pytest.raises(ValueError) as excinfo:
         methods.warm("2099-01-01")
-    assert "2099-01-01" in str(excinfo.value)
+    assert str(excinfo.value) == snapshot("version must be a known protocol version, got '2099-01-01'")
+
+
+def test_warm_report_is_an_immutable_dataclass():
+    """SDK-defined: the report is a frozen dataclass (fields read by name, arity free to grow),
+    not a tuple."""
+    report = methods.warm()
+    assert dataclasses.is_dataclass(report)
+    with pytest.raises(dataclasses.FrozenInstanceError):
+        setattr(report, "models", -1)