@@ -396,6 +396,10 @@ async def run(
                 read_stream,
                 write_stream,
                 raise_handler_exceptions=raise_exceptions,
+                # Handle `initialize` inline so a client that pipelines it with
+                # the next request (spec says SHOULD NOT, not MUST NOT) sees
+                # the initialized state instead of failing the init-gate.
+                inline_methods=frozenset({"initialize"}),
             )
             runner = ServerRunner(
                 server=self,
 
@@ -94,10 +94,13 @@ async def wrapped(
             case _:
                 parent = None
         span_name = f"MCP handle {method}{f' {target}' if target else ''}"
+        attributes: dict[str, str | int] = {"mcp.method.name": method}
+        if dctx.request_id is not None:
+            attributes["jsonrpc.request.id"] = dctx.request_id
         with otel_span(
             span_name,
             kind=SpanKind.SERVER,
-            attributes={"mcp.method.name": method},
+            attributes=attributes,
             context=parent,
             record_exception=False,
             set_status_on_exception=False,
 
@@ -213,6 +213,7 @@ def __init__(
         *,
         peer_cancel_mode: PeerCancelMode = "interrupt",
         raise_handler_exceptions: bool = False,
+        inline_methods: frozenset[str] = frozenset(),
     ) -> None: ...
     @overload
     def __init__(
@@ -223,6 +224,7 @@ def __init__(
         transport_builder: Callable[[MessageMetadata], TransportT],
         peer_cancel_mode: PeerCancelMode = "interrupt",
         raise_handler_exceptions: bool = False,
+        inline_methods: frozenset[str] = frozenset(),
     ) -> None: ...
     def __init__(
         self,
@@ -232,6 +234,7 @@ def __init__(
         transport_builder: Callable[[MessageMetadata], TransportT] | None = None,
         peer_cancel_mode: PeerCancelMode = "interrupt",
         raise_handler_exceptions: bool = False,
+        inline_methods: frozenset[str] = frozenset(),
     ) -> None:
         self._read_stream = read_stream
         self._write_stream = write_stream
@@ -244,6 +247,13 @@ def __init__(
         )
         self._peer_cancel_mode: PeerCancelMode = peer_cancel_mode
         self._raise_handler_exceptions = raise_handler_exceptions
+        self._inline_methods = inline_methods
+        """Request methods handled inline in the read loop (awaited before the
+        next message is dequeued) instead of spawned concurrently. Use for
+        methods whose side effects must be observable to the next message,
+        e.g. `initialize`, so a pipelined follow-up sees the initialized state.
+        Only suitable for handlers that complete quickly, since inline handling
+        blocks dequeuing."""
 
         self._next_id = 0
         self._pending: dict[RequestId, _Pending] = {}
@@ -384,7 +394,7 @@ async def run(
                                 sender_ctx: contextvars.Context | None = getattr(
                                     self._read_stream, "last_context", None
                                 )
-                                self._dispatch(item, on_request, on_notify, sender_ctx)
+                                await self._dispatch(item, on_request, on_notify, sender_ctx)
                         except anyio.ClosedResourceError:
                             # The transport closed our receive end and we looped
                             # back to `__anext__` on the now-closed stream
@@ -409,17 +419,19 @@ async def run(
             self._tg = None
             self._fan_out_closed()
 
-    def _dispatch(
+    async def _dispatch(
         self,
         item: SessionMessage | Exception,
         on_request: OnRequest,
         on_notify: OnNotify,
         sender_ctx: contextvars.Context | None,
     ) -> None:
-        """Route one inbound item. Synchronous: never awaits.
+        """Route one inbound item.
 
-        Everything here is `send_nowait` or `_spawn`. An `await` would let one
-        slow message head-of-line block the entire read loop.
+        Everything here is `send_nowait` or `_spawn`; the only `await` is for
+        `inline_methods` requests, which deliberately block dequeuing until
+        handled. Any other `await` would let one slow message head-of-line
+        block the entire read loop.
         """
         if isinstance(item, Exception):
             logger.debug("transport yielded exception: %r", item)
@@ -428,7 +440,7 @@ def _dispatch(
         msg = item.message
         match msg:
             case JSONRPCRequest():
-                self._dispatch_request(msg, metadata, on_request, sender_ctx)
+                await self._dispatch_request(msg, metadata, on_request, sender_ctx)
             case JSONRPCNotification():
                 self._dispatch_notification(msg, metadata, on_notify, sender_ctx)
             case JSONRPCResponse():
@@ -439,7 +451,7 @@ def _dispatch(
                 # on this final case is unreachable.
                 self._resolve_pending(msg.id, msg.error)
 
-    def _dispatch_request(
+    async def _dispatch_request(
         self,
         req: JSONRPCRequest,
         metadata: MessageMetadata,
@@ -462,7 +474,10 @@ def _dispatch_request(
         )
         scope = anyio.CancelScope()
         self._in_flight[req.id] = _InFlight(scope=scope, dctx=dctx)
-        self._spawn(self._handle_request, req, dctx, scope, on_request, sender_ctx=sender_ctx)
+        if req.method in self._inline_methods:
+            await self._handle_request(req, dctx, scope, on_request)
+        else:
+            self._spawn(self._handle_request, req, dctx, scope, on_request, sender_ctx=sender_ctx)
 
     def _dispatch_notification(
         self,
 
@@ -411,6 +411,7 @@ async def call_tool(ctx: Ctx, params: CallToolRequestParams) -> dict[str, Any]:
     assert span.name == "MCP handle tools/call mytool"
     assert span.attributes is not None
     assert span.attributes["mcp.method.name"] == "tools/call"
+    assert isinstance(span.attributes["jsonrpc.request.id"], int)
     assert span.status.status_code == StatusCode.UNSET
 
 
 
@@ -11,6 +11,7 @@
 from typing import Any
 
 import anyio
+import anyio.lowlevel
 import pytest
 
 from mcp.shared._context_streams import ContextReceiveStream, ContextSendStream
@@ -461,6 +462,39 @@ async def server_on_request(ctx: DCtx, method: str, params: Mapping[str, Any] |
     assert "progress callback raised" in caplog.text
 
 
+@pytest.mark.anyio
+async def test_inline_methods_are_handled_before_next_message_is_dequeued():
+    """A method in `inline_methods` runs to completion before subsequent
+    messages are dispatched, so its side effects are visible to them."""
+    c2s_send, c2s_recv = anyio.create_memory_object_stream[SessionMessage | Exception](32)
+    s2c_send, s2c_recv = anyio.create_memory_object_stream[SessionMessage | Exception](32)
+    server: JSONRPCDispatcher[TransportContext] = JSONRPCDispatcher(
+        c2s_recv, s2c_send, inline_methods=frozenset({"first"})
+    )
+    state = {"initialized": False}
+    seen: list[bool] = []
+
+    async def on_request(ctx: DCtx, method: str, params: Mapping[str, Any] | None) -> dict[str, Any]:
+        if method == "first":
+            await anyio.lowlevel.checkpoint()
+            state["initialized"] = True
+        else:
+            seen.append(state["initialized"])
+        return {}
+
+    async def on_notify(ctx: DCtx, method: str, params: Mapping[str, Any] | None) -> None:
+        raise NotImplementedError
+
+    # Buffer both requests before run() reads anything.
+    await c2s_send.send(SessionMessage(message=JSONRPCRequest(jsonrpc="2.0", id=1, method="first", params=None)))
+    await c2s_send.send(SessionMessage(message=JSONRPCRequest(jsonrpc="2.0", id=2, method="second", params=None)))
+    c2s_send.close()
+    with anyio.fail_after(5):
+        await server.run(on_request, on_notify)
+    assert seen == [True]
+    s2c_recv.close()
+
+
 @pytest.mark.anyio
 async def test_send_raw_request_always_carries_meta_on_the_wire():
     """Outbound requests always include `params._meta` (otel injection per SEP-414).