🟡 Nit: request_data.setdefault("params", {}).setdefault("_meta", {}) unconditionally adds params: {"_meta": {}} to every request, even paramless ones like ping and even when no OTel SDK is configured (where inject() is a no-op). Consider guarding the setdefault chain so _meta is only created when there is an active trace context to inject.

What the bug is

At line 280-282 of session.py, inside send_request, the code unconditionally calls:

meta: dict[str, Any] = request_data.setdefault("params", {}).setdefault("_meta", {})
inject_trace_context(meta)

This creates both a params key and a nested _meta key on every outgoing request, regardless of whether the request originally had params or whether an OTel SDK is actually configured.

How it manifests

Consider a PingRequest, which has params=None. When serialized via model_dump(exclude_none=True), the resulting request_data dict has no params key at all. Before this PR, the wire format would be:

{"jsonrpc": "2.0", "id": 0, "method": "ping"}

After this PR, the setdefault chain inserts params: {"_meta": {}}, changing the wire format to:

{"jsonrpc": "2.0", "id": 0, "method": "ping", "params": {"_meta": {}}}

When no OTel SDK is installed (the default case, since opentelemetry-api provides only a no-op tracer), inject() writes nothing into the dict, leaving an empty _meta: {} in every request.

Why existing code doesn't prevent it

The setdefault calls are placed unconditionally inside the otel_span context manager, with no check for whether there is actually a valid span context to propagate. The inject_trace_context wrapper simply calls inject(meta) without any conditional logic.

Impact

The practical impact is low. _meta is a well-defined field in the MCP protocol, and RequestParams validates {"_meta": {}} correctly since all RequestParamsMeta fields are NotRequired. No server should break from receiving this. However, it adds unnecessary bytes to every single request on the wire, even when tracing is completely unused, and it represents an unnecessary behavioral change to the wire format.

Suggested fix

Only create the _meta dict when there is an active span context worth propagating. For example, inject into a temporary dict first and only merge it into request_data if the dict is non-empty after injection:

tmp: dict[str, Any] = {}
inject_trace_context(tmp)
if tmp:
    request_data.setdefault("params", {}).setdefault("_meta", {}).update(tmp)

Step-by-step proof

1. Create a PingRequest with params=None.
2. model_dump(exclude_none=True) produces {"method": "ping"}.
3. request_data.setdefault("params", {}) inserts "params": {} and returns {}.
4. .setdefault("_meta", {}) inserts "_meta": {} into that new params dict.
5. inject_trace_context(meta) calls inject({}) which, with no OTel SDK, is a no-op.
6. The final request_data is {"method": "ping", "params": {"_meta": {}}} with extra fields that were never there before.

An empty _meta: {} is harmless per the MCP spec. When no OTel SDK is configured, inject() is already a no-op (writes nothing). Guarding this adds complexity for no benefit.

🟡 # pragma: no branch on line 482 is incorrect — PingRequest has params: RequestParams | None = None, so when a ping arrives req.params is None and the false branch is genuinely taken. Per CLAUDE.md, this pragma should only be used for coverage.py ->exit arc misreports on nested async with, not for real conditional branches. Remove the pragma to avoid masking missing test coverage for the None-params path.

What the bug is

The PR adds # pragma: no branch to the condition if hasattr(req, "params") and req.params is not None: at server.py:482. This pragma tells coverage.py that the false branch of this conditional is never taken, suppressing any coverage warning for the missing branch.

Why this is incorrect

PingRequest is defined as Request[RequestParams | None, ...] with params: RequestParams | None = None (see types/_types.py:589). When the server handles a ping request, req.params IS None, so the condition evaluates to False and the false branch is genuinely executed — task_metadata stays None and execution falls through to constructing the ServerRequestContext.

Step-by-step proof

1. A client sends a PingRequest with default params=None.
2. The server dispatches to _handle_request with this request.
3. At line 482, hasattr(req, "params") is True (PingRequest always has a params attribute), but req.params is not None is False.
4. The overall condition is False, so the body (task_metadata = getattr(req.params, "task", None)) is skipped.
5. task_metadata remains None from its initialization on line 481.
6. However, # pragma: no branch tells coverage.py this false branch never happens, which is wrong.

Project convention violated

The project's CLAUDE.md (lines 55-56) explicitly states that # pragma: no branch should only be used when coverage.py misreports the ->exit arc for nested async with blocks on Python 3.11+. This is a genuine conditional branch, not an async-with exit arc issue.

Impact

The impact is limited to test coverage reporting — this has zero runtime effect. The pragma was not present in the original code (visible in the diff) and was newly added by this PR. It could mask the fact that tests don't exercise the None-params path through this conditional, defeating the purpose of the project's 100% branch coverage requirement.

Fix

Simply remove the # pragma: no branch comment from line 482. If coverage then reports the false branch as uncovered, add a test that exercises a PingRequest (which has params=None) to cover it properly.

Pre-existing pragma, not introduced by this PR.