@@ -55,6 +55,19 @@
 logger = logging.getLogger("client")
 
 
+def _clamp_inbound_ttl(raw: dict[str, Any]) -> None:
+    """Floor a negative inbound `ttlMs` to 0, in place (2026-07-28 caching SHOULD).
+
+    Runs before the surface validation, whose `ge=0` would otherwise fail the
+    whole call over one bad hint. Emit-side strictness is untouched — only a
+    misbehaving peer reaches this. Floats are floored too; bools are not numbers
+    here and are left for the validation to reject.
+    """
+    ttl = raw.get("ttlMs")
+    if isinstance(ttl, int | float) and not isinstance(ttl, bool) and ttl < 0:
+        raw["ttlMs"] = 0
+
+
 def _preconnect_stamp(data: dict[str, Any], opts: CallOptions) -> None:
     # initialize/discover forbid cancellation; other pre-handshake requests (lowlevel
     # ClientSession callers may skip the handshake entirely) keep the courtesy cancel.
@@ -331,6 +344,7 @@ async def send_request(
             if metadata.on_resumption_token_update is not None:
                 opts["on_resumption_token"] = metadata.on_resumption_token_update
         raw = await self._dispatcher.send_raw_request(method, data.get("params"), opts)
+        _clamp_inbound_ttl(raw)
         # Literal fallback covers pre-handshake and stateless; matches runner.py.
         version = self._negotiated_version or "2025-11-25"
         try:
@@ -458,7 +472,13 @@ async def send_discover(self, version: str) -> dict[str, Any]:
             "cancel_on_abandon": False,
             "headers": {MCP_PROTOCOL_VERSION_HEADER: version, MCP_METHOD_HEADER: data["method"]},
         }
