Skip to content

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

Merge remote-tracking branch 'origin/main' into refactor-provider-inheritance-v2

Jeremiah Lowinddd2058f9741
diff --cc src/fastmcp/server/server.py
index dfaed6922,5fa10c11d..8dc0fde40
--- a/src/fastmcp/server/server.py
+++ b/src/fastmcp/server/server.py
@@@ -1053,38 -1216,34 +1105,32 @@@ class FastMCP(Provider, Generic[Lifespa
source="client",
type="request",
method="tools/list",
- fastmcp_context=fastmcp_ctx,
+ fastmcp_context=ctx,
)
- return list(
- await self._run_middleware(
- context=mw_context,
- call_next=lambda context: self.get_tools(run_middleware=False),
- )
+ return await self._run_middleware(
+ context=mw_context,
+ call_next=lambda context: self.get_tools(run_middleware=False),
)
- # Query through full transform chain (provider transforms + server transforms + visibility)
- tools = await self._source_list_tools()
+ # Query through full transform chain (provider transforms + server transforms + visibility)
+ tools = await self._list_tools()
- # Get auth context (skip_auth=True for STDIO which has no auth concept)
- skip_auth, token = _get_auth_context()
+ # Get auth context (skip_auth=True for STDIO which has no auth concept)
+ skip_auth, token = _get_auth_context()
- # Deduplicate by name (keeping highest version) and apply authorization checks
- by_name: dict[str, Tool] = {}
- # Filter by auth
- authorized: list[Tool] = []
- for tool in tools:
- if not skip_auth and tool.auth is not None:
- ctx = AuthContext(token=token, component=tool)
- try:
- if not run_auth_checks(tool.auth, ctx):
++ # Filter by auth
++ authorized: list[Tool] = []
+ for tool in tools:
- # Check tool-level auth (skip for STDIO)
+ if not skip_auth and tool.auth is not None:
+ ctx = AuthContext(token=token, component=tool)
+ try:
+ if not run_auth_checks(tool.auth, ctx):
+ continue
+ except AuthorizationError:
- # Treat auth errors as denials in list operations
continue
- # Keep highest version per name
- existing = by_name.get(tool.name)
- if existing is None or version_sort_key(tool) > version_sort_key(
- existing
- ):
- by_name[tool.name] = tool
- return list(by_name.values())
- except AuthorizationError:
- continue
- authorized.append(tool)
++ authorized.append(tool)
+
- return _dedupe_with_versions(authorized, lambda t: t.name)
++ return _dedupe_with_versions(authorized, lambda t: t.name)
async def get_tool(
self, name: str, version: VersionSpec | str | None = None
@@@ -1106,50 -1266,30 +1152,60 @@@
else:
version_spec = version
- tool = await self._source_get_tool(name, version_spec)
-
+ # Use _get_tool which applies server transforms
- return await self._get_tool(name, version_spec)
++ tool = await self._get_tool(name, version_spec)
+ if tool is None:
- if version is None:
- raise NotFoundError(f"Unknown tool: {name!r}")
- elif isinstance(version, str):
- raise NotFoundError(f"Unknown tool: {name!r} version {version!r}")
- else:
- raise NotFoundError(f"Unknown tool: {name!r} matching {version!r}")
-
- # Check tool-level auth (skip for STDIO)
++ return None
++
++ # Auth check
+ skip_auth, token = _get_auth_context()
+ if not skip_auth and tool.auth is not None:
+ ctx = AuthContext(token=token, component=tool)
+ if not run_auth_checks(tool.auth, ctx):
- if version is None:
- raise NotFoundError(f"Unknown tool: {name!r}")
- elif isinstance(version, str):
- raise NotFoundError(f"Unknown tool: {name!r} version {version!r}")
- else:
- raise NotFoundError(f"Unknown tool: {name!r} matching {version!r}")
-
++ return None
+ return tool
+ async def _get_tool(
+ self, name: str, version: VersionSpec | None = None
+ ) -> Tool | None:
+ """Get tool with all transforms applied (server transforms + aggregation).
+
+ Overrides Provider._get_tool to aggregate from providers after applying
+ server-level transforms.
+ """
+
+ async def base(n: str, *, version: VersionSpec | None = None) -> Tool | None:
+ # Aggregate from all sub-providers
+ results = await gather(
+ *[p._get_tool(n, version) for p in self._providers],
+ return_exceptions=True,
+ )
+
+ # Collect valid results, pick highest version
+ valid: list[Tool] = []
+ for i, result in enumerate(results):
+ if isinstance(result, BaseException):
+ if not isinstance(result, NotFoundError):
+ logger.debug(
+ f"Error during get_tool({n!r}) from provider "
+ f"{self._providers[i]}: {result}"
+ )
+ continue
+ if result is not None and self._is_component_enabled(result):
+ valid.append(result)
+
+ if not valid:
+ return None
+
+ return max(valid, key=version_sort_key) # type: ignore[type-var]
+
+ # Build transform chain: server transforms applied over aggregation
+ chain = base
+ for transform in self._get_all_transforms():
+ chain = partial(transform.get_tool, call_next=chain)
+
+ return await chain(name, version=version)
+
async def get_resources(self, *, run_middleware: bool = False) -> list[Resource]:
"""Get all enabled resources from providers.
@@@ -1167,39 -1307,36 +1223,32 @@@
source="client",
type="request",
method="resources/list",
- fastmcp_context=fastmcp_ctx,
+ fastmcp_context=ctx,
)
- return list(
- await self._run_middleware(
- context=mw_context,
- call_next=lambda context: self.get_resources(
- run_middleware=False
- ),
- )
+ return await self._run_middleware(
+ context=mw_context,
+ call_next=lambda context: self.get_resources(run_middleware=False),
)
- # Query through full transform chain (provider transforms + server transforms + visibility)
- resources = await self._source_list_resources()
-
- # Get auth context (skip_auth=True for STDIO which has no auth concept)
- skip_auth, token = _get_auth_context()
-
- # Filter by auth
- authorized: list[Resource] = []
- for resource in resources:
- if not skip_auth and resource.auth is not None:
- ctx = AuthContext(token=token, component=resource)
- try:
- if not run_auth_checks(resource.auth, ctx):
+ # Query through full transform chain (provider transforms + server transforms + visibility)
+ resources = await self._list_resources()
+
+ # Get auth context (skip_auth=True for STDIO which has no auth concept)
+ skip_auth, token = _get_auth_context()
+
- # Deduplicate by URI (keeping highest version) and apply authorization checks
- by_uri: dict[str, Resource] = {}
++ # Filter by auth
++ authorized: list[Resource] = []
+ for resource in resources:
- # Check resource-level auth (skip for STDIO)
+ if not skip_auth and resource.auth is not None:
+ ctx = AuthContext(token=token, component=resource)
+ try:
+ if not run_auth_checks(resource.auth, ctx):
+ continue
+ except AuthorizationError:
- # Treat auth errors as denials in list operations
continue
- # Keep highest version per URI
- uri_str = str(resource.uri)
- existing = by_uri.get(uri_str)
- if existing is None or version_sort_key(resource) > version_sort_key(
- existing
- ):
- by_uri[uri_str] = resource
- return list(by_uri.values())
- except AuthorizationError:
- continue
- authorized.append(resource)
++ authorized.append(resource)
+
- return _dedupe_with_versions(authorized, lambda r: str(r.uri))
++ return _dedupe_with_versions(authorized, lambda r: str(r.uri))
async def get_resource(
self, uri: str, version: VersionSpec | str | None = None
@@@ -1221,52 -1359,30 +1270,62 @@@
else:
version_spec = version
- resource = await self._source_get_resource(uri, version_spec)
-
+ # Use _get_resource which applies server transforms
- return await self._get_resource(uri, version_spec)
++ resource = await self._get_resource(uri, version_spec)
+ if resource is None:
- if version is None:
- raise NotFoundError(f"Unknown resource: {uri}")
- elif isinstance(version, str):
- raise NotFoundError(f"Unknown resource: {uri} version {version!r}")
- else:
- raise NotFoundError(f"Unknown resource: {uri} matching {version!r}")
-
- # Check resource-level auth (skip for STDIO)
++ return None
++
++ # Auth check
+ skip_auth, token = _get_auth_context()
+ if not skip_auth and resource.auth is not None:
+ ctx = AuthContext(token=token, component=resource)
+ if not run_auth_checks(resource.auth, ctx):
- if version is None:
- raise NotFoundError(f"Unknown resource: {uri}")
- elif isinstance(version, str):
- raise NotFoundError(f"Unknown resource: {uri} version {version!r}")
- else:
- raise NotFoundError(f"Unknown resource: {uri} matching {version!r}")
-
++ return None
+ return resource
+ async def _get_resource(
+ self, uri: str, version: VersionSpec | None = None
+ ) -> Resource | None:
+ """Get resource with all transforms applied (server transforms + aggregation).
+
+ Overrides Provider._get_resource to aggregate from providers after applying
+ server-level transforms.
+ """
+
+ async def base(
+ u: str, *, version: VersionSpec | None = None
+ ) -> Resource | None:
+ # Aggregate from all sub-providers
+ results = await gather(
+ *[p._get_resource(u, version) for p in self._providers],
+ return_exceptions=True,
+ )
+
+ # Collect valid results, pick highest version
+ valid: list[Resource] = []
+ for i, result in enumerate(results):
+ if isinstance(result, BaseException):
+ if not isinstance(result, NotFoundError):
+ logger.debug(
+ f"Error during get_resource({u!r}) from provider "
+ f"{self._providers[i]}: {result}"
+ )
+ continue
+ if result is not None and self._is_component_enabled(result):
+ valid.append(result)
+
+ if not valid:
+ return None
+
+ return max(valid, key=version_sort_key) # type: ignore[type-var]
+
+ # Build transform chain: server transforms applied over aggregation
+ chain = base
+ for transform in self._get_all_transforms():
+ chain = partial(transform.get_resource, call_next=chain)
+
+ return await chain(uri, version=version)
+
async def get_resource_templates(
self, *, run_middleware: bool = False
) -> list[ResourceTemplate]:
@@@ -1286,40 -1402,36 +1345,34 @@@
source="client",
type="request",
method="resources/templates/list",
- fastmcp_context=fastmcp_ctx,
+ fastmcp_context=ctx,
)
- return list(
- await self._run_middleware(
- context=mw_context,
- call_next=lambda context: self.get_resource_templates(
- run_middleware=False
- ),
- )
+ return await self._run_middleware(
+ context=mw_context,
+ call_next=lambda context: self.get_resource_templates(
+ run_middleware=False
+ ),
)
- # Query through full transform chain (provider transforms + server transforms + visibility)
- templates = await self._source_list_resource_templates()
-
- # Get auth context (skip_auth=True for STDIO which has no auth concept)
- skip_auth, token = _get_auth_context()
-
- # Filter by auth
- authorized: list[ResourceTemplate] = []
- for template in templates:
- if not skip_auth and template.auth is not None:
- ctx = AuthContext(token=token, component=template)
- try:
- if not run_auth_checks(template.auth, ctx):
+ # Query through full transform chain (provider transforms + server transforms + visibility)
+ templates = await self._list_resource_templates()
+
+ # Get auth context (skip_auth=True for STDIO which has no auth concept)
+ skip_auth, token = _get_auth_context()
+
- # Deduplicate by uri_template (keeping highest version) and apply authorization checks
- by_uri_template: dict[str, ResourceTemplate] = {}
++ # Filter by auth
++ authorized: list[ResourceTemplate] = []
+ for template in templates:
- # Check template-level auth (skip for STDIO)
+ if not skip_auth and template.auth is not None:
+ ctx = AuthContext(token=token, component=template)
+ try:
+ if not run_auth_checks(template.auth, ctx):
+ continue
+ except AuthorizationError:
- # Treat auth errors as denials in list operations
continue
- # Keep highest version per uri_template
- existing = by_uri_template.get(template.uri_template)
- if existing is None or version_sort_key(template) > version_sort_key(
- existing
- ):
- by_uri_template[template.uri_template] = template
- return list(by_uri_template.values())
- except AuthorizationError:
- continue
- authorized.append(template)
++ authorized.append(template)
+
- return _dedupe_with_versions(authorized, lambda t: t.uri_template)
++ return _dedupe_with_versions(authorized, lambda t: t.uri_template)
async def get_resource_template(
self, uri: str, version: VersionSpec | str | None = None
@@@ -1341,52 -1454,38 +1394,62 @@@
else:
version_spec = version
- template = await self._source_get_resource_template(uri, version_spec)
-
+ # Use _get_resource_template which applies server transforms
- return await self._get_resource_template(uri, version_spec)
++ template = await self._get_resource_template(uri, version_spec)
+ if template is None:
- if version is None:
- raise NotFoundError(f"Unknown resource template: {uri}")
- elif isinstance(version, str):
- raise NotFoundError(
- f"Unknown resource template: {uri} version {version!r}"
- )
- else:
- raise NotFoundError(
- f"Unknown resource template: {uri} matching {version!r}"
- )
++ return None
+
- # Check template-level auth (skip for STDIO)
++ # Auth check
+ skip_auth, token = _get_auth_context()
+ if not skip_auth and template.auth is not None:
+ ctx = AuthContext(token=token, component=template)
+ if not run_auth_checks(template.auth, ctx):
- if version is None:
- raise NotFoundError(f"Unknown resource template: {uri}")
- elif isinstance(version, str):
- raise NotFoundError(
- f"Unknown resource template: {uri} version {version!r}"
- )
- else:
- raise NotFoundError(
- f"Unknown resource template: {uri} matching {version!r}"
- )
-
++ return None
+ return template
+ async def _get_resource_template(
+ self, uri: str, version: VersionSpec | None = None
+ ) -> ResourceTemplate | None:
+ """Get resource template with all transforms applied.
+
+ Overrides Provider._get_resource_template to aggregate from providers after
+ applying server-level transforms.
+ """
+
+ async def base(
+ u: str, *, version: VersionSpec | None = None
+ ) -> ResourceTemplate | None:
+ # Aggregate from all sub-providers
+ results = await gather(
+ *[p._get_resource_template(u, version) for p in self._providers],
+ return_exceptions=True,
+ )
+
+ # Collect valid results, pick highest version
+ valid: list[ResourceTemplate] = []
+ for i, result in enumerate(results):
+ if isinstance(result, BaseException):
+ if not isinstance(result, NotFoundError):
+ logger.debug(
+ f"Error during get_resource_template({u!r}) from provider "
+ f"{self._providers[i]}: {result}"
+ )
+ continue
+ if result is not None and self._is_component_enabled(result):
+ valid.append(result)
+
+ if not valid:
+ return None
+
+ return max(valid, key=version_sort_key) # type: ignore[type-var]
+
+ # Build transform chain: server transforms applied over aggregation
+ chain = base
+ for transform in self._get_all_transforms():
+ chain = partial(transform.get_resource_template, call_next=chain)
+
+ return await chain(uri, version=version)
+
async def get_prompts(self, *, run_middleware: bool = False) -> list[Prompt]:
"""Get all enabled prompts from providers.
@@@ -1404,38 -1503,36 +1467,32 @@@
source="client",
type="request",
method="prompts/list",
- fastmcp_context=fastmcp_ctx,
+ fastmcp_context=ctx,
)
- return list(
- await self._run_middleware(
- context=mw_context,
- call_next=lambda context: self.get_prompts(
- run_middleware=False
- ),
- )
+ return await self._run_middleware(
+ context=mw_context,
+ call_next=lambda context: self.get_prompts(run_middleware=False),
)
- # Query through full transform chain (provider transforms + server transforms + visibility)
- prompts = await self._source_list_prompts()
-
- # Get auth context (skip_auth=True for STDIO which has no auth concept)
- skip_auth, token = _get_auth_context()
-
- # Filter by auth
- authorized: list[Prompt] = []
- for prompt in prompts:
- if not skip_auth and prompt.auth is not None:
- ctx = AuthContext(token=token, component=prompt)
- try:
- if not run_auth_checks(prompt.auth, ctx):
+ # Query through full transform chain (provider transforms + server transforms + visibility)
+ prompts = await self._list_prompts()
+
+ # Get auth context (skip_auth=True for STDIO which has no auth concept)
+ skip_auth, token = _get_auth_context()
+
- # Deduplicate by name (keeping highest version) and apply authorization checks
- by_name: dict[str, Prompt] = {}
++ # Filter by auth
++ authorized: list[Prompt] = []
+ for prompt in prompts:
- # Check prompt-level auth (skip for STDIO)
+ if not skip_auth and prompt.auth is not None:
+ ctx = AuthContext(token=token, component=prompt)
+ try:
+ if not run_auth_checks(prompt.auth, ctx):
+ continue
+ except AuthorizationError:
- # Treat auth errors as denials in list operations
continue
- # Keep highest version per name
- existing = by_name.get(prompt.name)
- if existing is None or version_sort_key(prompt) > version_sort_key(
- existing
- ):
- by_name[prompt.name] = prompt
- return list(by_name.values())
- except AuthorizationError:
- continue
- authorized.append(prompt)
++ authorized.append(prompt)
+
- return _dedupe_with_versions(authorized, lambda p: p.name)
++ return _dedupe_with_versions(authorized, lambda p: p.name)
async def get_prompt(
self, name: str, version: VersionSpec | str | None = None
@@@ -1457,76 -1555,32 +1514,86 @@@
else:
version_spec = version
- prompt = await self._source_get_prompt(name, version_spec)
-
+ # Use _get_prompt which applies server transforms
- return await self._get_prompt(name, version_spec)
++ prompt = await self._get_prompt(name, version_spec)
+ if prompt is None:
- if version is None:
- raise NotFoundError(f"Unknown prompt: {name}")
- elif isinstance(version, str):
- raise NotFoundError(f"Unknown prompt: {name!r} version {version!r}")
- else:
- raise NotFoundError(f"Unknown prompt: {name!r} matching {version!r}")
-
- # Check prompt-level auth (skip for STDIO)
++ return None
++
++ # Auth check
+ skip_auth, token = _get_auth_context()
+ if not skip_auth and prompt.auth is not None:
+ ctx = AuthContext(token=token, component=prompt)
+ if not run_auth_checks(prompt.auth, ctx):
- if version is None:
- raise NotFoundError(f"Unknown prompt: {name}")
- elif isinstance(version, str):
- raise NotFoundError(f"Unknown prompt: {name!r} version {version!r}")
- else:
- raise NotFoundError(
- f"Unknown prompt: {name!r} matching {version!r}"
- )
-
++ return None
+ return prompt
+ async def _get_prompt(
+ self, name: str, version: VersionSpec | None = None
+ ) -> Prompt | None:
+ """Get prompt with all transforms applied (server transforms + aggregation).
+
+ Overrides Provider._get_prompt to aggregate from providers after applying
+ server-level transforms.
+ """
+
+ async def base(n: str, *, version: VersionSpec | None = None) -> Prompt | None:
+ # Aggregate from all sub-providers
+ results = await gather(
+ *[p._get_prompt(n, version) for p in self._providers],
+ return_exceptions=True,
+ )
+
+ # Collect valid results, pick highest version
+ valid: list[Prompt] = []
+ for i, result in enumerate(results):
+ if isinstance(result, BaseException):
+ if not isinstance(result, NotFoundError):
+ logger.debug(
+ f"Error during get_prompt({n!r}) from provider "
+ f"{self._providers[i]}: {result}"
+ )
+ continue
+ if result is not None and self._is_component_enabled(result):
+ valid.append(result)
+
+ if not valid:
+ return None
+
+ return max(valid, key=version_sort_key) # type: ignore[type-var]
+
+ # Build transform chain: server transforms applied over aggregation
+ chain = base
+ for transform in self._get_all_transforms():
+ chain = partial(transform.get_prompt, call_next=chain)
+
+ return await chain(name, version=version)
+
+ async def get_component(
+ self, key: str
+ ) -> Tool | Resource | ResourceTemplate | Prompt | None:
+ """Get a component by its prefixed key.
+
+ Uses _get_* methods to apply server-level transforms (including namespace
+ resolution for mounted servers). Task keys use transformed names, so this
+ ensures proper resolution.
+
+ Args:
+ key: The prefixed key (e.g., "tool:name", "resource:uri", "template:uri").
+
+ Returns:
+ The component if found, None otherwise.
+ """
+ # Parse key and delegate to _get_* methods which apply server transforms
+ if key.startswith("tool:"):
+ return await self._get_tool(key[5:])
+ elif key.startswith("resource:"):
+ return await self._get_resource(key[9:])
+ elif key.startswith("template:"):
+ return await self._get_resource_template(key[9:])
+ elif key.startswith("prompt:"):
+ return await self._get_prompt(key[7:])
+ return None
+
@overload
async def call_tool(
self,
@@@ -1606,18 -1665,7 +1678,9 @@@
with server_span(
f"tools/call {name}", "tools/call", self.name, "tool", name
) as span:
- # Use _get_tool() to apply server transforms including visibility
- tool = await self._get_tool(name)
+ tool = await self.get_tool(name, version=version)
+ if tool is None:
+ raise NotFoundError(f"Unknown tool: {name!r}")
-
- # Check tool-level auth (skip for STDIO which has no auth concept)
- skip_auth, token = _get_auth_context()
- if not skip_auth and tool.auth is not None:
- auth_ctx = AuthContext(token=token, component=tool)
- if not run_auth_checks(tool.auth, auth_ctx):
- raise NotFoundError(f"Unknown tool: {name!r}")
-
span.set_attributes(tool.get_span_attributes())
if task_meta is not None and task_meta.fn_key is None:
task_meta = replace(task_meta, fn_key=tool.key)
@@@ -1716,49 -1769,33 +1784,35 @@@
uri,
resource_uri=uri,
) as span:
- # Get auth context (skip_auth=True for STDIO which has no auth concept)
- skip_auth, token = _get_auth_context()
-
- # Try concrete resources first (use _get_resource for server transforms)
- resource = await self._get_resource(uri)
- # Try concrete resources first
- try:
- resource = await self.get_resource(uri, version=version)
++ # Try concrete resources first (auth checked in get_resource)
++ resource = await self.get_resource(uri, version=version)
+ if resource is not None:
- # Check resource-level auth - auth failure on concrete resource
- # does NOT fall back to templates (deny immediately)
- if not skip_auth and resource.auth is not None:
- auth_ctx = AuthContext(token=token, component=resource)
- if not run_auth_checks(resource.auth, auth_ctx):
- raise NotFoundError(f"Unknown resource: {uri!r}")
-
- # Resource found and authorized
+ span.set_attributes(resource.get_span_attributes())
+ if task_meta is not None and task_meta.fn_key is None:
+ task_meta = replace(task_meta, fn_key=resource.key)
- return await resource._read(task_meta=task_meta)
- except NotFoundError:
- pass # Fall through to try templates
- except (FastMCPError, McpError):
- logger.exception(f"Error reading resource {uri!r}")
- raise
- except Exception as e:
- logger.exception(f"Error reading resource {uri!r}")
- if self._mask_error_details:
- raise ResourceError(f"Error reading resource {uri!r}") from e
- raise ResourceError(f"Error reading resource {uri!r}: {e}") from e
-
- # Try templates
- try:
- template = await self.get_resource_template(uri, version=version)
- except NotFoundError:
+ try:
- span.set_attributes(resource.get_span_attributes())
- if task_meta is not None and task_meta.fn_key is None:
- task_meta = replace(task_meta, fn_key=resource.key)
+ return await resource._read(task_meta=task_meta)
+ except (FastMCPError, McpError):
+ logger.exception(f"Error reading resource {uri!r}")
+ raise
+ except Exception as e:
+ logger.exception(f"Error reading resource {uri!r}")
+ if self._mask_error_details:
+ raise ResourceError(
+ f"Error reading resource {uri!r}"
+ ) from e
+ raise ResourceError(
+ f"Error reading resource {uri!r}: {e}"
+ ) from e
+
- # Try templates (use _get_resource_template for server transforms)
- template = await self._get_resource_template(uri)
- if template is not None:
- # Check template-level auth
- if not skip_auth and template.auth is not None:
- auth_ctx = AuthContext(token=token, component=template)
- if not run_auth_checks(template.auth, auth_ctx):
- template = None
-
++ # Try templates (auth checked in get_resource_template)
++ template = await self.get_resource_template(uri, version=version)
+ if template is None:
- raise NotFoundError(f"Unknown resource: {uri!r}")
+ if version is None:
- raise NotFoundError(f"Unknown resource: {uri!r}") from None
++ raise NotFoundError(f"Unknown resource: {uri!r}")
+ raise NotFoundError(
+ f"Unknown resource: {uri!r} version {version!r}"
- ) from None
++ )
span.set_attributes(template.get_span_attributes())
params = template.matches(uri)
assert params is not None
@@@ -1850,18 -1892,7 +1909,9 @@@
with server_span(
f"prompts/get {name}", "prompts/get", self.name, "prompt", name
) as span:
- # Use _get_prompt() to apply server transforms including visibility
- prompt = await self._get_prompt(name)
+ prompt = await self.get_prompt(name, version=version)
+ if prompt is None:
+ raise NotFoundError(f"Unknown prompt: {name!r}")
-
- # Check prompt-level auth (skip for STDIO which has no auth concept)
- skip_auth, token = _get_auth_context()
- if not skip_auth and prompt.auth is not None:
- auth_ctx = AuthContext(token=token, component=prompt)
- if not run_auth_checks(prompt.auth, auth_ctx):
- raise NotFoundError(f"Unknown prompt: {name!r}")
-
span.set_attributes(prompt.get_span_attributes())
if task_meta is not None and task_meta.fn_key is None:
task_meta = replace(task_meta, fn_key=prompt.key)
diff --cc tests/server/auth/test_authorization.py
index ffdaa185a,55acd5e7b..79d4e5e3d
--- a/tests/server/auth/test_authorization.py
+++ b/tests/server/auth/test_authorization.py
@@@ -301,21 -302,15 +301,17 @@@ class TestToolLevelAuth
finally:
auth_context_var.reset(tok)
- async def test_get_tool_returns_tool_without_auth_check(self):
- """get_tool() is the Provider interface and doesn't check auth.
-
- Auth is checked in call_tool() during execution, not during lookup.
- """
- async def test_get_tool_returns_not_found_without_auth(self):
++ async def test_get_tool_returns_none_without_auth(self):
++ """get_tool() checks auth and returns None for unauthorized tools."""
mcp = FastMCP()
@mcp.tool(auth=require_auth)
def protected_tool() -> str:
return "protected"
- # get_tool() returns the tool without checking auth
- with pytest.raises(NotFoundError):
- await mcp.get_tool("protected_tool")
++ # get_tool() returns None for unauthorized tools
+ tool = await mcp.get_tool("protected_tool")
- assert tool is not None
- assert tool.name == "protected_tool"
++ assert tool is None
async def test_get_tool_returns_tool_with_auth(self):
mcp = FastMCP()