Reject unanchored bounded vars on both sides of a greedy var

A template like {a}{+p}{b}Y{c} has bounded variables immediately
adjacent to the greedy var on both sides with no literal anchor on
either. The scan cannot determine where {a} ends or {b} begins; this
is now rejected at parse time alongside the existing adjacent-bounded
check. Templates with a literal anchor on at least one side
({a}{+p}-{b}, X{+a}{b}, {name}{+path}{.ext}) remain supported.

Author: maxisbey

src/mcp/shared/uri_template.py

@@ -25,7 +25,8 @@
 surrounding bounded variables and literals do not. Two such variables
 in one template are inherently ambiguous (which one gets the extra
 segment?) and are rejected at parse time. Two adjacent bounded
-variables with no literal between them are rejected for the same
+variables with no literal between them — or bordering the
+multi-segment variable on both sides — are rejected for the same
 reason: the scan has nothing to anchor the boundary on.
 
 Bounded variables before the multi-segment variable match **lazily**
@@ -550,9 +551,11 @@ def _scan(self, uri: str) -> dict[str, str | list[str]] | None:
             prefix_result, prefix_end = prefix
         else:
             # Suffix begins with a _Cap (or is empty): its start IS the
-            # floor, so prefix must scan first. Ceiling reserves suffix
-            # _Lit bytes only — exact here, since with no leading suffix
-            # _Cap the trailing prefix _Cap may safely run up to it.
+            # floor, so prefix must scan first. Parse-time rejection of
+            # a bounded _Cap on *both* sides of the greedy slot means
+            # the prefix here ends in a _Lit (or is empty), so there is
+            # no trailing prefix _Cap to over-consume — reserving only
+            # the suffix _Lit bytes is sufficient.
             ceiling = n - sum(len(a.text) for a in self._suffix if isinstance(a, _Lit))
             prefix = _scan_prefix(self._prefix, uri, 0, ceiling)
             if prefix is None:
@@ -931,8 +934,9 @@ def _partition_greedy(atoms: list[_Atom], template: str) -> tuple[list[_Atom], V
             present (two multi-segment variables in one template are
             inherently ambiguous — there is no principled way to decide
             which one absorbs an extra segment), or if two bounded
-            variables are adjacent with no literal between them (the
-            scan cannot determine where one ends and the other begins).
+            variables are adjacent with no literal between them, or if
+            bounded variables border the greedy slot on both sides (in
+            either case the scan has nothing to anchor a boundary on).
     """
     greedy_idx: int | None = None
     prev: _Atom | None = None
@@ -958,7 +962,16 @@ def _partition_greedy(atoms: list[_Atom], template: str) -> tuple[list[_Atom], V
         return [], None, atoms
     greedy = atoms[greedy_idx]
     assert isinstance(greedy, _Cap)
-    return atoms[:greedy_idx], greedy.var, atoms[greedy_idx + 1 :]
+    prefix, suffix = atoms[:greedy_idx], atoms[greedy_idx + 1 :]
+    if prefix and suffix and isinstance(prefix[-1], _Cap) and isinstance(suffix[0], _Cap):
+        raise InvalidUriTemplate(
+            f"Variables {prefix[-1].var.name!r} and {suffix[0].var.name!r} border "
+            f"multi-segment variable {greedy.var.name!r} on both sides with no "
+            "literal separator; matching cannot determine where they end. Add a "
+            "literal before or after the multi-segment variable.",
+            template=template,
+        )
+    return prefix, greedy.var, suffix
 
 
 def _scan_suffix(

tests/shared/test_uri_template.py

@@ -198,6 +198,23 @@ def test_parse_rejects_adjacent_bounded_variables(template: str) -> None:
         UriTemplate.parse(template)
 
 
+@pytest.mark.parametrize(
+    "template",
+    [
+        "{a}{+b}{c}",
+        "{a}{+p}{b}Y{c}",
+        "X{a}{+p}{b}Y{c}",
+        "{a}{/p*}{b}",
+    ],
+)
+def test_parse_rejects_unanchored_greedy_adjacency(template: str) -> None:
+    # Bounded captures on *both* sides of the greedy slot with no literal
+    # anchor on either: the prefix scan cannot tell where {a} stops and
+    # the suffix scan cannot tell where the trailing var starts.
+    with pytest.raises(InvalidUriTemplate, match="border multi-segment variable"):
+        UriTemplate.parse(template)
+
+
 @pytest.mark.parametrize(
     "template",
     [
@@ -221,7 +238,12 @@ def test_parse_rejects_adjacent_bounded_variables(template: str) -> None:
         "{.a}{+b}",
         "{/a}{+b}",
         "x{name}{+path}y",
-        "{a}{+b}{c}",  # greedy slot legitimately separates two bounded caps
+        # Bounded var on each side is fine when at least one side has a
+        # literal anchor (operator-prefixed or explicit).
+        "{name}{+path}{.ext}",
+        "{a}-{+p}{b}",
+        "{a}{+p}-{b}",
+        "{base}{+p}{;k}",
     ],
 )
 def test_parse_allows_single_multi_segment_variable(template: str):