fix: preserve empty list items in explode matching

_extract_path was dropping all empty segments when splitting an
explode capture, but only the first empty item comes from the
leading operator prefix. Subsequent empties are legitimate values:
{/path*} with ['a', '', 'c'] expands to /a//c and must match back
to the same list.

Split by separator, strip only items[0] if empty, then iterate.
The ; operator is unaffected since empty values use the bare-name
form which is a non-empty segment.

Author: maxisbey

src/mcp/shared/uri_template.py

@@ -522,9 +522,14 @@ def _extract_path(m: re.Match[str], variables: Sequence[Variable]) -> dict[str,
                 continue
             segments: list[str] = []
             prefix = f"{var.name}="
-            for seg in raw.split(spec.separator):
-                if not seg:  # leading separator produces an empty first item
-                    continue
+            # Splitting on the separator yields an empty first item from
+            # the leading prefix. Strip only that one; subsequent empty
+            # items are legitimate empty values ({/path*} with ["a","","c"]
+            # expands to /a//c and must round-trip).
+            items = raw.split(spec.separator)
+            if items and not items[0]:
+                items = items[1:]
+            for seg in items:
                 if spec.named:
                     # Named explode emits name=value per item (or bare
                     # name for ; with empty value). Validate the name

tests/shared/test_uri_template.py

@@ -512,6 +512,19 @@ def test_match_adjacent_vars_with_prefix_names():
     assert t.match("abcd") == {"var": "abcd", "vara": ""}
 
 
+def test_match_explode_preserves_empty_list_items():
+    # Splitting the explode capture on its separator yields a leading
+    # empty item from the operator prefix; only that one is stripped.
+    # Subsequent empties are legitimate values from the input list.
+    t = UriTemplate.parse("{/path*}")
+    assert t.match("/a//c") == {"path": ["a", "", "c"]}
+    assert t.match("//a") == {"path": ["", "a"]}
+    assert t.match("/a/") == {"path": ["a", ""]}
+
+    t = UriTemplate.parse("host{.labels*}")
+    assert t.match("host.a..c") == {"labels": ["a", "", "c"]}
+
+
 def test_match_adjacent_vars_disambiguated_by_literal():
     # A literal between vars resolves the ambiguity.
     t = UriTemplate.parse("{a}-{b}")
@@ -609,6 +622,10 @@ def test_match_explode_encoded_separator_in_segment():
         ("x{name}y", {"name": ""}),
         ("item{;keys*}", {"keys": ["a", "b", "c"]}),
         ("item{;keys*}", {"keys": ["a", "", "b"]}),
+        # Empty strings in explode lists round-trip for unnamed operators
+        ("{/path*}", {"path": ["a", "", "c"]}),
+        ("{/path*}", {"path": ["", "a"]}),
+        ("host{.labels*}", {"labels": ["a", "", "c"]}),
         # Partial query expansion round-trips: expand omits undefined
         # vars, match leaves them absent from the result.
         ("logs://{service}{?since,level}", {"service": "api"}),