Catch RecursionError at the parse guard; disambiguate envelope vs handler faults in the schema listing

json.loads raises RecursionError, not ValueError, for deeply nested
bodies - widen the parse guard so they stay 400 + PARSE_ERROR.

The synthetic tools/list now surface-validates its params before
dispatch: a mis-shaped envelope is caught up front (debug, client
fault), so a ValidationError escaping serve_one can only be
handler-origin and gets the error-level log the fail-open skip
promises.

Author: maxisbey

src/mcp/server/_streamable_http_modern.py

@@ -44,6 +44,7 @@
     ProgressToken,
     RequestId,
 )
+from mcp_types import methods as _methods
 from pydantic import BaseModel, ValidationError
 from starlette.requests import Request
 from starlette.responses import Response
@@ -242,6 +243,13 @@ async def _tool_input_schema(
         CLIENT_CAPABILITIES_META_KEY: verdict.client_capabilities,
     }
     list_params: dict[str, Any] = {"_meta": meta}
+    try:
+        _methods.validate_client_request("tools/list", verdict.protocol_version, list_params)
+    except ValidationError:
+        # Client-fault envelope: the real dispatch produces the INVALID_PARAMS
+        # reply, and anything above a debug line would let clients flood the log.
+        logger.debug("Mcp-Param header validation skipped: the request envelope fails tools/list validation")
+        return None
     seen_cursors: set[str] = set()
     client_info = _typed(Implementation, verdict.client_info)
     client_capabilities = _typed(ClientCapabilities, verdict.client_capabilities)
@@ -261,11 +269,6 @@ async def _tool_input_schema(
                 if tool.get("name") == name:
                     return tool.get("inputSchema")
             cursor = result.get("nextCursor")
-        except ValidationError:
-            # Client-fault envelope: the real dispatch produces the INVALID_PARAMS
-            # reply, and anything above a debug line would let clients flood the log.
-            logger.debug("Mcp-Param header validation skipped: the request envelope fails tools/list validation")
-            return None
         except Exception:
             # Fail-open boundary by design: header validation must never break a
             # working call path. Loud, precisely because the skip is fail-open.
@@ -357,8 +360,8 @@ async def handle_modern_request(
     body = await request.body()
     try:
         decoded = json.loads(body)
-    except ValueError:
-        # Not just JSONDecodeError: integer literals beyond CPython's digit limit raise bare ValueError.
+    except (ValueError, RecursionError):
+        # Not just JSONDecodeError: oversized integer literals raise bare ValueError, deep nesting RecursionError.
         rej = JSONRPCError(jsonrpc="2.0", id=None, error=ErrorData(code=PARSE_ERROR, message="Parse error"))
         await _write(rej, scope, receive, send)
         return

tests/server/test_streamable_http_modern.py

@@ -978,3 +978,33 @@ async def test_modern_post_with_an_oversized_integer_literal_is_parse_error_not_
         response = await http.post("/mcp", content=body, headers={"content-type": "application/json"})
     assert response.status_code == 400
     assert response.json()["error"]["code"] == PARSE_ERROR
+
+
+async def test_modern_tools_call_logs_a_handler_raised_validation_error_loudly(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """A ValidationError from inside the tools/list handler is a server fault: the skip is
+    logged at error level, not mistaken for a client-fault envelope."""
+
+    async def broken_list(ctx: ServerRequestContext, params: PaginatedRequestParams | None) -> ListToolsResult:
+        return ListToolsResult(tools=[Tool.model_validate({"bogus": 1})], ttl_ms=0, cache_scope="public")
+
+    server: Server[Any] = Server("test", on_list_tools=broken_list, on_call_tool=_ok_call_tool)
+    with caplog.at_level(logging.ERROR, logger=_streamable_http_modern.__name__):
+        async with _asgi_client(server) as http:
+            response = await http.post(
+                "/mcp",
+                json=_tool_call_body({"region": "us"}),
+                headers=_TOOL_CALL_HEADERS | {"mcp-param-region": "eu"},
+            )
+    assert response.status_code == 200
+    assert "Mcp-Param header validation skipped: the tools/list listing failed" in caplog.text
+
+
+async def test_modern_post_with_deeply_nested_body_is_parse_error_not_a_crash() -> None:
+    """Deep nesting makes json.loads raise RecursionError; still an unparseable body: 400 + PARSE_ERROR."""
+    body = b"[" * 100_000 + b"]" * 100_000
+    async with _asgi_client(_x_mcp_server()) as http:
+        response = await http.post("/mcp", content=body, headers={"content-type": "application/json"})
+    assert response.status_code == 400
+    assert response.json()["error"]["code"] == PARSE_ERROR