fix: decide template vs static purely on URI variables

The @resource() decorator now classifies resources based solely on
whether the URI contains template variables, not on whether the
handler has parameters.

Previously, a handler taking only a Context parameter on a
non-template URI would register as a zero-variable template. The
template matched with an empty dict, which the walrus check in
resource_manager treated as falsy, making the resource permanently
unreachable. This has never worked.

Now such a handler errors at decoration time with a clear message
noting that Context injection for static resources is planned but not
yet supported. Handlers with non-Context parameters on non-template
URIs also get a clearer error than the old 'Mismatch' message.

Also changes the resource_manager walrus check to compare against
None explicitly, as defense-in-depth against any future case where
matches() legitimately returns an empty dict.

Author: maxisbey

src/mcp/server/mcpserver/resources/resource_manager.py

@@ -93,7 +93,7 @@ async def get_resource(self, uri: AnyUrl | str, context: Context[LifespanContext
 
         # Then check templates
         for template in self._templates.values():
-            if params := template.matches(uri_str):
+            if (params := template.matches(uri_str)) is not None:
                 try:
                     return await template.create_resource(uri_str, params, context=context)
                 except Exception as e:  # pragma: no cover

src/mcp/server/mcpserver/server.py

@@ -702,18 +702,13 @@ async def get_weather(city: str) -> str:
         uri_params = set(parsed.variable_names)
 
         def decorator(fn: _CallableT) -> _CallableT:
-            # Check if this should be a template
             sig = inspect.signature(fn)
-            has_func_params = bool(sig.parameters)
-
-            if uri_params or has_func_params:
-                # Check for Context parameter to exclude from validation
-                context_param = find_context_parameter(fn)
-
-                # We need to remove the context_param from the resource function if
-                # there is any.
-                func_params = {p for p in sig.parameters.keys() if p != context_param}
+            context_param = find_context_parameter(fn)
+            func_params = {p for p in sig.parameters.keys() if p != context_param}
 
+            # Template/static is decided purely by the URI: variables
+            # present means template, none means static.
+            if uri_params:
                 if uri_params != func_params:
                     raise ValueError(
                         f"Mismatch between URI parameters {uri_params} and function parameters {func_params}"
@@ -733,6 +728,20 @@ def decorator(fn: _CallableT) -> _CallableT:
                     meta=meta,
                 )
             else:
+                if func_params:
+                    raise ValueError(
+                        f"Resource {uri!r} has no URI template variables, but the "
+                        f"handler declares parameters {func_params}. Add matching "
+                        f"{{...}} variables to the URI or remove the parameters."
+                    )
+                if context_param is not None:
+                    raise ValueError(
+                        f"Resource {uri!r} has no URI template variables, but the "
+                        f"handler declares a Context parameter. Context injection "
+                        f"for static resources is not yet supported but is planned. "
+                        f"For now, add a template variable to the URI or remove the "
+                        f"Context parameter."
+                    )
                 # Register as regular resource
                 resource = FunctionResource.from_function(
                     fn=fn,

tests/server/mcpserver/test_server.py

@@ -851,7 +851,7 @@ async def test_resource_with_params(self):
         parameters don't match"""
         mcp = MCPServer()
 
-        with pytest.raises(ValueError, match="Mismatch between URI parameters"):
+        with pytest.raises(ValueError, match="has no URI template variables"):
 
             @mcp.resource("resource://data")
             def get_data_fn(param: str) -> str:  # pragma: no cover
@@ -1192,6 +1192,29 @@ def resource_with_context(name: str, ctx: Context) -> str:
             # Should have either request_id or indication that context was injected
             assert "Resource test - context injected" == content.text
 
+    async def test_static_resource_with_context_param_errors(self):
+        """A non-template URI with a Context-only handler should error
+        at decoration time with a clear message, not silently register
+        an unreachable resource."""
+        mcp = MCPServer()
+
+        with pytest.raises(ValueError, match="Context injection for static resources is not yet supported"):
+
+            @mcp.resource("weather://current")
+            def current_weather(ctx: Context) -> str:
+                raise NotImplementedError
+
+    async def test_static_resource_with_extra_params_errors(self):
+        """A non-template URI with non-Context params should error at
+        decoration time."""
+        mcp = MCPServer()
+
+        with pytest.raises(ValueError, match="has no URI template variables"):
+
+            @mcp.resource("data://fixed")
+            def get_data(name: str) -> str:
+                raise NotImplementedError
+
     async def test_resource_without_context(self):
         """Test that resources without context work normally."""
         mcp = MCPServer()