Modern results always carry the resultType discriminator

The 2026-07-28 schema requires Result.resultType: servers implementing
the revision MUST include it; the absent-means-complete bridge exists
for clients of older servers only. The per-version sieve guaranteed it
for core spec methods but custom methods, extension methods, and empty
results shipped without it, which the typescript client rejects as an
invalid result. Fill 'complete' at the envelope pass when the field is
absent (or explicitly null) on a modern-era result, mirroring the
typescript server's stampResultType. Handshake-era results are
untouched, and claimed extension shapes keep their own tag.

Author: maxisbey

src/mcp/server/runner.py

@@ -377,6 +377,13 @@ def _serialize(self, method: str, version: str, result: HandlerResult) -> dict[s
                 # pydantic messages echo the result body.
                 logger.exception("handler for %r returned an invalid result", method)
                 raise MCPError(code=INTERNAL_ERROR, message="Handler returned an invalid result") from None
+        if version in MODERN_PROTOCOL_VERSIONS and dumped.get("resultType") is None:
+            # Spec 2026-07-28: `Result.resultType` is required - servers MUST
+            # include it (the absent-means-complete bridge is for clients of
+            # older servers only). The sieve guarantees it for core methods;
+            # this covers everything else: custom methods, extension methods,
+            # and empty results.
+            dumped["resultType"] = "complete"
         return self._stamp_server_info(version, dumped)
 
     def _stamp_server_info(self, version: str, result: dict[str, Any]) -> dict[str, Any]:

tests/server/test_runner.py

@@ -957,10 +957,12 @@ async def echo(ctx: Ctx, params: RequestParams) -> dict[str, Any]:
     born_ready = Connection.from_envelope(LATEST_MODERN_VERSION, None, None)
     async with connected_runner(server, initialized=False, connection=born_ready) as (client, _):
         result = await client.send_raw_request("myorg/echo", None)
-    # Custom-method results served at a modern version carry the serverInfo
-    # `_meta` stamp like any other result (spec 2026-07-28, #3002).
+    # Custom-method results served at a modern version carry the required
+    # `resultType` discriminator and the serverInfo `_meta` stamp like any
+    # other result (spec 2026-07-28, #3002).
     assert result == {
         "echoed": True,
+        "resultType": "complete",
         "_meta": {SERVER_INFO_META_KEY: {"name": "test-server", "version": "0.0.1"}},
     }
 
@@ -1039,7 +1041,7 @@ async def custom(ctx: Ctx, params: RequestParams) -> dict[str, Any]:
     born_ready = Connection.from_envelope(LATEST_MODERN_VERSION, None, None)
     async with connected_runner(server, initialized=False, connection=born_ready) as (client, _):
         result = await client.send_raw_request("myorg/odd-meta", None)
-    assert result == {"_meta": "not-a-mapping"}
+    assert result == {"_meta": "not-a-mapping", "resultType": "complete"}
 
 
 @pytest.mark.anyio
@@ -1103,6 +1105,40 @@ async def custom(ctx: Ctx, params: CallToolRequestParams) -> dict[str, Any]:
     assert exc.value.error.message == "Handler returned an invalid result"
 
 
+@pytest.mark.anyio
+async def test_a_handshake_era_custom_result_gains_no_discriminator(server: SrvT):
+    """The `resultType` fill is modern-only: handshake-era results keep the
+    handler's exact shape (the field does not exist pre-2026)."""
+
+    async def echo(ctx: Ctx, params: RequestParams) -> dict[str, Any]:
+        return {"echoed": True}
+
+    server.add_request_handler("myorg/echo", RequestParams, echo)
+    async with connected_runner(server) as (client, _):
+        result = await client.send_raw_request("myorg/echo", None)
+    assert result == {"echoed": True}
+
+
+@pytest.mark.anyio
+async def test_an_explicit_null_result_type_is_filled_on_the_modern_path(server: SrvT):
+    """A handler-authored `"resultType": null` reads as absent (null is not a
+    valid discriminator) and is filled, mirroring the null posture of the
+    identity stamp."""
+
+    async def custom(ctx: Ctx, params: RequestParams) -> dict[str, Any]:
+        return {"echoed": True, "resultType": None}
+
+    server.add_request_handler("myorg/echo", RequestParams, custom)
+    born_ready = Connection.from_envelope(LATEST_MODERN_VERSION, None, None)
+    async with connected_runner(server, initialized=False, connection=born_ready) as (client, _):
+        result = await client.send_raw_request("myorg/echo", None)
+    assert result == {
+        "echoed": True,
+        "resultType": "complete",
+        "_meta": {SERVER_INFO_META_KEY: {"name": "test-server", "version": "0.0.1"}},
+    }
+
+
 @pytest.mark.anyio
 async def test_a_claimed_extension_result_type_bypasses_the_sieve_and_is_stamped(server: SrvT):
     """SDK-defined: a spec-method result carrying an extension `resultType` is a
@@ -1125,10 +1161,11 @@ async def custom(ctx: Ctx, params: CallToolRequestParams) -> dict[str, Any]:
 
 
 @pytest.mark.anyio
-async def test_an_empty_result_on_the_modern_path_carries_only_the_stamp(server: SrvT):
-    """Spec-mandated (2026-07-28, #3002): serverInfo is stamped into every
-    result, including empty ones — a result that dumps as `{}` goes on the
-    modern wire as just the identity `_meta`."""
+async def test_an_empty_result_on_the_modern_path_carries_the_discriminator_and_stamp(server: SrvT):
+    """Spec-mandated (2026-07-28): `resultType` is required on every result a
+    modern server sends (the absent-means-complete bridge is for clients of
+    older servers only), and serverInfo is stamped into every result too - so
+    a result that dumps as `{}` goes on the modern wire with both."""
 
     async def custom(ctx: Ctx, params: RequestParams) -> EmptyResult:
         return EmptyResult()
@@ -1137,7 +1174,10 @@ async def custom(ctx: Ctx, params: RequestParams) -> EmptyResult:
     born_ready = Connection.from_envelope(LATEST_MODERN_VERSION, None, None)
     async with connected_runner(server, initialized=False, connection=born_ready) as (client, _):
         result = await client.send_raw_request("myorg/empty", None)
-    assert result == {"_meta": {SERVER_INFO_META_KEY: {"name": "test-server", "version": "0.0.1"}}}
+    assert result == {
+        "resultType": "complete",
+        "_meta": {SERVER_INFO_META_KEY: {"name": "test-server", "version": "0.0.1"}},
+    }
 
 
 @pytest.mark.anyio
@@ -1879,7 +1919,11 @@ async def greet(ctx: Ctx, params: RequestParams | None) -> dict[str, Any]:
     params["_meta"][CLIENT_INFO_META_KEY] = "not-an-object"
     async with dual_era_client(greeter) as (client, _):
         result = await client.send_raw_request("custom/greet", params)
-    assert result == {"ok": True, "_meta": {SERVER_INFO_META_KEY: {"name": "greeter-server", "version": "0.0.1"}}}
+    assert result == {
+        "ok": True,
+        "resultType": "complete",
+        "_meta": {SERVER_INFO_META_KEY: {"name": "greeter-server", "version": "0.0.1"}},
+    }
     assert seen == [None]
 
 

tests/server/test_streamable_http_modern.py

@@ -215,7 +215,11 @@ async def greet(ctx: ServerRequestContext, params: PaginatedRequestParams) -> di
         response = await http.post("/mcp", json=body, headers={MCP_METHOD_HEADER: "custom/greet"})
     assert response.status_code == 200
     result = response.json()["result"]
-    assert result == {"_meta": {SERVER_INFO_META_KEY: {"name": "test", "version": ""}}, "ok": True}
+    assert result == {
+        "_meta": {SERVER_INFO_META_KEY: {"name": "test", "version": ""}},
+        "ok": True,
+        "resultType": "complete",
+    }
     assert seen == [None]