π The fast, Pythonic way to build MCP servers and clients.
Split Tool into Tool and FunctionTool
Jeremiah Lowin3a3c01708d1b
diff --git a/src/fastmcp/resources/resource.py b/src/fastmcp/resources/resource.pyindex 95bb7b034..6121c0a51 100644--- a/src/fastmcp/resources/resource.py+++ b/src/fastmcp/resources/resource.py@@ -8,7 +8,6 @@ from typing import TYPE_CHECKING, Annotated, Anyfrom mcp.types import Resource as MCPResourcefrom pydantic import (AnyUrl,- BaseModel,BeforeValidator,ConfigDict,Field,@@ -17,13 +16,13 @@ from pydantic import (field_validator,)-from fastmcp.utilities.types import _convert_set_defaults+from fastmcp.utilities.types import FastMCPBaseModel, _convert_set_defaultsif TYPE_CHECKING:pass-class Resource(BaseModel, abc.ABC):+class Resource(FastMCPBaseModel, abc.ABC):"""Base class for all resources."""model_config = ConfigDict(validate_default=True)diff --git a/src/fastmcp/resources/template.py b/src/fastmcp/resources/template.pyindex 5077a910b..dbbdb5338 100644--- a/src/fastmcp/resources/template.py+++ b/src/fastmcp/resources/template.py@@ -11,7 +11,6 @@ from urllib.parse import unquotefrom mcp.types import ResourceTemplate as MCPResourceTemplatefrom pydantic import (AnyUrl,- BaseModel,BeforeValidator,Field,field_validator,@@ -22,6 +21,7 @@ from fastmcp.resources.types import FunctionResource, Resourcefrom fastmcp.server.dependencies import get_contextfrom fastmcp.utilities.json_schema import compress_schemafrom fastmcp.utilities.types import (+ FastMCPBaseModel,_convert_set_defaults,find_kwarg_by_type,get_cached_typeadapter,@@ -52,12 +52,7 @@ def match_uri_template(uri: str, uri_template: str) -> dict[str, str] | None:return None-class MyModel(BaseModel):- key: str- value: int---class ResourceTemplate(BaseModel):+class ResourceTemplate(FastMCPBaseModel):"""A template for dynamically creating resources."""uri_template: str = Field(diff --git a/src/fastmcp/server/openapi.py b/src/fastmcp/server/openapi.pyindex 167e412f6..d74bb563e 100644--- a/src/fastmcp/server/openapi.py+++ b/src/fastmcp/server/openapi.py@@ -233,7 +233,6 @@ class OpenAPITool(Tool):name=name,description=description,parameters=parameters,- fn=self._execute_request, # We'll use an instance method instead of a global functiontags=tags,annotations=annotations,exclude_args=exclude_args,@@ -247,9 +246,10 @@ class OpenAPITool(Tool):"""Custom representation to prevent recursion errors when printing."""return f"OpenAPITool(name={self.name!r}, method={self._route.method}, path={self._route.path})"- async def _execute_request(self, *args, **kwargs):+ async def run(+ self, arguments: dict[str, Any]+ ) -> list[TextContent | ImageContent | EmbeddedResource]:"""Execute the HTTP request based on the route configuration."""- context = kwargs.get("context")# Prepare URLpath = self._route.path@@ -258,11 +258,11 @@ class OpenAPITool(Tool):# Path parameters should never be None as they're typically required# but we'll handle that case anywaypath_params = {- p.name: kwargs.get(p.name)+ p.name: arguments.get(p.name)for p in self._route.parametersif p.location == "path"- and p.name in kwargs- and kwargs.get(p.name) is not None+ and p.name in arguments+ and arguments.get(p.name) is not None}# Ensure all path parameters are provided@@ -340,11 +340,11 @@ class OpenAPITool(Tool):for p in self._route.parameters:if (p.location == "query"- and p.name in kwargs- and kwargs.get(p.name) is not None- and kwargs.get(p.name) != ""+ and p.name in arguments+ and arguments.get(p.name) is not None+ and arguments.get(p.name) != ""):- param_value = kwargs.get(p.name)+ param_value = arguments.get(p.name)# Format array query parameters as comma-separated strings# following OpenAPI form style (default for query parameters)@@ -399,10 +399,10 @@ class OpenAPITool(Tool):for p in self._route.parameters:if (p.location == "header"- and p.name in kwargs- and kwargs[p.name] is not None+ and p.name in arguments+ and arguments[p.name] is not None):- openapi_headers[p.name.lower()] = str(kwargs[p.name])+ openapi_headers[p.name.lower()] = str(arguments[p.name])headers.update(openapi_headers)# Add headers from the current MCP client HTTP request (these take precedence)@@ -420,21 +420,13 @@ class OpenAPITool(Tool):}body_params = {k: v- for k, v in kwargs.items()+ for k, v in arguments.items()if k not in path_query_header_params and k != "context"}if body_params:json_data = body_params- # Log the request details if a context is available- if context:- try:- await context.info(f"Making {self._route.method} request to {path}")- except (ValueError, AttributeError):- # Silently continue if context logging is not available- pass-# Execute the requesttry:response = await self._client.request(@@ -451,10 +443,11 @@ class OpenAPITool(Tool):# Try to parse as JSON firsttry:- return response.json()+ result = response.json()except (json.JSONDecodeError, ValueError):# Return text content if not JSON- return response.text+ result = response.text+ return _convert_to_content(result)except httpx.HTTPStatusError as e:# Handle HTTP errors (4xx, 5xx)@@ -474,13 +467,6 @@ class OpenAPITool(Tool):# Handle request errors (connection, timeout, etc.)raise ValueError(f"Request error: {str(e)}")- async def run(- self, arguments: dict[str, Any]- ) -> list[TextContent | ImageContent | EmbeddedResource]:- """Run the tool with arguments and optional context."""- response = await self._execute_request(**arguments)- return _convert_to_content(response)-class OpenAPIResource(Resource):"""Resource implementation for OpenAPI endpoints."""diff --git a/src/fastmcp/server/proxy.py b/src/fastmcp/server/proxy.pyindex 8f7123bab..96d5d1a41 100644--- a/src/fastmcp/server/proxy.py+++ b/src/fastmcp/server/proxy.py@@ -48,7 +48,6 @@ class ProxyTool(Tool):name=tool.name,description=tool.description,parameters=tool.inputSchema,- fn=_proxy_passthrough,)async def run(@@ -69,6 +68,9 @@ class ProxyTool(Tool):class ProxyResource(Resource):+ _client: Client+ _value: str | bytes | None = None+def __init__(self, client: Client, *, _value: str | bytes | None = None, **kwargs):super().__init__(**kwargs)self._client = client@@ -146,7 +148,6 @@ class ProxyTemplate(ResourceTemplate):name=self.name,description=self.description,mime_type=result[0].mimeType,- contents=result,_value=value,)diff --git a/src/fastmcp/server/server.py b/src/fastmcp/server/server.pyindex 3d33595ef..0729efbb2 100644--- a/src/fastmcp/server/server.py+++ b/src/fastmcp/server/server.py@@ -55,7 +55,7 @@ from fastmcp.server.http import (create_streamable_http_app,)from fastmcp.tools import ToolManager-from fastmcp.tools.tool import Tool+from fastmcp.tools.tool import FunctionTool, Toolfrom fastmcp.utilities.cache import TimedCachefrom fastmcp.utilities.decorators import DecoratedFunctionfrom fastmcp.utilities.logging import get_logger@@ -508,7 +508,7 @@ class FastMCP(Generic[LifespanResultT]):if isinstance(annotations, dict):annotations = ToolAnnotations(**annotations)- self._tool_manager.add_tool_from_fn(+ tool = FunctionTool.from_function(fn,name=name,description=description,@@ -516,6 +516,8 @@ class FastMCP(Generic[LifespanResultT]):annotations=annotations,exclude_args=exclude_args,)++ self._tool_manager.add_tool(tool)self._cache.clear()def remove_tool(self, name: str) -> None:diff --git a/src/fastmcp/tools/__init__.py b/src/fastmcp/tools/__init__.pyindex 22b69a0c7..e659a7785 100644--- a/src/fastmcp/tools/__init__.py+++ b/src/fastmcp/tools/__init__.py@@ -1,4 +1,4 @@-from .tool import Tool+from .tool import Tool, FunctionToolfrom .tool_manager import ToolManager-__all__ = ["Tool", "ToolManager"]+__all__ = ["Tool", "ToolManager", "FunctionTool"]diff --git a/src/fastmcp/tools/tool.py b/src/fastmcp/tools/tool.pyindex 3d22a1810..e1b444ae0 100644--- a/src/fastmcp/tools/tool.py+++ b/src/fastmcp/tools/tool.py@@ -2,19 +2,22 @@ from __future__ import annotationsimport inspectimport json+import warnings+from abc import ABC, abstractmethodfrom collections.abc import Callablefrom typing import TYPE_CHECKING, Annotated, Anyimport pydantic_corefrom mcp.types import EmbeddedResource, ImageContent, TextContent, ToolAnnotationsfrom mcp.types import Tool as MCPTool-from pydantic import BaseModel, BeforeValidator, Field+from pydantic import BeforeValidator, Fieldimport fastmcpfrom fastmcp.server.dependencies import get_contextfrom fastmcp.utilities.json_schema import compress_schemafrom fastmcp.utilities.logging import get_loggerfrom fastmcp.utilities.types import (+ FastMCPBaseModel,Image,_convert_set_defaults,find_kwarg_by_type,@@ -31,10 +34,9 @@ def default_serializer(data: Any) -> str:return pydantic_core.to_json(data, fallback=str, indent=2).decode()-class Tool(BaseModel):+class Tool(FastMCPBaseModel, ABC):"""Internal tool registration info."""- fn: Callable[..., Any]name: str = Field(description="Name of the tool")description: str | None = Field(default=None, description="Description of what the tool does"@@ -54,6 +56,39 @@ class Tool(BaseModel):None, description="Optional custom serializer for tool results")+ def to_mcp_tool(self, **overrides: Any) -> MCPTool:+ kwargs = {+ "name": self.name,+ "description": self.description,+ "inputSchema": self.parameters,+ "annotations": self.annotations,+ }+ return MCPTool(**kwargs | overrides)++ @staticmethod+ def from_function(fn: Callable[..., Any], **overrides: Any) -> FunctionTool:+ # deprecated in 2.6.2+ warnings.warn(+ "Tool.from_function() is deprecated. Use FunctionTool.from_function() instead."+ )+ return FunctionTool.from_function(fn, **overrides)++ def __eq__(self, other: object) -> bool:+ if not isinstance(other, Tool):+ return False+ return self.model_dump() == other.model_dump()++ @abstractmethod+ async def run(+ self, arguments: dict[str, Any]+ ) -> list[TextContent | ImageContent | EmbeddedResource]:+ """Run the tool with arguments."""+ raise NotImplementedError("Subclasses must implement run()")+++class FunctionTool(Tool):+ fn: Callable[..., Any]+@classmethoddef from_function(cls,@@ -64,7 +99,7 @@ class Tool(BaseModel):annotations: ToolAnnotations | None = None,exclude_args: list[str] | None = None,serializer: Callable[[Any], str] | None = None,- ) -> Tool:+ ) -> FunctionTool:"""Create a Tool from a function."""from fastmcp.server.context import Context@@ -170,20 +205,6 @@ class Tool(BaseModel):return _convert_to_content(result, serializer=self.serializer)- def to_mcp_tool(self, **overrides: Any) -> MCPTool:- kwargs = {- "name": self.name,- "description": self.description,- "inputSchema": self.parameters,- "annotations": self.annotations,- }- return MCPTool(**kwargs | overrides)-- def __eq__(self, other: object) -> bool:- if not isinstance(other, Tool):- return False- return self.model_dump() == other.model_dump()-def _convert_to_content(result: Any,diff --git a/src/fastmcp/tools/tool_manager.py b/src/fastmcp/tools/tool_manager.pyindex e89ba0ef9..b5000a840 100644--- a/src/fastmcp/tools/tool_manager.py+++ b/src/fastmcp/tools/tool_manager.py@@ -7,7 +7,7 @@ from mcp.types import EmbeddedResource, ImageContent, TextContent, ToolAnnotatiofrom fastmcp.exceptions import NotFoundError, ToolErrorfrom fastmcp.settings import DuplicateBehavior-from fastmcp.tools.tool import Tool+from fastmcp.tools.tool import FunctionTool, Toolfrom fastmcp.utilities.logging import get_loggerif TYPE_CHECKING:@@ -69,7 +69,7 @@ class ToolManager:exclude_args: list[str] | None = None,) -> Tool:"""Add a tool to the server."""- tool = Tool.from_function(+ tool = FunctionTool.from_function(fn,name=name,description=description,diff --git a/src/fastmcp/utilities/mcp_config.py b/src/fastmcp/utilities/mcp_config.pyindex a9f5abee6..5a2990980 100644--- a/src/fastmcp/utilities/mcp_config.py+++ b/src/fastmcp/utilities/mcp_config.py@@ -3,7 +3,9 @@ from __future__ import annotationsfrom typing import TYPE_CHECKING, Any, Literalfrom urllib.parse import urlparse-from pydantic import AnyUrl, BaseModel, Field+from pydantic import AnyUrl, Field++from fastmcp.utilities.types import FastMCPBaseModelif TYPE_CHECKING:from fastmcp.client.transports import (@@ -32,7 +34,7 @@ def infer_transport_type_from_url(return "streamable-http"-class StdioMCPServer(BaseModel):+class StdioMCPServer(FastMCPBaseModel):command: strargs: list[str] = Field(default_factory=list)env: dict[str, Any] = Field(default_factory=dict)@@ -50,7 +52,7 @@ class StdioMCPServer(BaseModel):)-class RemoteMCPServer(BaseModel):+class RemoteMCPServer(FastMCPBaseModel):url: strheaders: dict[str, str] = Field(default_factory=dict)transport: Literal["streamable-http", "sse", "http"] | None = None@@ -69,7 +71,7 @@ class RemoteMCPServer(BaseModel):return StreamableHttpTransport(self.url, headers=self.headers)-class MCPConfig(BaseModel):+class MCPConfig(FastMCPBaseModel):mcpServers: dict[str, StdioMCPServer | RemoteMCPServer]@classmethoddiff --git a/src/fastmcp/utilities/openapi.py b/src/fastmcp/utilities/openapi.pyindex c56d9c558..ebd35b172 100644--- a/src/fastmcp/utilities/openapi.py+++ b/src/fastmcp/utilities/openapi.py@@ -25,6 +25,7 @@ from openapi_pydantic.v3.v3_0 import Schema as Schema_30from pydantic import BaseModel, Field, ValidationErrorfrom fastmcp.utilities.json_schema import compress_schema+from fastmcp.utilities.types import FastMCPBaseModellogger = logging.getLogger(__name__)@@ -38,7 +39,7 @@ ParameterLocation = Literal["path", "query", "header", "cookie"]JsonSchema = dict[str, Any]-class ParameterInfo(BaseModel):+class ParameterInfo(FastMCPBaseModel):"""Represents a single parameter for an HTTP operation in our IR."""name: str@@ -48,7 +49,7 @@ class ParameterInfo(BaseModel):description: str | None = None-class RequestBodyInfo(BaseModel):+class RequestBodyInfo(FastMCPBaseModel):"""Represents the request body for an HTTP operation in our IR."""required: bool = False@@ -58,7 +59,7 @@ class RequestBodyInfo(BaseModel):description: str | None = None-class ResponseInfo(BaseModel):+class ResponseInfo(FastMCPBaseModel):"""Represents response information in our IR."""description: str | None = None@@ -66,7 +67,7 @@ class ResponseInfo(BaseModel):content_schema: dict[str, JsonSchema] = Field(default_factory=dict)-class HTTPRoute(BaseModel):+class HTTPRoute(FastMCPBaseModel):"""Intermediate Representation for a single OpenAPI operation."""path: strdiff --git a/src/fastmcp/utilities/types.py b/src/fastmcp/utilities/types.pyindex 0ad371db3..301434c1a 100644--- a/src/fastmcp/utilities/types.py+++ b/src/fastmcp/utilities/types.py@@ -9,11 +9,17 @@ from types import UnionTypefrom typing import Annotated, TypeVar, Union, get_args, get_originfrom mcp.types import ImageContent-from pydantic import TypeAdapter+from pydantic import BaseModel, ConfigDict, TypeAdapterT = TypeVar("T")+class FastMCPBaseModel(BaseModel):+ """Base model for FastMCP models."""++ model_config = ConfigDict(extra="forbid")++@lru_cache(maxsize=5000)def get_cached_typeadapter(cls: T) -> TypeAdapter[T]:"""diff --git a/tests/deprecated/test_tool_from_function_deprecated.py b/tests/deprecated/test_tool_from_function_deprecated.pynew file mode 100644index 000000000..3c81d6616--- /dev/null+++ b/tests/deprecated/test_tool_from_function_deprecated.py@@ -0,0 +1,76 @@+"""Tests for deprecated Tool.from_function() method.++The Tool.from_function() method was deprecated in version 2.6.2 in favor of+FunctionTool.from_function().+"""++import warnings++import pytest++from fastmcp.tools.tool import FunctionTool, Tool+++def test_tool_from_function_deprecation_warning():+ """Test that Tool.from_function() raises a deprecation warning."""++ def example_function(x: int) -> str:+ """Example function for testing."""+ return f"Result: {x}"++ with pytest.warns(+ UserWarning,+ match="Tool.from_function\\(\\) is deprecated. Use FunctionTool.from_function\\(\\) instead.",+ ):+ tool = Tool.from_function(example_function)++ # Verify the tool was created correctly despite the warning+ assert isinstance(tool, FunctionTool)+ assert tool.name == "example_function"+ assert tool.description == "Example function for testing."+++def test_tool_from_function_produces_same_result_as_function_tool():+ """Test that Tool.from_function() produces the same result as FunctionTool.from_function()."""++ def example_function(x: int, y: str = "default") -> dict:+ """Example function with parameters."""+ return {"x": x, "y": y}++ # Create tool using the deprecated method (with warning suppressed)+ with warnings.catch_warnings():+ warnings.simplefilter("ignore")+ deprecated_tool = Tool.from_function(example_function)++ # Create tool using the new method+ new_tool = FunctionTool.from_function(example_function)++ # They should be equivalent+ assert deprecated_tool == new_tool+ assert deprecated_tool.name == new_tool.name+ assert deprecated_tool.description == new_tool.description+ assert deprecated_tool.parameters == new_tool.parameters+++def test_tool_from_function_with_overrides():+ """Test that Tool.from_function() works with parameter overrides."""++ def example_function() -> str:+ """Original description."""+ return "test"++ custom_name = "custom_tool_name"+ custom_description = "Custom description"+ custom_tags = {"test", "deprecated"}++ with pytest.warns(UserWarning, match="Tool.from_function\\(\\) is deprecated"):+ tool = Tool.from_function(+ example_function,+ name=custom_name,+ description=custom_description,+ tags=custom_tags,+ )++ assert tool.name == custom_name+ assert tool.description == custom_description+ assert tool.tags == custom_tagsdiff --git a/tests/server/openapi/test_openapi_path_parameters.py b/tests/server/openapi/test_openapi_path_parameters.pyindex 1d188fb60..078e61a58 100644--- a/tests/server/openapi/test_openapi_path_parameters.py+++ b/tests/server/openapi/test_openapi_path_parameters.py@@ -128,7 +128,7 @@ async def test_array_path_parameter_handling(mock_client):)# Test with a single value- await tool._execute_request(days=["monday"])+ await tool.run({"days": ["monday"]})# Check that the path parameter is formatted correctly# This is where the bug is: it should be '/select/monday' not '/select/[\'monday\']'@@ -143,7 +143,7 @@ async def test_array_path_parameter_handling(mock_client):mock_client.request.reset_mock()# Test with multiple values- await tool._execute_request(days=["monday", "tuesday"])+ await tool.run({"days": ["monday", "tuesday"]})# Check that the path parameter is formatted correctly# It should be '/select/monday,tuesday' not '/select/[\'monday\', \'tuesday\']'@@ -234,7 +234,7 @@ async def test_complex_nested_array_path_parameter(mock_client):]# Execute the request with complex filters- await tool._execute_request(filters=complex_filters)+ await tool.run({"filters": complex_filters})# The complex object should be properly serialized in the URL# For path parameters, this would typically need a custom serialization strategy@@ -359,7 +359,7 @@ async def test_array_query_parameter_format(mock_client):)# Test with a single value- await tool._execute_request(days=["monday"])+ await tool.run({"days": ["monday"]})# Check that the query parameter is formatted correctlymock_client.request.assert_called_with(@@ -373,7 +373,7 @@ async def test_array_query_parameter_format(mock_client):mock_client.request.reset_mock()# Test with multiple values- await tool._execute_request(days=["monday", "tuesday"])+ await tool.run({"days": ["monday", "tuesday"]})# Check that the query parameter is formatted correctly# It should be 'days=monday,tuesday' not 'days=["monday","tuesday"]'@@ -429,7 +429,7 @@ async def test_array_query_parameter_exploded_format(mock_client):)# Test with a single value- await tool._execute_request(days=["monday"])+ await tool.run({"days": ["monday"]})# Check that the query parameter is formatted correctlymock_client.request.assert_called_with(@@ -443,7 +443,7 @@ async def test_array_query_parameter_exploded_format(mock_client):mock_client.request.reset_mock()# Test with multiple values- await tool._execute_request(days=["monday", "tuesday"])+ await tool.run({"days": ["monday", "tuesday"]})# Check that the query parameter is formatted correctly# It should be passed as an array, which httpx will serialize as days=monday&days=tuesdaydiff --git a/tests/server/test_import_server.py b/tests/server/test_import_server.pyindex 2e004bbfe..18e5bfaa2 100644--- a/tests/server/test_import_server.py+++ b/tests/server/test_import_server.py@@ -3,6 +3,7 @@ from urllib.parse import quotefrom fastmcp.client.client import Clientfrom fastmcp.server.server import FastMCP+from fastmcp.tools.tool import FunctionToolasync def test_import_basic_functionality():@@ -27,6 +28,7 @@ async def test_import_basic_functionality():tool = main_app._tool_manager.get_tool("sub_sub_tool")assert tool is not Noneassert tool.name == "sub_tool"+ assert isinstance(tool, FunctionTool)assert callable(tool.fn)@@ -205,6 +207,7 @@ async def test_tool_custom_name_preserved_when_imported():assert tool is not None# Check that the function name is preserved+ assert isinstance(tool, FunctionTool)assert tool.fn.__name__ == "fetch_data"@@ -238,6 +241,7 @@ async def test_first_level_importing_with_custom_name():# Tool is accessible in the service app with the first prefixtool = service_app._tool_manager.get_tool("provider_compute")assert tool is not None+ assert isinstance(tool, FunctionTool)assert tool.fn.__name__ == "calculate_value"diff --git a/tests/server/test_server.py b/tests/server/test_server.pyindex a5416229d..173fbf7c1 100644--- a/tests/server/test_server.py+++ b/tests/server/test_server.py@@ -12,7 +12,7 @@ from fastmcp.server.server import (has_resource_prefix,remove_resource_prefix,)-from fastmcp.tools.tool import Tool+from fastmcp.tools import FunctionToolclass TestCreateServer:@@ -102,7 +102,7 @@ class TestTools:"""add two to a number"""return x + 2- g_tool = Tool.from_function(g, name="g-tool")+ g_tool = FunctionTool.from_function(g, name="g-tool")mcp = FastMCP(tools=[f, g_tool])diff --git a/tests/tools/test_tool.py b/tests/tools/test_tool.pyindex bcb9a671a..bc7423848 100644--- a/tests/tools/test_tool.py+++ b/tests/tools/test_tool.py@@ -5,7 +5,7 @@ from pydantic import BaseModelfrom fastmcp import FastMCP, Imagefrom fastmcp.client import Clientfrom fastmcp.exceptions import ToolError-from fastmcp.tools.tool import Tool+from fastmcp.tools import FunctionToolfrom fastmcp.utilities.tests import temporary_settings@@ -17,7 +17,7 @@ class TestToolFromFunction:"""Add two numbers."""return a + b- tool = Tool.from_function(add)+ tool = FunctionTool.from_function(add)assert tool.name == "add"assert tool.description == "Add two numbers."@@ -32,7 +32,7 @@ class TestToolFromFunction:"""Fetch data from URL."""return f"Data from {url}"- tool = Tool.from_function(fetch_data)+ tool = FunctionTool.from_function(fetch_data)assert tool.name == "fetch_data"assert tool.description == "Fetch data from URL."@@ -46,7 +46,7 @@ class TestToolFromFunction:"""ignore this"""return x + y- tool = Tool.from_function(Adder())+ tool = FunctionTool.from_function(Adder())assert tool.name == "Adder"assert tool.description == "Adds two numbers."assert len(tool.parameters["properties"]) == 2@@ -61,7 +61,7 @@ class TestToolFromFunction:"""ignore this"""return x + y- tool = Tool.from_function(Adder())+ tool = FunctionTool.from_function(Adder())assert tool.name == "Adder"assert tool.description == "Adds two numbers."assert len(tool.parameters["properties"]) == 2@@ -79,7 +79,7 @@ class TestToolFromFunction:"""Create a new user."""return {"id": 1, **user.model_dump()}- tool = Tool.from_function(create_user)+ tool = FunctionTool.from_function(create_user)assert tool.name == "create_user"assert tool.description == "Create a new user."@@ -91,7 +91,7 @@ class TestToolFromFunction:def image_tool(data: bytes) -> Image:return Image(data=data)- tool = Tool.from_function(image_tool)+ tool = FunctionTool.from_function(image_tool)result = await tool.run({"data": "test.png"})assert tool.parameters["properties"]["data"]["type"] == "string"@@ -99,24 +99,24 @@ class TestToolFromFunction:def test_non_callable_fn(self):with pytest.raises(TypeError, match="not a callable object"):- Tool.from_function(1) # type: ignore+ FunctionTool.from_function(1) # type: ignoredef test_lambda(self):- tool = Tool.from_function(lambda x: x, name="my_tool")+ tool = FunctionTool.from_function(lambda x: x, name="my_tool")assert tool.name == "my_tool"def test_lambda_with_no_name(self):with pytest.raises(ValueError, match="You must provide a name for lambda functions"):- Tool.from_function(lambda x: x)+ FunctionTool.from_function(lambda x: x)def test_private_arguments(self):def add(_a: int, _b: int) -> int:"""Add two numbers."""return _a + _b- tool = Tool.from_function(add)+ tool = FunctionTool.from_function(add)assert tool.parameters["properties"]["_a"]["type"] == "integer"assert tool.parameters["properties"]["_b"]["type"] == "integer"@@ -128,7 +128,7 @@ class TestToolFromFunction:with pytest.raises(ValueError, match=r"Functions with \*args are not supported as tools"):- Tool.from_function(func)+ FunctionTool.from_function(func)def test_tool_with_varkwargs_not_allowed(self):def func(a: int, b: int, **kwargs: int) -> int:@@ -138,7 +138,7 @@ class TestToolFromFunction:with pytest.raises(ValueError, match=r"Functions with \*\*kwargs are not supported as tools"):- Tool.from_function(func)+ FunctionTool.from_function(func)async def test_instance_method(self):class MyClass:@@ -148,7 +148,7 @@ class TestToolFromFunction:obj = MyClass()- tool = Tool.from_function(obj.add)+ tool = FunctionTool.from_function(obj.add)assert tool.name == "add"assert tool.description == "Add two numbers."assert "self" not in tool.parameters["properties"]@@ -164,7 +164,7 @@ class TestToolFromFunction:with pytest.raises(ValueError, match=r"Functions with \*args are not supported as tools"):- Tool.from_function(obj.add)+ FunctionTool.from_function(obj.add)async def test_instance_method_with_varkwargs_not_allowed(self):class MyClass:@@ -177,7 +177,7 @@ class TestToolFromFunction:with pytest.raises(ValueError, match=r"Functions with \*\*kwargs are not supported as tools"):- Tool.from_function(obj.add)+ FunctionTool.from_function(obj.add)async def test_classmethod(self):class MyClass:@@ -199,7 +199,7 @@ class TestLegacyToolJsonParsing:return f"{x}-{','.join(y)}"# Create a tool to use its JSON pre-parsing logic- tool = Tool.from_function(simple_func)+ tool = FunctionTool.from_function(simple_func)# Prepare arguments where some are JSON stringsjson_args = {@@ -217,7 +217,7 @@ class TestLegacyToolJsonParsing:def func_with_str_types(str_or_list: str | list[str]) -> str | list[str]:return str_or_list- tool = Tool.from_function(func_with_str_types)+ tool = FunctionTool.from_function(func_with_str_types)# Test regular string input (should remain a string)result = await tool.run({"str_or_list": "hello"})@@ -243,7 +243,7 @@ class TestLegacyToolJsonParsing:def func_with_str_types(string: str) -> str:return string- tool = Tool.from_function(func_with_str_types)+ tool = FunctionTool.from_function(func_with_str_types)# Invalid JSON should remain a stringinvalid_json = "{'nice to meet you': 'hello', 'goodbye': 5}"@@ -258,7 +258,7 @@ class TestLegacyToolJsonParsing:) -> str | dict[int, str] | None:return string- tool = Tool.from_function(func_with_str_types)+ tool = FunctionTool.from_function(func_with_str_types)# Invalid JSON for the union type should remain a stringinvalid_json = "{'nice to meet you': 'hello', 'goodbye': 5}"@@ -275,7 +275,7 @@ class TestLegacyToolJsonParsing:def func_with_complex_type(data: SomeModel) -> SomeModel:return data- tool = Tool.from_function(func_with_complex_type)+ tool = FunctionTool.from_function(func_with_complex_type)# Valid JSON for the modelvalid_json = '{"x": 1, "y": {"1": "hello"}}'diff --git a/tests/tools/test_tool_manager.py b/tests/tools/test_tool_manager.pyindex 75ccf0349..7902effa9 100644--- a/tests/tools/test_tool_manager.py+++ b/tests/tools/test_tool_manager.py@@ -10,8 +10,7 @@ from pydantic import BaseModelfrom fastmcp import Context, FastMCP, Imagefrom fastmcp.exceptions import NotFoundError, ToolError-from fastmcp.tools import ToolManager-from fastmcp.tools.tool import Tool+from fastmcp.tools import FunctionTool, ToolManagerfrom fastmcp.utilities.tests import temporary_settings@@ -212,6 +211,7 @@ class TestAddTools:# Should have replaced with the new functiontool = manager.get_tool("test_tool")assert tool is not None+ assert isinstance(tool, FunctionTool)assert tool.fn.__name__ == "replacement_fn"def test_ignore_duplicate_tools(self):@@ -230,8 +230,10 @@ class TestAddTools:# Should keep the originaltool = manager.get_tool("test_tool")assert tool is not None+ assert isinstance(tool, FunctionTool)assert tool.fn.__name__ == "original_fn"# Result should be the original tool+ assert isinstance(result, FunctionTool)assert result.fn.__name__ == "original_fn"@@ -566,7 +568,7 @@ class TestContextHandling:def test_context_parameter_detection(self):"""Test that context parameters are properly detected in- Tool.from_function()."""+ FunctionTool.from_function()."""def tool_with_context(x: int, ctx: Context) -> str:return str(x)@@ -632,7 +634,7 @@ class TestContextHandling:def test_parameterized_context_parameter_detection(self):"""Test that context parameters are properly detected in- Tool.from_function()."""+ FunctionTool.from_function()."""def tool_with_context(x: int, ctx: Context) -> str:return str(x)@@ -649,7 +651,7 @@ class TestContextHandling:def test_parameterized_union_context_parameter_detection(self):"""Test that context parameters are properly detected in- Tool.from_function()."""+ FunctionTool.from_function()."""def tool_with_context(x: int, ctx: Context | None) -> str:return str(x)@@ -703,7 +705,7 @@ class TestCustomToolNames:return x + 1# Create a tool with a specific name- tool = Tool.from_function(fn, name="my_tool")+ tool = FunctionTool.from_function(fn, name="my_tool")manager = ToolManager()# Store it under a different namemanager.add_tool(tool, key="proxy_tool")