Address review: pin spec-invalid hybrid divergences, de-bias benchmark ordering

The discriminator does not reproduce smart-union scoring on spec-invalid
hybrids: {method, error} now classifies as a call instead of
JSONRPCError, and {method: <non-str>, result} is rejected instead of
falling through to JSONRPCResponse. No fixed key-priority order can
mirror field-count scoring on these shapes, and the key-presence rule is
the safer choice (a malformed frame can no longer masquerade as the
error response to a pending request), so pin the divergence with tests
and correct the docstring's parity claim to spec-valid messages.

Also alternate adapter run order each benchmark round so warm-up and
CPU-state effects are not attributed to either adapter; speedups are
unchanged (1.6-2.2x).

Author: sandole

scripts/bench_jsonrpc_codec.py

@@ -51,15 +51,22 @@
 REPEATS = 5
 
 
-def bench(fn: Callable[[], Any], iterations: int) -> float:
-    """Return best-of-REPEATS per-call time in microseconds."""
-    best = float("inf")
-    for _ in range(REPEATS):
-        start = time.perf_counter()
-        for _ in range(iterations):
-            fn()
-        best = min(best, time.perf_counter() - start)
-    return best / iterations * 1e6
+def bench_pair(old_fn: Callable[[], Any], new_fn: Callable[[], Any], iterations: int) -> tuple[float, float]:
+    """Return best per-call time in microseconds for each adapter over 2*REPEATS rounds.
+
+    Run order alternates each round so warm-up and CPU-state effects are not
+    attributed to either adapter.
+    """
+    fns = (old_fn, new_fn)
+    best = [float("inf"), float("inf")]
+    for round_index in range(2 * REPEATS):
+        order = (0, 1) if round_index % 2 == 0 else (1, 0)
+        for key in order:
+            start = time.perf_counter()
+            for _ in range(iterations):
+                fns[key]()
+            best[key] = min(best[key], time.perf_counter() - start)
+    return best[0] / iterations * 1e6, best[1] / iterations * 1e6
 
 
 def _decode_validate_json(adapter: TypeAdapter[Any], body: bytes) -> Any:
@@ -88,8 +95,11 @@ def main() -> None:
     print(f"{'payload':<20} {'path':<14} {'smart union':>12} {'discriminator':>14} {'speedup':>8}")
     for label, body, iterations in payloads:
         for path_label, decode in decoders:
-            old = bench(lambda: decode(bare_union_adapter, body), iterations)
-            new = bench(lambda: decode(jsonrpc_message_adapter, body), iterations)
+            old, new = bench_pair(
+                lambda: decode(bare_union_adapter, body),
+                lambda: decode(jsonrpc_message_adapter, body),
+                iterations,
+            )
             print(f"{label:<20} {path_label:<14} {old:>10.2f}us {new:>12.2f}us {old / new:>7.2f}x")
 
 

src/mcp-types/mcp_types/jsonrpc.py

@@ -127,10 +127,14 @@ def _discriminate_jsonrpc_message(value: Any) -> str | None:
     """Tag a wire object by key presence per JSON-RPC 2.0.
 
     Selects exactly one union branch to validate instead of letting smart-union
-    mode score all four on every message. Mirrors the smart-union outcomes
-    exactly, including the rule that a ``method`` member with a missing, null,
-    or non-int/str ``id`` classifies as a notification, and that ``error`` wins
-    over ``result`` when both are present.
+    mode score all four on every message. Classification matches the previous
+    smart-union outcome for every spec-valid message: a ``method`` member with
+    a missing, null, or non-int/str ``id`` classifies as a notification
+    (mirroring ``RequestId``), and ``error`` wins over ``result`` when both are
+    present. For spec-invalid hybrids that combine ``method`` with ``result``/
+    ``error`` members, the ``method`` key deterministically makes the message a
+    call; smart-union scoring previously preferred whichever branch matched
+    more fields, which let a malformed frame classify as an error response.
     """
     if isinstance(value, dict):
         wire = cast("dict[str, Any]", value)

tests/types/test_jsonrpc_discriminator.py

@@ -67,6 +67,37 @@ def test_error_wins_over_result() -> None:
     assert type(message) is JSONRPCError
 
 
+@pytest.mark.parametrize(
+    ("request_id", "expected_type"),
+    [
+        (1, JSONRPCRequest),
+        (None, JSONRPCNotification),
+    ],
+)
+def test_method_wins_over_error(request_id: object, expected_type: type) -> None:
+    """A spec-invalid {method, error} hybrid classifies as a call, deliberately diverging from smart union.
+
+    Smart-union scoring preferred `JSONRPCError` here (more matching fields),
+    which let a malformed frame masquerade as an error response to a pending
+    request. The `method` key now deterministically makes the message a call.
+    """
+    wire: dict[str, Any] = {"jsonrpc": "2.0", "id": request_id, "method": "m", "error": {"code": -1, "message": "x"}}
+    message = jsonrpc_message_adapter.validate_python(wire, by_name=False)
+    assert type(message) is expected_type
+
+
+def test_non_string_method_with_result_is_rejected() -> None:
+    """A `method` key selects the call arm even when its value is invalid, deliberately diverging from smart union.
+
+    Smart union previously fell through to `JSONRPCResponse` for
+    {method: 123, result: {}}; the call arm now rejects the non-string method.
+    """
+    wire: dict[str, Any] = {"jsonrpc": "2.0", "id": 1, "method": 123, "result": {}}
+    with pytest.raises(ValidationError) as exc_info:
+        jsonrpc_message_adapter.validate_python(wire, by_name=False)
+    assert exc_info.value.errors()[0]["loc"] == ("request", "method")
+
+
 @pytest.mark.parametrize(
     "unclassifiable",
     [