Address review feedback on middleware reshape

- OpenTelemetryMiddleware: nest under the ambient span when no traceparent
  is present. Passing an explicit empty Context to start_as_current_span
  orphans the span; extract_trace_context now returns None for an absent
  or malformed carrier so callers fall through to ambient parenting.
  Adds a regression test with both span tiers installed.
- Rename 'mw' -> 'middleware' across runner.py; drop redundant CallNext
  annotation on the compose-loop accumulator.
- Document that 'initialize' is observed by ServerMiddleware but not
  rewritable: the post-chain handshake commit reads the wire params, so
  a rewritten ctx.params on initialize does not reach connection state.
  TODO at the commit site names the desync triggers; resolves when
  initialize becomes a built-in handler.

Author: maxisbey

src/mcp/server/_otel.py

@@ -32,7 +32,7 @@ async def __call__(self, ctx: ServerRequestContext[Any, Any], call_next: CallNex
             name=f"MCP handle {ctx.method}{f' {target}' if target else ''}",
             kind=SpanKind.SERVER,
             attributes=attributes,
-            context=extract_trace_context(ctx.meta or {}),
+            context=extract_trace_context(ctx.meta),
             record_exception=False,
             set_status_on_exception=False,
         ) as span:

src/mcp/server/context.py

@@ -150,6 +150,9 @@ class ServerMiddleware(Protocol[_MwLifespanT]):
         server-to-client request (`ctx.session.send_request`, `send_ping`, ...)
         while handling `initialize` therefore deadlocks the connection: the
         response can never be dequeued. Send-and-forget notifications are safe.
+        `initialize` is observed but not rewritable: the post-chain handshake
+        commit reads the wire params, so to veto the handshake raise *before*
+        `call_next()`.
 
     `Server[L].middleware` holds `ServerMiddleware[L]`, so an app-specific
     middleware sees `ctx.lifespan_context: L`. While the context is the

src/mcp/server/runner.py

@@ -201,11 +201,11 @@ async def to_jsonrpc_response(request_id: RequestId, coro: Awaitable[dict[str, A
 
 
 def _apply_middleware(
-    mw: ServerMiddleware[Any], call_next: CallNext, ctx: ServerRequestContext[Any, Any]
+    middleware: ServerMiddleware[Any], call_next: CallNext, ctx: ServerRequestContext[Any, Any]
 ) -> Awaitable[HandlerResult]:
     """Adapt one middleware to the `CallNext` shape: bind `call_next`, take
     `ctx` at call time so a rewritten context flows down the chain."""
-    return mw(ctx, call_next)
+    return middleware(ctx, call_next)
 
 
 @dataclass
@@ -228,7 +228,9 @@ def on_request(self) -> OnRequest:
         wraps everything - initialize, METHOD_NOT_FOUND, validation failures
         included.
         """
-        return reduce(lambda h, mw: mw(h), reversed(self.dispatch_middleware), self._on_request)
+        return reduce(
+            lambda handler, middleware: middleware(handler), reversed(self.dispatch_middleware), self._on_request
+        )
 
     @cached_property
     def on_notify(self) -> OnNotify:
@@ -303,6 +305,11 @@ async def _inner(ctx: ServerRequestContext[LifespanT, Any]) -> HandlerResult:
         if method == "initialize":
             # Commit only on chain success, so a middleware veto leaves no state.
             # Race-free: the read loop is parked until this call returns.
+            # TODO: this re-reads the wire `params`, so a middleware that rewrote
+            # `ctx.params` (or `ctx.method`, or short-circuited without `call_next`)
+            # can leave `connection.protocol_version` out of step with the
+            # `InitializeResult` `_inner` produced. Resolve when `initialize` becomes
+            # a built-in handler so commit and result derive from one negotiation.
             self.connection.client_params, self.connection.protocol_version = self._negotiate_initialize(params)
         return result
 
@@ -362,9 +369,9 @@ def _compose_server_middleware(self, inner: CallNext) -> CallNext:
         observes every inbound message. The composed callable takes the `ctx`
         at call time, so a middleware can rewrite it for the rest of the chain.
         """
-        call: CallNext = inner
-        for mw in reversed(self.server.middleware):
-            call = partial(_apply_middleware, mw, call)
+        call = inner
+        for middleware in reversed(self.server.middleware):
+            call = partial(_apply_middleware, middleware, call)
         return call
 
     def _make_context(

src/mcp/shared/_otel.py

@@ -41,10 +41,16 @@ def inject_trace_context(meta: dict[str, Any]) -> None:
     inject(meta)
 
 
-def extract_trace_context(meta: Mapping[str, Any]) -> Context:
-    """Extract W3C trace context from a `_meta` dict."""
+def extract_trace_context(meta: Mapping[str, Any] | None) -> Context | None:
+    """Extract W3C trace context from a `_meta` dict.
+
+    Returns `None` when the carrier is absent or malformed so callers fall
+    through to ambient parenting; an explicit empty `Context` would orphan
+    the span instead of nesting under the current one.
+    """
+    if not meta:
+        return None
     try:
         return extract(meta)
     except (ValueError, TypeError):
-        # If the traceparent is malformed, degrade to no parent rather than failing the request.
-        return Context()
+        return None

tests/server/test_otel.py

@@ -10,6 +10,7 @@
 from mcp.server._otel import OpenTelemetryMiddleware
 from mcp.server.context import CallNext
 from mcp.server.lowlevel.server import Server
+from mcp.server.runner import otel_middleware
 from mcp.shared._otel import inject_trace_context
 from mcp.shared.exceptions import MCPError
 from mcp.types import CallToolRequestParams, ListToolsResult, NotificationParams, PaginatedRequestParams, Tool
@@ -64,6 +65,36 @@ async def on_roots(ctx: Ctx, params: NotificationParams | None) -> None:
     assert "jsonrpc.request.id" not in span.attributes
 
 
+@pytest.mark.anyio
+async def test_nests_under_ambient_span_when_no_traceparent(server: SrvT, spans: SpanCapture):
+    """With no `_meta` on the inbound message (a non-SDK client), the
+    context-tier span must parent to the ambient current span (here, the
+    dispatch-tier `otel_middleware` span) rather than become an orphan root.
+    SDK-defined: SEP-414 only covers the traceparent-present case."""
+
+    def strip_meta(call_next: Any) -> Any:
+        # The in-process client always injects `_meta.traceparent`; strip it so
+        # both server tiers see the no-carrier path.
+        async def wrapped(dctx: Any, method: str, params: dict[str, Any] | None) -> Any:
+            stripped = {k: v for k, v in (params or {}).items() if k != "_meta"}
+            return await call_next(dctx, method, stripped or None)
+
+        return wrapped
+
+    server.middleware.append(OpenTelemetryMiddleware())
+    async with connected_runner(server, dispatch_middleware=[strip_meta, otel_middleware]) as (client, _):
+        spans.clear()
+        await client.send_raw_request("tools/list", None)
+    server_spans = [s for s in spans.finished() if s.kind == SpanKind.SERVER]
+    assert len(server_spans) == 2
+    [outer] = [s for s in server_spans if s.parent is None]
+    [inner] = [s for s in server_spans if s.parent is not None]
+    assert inner.context is not None and outer.context is not None
+    assert inner.parent is not None
+    assert inner.context.trace_id == outer.context.trace_id
+    assert inner.parent.span_id == outer.context.span_id
+
+
 @pytest.mark.anyio
 async def test_extracts_trace_context_from_meta(server: SrvT, spans: SpanCapture):
     meta: dict[str, Any] = {}