-        return await self._dispatcher.send_raw_request(data["method"], data.get("params"), opts)
+        raw = await self._dispatcher.send_raw_request(data["method"], data.get("params"), opts)
+        # Clamping here (not in the callers) covers both discover() and the
+        # mode='auto' probe — un-floored, a negative ttl fails DiscoverResult
+        # validation in the probe, which reads as "not modern evidence" and
+        # silently downgrades the connection to the legacy handshake.
+        _clamp_inbound_ttl(raw)
+        return raw
 
     async def discover(self) -> types.DiscoverResult:
         """Probe `server/discover` and adopt the result.
 
@@ -8,6 +8,8 @@
 
 import json
 import time
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
 from types import TracebackType
 from typing import Any
 
@@ -54,6 +56,8 @@
 from mcp.server import Server, ServerRequestContext
 from mcp.server.caching import CacheHint
 from mcp.shared.exceptions import MCPError
+from mcp.shared.memory import MessageStream, create_client_server_memory_streams
+from mcp.shared.message import SessionMessage
 from mcp.shared.session import RequestResponder
 from tests.interaction._connect import BASE_URL, mounted_app
 
@@ -960,3 +964,102 @@ async def on_message(message: IncomingMessage) -> None:
     # The notification carried the exact string the entry was stored under.
     assert delivered == [uri]
     assert reads == [uri, uri]
+
+
+# --- The inbound ttlMs clamp (parse seam) ---
+
+
+@pytest.mark.parametrize("wire_ttl", [-5, -5.0])
+async def test_a_negative_inbound_ttl_is_served_as_zero_and_never_cached(wire_ttl: int | float) -> None:
+    """Spec SHOULD (2026-07-28 caching): a negative `ttlMs` is treated as 0 — the
+    call succeeds instead of failing the `ge=0` wire validation, and a zero ttl is
+    never stored, so the next call goes back to the server. The peer is scripted
+    over raw streams because an SDK server cannot emit a negative ttl (server-side
+    `ge=0` enforcement)."""
+    listings_served = 0
+
+    async def scripted_server(streams: MessageStream) -> None:
+        nonlocal listings_served
+        server_read, server_write = streams
+        async for message in server_read:
+            assert isinstance(message, SessionMessage)
+            frame = message.message
+            assert isinstance(frame, types.JSONRPCRequest)
+            if frame.method == "server/discover":
+                result: dict[str, Any] = {
+                    "supportedVersions": [LATEST_MODERN_VERSION],
+                    "capabilities": {},
+                    "serverInfo": {"name": "negative-ttl", "version": "0.0.1"},
+                    "resultType": "complete",
+                    "ttlMs": 0,
+                }
+            else:
+                assert frame.method == "tools/list"
+                listings_served += 1
+                result = {"resultType": "complete", "tools": [], "ttlMs": wire_ttl, "cacheScope": "private"}
+            await server_write.send(SessionMessage(types.JSONRPCResponse(jsonrpc="2.0", id=frame.id, result=result)))
+
+    @asynccontextmanager
+    async def scripted_transport() -> AsyncIterator[TransportStreams]:
+        async with (
+            create_client_server_memory_streams() as ((client_read, client_write), server_streams),
+            anyio.create_task_group() as tg,
+        ):
+            tg.start_soon(scripted_server, server_streams)
+            yield client_read, client_write
+            tg.cancel_scope.cancel()
+
+    with anyio.fail_after(5):
+        async with Client(scripted_transport(), mode="auto") as client:
+            first = await client.list_tools()
+            second = await client.list_tools()
+
+    assert first.ttl_ms == 0
+    assert second.ttl_ms == 0
+    assert listings_served == 2  # the clamped-to-zero ttl was never stored: the second call re-fetched
+
+
+async def test_a_negative_discover_ttl_still_connects_modern_in_auto_mode() -> None:
+    """Spec SHOULD (2026-07-28 caching) — silent-downgrade regression: before the
+    parse-seam clamp, a negative `ttlMs` on `server/discover` failed `DiscoverResult`
+    validation inside the mode='auto' probe, which reads as "not modern evidence" and
+    silently fell back to the legacy initialize handshake. Clamped, the probe adopts
+    the modern era and the result carries `ttl_ms == 0`."""
+    methods_seen: list[str] = []
+
+    async def scripted_server(streams: MessageStream) -> None:
+        server_read, server_write = streams
+        async for message in server_read:
+            assert isinstance(message, SessionMessage)
+            frame = message.message
+            assert isinstance(frame, types.JSONRPCRequest)
+            methods_seen.append(frame.method)
+            # A legacy downgrade would send `initialize` next; fail loudly instead.
+            assert frame.method == "server/discover"
+            result: dict[str, Any] = {
+                "supportedVersions": [LATEST_MODERN_VERSION],
+                "capabilities": {},
+                "serverInfo": {"name": "negative-ttl", "version": "0.0.1"},
+                "resultType": "complete",
+                "ttlMs": -5,
+            }
+            await server_write.send(SessionMessage(types.JSONRPCResponse(jsonrpc="2.0", id=frame.id, result=result)))
+
+    @asynccontextmanager
+    async def scripted_transport() -> AsyncIterator[TransportStreams]:
+        async with (
+            create_client_server_memory_streams() as ((client_read, client_write), server_streams),
+            anyio.create_task_group() as tg,
+        ):
+            tg.start_soon(scripted_server, server_streams)
+            yield client_read, client_write
+            tg.cancel_scope.cancel()
+
+    with anyio.fail_after(5):
+        async with Client(scripted_transport(), mode="auto") as client:
+            assert client.protocol_version == LATEST_MODERN_VERSION
+            discover = client.session.discover_result
+            assert discover is not None
+            assert discover.ttl_ms == 0
+
+    assert methods_seen == ["server/discover"]
@@ -1661,6 +1661,37 @@ async def test_discover_reraises_unsupported_version_with_malformed_error_data()
     assert [m for m, _ in dispatcher.calls] == ["server/discover"]
 
 
+# --- inbound ttlMs clamp ---
+
+
+@pytest.mark.anyio
+async def test_a_positive_inbound_ttl_reaches_the_result_unchanged() -> None:
+    """SDK-defined: the inbound clamp only floors negative `ttlMs` values — a valid
+    positive hint passes through to the typed result untouched."""
+    listing: dict[str, Any] = {"resultType": "complete", "tools": [], "ttlMs": 60_000, "cacheScope": "private"}
+    dispatcher = _ScriptedDispatcher(_discover_result_dict(), listing)
+    with anyio.fail_after(5):
+        async with ClientSession(dispatcher=dispatcher) as session:
+            await session.discover()
+            result = await session.list_tools()
+    assert result.ttl_ms == 60_000
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("wire_ttl", [True, False])
+async def test_a_boolean_inbound_ttl_is_not_clamped_only_coerced_by_validation(wire_ttl: bool) -> None:
+    """SDK-defined: `bool` is an `int` subclass but the clamp does not treat it as a
+    number — the value reaches validation untouched, where pydantic's lax mode
+    coerces it (True -> 1, False -> 0) rather than rejecting it."""
+    listing: dict[str, Any] = {"resultType": "complete", "tools": [], "ttlMs": wire_ttl, "cacheScope": "private"}
+    dispatcher = _ScriptedDispatcher(_discover_result_dict(), listing)
+    with anyio.fail_after(5):
+        async with ClientSession(dispatcher=dispatcher) as session:
+            await session.discover()
+            result = await session.list_tools()
+    assert result.ttl_ms == int(wire_ttl)
+
+
 @pytest.mark.anyio
 async def test_session_call_tool_returns_input_required_result_when_opted_in() -> None:
     """`ClientSession.call_tool(..., allow_input_required=True)` surfaces the