fastmcp 2.0.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

fastmcp/tools/{base.py → tool.py}

@@ -2,12 +2,14 @@ from __future__ import annotations as _annotations
 
 import inspect
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Annotated, Any
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, BeforeValidator, Field
+from typing_extensions import Self
 
 from fastmcp.exceptions import ToolError
 from fastmcp.utilities.func_metadata import FuncMetadata, func_metadata
+from fastmcp.utilities.types import _convert_set_defaults
 
 if TYPE_CHECKING:
     from mcp.server.session import ServerSessionT
@@ -19,7 +21,7 @@ if TYPE_CHECKING:
 class Tool(BaseModel):
     """Internal tool registration info."""
 
-    fn: Callable[..., Any] = Field(exclude=True)
+    fn: Callable[..., Any]
     name: str = Field(description="Name of the tool")
     description: str = Field(description="Description of what the tool does")
     parameters: dict[str, Any] = Field(description="JSON schema for tool parameters")
@@ -31,6 +33,9 @@ class Tool(BaseModel):
     context_kwarg: str | None = Field(
         None, description="Name of the kwarg that should receive context"
     )
+    tags: Annotated[set[str], BeforeValidator(_convert_set_defaults)] = Field(
+        default_factory=set, description="Tags for the tool"
+    )
 
     @classmethod
     def from_function(
@@ -39,6 +44,7 @@ class Tool(BaseModel):
         name: str | None = None,
         description: str | None = None,
         context_kwarg: str | None = None,
+        tags: set[str] | None = None,
     ) -> Tool:
         """Create a Tool from a function."""
         from fastmcp import Context
@@ -52,7 +58,10 @@ class Tool(BaseModel):
         is_async = inspect.iscoroutinefunction(fn)
 
         if context_kwarg is None:
-            sig = inspect.signature(fn)
+            if isinstance(fn, classmethod):
+                sig = inspect.signature(fn.__func__)
+            else:
+                sig = inspect.signature(fn)
             for param_name, param in sig.parameters.items():
                 if param.annotation is Context:
                     context_kwarg = param_name
@@ -72,6 +81,7 @@ class Tool(BaseModel):
             fn_metadata=func_arg_metadata,
             is_async=is_async,
             context_kwarg=context_kwarg,
+            tags=tags or set(),
         )
 
     async def run(
@@ -91,3 +101,15 @@ class Tool(BaseModel):
             )
         except Exception as e:
             raise ToolError(f"Error executing tool {self.name}: {e}") from e
+
+    def copy(self, updates: dict[str, Any] | None = None) -> Self:
+        """Copy the tool with optional updates."""
+        data = self.model_dump()
+        if updates:
+            data.update(updates)
+        return type(self)(**data)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Tool):
+            return False
+        return self.model_dump() == other.model_dump()

fastmcp/tools/tool_manager.py

@@ -6,7 +6,8 @@ from typing import TYPE_CHECKING, Any
 from mcp.shared.context import LifespanContextT
 
 from fastmcp.exceptions import ToolError
-from fastmcp.tools.base import Tool
+from fastmcp.settings import DuplicateBehavior
+from fastmcp.tools.tool import Tool
 from fastmcp.utilities.logging import get_logger
 
 if TYPE_CHECKING:
@@ -20,9 +21,9 @@ logger = get_logger(__name__)
 class ToolManager:
     """Manages FastMCP tools."""
 
-    def __init__(self, warn_on_duplicate_tools: bool = True):
+    def __init__(self, duplicate_behavior: DuplicateBehavior = DuplicateBehavior.WARN):
         self._tools: dict[str, Tool] = {}
-        self.warn_on_duplicate_tools = warn_on_duplicate_tools
+        self.duplicate_behavior = duplicate_behavior
 
     def get_tool(self, name: str) -> Tool | None:
         """Get tool by name."""
@@ -32,19 +33,30 @@ class ToolManager:
         """List all registered tools."""
         return list(self._tools.values())
 
