Narrow the transport's back-channel verdict to JSON-response mode

The previous commit had the transport also refuse whenever it holds no
session id, but a missing session id is not what makes a client's
reply unroutable - the session manager creating a fresh transport per
request is. A single long-lived sessionless transport still receives
the reply on the same instance, so server-initiated requests over SSE
kept working there and must continue to.

The transport now states only the fact it owns (a JSON body carries
one response), and the manager keeps its own can_send_request=False
builder for the stateless leg. The manager module is unchanged from
main.

Author: maxisbey

src/mcp/server/streamable_http.py

@@ -220,11 +220,12 @@ def is_terminated(self) -> bool:
     @property
     def _request_channel_can_send_request(self) -> bool:
         """Whether the request-scoped channel of a message this transport delivers can carry a
-        server-initiated request. It cannot in JSON-response mode (the POST is answered with one
-        JSON body) nor with no session (the client's reply would have no session to land on);
-        stamped on each message's `ServerMessageMetadata` so any dispatcher's builder reads it.
+        server-initiated request. It cannot in JSON-response mode: the POST is answered with one
+        JSON body, which holds only the response. Stamped on each message's
+        `ServerMessageMetadata` so any dispatcher's builder reads it; whether a reply has a session
+        to land on is the session manager's fact, not the transport's, so it is not decided here.
         """
-        return self.mcp_session_id is not None and not self.is_json_response_enabled
+        return not self.is_json_response_enabled
 
     def close_sse_stream(self, request_id: RequestId) -> None:
         """Close SSE connection for a specific request without terminating the stream.

src/mcp/server/streamable_http_manager.py

@@ -214,11 +214,12 @@ async def run_stateless_server(*, task_status: TaskStatus[None] = anyio.TASK_STA
                     read_stream,
                     write_stream,
                     inline_methods=frozenset({"initialize"}),
-                    # No `transport_builder`: with no session ID the transport
-                    # marks each message's request-scoped channel unable to
-                    # carry a server-initiated request (the client's reply has
-                    # nowhere to land), so requests raise `NoBackChannelError`
-                    # while notifications still flow.
+                    # No session ID means a server-to-client request can be
+                    # written to this POST's response stream, but the client's
+                    # reply has nowhere to land — `can_send_request=False`
+                    # makes the per-request channel raise `NoBackChannelError`
+                    # for requests while still allowing notifications.
+                    transport_builder=lambda _md: TransportContext(kind="streamable-http", can_send_request=False),
                 )
                 # Born-ready, no standalone channel: the legacy stateless path
                 # never opens a GET stream and need not see `initialize`. The
@@ -319,8 +320,7 @@ async def run_server(*, task_status: TaskStatus[None] = anyio.TASK_STATUS_IGNORE
                             with idle_scope:
                                 # Drive via `serve_loop` (not `Server.run()`) so the
                                 # manager's already-entered lifespan is reused
-                                # rather than re-entered per session; the transport
-                                # marks each message with what its channel can carry.
+                                # rather than re-entered per session.
                                 await serve_loop(
                                     self.app,
                                     read_stream,

src/mcp/shared/jsonrpc_dispatcher.py

@@ -189,11 +189,10 @@ def _default_transport_builder(metadata: MessageMetadata) -> TransportContext:
 
     A message reads as riding a full duplex pipe (`can_send_request=True`)
     unless the transport that framed it says otherwise on the metadata it
-    attached: streamable HTTP marks JSON-response-mode and sessionless
-    messages `ServerMessageMetadata(can_send_request=False)`, so their
-    request-scoped channel raises `NoBackChannelError` instead of parking a
-    waiter no reply can reach - with no wiring needed from whoever drives the
-    streams.
+    attached: streamable HTTP marks JSON-response-mode messages
+    `ServerMessageMetadata(can_send_request=False)`, so their request-scoped
+    channel raises `NoBackChannelError` instead of parking a waiter no reply
+    can reach - with no wiring needed from whoever drives the streams.
     """
     can_send_request = True
     if isinstance(metadata, ServerMessageMetadata) and metadata.can_send_request is not None: