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

fastmcp/settings.py

@@ -0,0 +1,73 @@
+from __future__ import annotations as _annotations
+
+from typing import TYPE_CHECKING, Literal
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+if TYPE_CHECKING:
+    pass
+
+LOG_LEVEL = Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+
+
+class Settings(BaseSettings):
+    """FastMCP settings."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="FASTMCP_",
+        env_file=".env",
+        extra="ignore",
+    )
+
+    test_mode: bool = False
+    log_level: LOG_LEVEL = "INFO"
+
+
+class ServerSettings(BaseSettings):
+    """FastMCP server settings.
+
+    All settings can be configured via environment variables with the prefix FASTMCP_.
+    For example, FASTMCP_DEBUG=true will set debug=True.
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="FASTMCP_SERVER_",
+        env_file=".env",
+        extra="ignore",
+    )
+
+    log_level: LOG_LEVEL = Field(default_factory=lambda: Settings().log_level)
+
+    # HTTP settings
+    host: str = "0.0.0.0"
+    port: int = 8000
+    sse_path: str = "/sse"
+    message_path: str = "/messages/"
+    debug: bool = False
+
+    # resource settings
+    warn_on_duplicate_resources: bool = True
+
+    # tool settings
+    warn_on_duplicate_tools: bool = True
+
+    # prompt settings
+    warn_on_duplicate_prompts: bool = True
+
+    dependencies: list[str] = Field(
+        default_factory=list,
+        description="List of dependencies to install in the server environment",
+    )
+
+
+class ClientSettings(BaseSettings):
+    """FastMCP client settings."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="FASTMCP_CLIENT_",
+        env_file=".env",
+        extra="ignore",
+    )
+
+    log_level: LOG_LEVEL = Field(default_factory=lambda: Settings().log_level)

fastmcp/tools/base.py

@@ -1,41 +1,48 @@
-import fastmcp
-from fastmcp.exceptions import ToolError
+from __future__ import annotations as _annotations
 
-from fastmcp.utilities.func_metadata import func_metadata, FuncMetadata
-from pydantic import BaseModel, Field
+import inspect
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
 
+from pydantic import BaseModel, Field
 
-import inspect
-from typing import TYPE_CHECKING, Any, Callable, Optional
+from fastmcp.exceptions import ToolError
+from fastmcp.utilities.func_metadata import FuncMetadata, func_metadata
 
 if TYPE_CHECKING:
+    from mcp.server.session import ServerSessionT
+    from mcp.shared.context import LifespanContextT
+
     from fastmcp.server import Context
 
 
 class Tool(BaseModel):
     """Internal tool registration info."""
 
-    fn: Callable = Field(exclude=True)
+    fn: Callable[..., Any] = Field(exclude=True)
     name: str = Field(description="Name of the tool")
     description: str = Field(description="Description of what the tool does")
-    parameters: dict = Field(description="JSON schema for tool parameters")
+    parameters: dict[str, Any] = Field(description="JSON schema for tool parameters")
     fn_metadata: FuncMetadata = Field(
-        description="Metadata about the function including a pydantic model for tool arguments"
+        description="Metadata about the function including a pydantic model for tool"
+        " arguments"
     )
     is_async: bool = Field(description="Whether the tool is async")
-    context_kwarg: Optional[str] = Field(
+    context_kwarg: str | None = Field(
         None, description="Name of the kwarg that should receive context"
     )
 
     @classmethod
     def from_function(
         cls,
-        fn: Callable,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        context_kwarg: Optional[str] = None,
-    ) -> "Tool":
+        fn: Callable[..., Any],
+        name: str | None = None,
+        description: str | None = None,
+        context_kwarg: str | None = None,
+    ) -> Tool:
         """Create a Tool from a function."""
+        from fastmcp import Context
+
         func_name = name or fn.__name__
 
         if func_name == "<lambda>":
@@ -44,11 +51,10 @@ class Tool(BaseModel):
         func_doc = description or fn.__doc__ or ""
         is_async = inspect.iscoroutinefunction(fn)
 
-        # Find context parameter if it exists
         if context_kwarg is None:
             sig = inspect.signature(fn)
             for param_name, param in sig.parameters.items():
-                if param.annotation is fastmcp.Context:
+                if param.annotation is Context:
                     context_kwarg = param_name
                     break
 
@@ -68,7 +74,11 @@ class Tool(BaseModel):
             context_kwarg=context_kwarg,
         )
 
-    async def run(self, arguments: dict, context: Optional["Context"] = None) -> Any:
+    async def run(
+        self,
+        arguments: dict[str, Any],
+        context: Context[ServerSessionT, LifespanContextT] | None = None,
+    ) -> Any:
         """Run the tool with arguments."""
         try:
             return await self.fn_metadata.call_fn_with_arg_validation(

fastmcp/tools/tool_manager.py

@@ -1,13 +1,17 @@
-from fastmcp.exceptions import ToolError
-
-from fastmcp.tools.base import Tool
+from __future__ import annotations as _annotations
 
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
 
-from typing import Any, Callable, Dict, Optional, TYPE_CHECKING
+from mcp.shared.context import LifespanContextT
 
+from fastmcp.exceptions import ToolError
+from fastmcp.tools.base import Tool
 from fastmcp.utilities.logging import get_logger
 
 if TYPE_CHECKING:
+    from mcp.server.session import ServerSessionT
+
     from fastmcp.server import Context
 
 logger = get_logger(__name__)
@@ -17,10 +21,10 @@ class ToolManager:
     """Manages FastMCP tools."""
 
     def __init__(self, warn_on_duplicate_tools: bool = True):
-        self._tools: Dict[str, Tool] = {}
+        self._tools: dict[str, Tool] = {}
         self.warn_on_duplicate_tools = warn_on_duplicate_tools
 
-    def get_tool(self, name: str) -> Optional[Tool]:
+    def get_tool(self, name: str) -> Tool | None:
         """Get tool by name."""
         return self._tools.get(name)
 
@@ -30,9 +34,9 @@ class ToolManager:
 
     def add_tool(
         self,
-        fn: Callable,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
+        fn: Callable[..., Any],
+        name: str | None = None,
+        description: str | None = None,
     ) -> Tool:
         """Add a tool to the server."""
         tool = Tool.from_function(fn, name=name, description=description)
@@ -45,7 +49,10 @@ class ToolManager:
         return tool
 
     async def call_tool(
-        self, name: str, arguments: dict, context: Optional["Context"] = None
+        self,
+        name: str,
+        arguments: dict[str, Any],
+        context: Context[ServerSessionT, LifespanContextT] | None = None,
     ) -> Any:
         """Call a tool by name with arguments."""
         tool = self.get_tool(name)
@@ -53,3 +60,31 @@ class ToolManager:
             raise ToolError(f"Unknown tool: {name}")
 
         return await tool.run(arguments, context=context)
+
+    def import_tools(
+        self, tool_manager: ToolManager, prefix: str | None = None
+    ) -> None:
+        """
+        Import all tools from another ToolManager with prefixed names.
+
+        Args:
+            tool_manager: Another ToolManager instance to import tools from
+            prefix: Prefix to add to tool names, including the delimiter.
+                   The resulting tool name will be in the format "{prefix}{original_name}"
+                   if prefix is provided, otherwise the original name is used.
+                   For example, with prefix "weather/" and tool "forecast",
+                   the imported tool would be available as "weather/forecast"
+        """
+        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,
+            )
+
+            # Store the copied tool
+            self._tools[prefixed_name] = copied_tool
+            logger.debug(f"Imported tool: {name} as {prefixed_name}")

fastmcp/utilities/func_metadata.py

@@ -1,22 +1,19 @@
 import inspect
-from collections.abc import Callable, Sequence, Awaitable
+import json
+from collections.abc import Awaitable, Callable, Sequence
 from typing import (
     Annotated,
     Any,
-    Dict,
     ForwardRef,
 )
-from pydantic import Field
-from fastmcp.exceptions import InvalidSignature
-from pydantic._internal._typing_extra import eval_type_lenient
-import json
-from pydantic import BaseModel
+
+from pydantic import BaseModel, ConfigDict, Field, WithJsonSchema, create_model
+from pydantic._internal._typing_extra import eval_type_backport
 from pydantic.fields import FieldInfo
-from pydantic import ConfigDict, create_model
-from pydantic import WithJsonSchema
 from pydantic_core import PydanticUndefined
-from fastmcp.utilities.logging import get_logger
 
+from fastmcp.exceptions import InvalidSignature
+from fastmcp.utilities.logging import get_logger
 
 logger = get_logger(__name__)
 
@@ -30,7 +27,7 @@ class ArgModelBase(BaseModel):
         That is, sub-models etc are not dumped - they are kept as pydantic models.
         """
         kwargs: dict[str, Any] = {}