-    def add_tool(
+    def add_tool_from_fn(
         self,
         fn: Callable[..., Any],
         name: str | None = None,
         description: str | None = None,
+        tags: set[str] | None = None,
     ) -> Tool:
         """Add a tool to the server."""
-        tool = Tool.from_function(fn, name=name, description=description)
+        tool = Tool.from_function(fn, name=name, description=description, tags=tags)
+        return self.add_tool(tool)
+
+    def add_tool(self, tool: Tool) -> Tool:
+        """Register a tool with the server."""
         existing = self._tools.get(tool.name)
         if existing:
-            if self.warn_on_duplicate_tools:
+            if self.duplicate_behavior == DuplicateBehavior.WARN:
                 logger.warning(f"Tool already exists: {tool.name}")
-            return existing
+                self._tools[tool.name] = tool
+            elif self.duplicate_behavior == DuplicateBehavior.REPLACE:
+                self._tools[tool.name] = tool
+            elif self.duplicate_behavior == DuplicateBehavior.ERROR:
+                raise ValueError(f"Tool already exists: {tool.name}")
+            elif self.duplicate_behavior == DuplicateBehavior.IGNORE:
+                pass
         self._tools[tool.name] = tool
         return tool
 
@@ -78,13 +90,7 @@ class ToolManager:
         for name, tool in tool_manager._tools.items():
             prefixed_name = f"{prefix}{name}" if prefix else name
 
-            # Create a shallow copy of the tool with the prefixed name
-            copied_tool = Tool.from_function(
-                tool.fn,
-                name=prefixed_name,
-                description=tool.description,
-            )
-
+            new_tool = tool.copy(updates=dict(name=prefixed_name))
             # Store the copied tool
-            self._tools[prefixed_name] = copied_tool
-            logger.debug(f"Imported tool: {name} as {prefixed_name}")
+            self.add_tool(new_tool)
+            logger.debug(f'Imported tool "{name}" as "{prefixed_name}"')

fastmcp/utilities/decorators.py

@@ -0,0 +1,101 @@
+import inspect
+from collections.abc import Callable
+from typing import Generic, ParamSpec, TypeVar, cast, overload
+
+from typing_extensions import Self
+
+R = TypeVar("R")
+P = ParamSpec("P")
+
+
+class DecoratedFunction(Generic[P, R]):
+    """Descriptor for decorated functions.
+
+    You can return this object from a decorator to ensure that it works across
+    all types of functions: vanilla, instance methods, class methods, and static
+    methods; both synchronous and asynchronous.
+
+    This class is used to store the original function and metadata about how to
+    register it as a tool.
+
+    Example usage:
+
+    ```python
+    def my_decorator(fn: Callable[P, R]) -> DecoratedFunction[P, R]:
+        return DecoratedFunction(fn)
+    ```
+
+    On a function:
+    ```python
+    @my_decorator
+    def my_function(a: int, b: int) -> int:
+        return a + b
+    ```
+
+    On an instance method:
+    ```python
+    class Test:
+        @my_decorator
+        def my_function(self, a: int, b: int) -> int:
+            return a + b
+    ```
+
+    On a class method:
+    ```python
+    class Test:
+        @classmethod
+        @my_decorator
+        def my_function(cls, a: int, b: int) -> int:
+            return a + b
+    ```
+
+    Note that for classmethods, the decorator must be applied first, then
+    `@classmethod` on top.
+
+    On a static method:
+    ```python
+    class Test:
+        @staticmethod
+        @my_decorator
+        def my_function(a: int, b: int) -> int:
+            return a + b
+    ```
+    """
+
+    def __init__(self, fn: Callable[P, R]):
+        self.fn = fn
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
+        """Call the original function."""
+        try:
+            return self.fn(*args, **kwargs)
+        except TypeError as e:
+            if "'classmethod' object is not callable" in str(e):
+                raise TypeError(
+                    "To apply this decorator to a classmethod, apply the decorator first, then @classmethod on top."
+                )
+            raise
+
+    @overload
+    def __get__(self, instance: None, owner: type | None = None) -> Self: ...
+
+    @overload
+    def __get__(
+        self, instance: object, owner: type | None = None
+    ) -> Callable[P, R]: ...
+
+    def __get__(
+        self, instance: object | None, owner: type | None = None
+    ) -> Self | Callable[P, R]:
+        """Return the original function when accessed from an instance, or self when accessed from the class."""
+        if instance is None:
+            return self
+        # Return the original function bound to the instance
+        return cast(Callable[P, R], self.fn.__get__(instance, owner))
+
+    def __repr__(self) -> str:
+        """Return a representation that matches Python's function representation."""
+        module = getattr(self.fn, "__module__", "unknown")
+        qualname = getattr(self.fn, "__qualname__", str(self.fn))
+        sig_str = str(inspect.signature(self.fn))
+        return f"<function {module}.{qualname}{sig_str}>"

fastmcp/utilities/func_metadata.py

@@ -125,7 +125,10 @@ def func_metadata(
     Returns:
         A pydantic model representing the function's signature.
     """
-    sig = _get_typed_signature(func)
+    if isinstance(func, classmethod):
+        sig = _get_typed_signature(func.__func__)
+    else:
+        sig = _get_typed_signature(func)
     params = sig.parameters
     dynamic_pydantic_model_params: dict[str, Any] = {}
     globalns = getattr(func, "__globals__", {})