🚀 The fast, Pythonic way to build MCP servers and clients.
Add task_meta parameter to read_resource() for explicit task control (#2750)
Jeremiah Lowinfc19f1f8de7e
diff --git a/src/fastmcp/resources/resource.py b/src/fastmcp/resources/resource.pyindex 1a90bdb70..61739bb5e 100644--- a/src/fastmcp/resources/resource.py+++ b/src/fastmcp/resources/resource.py@@ -5,7 +5,8 @@ from __future__ import annotationsimport base64import inspectfrom collections.abc import Callable-from typing import TYPE_CHECKING, Annotated, Any, ClassVar+from dataclasses import replace+from typing import TYPE_CHECKING, Annotated, Any, ClassVar, overloadimport mcp.types@@ -27,7 +28,7 @@ from pydantic import (from typing_extensions import Selffrom fastmcp.server.dependencies import without_injected_parameters-from fastmcp.server.tasks.config import TaskConfig+from fastmcp.server.tasks.config import TaskConfig, TaskMetafrom fastmcp.utilities.components import FastMCPComponentfrom fastmcp.utilities.types import get_fn_name@@ -300,23 +301,42 @@ class Resource(FastMCPComponent):# ResourceResult.__init__ handles all normalizationreturn ResourceResult(raw_value)- async def _read(self) -> ResourceResult | mcp.types.CreateTaskResult:+ @overload+ async def _read(self, task_meta: None = None) -> ResourceResult: ...++ @overload+ async def _read(self, task_meta: TaskMeta) -> mcp.types.CreateTaskResult: ...++ async def _read(+ self, task_meta: TaskMeta | None = None+ ) -> ResourceResult | mcp.types.CreateTaskResult:"""Server entry point that handles task routing.This allows ANY Resource subclass to support background execution by settingtask_config.mode to "supported" or "required". The server calls thismethod instead of read() directly.+ Args:+ task_meta: If provided, execute as a background task and return+ CreateTaskResult. If None (default), execute synchronously and+ return ResourceResult.++ Returns:+ ResourceResult when task_meta is None.+ CreateTaskResult when task_meta is provided.+Subclasses can override this to customize task routing behavior.For example, FastMCPProviderResource overrides to delegate to childmiddleware without submitting to Docket."""- from fastmcp.server.dependencies import _docket_fn_keyfrom fastmcp.server.tasks.routing import check_background_task- key = _docket_fn_key.get() or self.key+ # Enrich task_meta with fn_key if not already set (fallback for programmatic API)+ if task_meta is not None and task_meta.fn_key is None:+ task_meta = replace(task_meta, fn_key=self.key)+task_result = await check_background_task(- component=self, task_type="resource", key=key+ component=self, task_type="resource", arguments=None, task_meta=task_meta)if task_result:return task_resultdiff --git a/src/fastmcp/resources/template.py b/src/fastmcp/resources/template.pyindex 3f73d512e..e56746ca0 100644--- a/src/fastmcp/resources/template.py+++ b/src/fastmcp/resources/template.py@@ -5,7 +5,8 @@ from __future__ import annotationsimport inspectimport refrom collections.abc import Callable-from typing import TYPE_CHECKING, Any, ClassVar+from dataclasses import replace+from typing import TYPE_CHECKING, Any, ClassVar, overloadfrom urllib.parse import parse_qs, unquoteimport mcp.types@@ -23,7 +24,7 @@ from pydantic import (from fastmcp.resources.resource import Resource, ResourceResultfrom fastmcp.server.dependencies import without_injected_parameters-from fastmcp.server.tasks.config import TaskConfig+from fastmcp.server.tasks.config import TaskConfig, TaskMetafrom fastmcp.utilities.components import FastMCPComponentfrom fastmcp.utilities.json_schema import compress_schemafrom fastmcp.utilities.types import get_cached_typeadapter@@ -177,8 +178,18 @@ class ResourceTemplate(FastMCPComponent):# ResourceResult.__init__ handles all normalizationreturn ResourceResult(raw_value)+ @overloadasync def _read(- self, uri: str, params: dict[str, Any]+ self, uri: str, params: dict[str, Any], task_meta: None = None+ ) -> ResourceResult: ...++ @overload+ async def _read(+ self, uri: str, params: dict[str, Any], task_meta: TaskMeta+ ) -> mcp.types.CreateTaskResult: ...++ async def _read(+ self, uri: str, params: dict[str, Any], task_meta: TaskMeta | None = None) -> ResourceResult | mcp.types.CreateTaskResult:"""Server entry point that handles task routing.@@ -186,19 +197,29 @@ class ResourceTemplate(FastMCPComponent):by setting task_config.mode to "supported" or "required". The server callsthis method instead of create_resource()/read() directly.+ Args:+ uri: The concrete URI being read+ params: Template parameters extracted from the URI+ task_meta: If provided, execute as a background task and return+ CreateTaskResult. If None (default), execute synchronously and+ return ResourceResult.++ Returns:+ ResourceResult when task_meta is None.+ CreateTaskResult when task_meta is provided.+Subclasses can override this to customize task routing behavior.For example, FastMCPProviderResourceTemplate overrides to delegate to childmiddleware without submitting to Docket."""- from fastmcp.server.dependencies import _docket_fn_keyfrom fastmcp.server.tasks.routing import check_background_task- # Templates need pattern check: only use contextvar if it contains '{'- key = _docket_fn_key.get()- if not key or "{" not in key:- key = self.key+ # Enrich task_meta with fn_key if not already set (fallback for programmatic API)+ if task_meta is not None and task_meta.fn_key is None:+ task_meta = replace(task_meta, fn_key=self.key)+task_result = await check_background_task(- component=self, task_type="template", key=key, arguments=params+ component=self, task_type="template", arguments=params, task_meta=task_meta)if task_result:return task_result@@ -294,23 +315,43 @@ class FunctionResourceTemplate(ResourceTemplate):fn: Callable[..., Any]+ @overloadasync def _read(- self, uri: str, params: dict[str, Any]+ self, uri: str, params: dict[str, Any], task_meta: None = None+ ) -> ResourceResult: ...++ @overload+ async def _read(+ self, uri: str, params: dict[str, Any], task_meta: TaskMeta+ ) -> mcp.types.CreateTaskResult: ...++ async def _read(+ self, uri: str, params: dict[str, Any], task_meta: TaskMeta | None = None) -> ResourceResult | mcp.types.CreateTaskResult:"""Optimized server entry point that skips ephemeral resource creation.For FunctionResourceTemplate, we can call read() directly instead ofcreating a temporary resource, which is more efficient.++ Args:+ uri: The concrete URI being read+ params: Template parameters extracted from the URI+ task_meta: If provided, execute as a background task and return+ CreateTaskResult. If None (default), execute synchronously and+ return ResourceResult.++ Returns:+ ResourceResult when task_meta is None.+ CreateTaskResult when task_meta is provided."""- from fastmcp.server.dependencies import _docket_fn_keyfrom fastmcp.server.tasks.routing import check_background_task- # Templates need pattern check: only use contextvar if it contains '{'- key = _docket_fn_key.get()- if not key or "{" not in key:- key = self.key+ # Enrich task_meta with fn_key if not already set (fallback for programmatic API)+ if task_meta is not None and task_meta.fn_key is None:+ task_meta = replace(task_meta, fn_key=self.key)+task_result = await check_background_task(- component=self, task_type="template", key=key, arguments=params+ component=self, task_type="template", arguments=params, task_meta=task_meta)if task_result:return task_resultdiff --git a/src/fastmcp/server/providers/fastmcp_provider.py b/src/fastmcp/server/providers/fastmcp_provider.pyindex ee345bd9e..e94ac782a 100644--- a/src/fastmcp/server/providers/fastmcp_provider.py+++ b/src/fastmcp/server/providers/fastmcp_provider.py@@ -13,7 +13,8 @@ from __future__ import annotationsimport refrom collections.abc import AsyncIterator, Sequencefrom contextlib import asynccontextmanager-from typing import TYPE_CHECKING, Any+from dataclasses import replace+from typing import TYPE_CHECKING, Any, overloadimport mcp.typesfrom mcp.types import AnyUrl@@ -85,6 +86,20 @@ class FastMCPProviderTool(Tool):task_config=tool.task_config,)+ @overload+ async def _run(+ self,+ arguments: dict[str, Any],+ task_meta: None = None,+ ) -> ToolResult: ...++ @overload+ async def _run(+ self,+ arguments: dict[str, Any],+ task_meta: TaskMeta,+ ) -> mcp.types.CreateTaskResult: ...+async def _run(self,arguments: dict[str, Any],@@ -94,7 +109,15 @@ class FastMCPProviderTool(Tool):Passes task_meta through to the child server so it can handlebackgrounding appropriately.++ Enriches fn_key with self.key (the parent's namespaced tool name) so that+ when the child tool delegates to Docket, it uses the correct lookup key+ that was registered via get_tasks()."""+ # Enrich fn_key with parent's key before delegating to child+ if task_meta is not None and task_meta.fn_key is None:+ task_meta = replace(task_meta, fn_key=self.key)+return await self._server.call_tool(self._original_name, arguments, task_meta=task_meta)@@ -148,19 +171,29 @@ class FastMCPProviderResource(Resource):task_config=resource.task_config,)- async def _read(self) -> ResourceResult | mcp.types.CreateTaskResult:- """Skip task routing - delegate to child server's read_resource().+ @overload+ async def _read(self, task_meta: None = None) -> ResourceResult: ...- The actual underlying resource will check _task_metadata contextvar and- submit to Docket if appropriate. This wrapper just passes through.+ @overload+ async def _read(self, task_meta: TaskMeta) -> mcp.types.CreateTaskResult: ...- Note: The _docket_fn_key contextvar is intentionally NOT updated here.- The parent set it to the full namespaced key (e.g., data://c/gc/value)- which is what the function is registered under in Docket. All provider- layers pass this through unchanged so the eventual resource._read()- uses the correct Docket lookup key.+ async def _read(+ self, task_meta: TaskMeta | None = None+ ) -> ResourceResult | mcp.types.CreateTaskResult:+ """Delegate to child server's read_resource() with task_meta.++ Passes task_meta through to the child server so it can handle+ backgrounding appropriately.++ Enriches fn_key with self.key (the parent's namespaced URI) so that+ when the child resource delegates to Docket, it uses the correct+ lookup key that was registered via get_tasks()."""- return await self._server.read_resource(self._original_uri)+ # Enrich fn_key with parent's URI before delegating to child+ if task_meta is not None and task_meta.fn_key is None:+ task_meta = TaskMeta(ttl=task_meta.ttl, fn_key=self.key)++ return await self._server.read_resource(self._original_uri, task_meta=task_meta)class FastMCPProviderPrompt(Prompt):@@ -277,41 +310,36 @@ class FastMCPProviderResourceTemplate(ResourceTemplate):mime_type=self.mime_type,)+ @overloadasync def _read(- self, uri: str, params: dict[str, Any]- ) -> ResourceResult | mcp.types.CreateTaskResult:- """Delegate to child server's read_resource().+ self, uri: str, params: dict[str, Any], task_meta: None = None+ ) -> ResourceResult: ...++ @overload+ async def _read(+ self, uri: str, params: dict[str, Any], task_meta: TaskMeta+ ) -> mcp.types.CreateTaskResult: ...- Skips task routing at this layer - the child's template._read() will- check _task_metadata contextvar and submit to Docket if appropriate.+ async def _read(+ self, uri: str, params: dict[str, Any], task_meta: TaskMeta | None = None+ ) -> ResourceResult | mcp.types.CreateTaskResult:+ """Delegate to child server's read_resource() with task_meta.- Sets _docket_fn_key to self.uri_template (the transformed pattern) so that- when the child template's _read() submits to Docket, it uses the correct- key that matches what was registered via TransformingProvider.get_tasks().+ Passes task_meta through to the child server so it can handle+ backgrounding appropriately.- Only sets _docket_fn_key if not already set - in nested mounts, the- outermost wrapper sets the key and inner wrappers preserve it.+ Enriches fn_key with self.key (the parent's namespaced template pattern)+ so that when the child template delegates to Docket, it uses the correct+ lookup key that was registered via get_tasks()."""- from fastmcp.server.dependencies import _docket_fn_key-# Expand the original template with params to get internal URIoriginal_uri = _expand_uri_template(self._original_uri_template or "", params)- # Set _docket_fn_key to the template pattern, but only if the current- # value isn't already a template pattern (contains '{').- # - Server sets concrete URI (e.g., "item://c/gc/42") - no '{', override it- # - Outer wrapper sets pattern (e.g., "item://c/gc/{id}") - has '{', keep it- # In nested mounts (parent→child→grandchild), the outermost wrapper- # has the fully-transformed pattern that matches Docket registration.- existing_key = _docket_fn_key.get()- key_token = None- if not existing_key or "{" not in existing_key:- key_token = _docket_fn_key.set(self.key)- try:- return await self._server.read_resource(original_uri)- finally:- if key_token is not None:- _docket_fn_key.reset(key_token)+ # Enrich fn_key with parent's namespaced template pattern before delegating+ if task_meta is not None and task_meta.fn_key is None:+ task_meta = replace(task_meta, fn_key=self.key)++ return await self._server.read_resource(original_uri, task_meta=task_meta)async def read(self, arguments: dict[str, Any]) -> str | bytes | ResourceResult:"""Read the resource content for background task execution.diff --git a/src/fastmcp/server/server.py b/src/fastmcp/server/server.pyindex eb161f751..e4b3fde2d 100644--- a/src/fastmcp/server/server.py+++ b/src/fastmcp/server/server.py@@ -1176,9 +1176,8 @@ class FastMCP(Generic[LifespanResultT]):ToolError: If tool execution failsValidationError: If arguments fail validation"""- # Enrich task_meta with fn_key if task execution requested- if task_meta is not None and task_meta.fn_key is None:- task_meta = TaskMeta(ttl=task_meta.ttl, fn_key=Tool.make_key(name))+ # Note: fn_key enrichment happens in Tool._run(), not here,+ # so that provider wrappers can enrich with their namespaced key.async with fastmcp.server.context.Context(fastmcp=self) as ctx:if run_middleware:@@ -1221,11 +1220,30 @@ class FastMCP(Generic[LifespanResultT]):raise NotFoundError(f"Unknown tool: {name!r}")+ @overloadasync def read_resource(self,uri: str,*,run_middleware: bool = True,+ task_meta: None = None,+ ) -> ResourceResult: ...++ @overload+ async def read_resource(+ self,+ uri: str,+ *,+ run_middleware: bool = True,+ task_meta: TaskMeta,+ ) -> mcp.types.CreateTaskResult: ...++ async def read_resource(+ self,+ uri: str,+ *,+ run_middleware: bool = True,+ task_meta: TaskMeta | None = None,) -> ResourceResult | mcp.types.CreateTaskResult:"""Read a resource by URI.@@ -1236,15 +1254,23 @@ class FastMCP(Generic[LifespanResultT]):uri: The resource URIrun_middleware: If True (default), apply the middleware chain.Set to False when called from middleware to avoid re-applying.+ task_meta: If provided, execute as a background task and return+ CreateTaskResult. If None (default), execute synchronously and+ return ResourceResult.Returns:- ResourceResult with contents.- May return CreateTaskResult if called in MCP context with task metadata.+ ResourceResult when task_meta is None.+ CreateTaskResult when task_meta is provided.Raises:NotFoundError: If resource not found or disabledResourceError: If resource read fails"""+ # Note: fn_key enrichment happens in each component's _read() method,+ # not here, because resources and templates use different key formats:+ # - Resources use Resource.make_key(uri) for the concrete URI+ # - Templates use self.key which is the template pattern+async with fastmcp.server.context.Context(fastmcp=self) as ctx:if run_middleware:uri_param = AnyUrl(uri)@@ -1255,16 +1281,14 @@ class FastMCP(Generic[LifespanResultT]):method="resources/read",fastmcp_context=ctx,)- result = await self._run_middleware(+ return await self._run_middleware(context=mw_context,call_next=lambda context: self.read_resource(str(context.message.uri),run_middleware=False,+ task_meta=task_meta,),)- if isinstance(result, mcp.types.CreateTaskResult):- return result- return result# Core logic: find and read resource# First pass: try concrete resources from all providers@@ -1272,10 +1296,7 @@ class FastMCP(Generic[LifespanResultT]):resource = await provider.get_resource(uri)if resource is not None and self._is_component_enabled(resource):try:- result = await resource._read()- if isinstance(result, mcp.types.CreateTaskResult):- return result- return result+ return await resource._read(task_meta=task_meta)except (FastMCPError, McpError):logger.exception(f"Error reading resource {uri!r}")raise@@ -1296,10 +1317,9 @@ class FastMCP(Generic[LifespanResultT]):params = template.matches(uri)if params is not None:try:- result = await template._read(uri, params)- if isinstance(result, mcp.types.CreateTaskResult):- return result- return result+ return await template._read(+ uri, params, task_meta=task_meta+ )except (FastMCPError, McpError):logger.exception(f"Error reading resource {uri!r}")raise@@ -1536,17 +1556,18 @@ class FastMCP(Generic[LifespanResultT]):)try:- # Extract SEP-1686 task metadata from request context+ # Extract SEP-1686 task metadata from request context.+ # NOTE: fn_key is NOT set here. The component (or provider wrapper) will+ # enrich fn_key with self.key. For mounted servers, the provider wrapper+ # sets fn_key to the parent's namespaced key, ensuring Docket finds the+ # correctly registered function.task_meta: TaskMeta | None = Nonetry:ctx = self._mcp_server.request_contextif ctx.experimental.is_task:mcp_task_meta = ctx.experimental.task_metadatatask_meta_dict = mcp_task_meta.model_dump(exclude_none=True)- task_meta = TaskMeta(- ttl=task_meta_dict.get("ttl"),- fn_key=Tool.make_key(key),- )+ task_meta = TaskMeta(ttl=task_meta_dict.get("ttl"))except (AttributeError, LookupError):pass@@ -1566,8 +1587,9 @@ class FastMCP(Generic[LifespanResultT]):) -> mcp.types.ReadResourceResult | mcp.types.CreateTaskResult:"""Handle MCP 'readResource' requests.- Sets task metadata contextvar and calls read_resource(). The resource's- _read() method handles the backgrounding decision.+ Extracts task metadata from MCP request context and passes it explicitly+ to read_resource(). The resource's _read() method handles the backgrounding+ decision, ensuring middleware runs before Docket.Args:uri: The resource URI@@ -1575,33 +1597,31 @@ class FastMCP(Generic[LifespanResultT]):Returns:ReadResourceResult or CreateTaskResult for background execution"""- from fastmcp.server.dependencies import _docket_fn_key, _task_metadata-logger.debug(f"[{self.name}] Handler called: read_resource %s", uri)try:- # Extract SEP-1686 task metadata from request context- task_meta_dict: dict[str, Any] | None = None+ # Extract SEP-1686 task metadata from request context.+ # NOTE: fn_key is NOT set here for resources because we don't know yet+ # if the URI will be handled by a direct resource or a template. Templates+ # need their pattern-based key for Docket lookup, not the concrete URI.+ # The component (or provider wrapper) will enrich fn_key with self.key.+ # For mounted servers, the provider wrapper sets fn_key to the parent's+ # namespaced key, ensuring Docket finds the correctly registered function.+ task_meta: TaskMeta | None = Nonetry:ctx = self._mcp_server.request_contextif ctx.experimental.is_task:- task_meta = ctx.experimental.task_metadata- task_meta_dict = task_meta.model_dump(exclude_none=True)+ mcp_task_meta = ctx.experimental.task_metadata+ task_meta_dict = mcp_task_meta.model_dump(exclude_none=True)+ task_meta = TaskMeta(ttl=task_meta_dict.get("ttl"))except (AttributeError, LookupError):pass- # Set contextvars so resource._read() can access them- task_token = _task_metadata.set(task_meta_dict)- key_token = _docket_fn_key.set(Resource.make_key(str(uri)))- try:- result = await self.read_resource(str(uri))+ result = await self.read_resource(str(uri), task_meta=task_meta)- if isinstance(result, mcp.types.CreateTaskResult):- return result- return result.to_mcp_result(uri)- finally:- _task_metadata.reset(task_token)- _docket_fn_key.reset(key_token)+ if isinstance(result, mcp.types.CreateTaskResult):+ return result+ return result.to_mcp_result(uri)except DisabledError as e:raise NotFoundError(f"Unknown resource: {str(uri)!r}") from eexcept NotFoundError:diff --git a/src/fastmcp/tools/tool.py b/src/fastmcp/tools/tool.pyindex 4c0d3aa3a..bba0302ee 100644--- a/src/fastmcp/tools/tool.py+++ b/src/fastmcp/tools/tool.py@@ -3,7 +3,7 @@ from __future__ import annotationsimport inspectimport warningsfrom collections.abc import Callable-from dataclasses import dataclass+from dataclasses import dataclass, replacefrom typing import (TYPE_CHECKING,Annotated,@@ -12,6 +12,7 @@ from typing import (Generic,TypeAlias,get_type_hints,+ overload,)import mcp.types@@ -277,6 +278,20 @@ class Tool(FastMCPComponent):structured_content={"result": structured} if wrap_result else structured,)+ @overload+ async def _run(+ self,+ arguments: dict[str, Any],+ task_meta: None = None,+ ) -> ToolResult: ...++ @overload+ async def _run(+ self,+ arguments: dict[str, Any],+ task_meta: TaskMeta,+ ) -> mcp.types.CreateTaskResult: ...+async def _run(self,arguments: dict[str, Any],@@ -290,8 +305,13 @@ class Tool(FastMCPComponent):Args:arguments: Tool arguments- task_meta: If provided, execute as background task. If None, execute- synchronously.+ task_meta: If provided, execute as background task and return+ CreateTaskResult. If None (default), execute synchronously and+ return ToolResult.++ Returns:+ ToolResult when task_meta is None.+ CreateTaskResult when task_meta is provided.Subclasses can override this to customize task routing behavior.For example, FastMCPProviderTool overrides to delegate to child@@ -299,6 +319,10 @@ class Tool(FastMCPComponent):"""from fastmcp.server.tasks.routing import check_background_task+ # Enrich task_meta with fn_key if not already set (fallback for programmatic API)+ if task_meta is not None and task_meta.fn_key is None:+ task_meta = replace(task_meta, fn_key=self.key)+task_result = await check_background_task(component=self,task_type="tool",diff --git a/tests/resources/test_function_resources.py b/tests/resources/test_function_resources.pyindex c819b11b5..45ddf97ea 100644--- a/tests/resources/test_function_resources.py+++ b/tests/resources/test_function_resources.py@@ -1,7 +1,7 @@import pytestfrom pydantic import AnyUrl, BaseModel-from fastmcp.resources.resource import FunctionResource, ResourceContent, ResourceResult+from fastmcp.resources.resource import FunctionResource, ResourceContentclass TestFunctionResource:@@ -42,7 +42,6 @@ class TestFunctionResource:# _read() converts to ResourceResultresult = await resource._read()- assert isinstance(result, ResourceResult)assert len(result.contents) == 1assert result.contents[0].content == "Hello, world!"assert result.contents[0].mime_type == "text/plain"@@ -64,7 +63,6 @@ class TestFunctionResource:# _read() converts to ResourceResultresult = await resource._read()- assert isinstance(result, ResourceResult)assert result.contents[0].content == b"Hello, world!"async def test_dict_return_raises_type_error(self):@@ -159,7 +157,6 @@ class TestFunctionResource:# _read() converts to ResourceResultresult = await resource._read()- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Hello, world!"assert result.contents[0].mime_type == "text/plain"diff --git a/tests/resources/test_resource_template.py b/tests/resources/test_resource_template.pyindex b58327661..7d7a3bb33 100644--- a/tests/resources/test_resource_template.py+++ b/tests/resources/test_resource_template.py@@ -6,7 +6,7 @@ from pydantic import BaseModelfrom fastmcp import Context, FastMCPfrom fastmcp.resources import ResourceTemplate-from fastmcp.resources.resource import FunctionResource, ResourceResult+from fastmcp.resources.resource import FunctionResourcefrom fastmcp.resources.template import match_uri_template@@ -188,7 +188,6 @@ class TestResourceTemplate:# _read() wraps in ResourceResultresource_result = await resource._read()- assert isinstance(resource_result, ResourceResult)assert len(resource_result.contents) == 1assert resource_result.contents[0].content == "key=foo, value=123"diff --git a/tests/resources/test_resources.py b/tests/resources/test_resources.pyindex 8b9906cc4..c872a33b2 100644--- a/tests/resources/test_resources.py+++ b/tests/resources/test_resources.py@@ -303,7 +303,6 @@ class TestResourceConvertResult:resource = FunctionResource(uri=AnyUrl("test://test"), name="test", fn=fn)result = await resource._read()- assert isinstance(result, ResourceResult)assert len(result.contents) == 1assert result.contents[0].content == "hello world"diff --git a/tests/server/middleware/test_middleware.py b/tests/server/middleware/test_middleware.pyindex 5ebae8451..cbf5e4f0d 100644--- a/tests/server/middleware/test_middleware.py+++ b/tests/server/middleware/test_middleware.py@@ -7,7 +7,6 @@ import pytestfrom fastmcp import Client, FastMCPfrom fastmcp.exceptions import ToolError-from fastmcp.resources.resource import ResourceResultfrom fastmcp.server.context import Contextfrom fastmcp.server.middleware import CallNext, Middleware, MiddlewareContextfrom fastmcp.tools.tool import ToolResult@@ -514,7 +513,6 @@ class TestApplyMiddlewareParameter:result = await server.read_resource("resource://test")- assert isinstance(result, ResourceResult)assert len(result.contents) == 1assert result.contents[0].content == "test content"assert recording.assert_called(hook="on_read_resource", times=1)@@ -532,7 +530,6 @@ class TestApplyMiddlewareParameter:result = await server.read_resource("resource://test", run_middleware=False)- assert isinstance(result, ResourceResult)assert len(result.contents) == 1assert result.contents[0].content == "test content"# Middleware should not have been called@@ -551,7 +548,6 @@ class TestApplyMiddlewareParameter:result = await server.read_resource("resource://items/42", run_middleware=False)- assert isinstance(result, ResourceResult)assert len(result.contents) == 1assert result.contents[0].content == "item 42"assert len(recording.calls) == 0diff --git a/tests/server/providers/test_local_provider_resources.py b/tests/server/providers/test_local_provider_resources.pyindex af42f8ddb..e485586fc 100644--- a/tests/server/providers/test_local_provider_resources.py+++ b/tests/server/providers/test_local_provider_resources.py@@ -82,7 +82,6 @@ class TestResourceTemplates:return f"Data for {name}"result = await mcp.read_resource("resource://test/data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Data for test"async def test_resource_mismatched_params(self):@@ -107,7 +106,6 @@ class TestResourceTemplates:return f"Data for {org}/{repo}"result = await mcp.read_resource("resource://cursor/fastmcp/data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Data for cursor/fastmcp"async def test_resource_multiple_mismatched_params(self):@@ -132,7 +130,6 @@ class TestResourceTemplates:return str(sum(int(v) for v in kwargs.values()))result = await mcp.read_resource("test://1/2/3")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "6"async def test_template_with_default_params(self):@@ -148,11 +145,9 @@ class TestResourceTemplates:assert templates[0].uri_template == "math://add/{x}"result = await mcp.read_resource("math://add/5")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "15"result2 = await mcp.read_resource("math://add/7")- assert isinstance(result2, ResourceResult)assert result2.contents[0].content == "17"async def test_template_to_resource_conversion(self):@@ -168,7 +163,6 @@ class TestResourceTemplates:assert templates[0].uri_template == "resource://{name}/data"result = await mcp.read_resource("resource://test/data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Data for test"async def test_template_decorator_with_tags(self):@@ -190,7 +184,6 @@ class TestResourceTemplates:return f"Template resource: {param}"result = await mcp.read_resource("resource://test/data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Template resource: test/data"async def test_template_with_query_params(self):@@ -202,15 +195,12 @@ class TestResourceTemplates:return f"id={id}, format={format}, limit={limit}"result = await mcp.read_resource("data://123")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "id=123, format=json, limit=10"result = await mcp.read_resource("data://123?format=xml")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "id=123, format=xml, limit=10"result = await mcp.read_resource("data://123?format=csv&limit=50")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "id=123, format=csv, limit=50"async def test_templates_match_in_order_of_definition(self):@@ -226,11 +216,9 @@ class TestResourceTemplates:return f"Template resource 2: {x}/{y}"result = await mcp.read_resource("resource://a/b/c")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Template resource 1: a/b/c"result = await mcp.read_resource("resource://a/b")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Template resource 1: a/b"async def test_templates_shadow_each_other_reorder(self):@@ -246,11 +234,9 @@ class TestResourceTemplates:return f"Template resource 2: {param}"result = await mcp.read_resource("resource://a/b/c")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Template resource 2: a/b/c"result = await mcp.read_resource("resource://a/b")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Template resource 1: a/b"async def test_resource_template_with_annotations(self):@@ -324,7 +310,6 @@ class TestResourceDecorator:return "Hello, world!"result = await mcp.read_resource("resource://data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Hello, world!"async def test_resource_decorator_incorrect_usage(self):@@ -350,7 +335,6 @@ class TestResourceDecorator:assert resources[0].name == "custom-data"result = await mcp.read_resource("resource://data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Hello, world!"async def test_resource_decorator_with_description(self):@@ -395,7 +379,6 @@ class TestResourceDecorator:)result = await mcp.read_resource("resource://data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "My prefix: Hello, world!"async def test_resource_decorator_classmethod(self):@@ -415,7 +398,6 @@ class TestResourceDecorator:)result = await mcp.read_resource("resource://data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Class prefix: Hello, world!"async def test_resource_decorator_classmethod_error(self):@@ -439,7 +421,6 @@ class TestResourceDecorator:return "Static Hello, world!"result = await mcp.read_resource("resource://data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Static Hello, world!"async def test_resource_decorator_async_function(self):@@ -450,7 +431,6 @@ class TestResourceDecorator:return "Async Hello, world!"result = await mcp.read_resource("resource://data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Async Hello, world!"async def test_resource_decorator_staticmethod_order(self):@@ -464,7 +444,6 @@ class TestResourceDecorator:return "Static Hello, world!"result = await mcp.read_resource("resource://data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Static Hello, world!"async def test_resource_decorator_with_meta(self):@@ -499,7 +478,6 @@ class TestResourceDecorator:)result = await mcp.read_resource("resource://widget")- assert isinstance(result, ResourceResult)assert len(result.contents) == 1assert result.contents[0].content == "<widget>content</widget>"assert result.contents[0].mime_type == "text/html"@@ -521,7 +499,6 @@ class TestResourceDecorator:)result = await mcp.read_resource("resource://binary")- assert isinstance(result, ResourceResult)assert len(result.contents) == 1assert result.contents[0].content == b"\x00\x01\x02"assert result.contents[0].meta == {"encoding": "raw"}@@ -535,7 +512,6 @@ class TestResourceDecorator:return ResourceResult([ResourceContent(content="plain content")])result = await mcp.read_resource("resource://plain")- assert isinstance(result, ResourceResult)assert len(result.contents) == 1assert result.contents[0].content == "plain content"assert result.contents[0].meta is None@@ -555,7 +531,6 @@ class TestTemplateDecorator:assert templates[0].uri_template == "resource://{name}/data"result = await mcp.read_resource("resource://test/data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Data for test"async def test_template_decorator_incorrect_usage(self):@@ -581,7 +556,6 @@ class TestTemplateDecorator:assert templates[0].name == "custom-template"result = await mcp.read_resource("resource://test/data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Data for test"async def test_template_decorator_with_description(self):@@ -614,7 +588,6 @@ class TestTemplateDecorator:mcp.add_template(template)result = await mcp.read_resource("resource://test/data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "My prefix: Data for test"async def test_template_decorator_classmethod(self):@@ -635,7 +608,6 @@ class TestTemplateDecorator:mcp.add_template(template)result = await mcp.read_resource("resource://test/data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Class prefix: Data for test"async def test_template_decorator_staticmethod(self):@@ -648,7 +620,6 @@ class TestTemplateDecorator:return f"Static Data for {name}"result = await mcp.read_resource("resource://test/data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Static Data for test"async def test_template_decorator_async_function(self):@@ -659,7 +630,6 @@ class TestTemplateDecorator:return f"Async Data for {name}"result = await mcp.read_resource("resource://test/data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "Async Data for test"async def test_template_decorator_with_tags(self):diff --git a/tests/server/tasks/test_resource_task_meta_parameter.py b/tests/server/tasks/test_resource_task_meta_parameter.pynew file mode 100644index 000000000..756e5e84f--- /dev/null+++ b/tests/server/tasks/test_resource_task_meta_parameter.py@@ -0,0 +1,291 @@+"""+Tests for the explicit task_meta parameter on FastMCP.read_resource().++These tests verify that the task_meta parameter provides explicit control+over sync vs task execution for resources and resource templates.+"""++import pytest+from mcp.shared.exceptions import McpError++from fastmcp import FastMCP+from fastmcp.client import Client+from fastmcp.resources.resource import Resource, ResourceResult+from fastmcp.resources.template import ResourceTemplate+from fastmcp.server.tasks.config import TaskMeta+++class TestResourceTaskMetaParameter:+ """Tests for task_meta parameter on FastMCP.read_resource()."""++ async def test_task_meta_none_returns_resource_result(self):+ """With task_meta=None (default), read_resource returns ResourceResult."""+ server = FastMCP("test")++ @server.resource("data://test")+ async def simple_resource() -> str:+ return "hello world"++ result = await server.read_resource("data://test")++ assert isinstance(result, ResourceResult)+ assert result.contents[0].content == "hello world"++ async def test_task_meta_none_on_task_enabled_resource_still_returns_result(self):+ """Even for task=True resources, task_meta=None returns ResourceResult."""+ server = FastMCP("test")++ @server.resource("data://test", task=True)+ async def task_enabled_resource() -> str:+ return "hello world"++ # Without task_meta, should execute synchronously+ result = await server.read_resource("data://test")++ assert isinstance(result, ResourceResult)+ assert result.contents[0].content == "hello world"++ async def test_task_meta_on_forbidden_resource_raises_error(self):+ """Providing task_meta to a task=False resource raises McpError."""+ server = FastMCP("test")++ @server.resource("data://test", task=False)+ async def sync_only_resource() -> str:+ return "hello"++ with pytest.raises(McpError) as exc_info:+ await server.read_resource("data://test", task_meta=TaskMeta())++ assert "does not support task-augmented execution" in str(exc_info.value)++ async def test_task_meta_fn_key_enrichment_for_resource(self):+ """Verify that fn_key enrichment uses Resource.make_key()."""+ resource_uri = "data://my-resource"+ expected_key = Resource.make_key(resource_uri)++ assert expected_key == "resource:data://my-resource"++ async def test_task_meta_fn_key_enrichment_for_template(self):+ """Verify that fn_key enrichment uses ResourceTemplate.make_key()."""+ template_pattern = "data://{id}"+ expected_key = ResourceTemplate.make_key(template_pattern)++ assert expected_key == "template:data://{id}"+++class TestResourceTemplateTaslMeta:+ """Tests for task_meta with resource templates."""++ async def test_template_task_meta_none_returns_resource_result(self):+ """With task_meta=None, template read returns ResourceResult."""+ server = FastMCP("test")++ @server.resource("item://{id}")+ async def get_item(id: str) -> str:+ return f"Item {id}"++ result = await server.read_resource("item://42")++ assert isinstance(result, ResourceResult)+ assert result.contents[0].content == "Item 42"++ async def test_template_task_meta_on_task_enabled_template_returns_result(self):+ """Even for task=True templates, task_meta=None returns ResourceResult."""+ server = FastMCP("test")++ @server.resource("item://{id}", task=True)+ async def get_item(id: str) -> str:+ return f"Item {id}"++ # Without task_meta, should execute synchronously+ result = await server.read_resource("item://42")++ assert isinstance(result, ResourceResult)+ assert result.contents[0].content == "Item 42"++ async def test_template_task_meta_on_forbidden_template_raises_error(self):+ """Providing task_meta to a task=False template raises McpError."""+ server = FastMCP("test")++ @server.resource("item://{id}", task=False)+ async def sync_only_template(id: str) -> str:+ return f"Item {id}"++ with pytest.raises(McpError) as exc_info:+ await server.read_resource("item://42", task_meta=TaskMeta())++ assert "does not support task-augmented execution" in str(exc_info.value)+++class TestResourceTaskMetaClientIntegration:+ """Tests that task_meta works correctly with the Client for resources."""++ async def test_client_read_resource_without_task_gets_immediate_result(self):+ """Client without task=True gets immediate result."""+ server = FastMCP("test")++ @server.resource("data://test", task=True)+ async def immediate_resource() -> str:+ return "hello"++ async with Client(server) as client:+ result = await client.read_resource("data://test")++ # Should get ReadResourceResult directly+ assert "hello" in str(result)++ async def test_client_read_resource_with_task_creates_task(self):+ """Client with task=True creates a background task."""+ server = FastMCP("test")++ @server.resource("data://test", task=True)+ async def task_resource() -> str:+ return "hello"++ async with Client(server) as client:+ from fastmcp.client.tasks import ResourceTask++ task = await client.read_resource("data://test", task=True)++ assert isinstance(task, ResourceTask)++ # Wait for result+ result = await task.result()+ assert "hello" in str(result)++ async def test_client_read_template_with_task_creates_task(self):+ """Client with task=True on template creates a background task."""+ server = FastMCP("test")++ @server.resource("item://{id}", task=True)+ async def get_item(id: str) -> str:+ return f"Item {id}"++ async with Client(server) as client:+ from fastmcp.client.tasks import ResourceTask++ task = await client.read_resource("item://42", task=True)++ assert isinstance(task, ResourceTask)++ # Wait for result+ result = await task.result()+ assert "Item 42" in str(result)+++class TestResourceTaskMetaDirectServerCall:+ """Tests for direct server read_resource calls with task_meta."""++ async def test_resource_can_read_another_resource_with_task(self):+ """A resource can read another resource as a background task."""+ server = FastMCP("test")++ @server.resource("data://inner", task=True)+ async def inner_resource() -> str:+ return "inner data"++ @server.tool+ async def outer_tool() -> str:+ # Read inner resource as background task+ result = await server.read_resource("data://inner", task_meta=TaskMeta())+ # Should get CreateTaskResult since we provided task_meta+ return f"Created task: {result.task.taskId}"++ async with Client(server) as client:+ result = await client.call_tool("outer_tool", {})+ assert "Created task:" in str(result)++ async def test_resource_can_read_another_resource_synchronously(self):+ """A resource can read another resource synchronously (no task_meta)."""+ server = FastMCP("test")++ @server.resource("data://inner", task=True)+ async def inner_resource() -> str:+ return "inner data"++ @server.tool+ async def outer_tool() -> str:+ # Read inner resource synchronously (no task_meta)+ result = await server.read_resource("data://inner")+ # Should get ResourceResult directly+ return f"Got result: {result.contents[0].content}"++ async with Client(server) as client:+ result = await client.call_tool("outer_tool", {})+ assert "Got result: inner data" in str(result)++ async def test_resource_can_read_template_with_task(self):+ """A tool can read a resource template as a background task."""+ server = FastMCP("test")++ @server.resource("item://{id}", task=True)+ async def get_item(id: str) -> str:+ return f"Item {id}"++ @server.tool+ async def outer_tool() -> str:+ result = await server.read_resource("item://99", task_meta=TaskMeta())+ return f"Created task: {result.task.taskId}"++ async with Client(server) as client:+ result = await client.call_tool("outer_tool", {})+ assert "Created task:" in str(result)++ async def test_resource_can_read_with_custom_ttl(self):+ """A tool can read a resource as a background task with custom TTL."""+ server = FastMCP("test")++ @server.resource("data://inner", task=True)+ async def inner_resource() -> str:+ return "inner data"++ @server.tool+ async def outer_tool() -> str:+ custom_ttl = 45000 # 45 seconds+ result = await server.read_resource(+ "data://inner", task_meta=TaskMeta(ttl=custom_ttl)+ )+ return f"Task TTL: {result.task.ttl}"++ async with Client(server) as client:+ result = await client.call_tool("outer_tool", {})+ assert "Task TTL: 45000" in str(result)+++class TestResourceTaskMetaTypeNarrowing:+ """Tests for type narrowing based on task_meta parameter."""++ async def test_read_resource_without_task_meta_type_is_resource_result(self):+ """Calling read_resource without task_meta returns ResourceResult type."""+ server = FastMCP("test")++ @server.resource("data://test")+ async def simple_resource() -> str:+ return "hello"++ # This should type-check as ResourceResult, not the union type+ result = await server.read_resource("data://test")++ # No isinstance check needed - type is narrowed by overload+ content = result.contents[0].content+ assert content == "hello"++ async def test_read_resource_with_task_meta_type_is_create_task_result(self):+ """Calling read_resource with task_meta returns CreateTaskResult type."""+ server = FastMCP("test")++ @server.resource("data://test", task=True)+ async def task_resource() -> str:+ return "hello"++ async with Client(server) as client:+ # Need to use client to get full task infrastructure+ from fastmcp.client.tasks import ResourceTask++ task = await client.read_resource("data://test", task=True)+ assert isinstance(task, ResourceTask)++ # For direct server call, we need the Client context for Docket+ # This test verifies the overload works via client integration+ result = await task.result()+ assert "hello" in str(result)diff --git a/tests/server/tasks/test_task_mount.py b/tests/server/tasks/test_task_mount.pyindex 395e5dc13..f3ebba85a 100644--- a/tests/server/tasks/test_task_mount.py+++ b/tests/server/tasks/test_task_mount.py@@ -773,3 +773,147 @@ class TestMiddlewareWithMountedTasks:"parent:after","grandchild:template",]+++class TestMountedTasksWithTaskMetaParameter:+ """Test mounted components called directly with task_meta parameter.++ These tests verify the programmatic API where server.call_tool() or+ server.read_resource() is called with an explicit task_meta parameter,+ as opposed to using the Client with task=True.++ Direct server calls require a running server context, so we use an outer+ tool that makes the direct call internally.+ """++ async def test_mounted_tool_with_task_meta_creates_task(self):+ """Mounted tool called with task_meta returns CreateTaskResult."""+ from fastmcp.server.tasks.config import TaskMeta++ child = FastMCP("Child")++ @child.tool(task=True)+ async def add(a: int, b: int) -> int:+ return a + b++ parent = FastMCP("Parent")+ parent.mount(child, namespace="child")++ @parent.tool+ async def outer() -> str:+ # Direct call with task_meta from within server context+ result = await parent.call_tool(+ "child_add", {"a": 2, "b": 3}, task_meta=TaskMeta(ttl=300)+ )+ assert isinstance(result, mt.CreateTaskResult)+ return f"task:{result.task.taskId}"++ async with Client(parent) as client:+ result = await client.call_tool("outer", {})+ assert "task:" in str(result)++ async def test_mounted_resource_with_task_meta_creates_task(self):+ """Mounted resource called with task_meta returns CreateTaskResult."""+ from fastmcp.server.tasks.config import TaskMeta++ child = FastMCP("Child")++ @child.resource("data://info", task=True)+ async def get_info() -> str:+ return "child info"++ parent = FastMCP("Parent")+ parent.mount(child, namespace="child")++ @parent.tool+ async def outer() -> str:+ result = await parent.read_resource(+ "data://child/info", task_meta=TaskMeta(ttl=300)+ )+ assert isinstance(result, mt.CreateTaskResult)+ return f"task:{result.task.taskId}"++ async with Client(parent) as client:+ result = await client.call_tool("outer", {})+ assert "task:" in str(result)++ async def test_mounted_template_with_task_meta_creates_task(self):+ """Mounted resource template with task_meta returns CreateTaskResult."""+ from fastmcp.server.tasks.config import TaskMeta++ child = FastMCP("Child")++ @child.resource("item://{id}", task=True)+ async def get_item(id: str) -> str:+ return f"item-{id}"++ parent = FastMCP("Parent")+ parent.mount(child, namespace="child")++ @parent.tool+ async def outer() -> str:+ result = await parent.read_resource(+ "item://child/42", task_meta=TaskMeta(ttl=300)+ )+ assert isinstance(result, mt.CreateTaskResult)+ return f"task:{result.task.taskId}"++ async with Client(parent) as client:+ result = await client.call_tool("outer", {})+ assert "task:" in str(result)++ async def test_deeply_nested_tool_with_task_meta(self):+ """Three-level nested tool works with task_meta."""+ from fastmcp.server.tasks.config import TaskMeta++ grandchild = FastMCP("Grandchild")++ @grandchild.tool(task=True)+ async def compute(n: int) -> int:+ return n * 3++ child = FastMCP("Child")+ child.mount(grandchild, namespace="gc")++ parent = FastMCP("Parent")+ parent.mount(child, namespace="c")++ @parent.tool+ async def outer() -> str:+ result = await parent.call_tool(+ "c_gc_compute", {"n": 7}, task_meta=TaskMeta(ttl=300)+ )+ assert isinstance(result, mt.CreateTaskResult)+ return f"task:{result.task.taskId}"++ async with Client(parent) as client:+ result = await client.call_tool("outer", {})+ assert "task:" in str(result)++ async def test_deeply_nested_template_with_task_meta(self):+ """Three-level nested template works with task_meta."""+ from fastmcp.server.tasks.config import TaskMeta++ grandchild = FastMCP("Grandchild")++ @grandchild.resource("doc://{name}", task=True)+ async def get_doc(name: str) -> str:+ return f"doc: {name}"++ child = FastMCP("Child")+ child.mount(grandchild, namespace="gc")++ parent = FastMCP("Parent")+ parent.mount(child, namespace="c")++ @parent.tool+ async def outer() -> str:+ result = await parent.read_resource(+ "doc://c/gc/readme", task_meta=TaskMeta(ttl=300)+ )+ assert isinstance(result, mt.CreateTaskResult)+ return f"task:{result.task.taskId}"++ async with Client(parent) as client:+ result = await client.call_tool("outer", {})+ assert "task:" in str(result)diff --git a/tests/server/test_dependencies.py b/tests/server/test_dependencies.pyindex 37e283630..39e2130ba 100644--- a/tests/server/test_dependencies.py+++ b/tests/server/test_dependencies.py@@ -9,7 +9,6 @@ from fastmcp import FastMCPfrom fastmcp.client import Clientfrom fastmcp.dependencies import CurrentContext, Dependsfrom fastmcp.prompts import PromptResult-from fastmcp.resources import ResourceResultfrom fastmcp.server.context import ContextHUZZAH = "huzzah!"@@ -266,7 +265,6 @@ async def test_resource_with_dependency(mcp: FastMCP):return f"Settings loaded from {storage}"result = await mcp.read_resource("config://settings")- assert isinstance(result, ResourceResult)assert len(result.contents) == 1assert result.contents[0].content == "Settings loaded from /data/config"@@ -343,7 +341,6 @@ async def test_resource_template_with_dependency(mcp: FastMCP):return f"Reading {base_path}/{filename}"result = await mcp.read_resource("data://config.txt")- assert isinstance(result, ResourceResult)assert len(result.contents) == 1assert result.contents[0].content == "Reading /var/data/config.txt"@@ -399,7 +396,6 @@ async def test_async_resource_context_manager_stays_open(mcp: FastMCP):return f"open={connection.is_open}"result = await mcp.read_resource("data://config")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "open=True"@@ -415,7 +411,6 @@ async def test_async_resource_template_context_manager_stays_open(mcp: FastMCP):return f"open={connection.is_open},user={user_id}"result = await mcp.read_resource("user://123")- assert isinstance(result, ResourceResult)assert isinstance(result.contents[0].content, str)assert "open=True" in result.contents[0].content@@ -525,7 +520,6 @@ async def test_sync_resource_context_manager_stays_open(mcp: FastMCP):return f"open={connection.is_open}"result = await mcp.read_resource("data://sync")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "open=True"assert not conn.is_open@@ -551,7 +545,6 @@ async def test_sync_resource_template_context_manager_stays_open(mcp: FastMCP):return f"open={connection.is_open},item={item_id}"result = await mcp.read_resource("item://456")- assert isinstance(result, ResourceResult)assert isinstance(result.contents[0].content, str)assert "open=True" in result.contents[0].contentassert not conn.is_open@@ -663,7 +656,6 @@ async def test_resource_dependency_cannot_be_overridden_externally(mcp: FastMCP)# Normal callresult = await mcp.read_resource("data://config")- assert isinstance(result, ResourceResult)assert isinstance(result.contents[0].content, str)assert "API Key: real_api_key" in result.contents[0].content@@ -689,7 +681,6 @@ async def test_resource_template_dependency_cannot_be_overridden_externally(# Normal callresult = await mcp.read_resource("user://123")- assert isinstance(result, ResourceResult)assert isinstance(result.contents[0].content, str)assert "User: 123, Token: real_token" in result.contents[0].contentdiff --git a/tests/server/test_mount.py b/tests/server/test_mount.pyindex ad20c2bdd..7659ab934 100644--- a/tests/server/test_mount.py+++ b/tests/server/test_mount.py@@ -10,7 +10,6 @@ from fastmcp.client import Clientfrom fastmcp.client.transports import FastMCPTransport, SSETransportfrom fastmcp.exceptions import NotFoundErrorfrom fastmcp.prompts import PromptResult-from fastmcp.resources import ResourceResultfrom fastmcp.server.providers import FastMCPProvider, TransformingProviderfrom fastmcp.server.providers.proxy import FastMCPProxyfrom fastmcp.tools.tool import Tool@@ -143,7 +142,6 @@ class TestBasicMount:# Test actual functionalityresource_result = await main_app.read_resource("data://config")- assert isinstance(resource_result, ResourceResult)assert resource_result.contents[0].content == "Sub resource data"async def test_mount_resource_templates_no_prefix(self):@@ -164,7 +162,6 @@ class TestBasicMount:# Test actual functionalitytemplate_result = await main_app.read_resource("users://123/info")- assert isinstance(template_result, ResourceResult)assert template_result.contents[0].content == "Sub template for user 123"async def test_mount_prompts_no_prefix(self):@@ -409,7 +406,6 @@ class TestPrefixConflictResolution:# Test that reading the resource uses the first server's implementationresult = await main_app.read_resource("shared://data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "First app data"async def test_first_server_wins_resources_same_prefix(self):@@ -438,7 +434,6 @@ class TestPrefixConflictResolution:# Test that reading the resource uses the first server's implementationresult = await main_app.read_resource("shared://api/data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "First app data"async def test_first_server_wins_resource_templates_no_prefix(self):@@ -469,7 +464,6 @@ class TestPrefixConflictResolution:# Test that reading the resource uses the first server's implementationresult = await main_app.read_resource("users://123/profile")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "First app user 123"async def test_first_server_wins_resource_templates_same_prefix(self):@@ -500,7 +494,6 @@ class TestPrefixConflictResolution:# Test that reading the resource uses the first server's implementationresult = await main_app.read_resource("users://api/123/profile")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "First app user 123"async def test_first_server_wins_prompts_no_prefix(self):@@ -639,7 +632,6 @@ class TestResourcesAndTemplates:# Check that resource can be accessedresult = await main_app.read_resource("data://data/users")- assert isinstance(result, ResourceResult)assert len(result.contents) == 1# Note: The function returns "user1, user2" which is not valid JSON# This test should be updated to return proper JSON or check the string directly@@ -663,7 +655,6 @@ class TestResourcesAndTemplates:# Check template instantiationresult = await main_app.read_resource("users://api/123/profile")- assert isinstance(result, ResourceResult)assert len(result.contents) == 1profile = json.loads(result.contents[0].content)assert profile["id"] == "123"@@ -688,7 +679,6 @@ class TestResourcesAndTemplates:# Check access to the resourceresult = await main_app.read_resource("data://data/config")- assert isinstance(result, ResourceResult)assert len(result.contents) == 1config = json.loads(result.contents[0].content)assert config["version"] == "1.0"@@ -813,7 +803,6 @@ class TestProxyServer:# Resource should be accessible through main appresult = await main_app.read_resource("config://proxy/settings")- assert isinstance(result, ResourceResult)assert len(result.contents) == 1config = json.loads(result.contents[0].content)assert config["api_key"] == "12345"@@ -1264,12 +1253,10 @@ class TestDeeplyNestedMount:# Resource at level 2 should workresult = await root.read_resource("middle://middle/data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "middle data"# Resource at level 3 should also workresult = await root.read_resource("leaf://middle/leaf/data")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "leaf data"async def test_three_level_nested_resource_template_invocation(self):@@ -1291,12 +1278,10 @@ class TestDeeplyNestedMount:# Resource template at level 2 should workresult = await root.read_resource("middle://middle/item/42")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "middle item 42"# Resource template at level 3 should also workresult = await root.read_resource("leaf://middle/leaf/item/99")- assert isinstance(result, ResourceResult)assert result.contents[0].content == "leaf item 99"async def test_three_level_nested_prompt_invocation(self):diff --git a/tests/server/test_providers.py b/tests/server/test_providers.pyindex 24e4679f8..28311c003 100644--- a/tests/server/test_providers.py+++ b/tests/server/test_providers.py@@ -8,7 +8,6 @@ from mcp.types import AnyUrl, TextContentfrom fastmcp import FastMCPfrom fastmcp.prompts.prompt import FunctionPrompt, Prompt, PromptResult-from fastmcp.resources import ResourceResultfrom fastmcp.resources.resource import FunctionResource, Resourcefrom fastmcp.resources.template import FunctionResourceTemplate, ResourceTemplatefrom fastmcp.server.providers import Provider@@ -389,7 +388,6 @@ class TestProviderExecutionMethods:result = await mcp.read_resource("test://data")- assert isinstance(result, ResourceResult)assert len(result.contents) == 1assert result.contents[0].content == "hello world"@@ -412,7 +410,6 @@ class TestProviderExecutionMethods:result = await mcp.read_resource("data://files/test.txt")- assert isinstance(result, ResourceResult)assert len(result.contents) == 1assert result.contents[0].content == "content of test.txt"