-        for field_name in self.model_fields.keys():
+        for field_name in self.__class__.model_fields.keys():
             kwargs[field_name] = getattr(self, field_name)
         return kwargs
 
@@ -83,7 +80,7 @@ class FuncMetadata(BaseModel):
         dicts (JSON objects) as JSON strings, which can be pre-parsed here.
         """
         new_data = data.copy()  # Shallow copy
-        for field_name, field_info in self.arg_model.model_fields.items():
+        for field_name, _field_info in self.arg_model.model_fields.items():
             if field_name not in data.keys():
                 continue
             if isinstance(data[field_name], str):
@@ -91,7 +88,7 @@ class FuncMetadata(BaseModel):
                     pre_parsed = json.loads(data[field_name])
                 except json.JSONDecodeError:
                     continue  # Not JSON - skip
-                if isinstance(pre_parsed, (str, int, float)):
+                if isinstance(pre_parsed, str | int | float):
                     # This is likely that the raw value is e.g. `"hello"` which we
                     # Should really be parsed as '"hello"' in Python - but if we parse
                     # it as JSON it'll turn into just 'hello'. So we skip it.
@@ -105,8 +102,11 @@ class FuncMetadata(BaseModel):
     )
 
 
-def func_metadata(func: Callable, skip_names: Sequence[str] = ()) -> FuncMetadata:
-    """Given a function, return metadata including a pydantic model representing its signature.
+def func_metadata(
+    func: Callable[..., Any], skip_names: Sequence[str] = ()
+) -> FuncMetadata:
+    """Given a function, return metadata including a pydantic model representing its
+    signature.
 
     The use case for this is
     ```
@@ -115,7 +115,8 @@ def func_metadata(func: Callable, skip_names: Sequence[str] = ()) -> FuncMetadat
     return func(**validated_args.model_dump_one_level())
     ```
 
-    **critically** it also provides pre-parse helper to attempt to parse things from JSON.
+    **critically** it also provides pre-parse helper to attempt to parse things from
+    JSON.
 
     Args:
         func: The function to convert to a pydantic model
@@ -131,7 +132,7 @@ def func_metadata(func: Callable, skip_names: Sequence[str] = ()) -> FuncMetadat
     for param in params.values():
         if param.name.startswith("_"):
             raise InvalidSignature(
-                f"Parameter {param.name} of {func.__name__} may not start with an underscore"
+                f"Parameter {param.name} of {func.__name__} cannot start with '_'"
             )
         if param.name in skip_names:
             continue
@@ -175,10 +176,23 @@ def func_metadata(func: Callable, skip_names: Sequence[str] = ()) -> FuncMetadat
     return resp
 
 
-def _get_typed_annotation(annotation: Any, globalns: Dict[str, Any]) -> Any:
+def _get_typed_annotation(annotation: Any, globalns: dict[str, Any]) -> Any:
+    def try_eval_type(
+        value: Any, globalns: dict[str, Any], localns: dict[str, Any]
+    ) -> tuple[Any, bool]:
+        try:
+            return eval_type_backport(value, globalns, localns), True
+        except NameError:
+            return value, False
+
     if isinstance(annotation, str):
         annotation = ForwardRef(annotation)
-        annotation = eval_type_lenient(annotation, globalns, globalns)
+        annotation, status = try_eval_type(annotation, globalns, globalns)
+
+        # This check and raise could perhaps be skipped, and we (FastMCP) just call
+        # model_rebuild right before using it 🤷
+        if status is False:
+            raise InvalidSignature(f"Unable to evaluate type annotation {annotation}")
 
     return annotation