Skip to content

πŸš€ The fast, Pythonic way to build MCP servers and clients.

Simplify .key as computed property (#2648)

Jeremiah Lowincaeaa86394a5
diff --git a/src/fastmcp/resources/resource.py b/src/fastmcp/resources/resource.py
index c88254524..21d03b8d9 100644
--- a/src/fastmcp/resources/resource.py
+++ b/src/fastmcp/resources/resource.py
@@ -274,13 +274,8 @@ class Resource(FastMCPComponent):
@property
def key(self) -> str:
- """
- The key of the component. This is used for internal bookkeeping
- and may reflect e.g. prefixes or other identifiers. You should not depend on
- keys having a certain value, as the same tool loaded from different
- hierarchies of servers may have different keys.
- """
- return self._key or str(self.uri)
+ """The lookup key for this resource. Returns str(uri)."""
+ return str(self.uri)
class FunctionResource(Resource):
diff --git a/src/fastmcp/resources/resource_manager.py b/src/fastmcp/resources/resource_manager.py
index 290fe8484..aea3f1d09 100644
--- a/src/fastmcp/resources/resource_manager.py
+++ b/src/fastmcp/resources/resource_manager.py
@@ -154,8 +154,8 @@ class ResourceManager:
Args:
resource: A Resource instance to add. The resource's .key attribute
- will be used as the storage key. To overwrite it, call
- Resource.model_copy(key=new_key) before calling this method.
+ (which is str(uri)) will be used as the storage key. To use a
+ different key, change the uri via model_copy(update={"uri": new_uri}).
"""
existing = self._resources.get(resource.key)
if existing:
@@ -203,8 +203,8 @@ class ResourceManager:
Args:
template: A ResourceTemplate instance to add. The template's .key attribute
- will be used as the storage key. To overwrite it, call
- ResourceTemplate.model_copy(key=new_key) before calling this method.
+ (which is uri_template) will be used as the storage key. To use a
+ different key, change uri_template via model_copy(update={"uri_template": new_uri}).
Returns:
The added template. If a template with the same URI already exists,
diff --git a/src/fastmcp/resources/template.py b/src/fastmcp/resources/template.py
index 961da0e57..ecf9824f0 100644
--- a/src/fastmcp/resources/template.py
+++ b/src/fastmcp/resources/template.py
@@ -219,13 +219,8 @@ class ResourceTemplate(FastMCPComponent):
@property
def key(self) -> str:
- """
- The key of the component. This is used for internal bookkeeping
- and may reflect e.g. prefixes or other identifiers. You should not depend on
- keys having a certain value, as the same tool loaded from different
- hierarchies of servers may have different keys.
- """
- return self._key or self.uri_template
+ """The lookup key for this template. Returns uri_template."""
+ return self.uri_template
class FunctionResourceTemplate(ResourceTemplate):
diff --git a/src/fastmcp/server/providers/mounted.py b/src/fastmcp/server/providers/mounted.py
index 490e8fddd..42809a287 100644
--- a/src/fastmcp/server/providers/mounted.py
+++ b/src/fastmcp/server/providers/mounted.py
@@ -179,39 +179,37 @@ class MountedProvider(Provider):
# -------------------------------------------------------------------------
def _prefix_tool(self, tool: Tool) -> Tool:
- """Apply prefix to a tool."""
+ """Apply prefix to a tool. Changes name which updates .key."""
if self.tool_names and tool.name in self.tool_names:
- new_key = self.tool_names[tool.name]
+ new_name = self.tool_names[tool.name]
else:
- new_key = self._add_tool_prefix(tool.key)
- return tool.model_copy(key=new_key) if new_key != tool.key else tool
+ new_name = self._add_tool_prefix(tool.name)
+ if new_name != tool.name:
+ return tool.model_copy(update={"name": new_name})
+ return tool
def _prefix_resource(self, resource: Resource) -> Resource:
- """Apply prefix to a resource."""
- new_key = self._add_resource_prefix(resource.key)
- update: dict[str, Any] = {}
- if self.prefix and resource.name:
- update["name"] = f"{self.prefix}_{resource.name}"
- if new_key != resource.key or update:
- return resource.model_copy(key=new_key, update=update)
+ """Apply prefix to a resource URI (name is NOT prefixed)."""
+ if self.prefix:
+ new_uri = self._add_resource_prefix(str(resource.uri))
+ if new_uri != str(resource.uri):
+ return resource.model_copy(update={"uri": new_uri})
return resource
def _prefix_template(self, template: ResourceTemplate) -> ResourceTemplate:
- """Apply prefix to a resource template."""
- new_key = self._add_resource_prefix(template.key)
- update: dict[str, Any] = {}
- if self.prefix and template.name:
- update["name"] = f"{self.prefix}_{template.name}"
+ """Apply prefix to a resource template URI (name is NOT prefixed)."""
if self.prefix and template.uri_template:
- update["uri_template"] = self._add_resource_prefix(template.uri_template)
- if new_key != template.key or update:
- return template.model_copy(key=new_key, update=update)
+ new_template = self._add_resource_prefix(template.uri_template)
+ if new_template != template.uri_template:
+ return template.model_copy(update={"uri_template": new_template})
return template
def _prefix_prompt(self, prompt: Prompt) -> Prompt:
- """Apply prefix to a prompt."""
- new_key = self._add_tool_prefix(prompt.key)
- return prompt.model_copy(key=new_key) if new_key != prompt.key else prompt
+ """Apply prefix to a prompt. Changes name which updates .key."""
+ new_name = self._add_tool_prefix(prompt.name)
+ if new_name != prompt.name:
+ return prompt.model_copy(update={"name": new_name})
+ return prompt
# -------------------------------------------------------------------------
# Tool methods
diff --git a/src/fastmcp/server/proxy.py b/src/fastmcp/server/proxy.py
index cfe70a6fe..2a4ae1136 100644
--- a/src/fastmcp/server/proxy.py
+++ b/src/fastmcp/server/proxy.py
@@ -280,11 +280,21 @@ class ProxyTool(Tool, MirroredComponent):
"""
task_config: TaskConfig = TaskConfig(mode="forbidden")
+ _backend_name: str | None = None
def __init__(self, client: Client, **kwargs: Any):
super().__init__(**kwargs)
self._client = client
+ def model_copy(self, **kwargs: Any) -> ProxyTool:
+ """Override to preserve _backend_name when name changes."""
+ update = kwargs.get("update", {})
+ if "name" in update and self._backend_name is None:
+ # First time name is being changed, preserve original for backend calls
+ update = {**update, "_backend_name": self.name}
+ kwargs["update"] = update
+ return super().model_copy(**kwargs) # type: ignore[return-value]
+
@classmethod
def from_mcp_tool(cls, client: Client, mcp_tool: mcp.types.Tool) -> ProxyTool:
"""Factory method to create a ProxyTool from a raw MCP tool schema."""
@@ -331,7 +341,7 @@ class ProxyTool(Tool, MirroredComponent):
)
result = await self._client.call_tool_mcp(
- name=self.name, arguments=arguments, meta=meta
+ name=self._backend_name or self.name, arguments=arguments, meta=meta
)
if result.isError:
raise ToolError(cast(mcp.types.TextContent, result.content[0]).text)
@@ -351,6 +361,7 @@ class ProxyResource(Resource, MirroredComponent):
task_config: TaskConfig = TaskConfig(mode="forbidden")
_client: Client
_cached_content: ResourceContent | None = None
+ _backend_uri: str | None = None
def __init__(
self,
@@ -363,6 +374,15 @@ class ProxyResource(Resource, MirroredComponent):
self._client = client
self._cached_content = _cached_content
+ def model_copy(self, **kwargs: Any) -> ProxyResource:
+ """Override to preserve _backend_uri when uri changes."""
+ update = kwargs.get("update", {})
+ if "uri" in update and self._backend_uri is None:
+ # First time uri is being changed, preserve original for backend calls
+ update = {**update, "_backend_uri": str(self.uri)}
+ kwargs["update"] = update
+ return super().model_copy(**kwargs) # type: ignore[return-value]
+
@classmethod
def from_mcp_resource(
cls,
@@ -390,10 +410,13 @@ class ProxyResource(Resource, MirroredComponent):
if self._cached_content is not None:
return self._cached_content
+ backend_uri = self._backend_uri or str(self.uri)
async with self._client:
- result = await self._client.read_resource(self.uri)
+ result = await self._client.read_resource(backend_uri)
if not result:
- raise ResourceError(f"Remote server returned empty content for {self.uri}")
+ raise ResourceError(
+ f"Remote server returned empty content for {backend_uri}"
+ )
if isinstance(result[0], TextResourceContents):
return ResourceContent(
content=result[0].text,
@@ -416,11 +439,21 @@ class ProxyTemplate(ResourceTemplate, MirroredComponent):
"""
task_config: TaskConfig = TaskConfig(mode="forbidden")
+ _backend_uri_template: str | None = None
def __init__(self, client: Client, **kwargs: Any):
super().__init__(**kwargs)
self._client = client
+ def model_copy(self, **kwargs: Any) -> ProxyTemplate:
+ """Override to preserve _backend_uri_template when uri_template changes."""
+ update = kwargs.get("update", {})
+ if "uri_template" in update and self._backend_uri_template is None:
+ # First time uri_template is being changed, preserve original for backend
+ update = {**update, "_backend_uri_template": self.uri_template}
+ kwargs["update"] = update
+ return super().model_copy(**kwargs) # type: ignore[return-value]
+
@classmethod
def from_mcp_template( # type: ignore[override]
cls, client: Client, mcp_template: mcp.types.ResourceTemplate
@@ -451,7 +484,8 @@ class ProxyTemplate(ResourceTemplate, MirroredComponent):
# don't use the provided uri, because it may not be the same as the
# uri_template on the remote server.
# quote params to ensure they are valid for the uri_template
- parameterized_uri = self.uri_template.format(
+ backend_template = self._backend_uri_template or self.uri_template
+ parameterized_uri = backend_template.format(
**{k: quote(v, safe="") for k, v in params.items()}
)
async with self._client:
@@ -497,11 +531,21 @@ class ProxyPrompt(Prompt, MirroredComponent):
task_config: TaskConfig = TaskConfig(mode="forbidden")
_client: Client
+ _backend_name: str | None = None
def __init__(self, client: Client, **kwargs):
super().__init__(**kwargs)
self._client = client
+ def model_copy(self, **kwargs: Any) -> ProxyPrompt:
+ """Override to preserve _backend_name when name changes."""
+ update = kwargs.get("update", {})
+ if "name" in update and self._backend_name is None:
+ # First time name is being changed, preserve original for backend calls
+ update = {**update, "_backend_name": self.name}
+ kwargs["update"] = update
+ return super().model_copy(**kwargs) # type: ignore[return-value]
+
@classmethod
def from_mcp_prompt(
cls, client: Client, mcp_prompt: mcp.types.Prompt
@@ -531,7 +575,9 @@ class ProxyPrompt(Prompt, MirroredComponent):
async def render(self, arguments: dict[str, Any]) -> PromptResult: # type: ignore[override]
"""Render the prompt by making a call through the client."""
async with self._client:
- result = await self._client.get_prompt(self.name, arguments)
+ result = await self._client.get_prompt(
+ self._backend_name or self.name, arguments
+ )
# Convert GetPromptResult to PromptResult, preserving runtime meta from the result
# (not the static prompt meta which includes fastmcp tags)
return PromptResult(
diff --git a/src/fastmcp/server/server.py b/src/fastmcp/server/server.py
index 47485e8bc..fdabb4e95 100644
--- a/src/fastmcp/server/server.py
+++ b/src/fastmcp/server/server.py
@@ -442,14 +442,14 @@ class FastMCP(Generic[LifespanResultT]):
isinstance(resource, FunctionResource)
and resource.task_config.mode != "forbidden"
):
- docket.register(resource.fn, names=[resource.name])
+ docket.register(resource.fn, names=[resource.key])
for template in self._resource_manager._templates.values():
if (
isinstance(template, FunctionResourceTemplate)
and template.task_config.mode != "forbidden"
):
- docket.register(template.fn, names=[template.name])
+ docket.register(template.fn, names=[template.key])
# Register provider components
for provider in self._providers:
@@ -458,9 +458,9 @@ class FastMCP(Generic[LifespanResultT]):
for tool in tasks.tools:
docket.register(tool.fn, names=[tool.key])
for resource in tasks.resources:
- docket.register(resource.fn, names=[resource.name])
+ docket.register(resource.fn, names=[resource.key])
for template in tasks.templates:
- docket.register(template.fn, names=[template.name])
+ docket.register(template.fn, names=[template.key])
for prompt in tasks.prompts:
docket.register(
cast(Callable[..., Awaitable[Any]], prompt.fn),
@@ -2755,32 +2755,30 @@ class FastMCP(Generic[LifespanResultT]):
)
# Import tools from the server
- for key, tool in (await server.get_tools()).items():
+ for tool in (await server.get_tools()).values():
if prefix:
- tool = tool.model_copy(key=f"{prefix}_{key}")
+ tool = tool.model_copy(update={"name": f"{prefix}_{tool.name}"})
self._tool_manager.add_tool(tool)
# Import resources and templates from the server
- for key, resource in (await server.get_resources()).items():
+ for resource in (await server.get_resources()).values():
if prefix:
- resource_key = add_resource_prefix(key, prefix)
- resource = resource.model_copy(
- update={"name": f"{prefix}_{resource.name}"}, key=resource_key
- )
+ new_uri = add_resource_prefix(str(resource.uri), prefix)
+ resource = resource.model_copy(update={"uri": new_uri})
self._resource_manager.add_resource(resource)
- for key, template in (await server.get_resource_templates()).items():
+ for template in (await server.get_resource_templates()).values():
if prefix:
- template_key = add_resource_prefix(key, prefix)
+ new_uri_template = add_resource_prefix(template.uri_template, prefix)
template = template.model_copy(
- update={"name": f"{prefix}_{template.name}"}, key=template_key
+ update={"uri_template": new_uri_template}
)
self._resource_manager.add_template(template)
# Import prompts from the server
- for key, prompt in (await server.get_prompts()).items():
+ for prompt in (await server.get_prompts()).values():
if prefix:
- prompt = prompt.model_copy(key=f"{prefix}_{key}")
+ prompt = prompt.model_copy(update={"name": f"{prefix}_{prompt.name}"})
self._prompt_manager.add_prompt(prompt)
if server._lifespan != default_lifespan:
diff --git a/src/fastmcp/server/tasks/handlers.py b/src/fastmcp/server/tasks/handlers.py
index 569330449..64424356a 100644
--- a/src/fastmcp/server/tasks/handlers.py
+++ b/src/fastmcp/server/tasks/handlers.py
@@ -99,7 +99,7 @@ async def handle_tool_as_task(
# Don't let notification failures break task creation
await ctx.session.send_notification(notification) # type: ignore[arg-type]
- # Queue function to Docket by name (result storage via execution_ttl)
+ # Queue function to Docket by key (result storage via execution_ttl)
# Use tool.key which matches what was registered - prefixed for mounted tools
await docket.add(
tool.key,
@@ -205,7 +205,7 @@ async def handle_prompt_as_task(
with suppress(Exception):
await ctx.session.send_notification(notification) # type: ignore[arg-type]
- # Queue function to Docket by name (result storage via execution_ttl)
+ # Queue function to Docket by key (result storage via execution_ttl)
# Use prompt.key which matches what was registered - prefixed for mounted prompts
await docket.add(
prompt.key,
@@ -309,20 +309,19 @@ async def handle_resource_as_task(
with suppress(Exception):
await ctx.session.send_notification(notification) # type: ignore[arg-type]
- # Queue function to Docket by name (result storage via execution_ttl)
- # Use resource.name which matches what was registered - prefixed for mounted resources
+ # Queue function to Docket by key (result storage via execution_ttl)
# For templates, extract URI params and pass them to the function
from fastmcp.resources.template import FunctionResourceTemplate, match_uri_template
if isinstance(resource, FunctionResourceTemplate):
params = match_uri_template(uri, resource.uri_template) or {}
await docket.add(
- resource.name,
+ resource.key,
key=task_key,
)(**params)
else:
await docket.add(
- resource.name,
+ resource.key,
key=task_key,
)()
diff --git a/src/fastmcp/utilities/components.py b/src/fastmcp/utilities/components.py
index 6d2f0f5b4..833f2fb97 100644
--- a/src/fastmcp/utilities/components.py
+++ b/src/fastmcp/utilities/components.py
@@ -1,7 +1,7 @@
from __future__ import annotations
from collections.abc import Sequence
-from typing import Annotated, Any, TypedDict, cast
+from typing import Annotated, Any, TypedDict
from mcp.types import Icon
from pydantic import BeforeValidator, Field, PrivateAttr
@@ -56,21 +56,16 @@ class FastMCPComponent(FastMCPBaseModel):
description="Whether the component is enabled.",
)
- _key: str | None = PrivateAttr()
-
- def __init__(self, *, key: str | None = None, **kwargs: Any) -> None:
- super().__init__(**kwargs)
- self._key = key
-
@property
def key(self) -> str:
+ """The lookup key for this component. Returns name by default.
+
+ Subclasses override this to return different identifiers:
+ - Tools/Prompts: name
+ - Resources: str(uri)
+ - Templates: uri_template
"""
- The key of the component. This is used for internal bookkeeping
- and may reflect e.g. prefixes or other identifiers. You should not depend on
- keys having a certain value, as the same tool loaded from different
- hierarchies of servers may have different keys.
- """
- return self._key or self.name
+ return self.name
def get_meta(
self, include_fastmcp_meta: bool | None = None
@@ -96,29 +91,6 @@ class FastMCPComponent(FastMCPBaseModel):
return meta or None
- def model_copy( # type: ignore[override]
- self,
- *,
- update: dict[str, Any] | None = None,
- deep: bool = False,
- key: str | None = None,
- ) -> Self:
- """
- Create a copy of the component.
-
- Args:
- update: A dictionary of fields to update.
- deep: Whether to deep copy the component.
- key: The key to use for the copy.
- """
- # `model_copy` has an `update` parameter but it doesn't work for certain private attributes
- # https://github.com/pydantic/pydantic/issues/12116
- # So we manually set the private attribute here instead, such as _key
- copy = super().model_copy(update=update, deep=deep)
- if key is not None:
- copy._key = key
- return cast(Self, copy)
-
def __eq__(self, other: object) -> bool:
if type(self) is not type(other):
return False
diff --git a/tests/deprecated/__init__.py b/tests/deprecated/__init__.py
index 8c1eca42b..b7d7878ba 100644
--- a/tests/deprecated/__init__.py
+++ b/tests/deprecated/__init__.py
@@ -1,4 +1 @@
-import pytest
-
-# reset deprecation warnings for this module
-pytestmark = pytest.mark.filterwarnings("default::DeprecationWarning")
+# Tests for deprecated features - deprecation warnings are suppressed via conftest.py
diff --git a/tests/deprecated/conftest.py b/tests/deprecated/conftest.py
new file mode 100644
index 000000000..b9f8cf40c
--- /dev/null
+++ b/tests/deprecated/conftest.py
@@ -0,0 +1,9 @@
+"""Conftest for deprecated tests - suppresses deprecation warnings."""
+
+import pytest
+
+
+def pytest_collection_modifyitems(items):
+ """Add filterwarnings marker to all tests in this directory."""
+ for item in items:
+ item.add_marker(pytest.mark.filterwarnings("ignore::DeprecationWarning"))
diff --git a/tests/server/test_import_server.py b/tests/deprecated/test_import_server.py
similarity index 89%
rename from tests/server/test_import_server.py
rename to tests/deprecated/test_import_server.py
index 446dbfcc9..503a4216a 100644
--- a/tests/server/test_import_server.py
+++ b/tests/deprecated/test_import_server.py
@@ -28,7 +28,8 @@ async def test_import_basic_functionality():
# Verify the original tool still exists in the sub-app
tool = await main_app._tool_manager.get_tool("sub_sub_tool")
assert tool is not None
- assert tool.name == "sub_tool"
+ # import_server creates copies with prefixed names (unlike mount which proxies)
+ assert tool.name == "sub_sub_tool"
assert isinstance(tool, FunctionTool)
assert callable(tool.fn)
@@ -589,8 +590,8 @@ async def test_import_conflict_resolution_with_prefix():
assert result.data == "Second app tool"
-async def test_import_server_resource_name_prefixing():
- """Test that resource names are prefixed when using import_server."""
+async def test_import_server_resource_uri_prefixing():
+ """Test that resource URIs are prefixed when using import_server (names are NOT prefixed)."""
# Create a sub-server with a resource
sub_server = FastMCP("SubServer")
@@ -602,14 +603,14 @@ async def test_import_server_resource_name_prefixing():
main_server = FastMCP("MainServer")
await main_server.import_server(sub_server, prefix="imported")
- # Get resources and verify name prefixing
+ # Get resources and verify URI prefixing (name should NOT be prefixed)
resources = await main_server.get_resources()
resource = resources["resource://imported/test_resource"]
- assert resource.name == "imported_test_resource"
+ assert resource.name == "test_resource"
-async def test_import_server_resource_template_name_prefixing():
- """Test that resource template names are prefixed when using import_server."""
+async def test_import_server_resource_template_uri_prefixing():
+ """Test that resource template URIs are prefixed when using import_server (names are NOT prefixed)."""
# Create a sub-server with a resource template
sub_server = FastMCP("SubServer")
@@ -621,7 +622,48 @@ async def test_import_server_resource_template_name_prefixing():
main_server = FastMCP("MainServer")
await main_server.import_server(sub_server, prefix="imported")
- # Get resource templates and verify name prefixing
+ # Get resource templates and verify URI prefixing (name should NOT be prefixed)
templates = await main_server.get_resource_templates()
template = templates["resource://imported/data/{item_id}"]
- assert template.name == "imported_data_template"
+ assert template.name == "data_template"
+
+
+async def test_import_server_with_new_prefix_format():
+ """Test that import_server correctly uses the new prefix format."""
+ # Create a server with resources
+ source_server = FastMCP(name="SourceServer")
+
+ @source_server.resource("resource://test-resource")
+ def get_resource():
+ return "Resource content"
+
+ @source_server.resource("resource:///absolute/path")
+ def get_absolute_resource():
+ return "Absolute resource content"
+
+ @source_server.resource("resource://{param}/template")
+ def get_template_resource(param: str):
+ return f"Template resource with {param}"
+
+ # Create target server and import the source server
+ target_server = FastMCP(name="TargetServer")
+ await target_server.import_server(source_server, "imported")
+
+ # Check that the resources were imported with the correct prefixes
+ resources = await target_server.get_resources()
+ templates = await target_server.get_resource_templates()
+
+ assert "resource://imported/test-resource" in resources
+ assert "resource://imported//absolute/path" in resources
+ assert "resource://imported/{param}/template" in templates
+
+ # Verify we can access the resources
+ async with Client(target_server) as client:
+ result = await client.read_resource("resource://imported/test-resource")
+ assert result[0].text == "Resource content" # type: ignore[attr-defined]
+
+ result = await client.read_resource("resource://imported//absolute/path")
+ assert result[0].text == "Absolute resource content" # type: ignore[attr-defined]
+
+ result = await client.read_resource("resource://imported/param-value/template")
+ assert result[0].text == "Template resource with param-value" # type: ignore[attr-defined]
diff --git a/tests/resources/test_resource_manager.py b/tests/resources/test_resource_manager.py
index ecbf10cfd..50d72018d 100644
--- a/tests/resources/test_resource_manager.py
+++ b/tests/resources/test_resource_manager.py
@@ -450,123 +450,6 @@ class TestResourceTags:
assert admin_resources[0].name == "system_data"
-class TestCustomResourceKeys:
- """Test adding resources and templates with custom keys."""
-
- def test_add_resource_with_custom_key(self, temp_file: Path):
- """Test adding a resource with a custom key different from its URI."""
- manager = ResourceManager()
- original_uri = "data://test/resource"
- custom_key = "custom://resource/key"
-
- # Create a function resource instead of file resource to avoid path issues
- async def get_data():
- return "Test data"
-
- resource = FunctionResource(
- uri=AnyUrl(original_uri),
- name="test_resource",
- fn=get_data,
- )
-
- # Use model_copy to create a new resource with the custom key
- resource_with_custom_key = resource.model_copy(key=custom_key)
- manager.add_resource(resource_with_custom_key)
-
- # Resource should be accessible via custom key
- assert custom_key in manager._resources
- # But not via its original URI
- assert original_uri not in manager._resources
- # The resource's internal URI remains unchanged
- assert str(manager._resources[custom_key].uri) == original_uri
-
- def test_add_template_with_custom_key(self):
- """Test adding a template with a custom key different from its URI template."""
- manager = ResourceManager()
-
- def template_fn(id: str) -> str:
- return f"Template {id}"
-
- original_uri_template = "test://{id}"
- custom_key = "custom://{id}/template"
-
- template = ResourceTemplate.from_function(
- fn=template_fn,
- uri_template=original_uri_template,
- name="test_template",
- )
-
- # Use model_copy to create a new template with the custom key
- template_with_custom_key = template.model_copy(key=custom_key)
- manager.add_template(template_with_custom_key)
-
- # Template should be accessible via custom key
- assert custom_key in manager._templates
- # But not via its original URI template
- assert original_uri_template not in manager._templates
- # The template's internal URI template remains unchanged
- assert str(manager._templates[custom_key].uri_template) == original_uri_template
-
- async def test_get_resource_with_custom_key(self, temp_file: Path):
- """Test that get_resource works with resources added with custom keys."""
- manager = ResourceManager()
- original_uri = "data://test/resource"
- custom_key = "custom://resource/path"
-
- # Create a function resource instead of file resource to avoid path issues
- async def get_data():
- return "Test data"
-
- resource = FunctionResource(
- uri=AnyUrl(original_uri),
- name="test_resource",
- fn=get_data,
- )
-
- # Use model_copy to create a new resource with the custom key
- resource_with_custom_key = resource.model_copy(key=custom_key)
- manager.add_resource(resource_with_custom_key)
-
- # Should be retrievable by the custom key
- retrieved = await manager.get_resource(custom_key)
- assert retrieved is not None
- assert str(retrieved.uri) == original_uri
-
- # Should NOT be retrievable by the original URI
- with pytest.raises(NotFoundError, match="Unknown resource"):
- await manager.get_resource(original_uri)
-
- async def test_get_resource_from_template_with_custom_key(self):
- """Test that templates with custom keys can create resources."""
- manager = ResourceManager()
-
- def greet(name: str) -> str:
- return f"Hello, {name}!"
-
- original_template = "greet://{name}"
- custom_key = "custom://greet/{name}"
-
- template = ResourceTemplate.from_function(
- fn=greet,
- uri_template=original_template,
- name="custom_greeter",
- )
-
- # Use model_copy to create a new template with the custom key
- template_with_custom_key = template.model_copy(key=custom_key)
- manager.add_template(template_with_custom_key)
-
- # Using a URI that matches the custom key pattern
- resource = await manager.get_resource("custom://greet/world")
- assert isinstance(resource, FunctionResource)
- result = await resource.read()
- assert result.content == "Hello, world!"
-
- # Shouldn't work with the original template pattern
- with pytest.raises(NotFoundError, match="Unknown resource"):
- await manager.get_resource("greet://world")
-
-
class TestQueryOnlyTemplates:
"""Test resource templates with only query parameters (no path params)."""
diff --git a/tests/server/tasks/test_server_tasks_parameter.py b/tests/server/tasks/test_server_tasks_parameter.py
index 90813814e..b61edb4a4 100644
--- a/tests/server/tasks/test_server_tasks_parameter.py
+++ b/tests/server/tasks/test_server_tasks_parameter.py
@@ -28,11 +28,12 @@ async def test_server_tasks_true_defaults_all_components():
async with Client(mcp) as client:
# Verify all task-enabled components are registered with docket
+ # Tools and prompts use .key (which equals name), resources use .key (which is URI)
docket = mcp.docket
assert docket is not None
assert "my_tool" in docket.tasks
assert "my_prompt" in docket.tasks
- assert "my_resource" in docket.tasks
+ assert "test://resource" in docket.tasks
# Tool should support background execution
tool_task = await client.call_tool("my_tool", task=True)
@@ -198,17 +199,18 @@ async def test_mixed_explicit_and_inherited():
async with Client(mcp) as client:
# Verify docket registration matches task settings
+ # Tools/prompts use .key (name), resources use .key (URI)
docket = mcp.docket
assert docket is not None
# task=True (explicit or inherited) means registered
assert "inherited_tool" in docket.tasks
assert "explicit_true_tool" in docket.tasks
assert "inherited_prompt" in docket.tasks
- assert "inherited_resource" in docket.tasks
+ assert "test://inherited" in docket.tasks
# task=False means NOT registered
assert "explicit_false_tool" not in docket.tasks
assert "explicit_false_prompt" not in docket.tasks
- assert "explicit_false_resource" not in docket.tasks
+ assert "test://explicit_false" not in docket.tasks
# Tools
inherited = await client.call_tool("inherited_tool", task=True)
@@ -339,8 +341,7 @@ async def test_task_with_custom_tool_name():
async def test_task_with_custom_resource_name():
"""Resources with custom names work correctly as tasks.
- When a resource is registered with a custom name different from the function
- name, task execution should use the custom name for Docket lookup.
+ Resources are registered/looked up by their .key (URI), not their name.
"""
mcp = FastMCP("test", tasks=True)
@@ -349,10 +350,10 @@ async def test_task_with_custom_resource_name():
return "result from custom-named resource"
async with Client(mcp) as client:
- # Verify the resource is registered with its custom name in Docket
+ # Verify the resource is registered with its key (URI) in Docket
docket = mcp.docket
assert docket is not None
- assert "custom-resource-name" in docket.tasks
+ assert "test://resource" in docket.tasks
# Call the resource as a task
task = await client.read_resource("test://resource", task=True)
@@ -364,8 +365,7 @@ async def test_task_with_custom_resource_name():
async def test_task_with_custom_template_name():
"""Resource templates with custom names work correctly as tasks.
- When a template is registered with a custom name different from the function
- name, task execution should use the custom name for Docket lookup.
+ Templates are registered/looked up by their .key (uri_template), not their name.
"""
mcp = FastMCP("test", tasks=True)
@@ -374,10 +374,10 @@ async def test_task_with_custom_template_name():
return f"result for {item_id}"
async with Client(mcp) as client:
- # Verify the template is registered with its custom name in Docket
+ # Verify the template is registered with its key (uri_template) in Docket
docket = mcp.docket
assert docket is not None
- assert "custom-template-name" in docket.tasks
+ assert "test://{item_id}" in docket.tasks
# Call the template as a task
task = await client.read_resource("test://123", task=True)
diff --git a/tests/server/test_mount.py b/tests/server/test_mount.py
index 7026429a5..b52b2ed17 100644
--- a/tests/server/test_mount.py
+++ b/tests/server/test_mount.py
@@ -970,11 +970,11 @@ class TestAsProxyKwarg:
assert lifespan_check == ["start"]
-class TestResourceNamePrefixing:
- """Test that resource and resource template names get prefixed when mounted."""
+class TestResourceUriPrefixing:
+ """Test that resource and resource template URIs get prefixed when mounted (names are NOT prefixed)."""
- async def test_resource_name_prefixing(self):
- """Test that resource names are prefixed when mounted."""
+ async def test_resource_uri_prefixing(self):
+ """Test that resource URIs are prefixed when mounted (names are NOT prefixed)."""
# Create a sub-app with a resource
sub_app = FastMCP("SubApp")
@@ -993,12 +993,12 @@ class TestResourceNamePrefixing:
# Should have prefixed key (using path format: resource://prefix/resource_name)
assert "resource://prefix/my_resource" in resources
- # The resource name should also be prefixed
+ # The resource name should NOT be prefixed (only URI is prefixed)
resource = resources["resource://prefix/my_resource"]
- assert resource.name == "prefix_my_resource"
+ assert resource.name == "my_resource"
- async def test_resource_template_name_prefixing(self):
- """Test that resource template names are prefixed when mounted."""
+ async def test_resource_template_uri_prefixing(self):
+ """Test that resource template URIs are prefixed when mounted (names are NOT prefixed)."""
# Create a sub-app with a resource template
sub_app = FastMCP("SubApp")
@@ -1017,9 +1017,9 @@ class TestResourceNamePrefixing:
# Should have prefixed key (using path format: resource://prefix/template_uri)
assert "resource://prefix/user/{user_id}" in templates
- # The template name should also be prefixed
+ # The template name should NOT be prefixed (only URI template is prefixed)
template = templates["resource://prefix/user/{user_id}"]
- assert template.name == "prefix_user_template"
+ assert template.name == "user_template"
class TestParentTagFiltering:
diff --git a/tests/server/test_server.py b/tests/server/test_server.py
index 22e884f0e..69b608fa2 100644
--- a/tests/server/test_server.py
+++ b/tests/server/test_server.py
@@ -1335,48 +1335,6 @@ class TestResourcePrefixMounting:
# Test stripping
assert remove_resource_prefix(uri, prefix) == expected_strip
- async def test_import_server_with_new_prefix_format(self):
- """Test that import_server correctly uses the new prefix format."""
- # Create a server with resources
- source_server = FastMCP(name="SourceServer")
-
- @source_server.resource("resource://test-resource")
- def get_resource():
- return "Resource content"
-
- @source_server.resource("resource:///absolute/path")
- def get_absolute_resource():
- return "Absolute resource content"
-
- @source_server.resource("resource://{param}/template")
- def get_template_resource(param: str):
- return f"Template resource with {param}"
-
- # Create target server and import the source server
- target_server = FastMCP(name="TargetServer")
- await target_server.import_server(source_server, "imported")
-
- # Check that the resources were imported with the correct prefixes
- resources = await target_server.get_resources()
- templates = await target_server.get_resource_templates()
-
- assert "resource://imported/test-resource" in resources
- assert "resource://imported//absolute/path" in resources
- assert "resource://imported/{param}/template" in templates
-
- # Verify we can access the resources
- async with Client(target_server) as client:
- result = await client.read_resource("resource://imported/test-resource")
- assert result[0].text == "Resource content" # type: ignore[attr-defined]
-
- result = await client.read_resource("resource://imported//absolute/path")
- assert result[0].text == "Absolute resource content" # type: ignore[attr-defined]
-
- result = await client.read_resource(
- "resource://imported/param-value/template"
- )
- assert result[0].text == "Template resource with param-value" # type: ignore[attr-defined]
-
class TestShouldIncludeComponent:
def test_no_filters_returns_true(self):
diff --git a/tests/tools/test_tool_manager.py b/tests/tools/test_tool_manager.py
index 500852c0a..9843f5d75 100644
--- a/tests/tools/test_tool_manager.py
+++ b/tests/tools/test_tool_manager.py
@@ -869,27 +869,6 @@ class TestCustomToolNames:
with pytest.raises(NotFoundError, match="Tool 'original_fn' not found"):
await manager.get_tool("original_fn")
- async def test_add_tool_object_with_custom_key(self):
- """Test adding a Tool object with a custom key using add_tool()."""
-
- def fn(x: int) -> int:
- return x + 1
-
- # Create a tool with a specific name
- tool = Tool.from_function(fn, name="my_tool")
- manager = ToolManager()
- # Use model_copy to create a new tool with the custom key
- tool_with_custom_key = tool.model_copy(key="proxy_tool")
- manager.add_tool(tool_with_custom_key)
- # The tool is accessible under the key
- stored = await manager.get_tool("proxy_tool")
- assert stored is not None
- # But the tool's .name is unchanged
- assert stored.name == "my_tool"
- # The tool is not accessible under its original name
- with pytest.raises(NotFoundError, match="Tool 'my_tool' not found"):
- await manager.get_tool("my_tool")
-
async def test_call_tool_with_custom_name(self):
"""Test calling a tool added with a custom name."""
diff --git a/tests/utilities/test_components.py b/tests/utilities/test_components.py
index 1211d1e1f..330ab896a 100644
--- a/tests/utilities/test_components.py
+++ b/tests/utilities/test_components.py
@@ -48,7 +48,7 @@ class TestFastMCPComponent:
name="test_component",
title="Test Component",
description="A test component",
- tags=["test", "component"],
+ tags={"test", "component"},
)
def test_initialization_with_minimal_params(self):
@@ -68,7 +68,7 @@ class TestFastMCPComponent:
name="full",
title="Full Component",
description="A fully configured component",
- tags=["tag1", "tag2"],
+ tags={"tag1", "tag2"},
meta=meta,
enabled=False,
)
@@ -83,12 +83,6 @@ class TestFastMCPComponent:
"""Test that key property returns name when no custom key is set."""
assert basic_component.key == "test_component"
- def test_key_property_with_custom_key(self):
- """Test that key property returns custom key when set."""
- component = FastMCPComponent(name="test", key="custom_key")
- assert component.key == "custom_key"
- assert component.name == "test"
-
def test_get_meta_without_fastmcp_meta(self, basic_component):
"""Test get_meta without including fastmcp meta."""
basic_component.meta = {"custom": "data"}
@@ -110,7 +104,7 @@ class TestFastMCPComponent:
component = FastMCPComponent(
name="test",
meta={"_fastmcp": {"existing": "value"}},
- tags=["new_tag"],
+ tags={"new_tag"},
)
result = component.get_meta(include_fastmcp_meta=True)
assert result is not None
@@ -123,14 +117,6 @@ class TestFastMCPComponent:
result = component.get_meta(include_fastmcp_meta=False)
assert result is None
- def test_model_copy_creates_copy_with_new_key(self, basic_component):
- """Test that model_copy with key creates a copy with a new key."""
- new_component = basic_component.model_copy(key="new_key")
- assert new_component.key == "new_key"
- assert new_component.name == basic_component.name
- assert new_component is not basic_component # Should be a copy
- assert basic_component.key == "test_component" # Original unchanged
-
def test_equality_same_components(self):
"""Test that identical components are equal."""
comp1 = FastMCPComponent(name="test", description="desc")
@@ -182,17 +168,17 @@ class TestFastMCPComponent:
assert basic_component.name == "test_component"
def test_tags_deduplication(self):
- """Test that tags are deduplicated."""
+ """Test that tags are deduplicated when passed as a sequence."""
component = FastMCPComponent(
name="test",
- tags=["tag1", "tag2", "tag1", "tag2"],
+ tags=["tag1", "tag2", "tag1", "tag2"], # type: ignore[arg-type]
)
assert component.tags == {"tag1", "tag2"}
def test_validation_error_for_invalid_data(self):
"""Test that validation errors are raised for invalid data."""
with pytest.raises(ValidationError):
- FastMCPComponent() # Missing required name field
+ FastMCPComponent() # type: ignore[call-arg]
def test_extra_fields_forbidden(self):
"""Test that extra fields are not allowed."""
@@ -290,10 +276,6 @@ class TestMirroredComponent:
# Test key property
assert mirrored_component.key == "mirrored"
- # Test model_copy with key
- with_key = mirrored_component.model_copy(key="new_key")
- assert with_key.key == "new_key"
-
# Test get_meta
mirrored_component.tags = {"tag1"}
meta = mirrored_component.get_meta(include_fastmcp_meta=True)
@@ -323,7 +305,7 @@ class TestEdgeCasesAndIntegration:
def test_empty_tags_conversion(self):
"""Test that empty tags are handled correctly."""
- component = FastMCPComponent(name="test", tags=[])
+ component = FastMCPComponent(name="test", tags=set())
assert component.tags == set()
def test_tags_with_none_values(self):
@@ -353,17 +335,17 @@ class TestEdgeCasesAndIntegration:
component = FastMCPComponent(name="test", meta=complex_meta)
assert component.meta == complex_meta
- def test_model_copy_with_key_preserves_all_attributes(self):
- """Test that model_copy with key preserves all component attributes."""
+ def test_model_copy_preserves_all_attributes(self):
+ """Test that model_copy preserves all component attributes."""
component = FastMCPComponent(
name="test",
title="Title",
description="Description",
- tags=["tag1", "tag2"],
+ tags={"tag1", "tag2"},
meta={"key": "value"},
enabled=False,
)
- new_component = component.model_copy(key="new_key")
+ new_component = component.model_copy()
assert new_component.name == component.name
assert new_component.title == component.title
@@ -371,7 +353,7 @@ class TestEdgeCasesAndIntegration:
assert new_component.tags == component.tags
assert new_component.meta == component.meta
assert new_component.enabled == component.enabled
- assert new_component.key == "new_key"
+ assert new_component.key == component.key
def test_mirrored_component_copy_chain(self):
"""Test creating copies of copies for mirrored components."""
@@ -390,30 +372,34 @@ class TestEdgeCasesAndIntegration:
assert copy1.name == "copy1"
assert copy2.name == "copy2"
- def test_model_copy_with_update_and_key(self):
- """Test that model_copy works with both update dict and key parameter."""
+ def test_model_copy_with_update(self):
+ """Test that model_copy works with update dict."""
component = FastMCPComponent(
name="test",
title="Original Title",
description="Original Description",
- tags=["tag1"],
+ tags={"tag1"},
enabled=True,
)
- # Test with both update and key
+ # Test with update (including name which affects .key)
updated_component = component.model_copy(
- update={"title": "New Title", "description": "New Description"},
- key="new_key",
+ update={
+ "name": "new_name",
+ "title": "New Title",
+ "description": "New Description",
+ },
)
- assert updated_component.name == "test" # Not in update, unchanged
+ assert updated_component.name == "new_name" # Updated
assert updated_component.title == "New Title" # Updated
assert updated_component.description == "New Description" # Updated
assert updated_component.tags == {"tag1"} # Not in update, unchanged
assert updated_component.enabled is True # Not in update, unchanged
- assert updated_component.key == "new_key" # Custom key set
+ assert updated_component.key == "new_name" # .key is computed from name
# Original should be unchanged
+ assert component.name == "test"
assert component.title == "Original Title"
assert component.description == "Original Description"
assert component.key == "test" # Uses name as key