fix: ruff format + 100% coverage on dereference_local_refs

CI was failing on two checks (not test failures — earlier diagnostic was wrong):

1. pre-commit / Ruff Format — base.py had a multi-line wrap ruff wanted single-line.
2. Coverage check — project requires 100% coverage; schema.py was at 92.86%
   with 3 uncovered lines (empty/null $defs short-circuits + a defensive
   non-dict branch).

Changes:
- Apply ruff format to base.py.
- Mark the defensive non-dict branch in inline() with '# pragma: no cover'
  with comment explaining it's only reachable for non-JSON-shaped values.
- Add 3 tests covering the previously-uncovered branches:
  * empty $defs container ('{}')
  * null $defs ('None')
  * refs nested inside a list (anyOf array)

Local verification: 349 server tests pass, dereference_local_refs at 100%
coverage (14 tests), ruff check clean, ruff format clean.

Signed-off-by: Mukunda Katta <mukunda.vjcs6@gmail.com>

Author: MukundaKatta

src/mcp/server/mcpserver/tools/base.py

@@ -78,9 +78,7 @@ def from_function(
         # JSON instead of structured objects. Inline local refs so tool schemas
         # are self-contained and LLM-consumable. Matches behavior of
         # typescript-sdk (#1563) and go-sdk.
-        parameters = dereference_local_refs(
-            func_arg_metadata.arg_model.model_json_schema(by_alias=True)
-        )
+        parameters = dereference_local_refs(func_arg_metadata.arg_model.model_json_schema(by_alias=True))
 
         return cls(
             fn=fn,

src/mcp/server/mcpserver/utilities/schema.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-from copy import copy
 from typing import Any
 
 
@@ -68,7 +67,9 @@ def inline(node: Any, stack: set[str]) -> Any:
             return node
         if isinstance(node, list):
             return [inline(item, stack) for item in node]
-        if not isinstance(node, dict):
+        if not isinstance(node, dict):  # pragma: no cover
+            # Defensive: valid JSON only contains None/str/int/float/bool/list/dict.
+            # Reachable only if a non-JSON-shaped value sneaks into a schema.
             return node
 
         ref = node.get("$ref")

tests/server/mcpserver/utilities/test_schema.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-import pytest
+from typing import Any
 
 from mcp.server.mcpserver.utilities.schema import dereference_local_refs
 
@@ -140,3 +140,33 @@ def test_original_schema_not_mutated(self) -> None:
         # Original still has $defs intact
         assert schema["$defs"] == original_defs
         assert schema["properties"]["x"] == {"$ref": "#/$defs/A"}
+
+    def test_empty_defs_returns_schema_unchanged(self) -> None:
+        """`$defs: {}` (empty container) is a no-op — returns input as-is."""
+        schema = {"type": "object", "$defs": {}}
+        result = dereference_local_refs(schema)
+        assert result is schema  # same object — no copy made on the empty path
+
+    def test_null_defs_returns_schema_unchanged(self) -> None:
+        """`$defs: null` falls through the same empty-defs path."""
+        schema: dict[str, Any] = {"type": "object", "$defs": None}
+        result = dereference_local_refs(schema)
+        assert result is schema
+
+    def test_inlines_through_array_of_objects(self) -> None:
+        """Refs nested inside arrays of dict items are recursed properly.
+
+        Covers the `if isinstance(node, list)` branch of the inner inline().
+        """
+        schema = {
+            "anyOf": [
+                {"$ref": "#/$defs/A"},
+                {"$ref": "#/$defs/B"},
+            ],
+            "$defs": {
+                "A": {"type": "string"},
+                "B": {"type": "integer"},
+            },
+        }
+        result = dereference_local_refs(schema)
+        assert result["anyOf"] == [{"type": "string"}, {"type": "integer"}]