π 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.pyindex 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[Lifespasource="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 operationscontinue- # 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 operationscontinue- # 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 operationscontinue- # 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 operationscontinue- # 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+@overloadasync 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.pyindex ffdaa185a,55acd5e7b..79d4e5e3d--- a/tests/server/auth/test_authorization.py+++ b/tests/server/auth/test_authorization.py@@@ -301,21 -302,15 +301,17 @@@ class TestToolLevelAuthfinally: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 Noneasync def test_get_tool_returns_tool_with_auth(self):mcp = FastMCP()