fix: resource with only Context param no longer classified as template

When a @mcp.resource() handler has only a Context parameter (no URI
template params), it was incorrectly classified as a resource template
because bool(sig.parameters) counted the Context param. Now the Context
parameter is excluded before checking has_func_params.

Also adds context injection support to FunctionResource so that
context-only resources can access the server context when read.

Fixes #1635

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Varun Sharma

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

@@ -51,12 +51,18 @@ class FunctionResource(Resource):
     """
 
     fn: Callable[[], Any] = Field(exclude=True)
+    context_kwarg: str | None = Field(default=None, exclude=True)
 
-    async def read(self) -> str | bytes:
+    async def read(self, context: Any | None = None) -> str | bytes:
         """Read the resource by calling the wrapped function."""
         try:
+            # Inject context if needed
+            kwargs: dict[str, Any] = {}
+            if self.context_kwarg is not None and context is not None:
+                kwargs[self.context_kwarg] = context
+
             # Call the function first to see if it returns a coroutine
-            result = self.fn()
+            result = self.fn(**kwargs)
             # If it's a coroutine, await it
             if inspect.iscoroutine(result):
                 result = await result
@@ -84,12 +90,19 @@ def from_function(
         icons: list[Icon] | None = None,
         annotations: Annotations | None = None,
         meta: dict[str, Any] | None = None,
+        context_kwarg: str | None = None,
     ) -> "FunctionResource":
         """Create a FunctionResource from a function."""
+        from mcp.server.mcpserver.utilities.context_injection import find_context_parameter
+
         func_name = name or fn.__name__
         if func_name == "<lambda>":  # pragma: no cover
             raise ValueError("You must provide a name for lambda functions")
 
+        # Detect context parameter
+        if context_kwarg is None:
+            context_kwarg = find_context_parameter(fn)
+
         # ensure the arguments are properly cast
         fn = validate_call(fn)
 
@@ -103,6 +116,7 @@ def from_function(
             icons=icons,
             annotations=annotations,
             meta=meta,
+            context_kwarg=context_kwarg,
         )
 
 

src/mcp/server/mcpserver/server.py

@@ -448,7 +448,10 @@ async def read_resource(self, uri: AnyUrl | str) -> Iterable[ReadResourceContent
             raise ResourceError(f"Unknown resource: {uri}")
 
         try:
-            content = await resource.read()
+            if isinstance(resource, FunctionResource):
+                content = await resource.read(context=context)
+            else:
+                content = await resource.read()
             return [ReadResourceContents(content=content, mime_type=resource.mime_type, meta=resource.meta)]
         except Exception as exc:
             logger.exception(f"Error getting resource {uri}")
@@ -686,12 +689,12 @@ def decorator(fn: _CallableT) -> _CallableT:
             # Check if this should be a template
             sig = inspect.signature(fn)
             has_uri_params = "{" in uri and "}" in uri
-            has_func_params = bool(sig.parameters)
 
-            if has_uri_params or has_func_params:
-                # Check for Context parameter to exclude from validation
-                context_param = find_context_parameter(fn)
+            # Exclude Context parameter when checking for function params
+            context_param = find_context_parameter(fn)
+            has_func_params = bool({p for p in sig.parameters if p != context_param})
 
+            if has_uri_params or has_func_params:
                 # Validate that URI params match function params (excluding context)
                 uri_params = set(re.findall(r"{(\w+)}", uri))
                 # We need to remove the context_param from the resource function if

tests/server/mcpserver/test_server.py

@@ -1189,6 +1189,29 @@ def resource_custom_ctx(id: str, my_ctx: Context[ServerSession, None]) -> str:
                 )
             )
 
+    async def test_resource_with_context_only_not_classified_as_template(self):
+        """Test that a resource with only a Context param is registered as a resource, not a template."""
+        mcp = MCPServer()
+
+        @mcp.resource("time://current")
+        def current_time(ctx: Context[ServerSession, None]) -> str:
+            """Resource with only context parameter."""
+            return "11:41"
+
+        # Should be registered as a regular resource, not a template
+        resources = await mcp.list_resources()
+        templates = mcp._resource_manager.list_templates()
+        assert len(resources) == 1
+        assert str(resources[0].uri) == "time://current"
+        assert len(templates) == 0
+
+        async with Client(mcp) as client:
+            result = await client.read_resource("time://current")
+            assert len(result.contents) == 1
+            content = result.contents[0]
+            assert isinstance(content, TextResourceContents)
+            assert content.text == "11:41"
+
     async def test_prompt_with_context(self):
         """Test that prompts can receive context parameter."""
         mcp = MCPServer()