fastmcp 2.1.2__py3-none-any.whl → 2.2.1__py3-none-any.whl

fastmcp/settings.py

@@ -1,6 +1,5 @@
 from __future__ import annotations as _annotations
 
-from enum import Enum
 from typing import TYPE_CHECKING, Literal
 
 from pydantic import Field
@@ -11,12 +10,7 @@ if TYPE_CHECKING:
 
 LOG_LEVEL = Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
 
-
-class DuplicateBehavior(Enum):
-    WARN = "warn"
-    ERROR = "error"
-    REPLACE = "replace"
-    IGNORE = "ignore"
+DuplicateBehavior = Literal["warn", "error", "replace", "ignore"]
 
 
 class Settings(BaseSettings):
@@ -48,26 +42,29 @@ class ServerSettings(BaseSettings):
     log_level: LOG_LEVEL = Field(default_factory=lambda: Settings().log_level)
 
     # HTTP settings
-    host: str = "0.0.0.0"
+    host: str = "127.0.0.1"
     port: int = 8000
     sse_path: str = "/sse"
     message_path: str = "/messages/"
     debug: bool = False
 
     # resource settings
-    on_duplicate_resources: DuplicateBehavior = DuplicateBehavior.WARN
+    on_duplicate_resources: DuplicateBehavior = "warn"
 
     # tool settings
-    on_duplicate_tools: DuplicateBehavior = DuplicateBehavior.WARN
+    on_duplicate_tools: DuplicateBehavior = "warn"
 
     # prompt settings
-    on_duplicate_prompts: DuplicateBehavior = DuplicateBehavior.WARN
+    on_duplicate_prompts: DuplicateBehavior = "warn"
 
     dependencies: list[str] = Field(
         default_factory=list,
         description="List of dependencies to install in the server environment",
     )
 
+    # cache settings (for checking mounted servers)
+    cache_expiration_seconds: float = 0
+
 
 class ClientSettings(BaseSettings):
     """FastMCP client settings."""

fastmcp/tools/tool.py

@@ -1,14 +1,18 @@
-from __future__ import annotations as _annotations
+from __future__ import annotations
 
 import inspect
+import json
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Annotated, Any
 
+import pydantic_core
+from mcp.types import EmbeddedResource, ImageContent, TextContent
+from mcp.types import Tool as MCPTool
 from pydantic import BaseModel, BeforeValidator, Field
 
 from fastmcp.exceptions import ToolError
 from fastmcp.utilities.func_metadata import FuncMetadata, func_metadata
-from fastmcp.utilities.types import _convert_set_defaults
+from fastmcp.utilities.types import Image, _convert_set_defaults
 
 if TYPE_CHECKING:
     from mcp.server.session import ServerSessionT
@@ -57,7 +61,7 @@ class Tool(BaseModel):
         is_async = inspect.iscoroutinefunction(fn)
 
         if context_kwarg is None:
-            if isinstance(fn, classmethod):
+            if inspect.ismethod(fn) and hasattr(fn, "__func__"):
                 sig = inspect.signature(fn.__func__)
             else:
                 sig = inspect.signature(fn)
@@ -66,14 +70,16 @@ class Tool(BaseModel):
                     context_kwarg = param_name
                     break
 
+        # Use callable typing to ensure fn is treated as a callable despite being a classmethod
+        fn_callable: Callable[..., Any] = fn
         func_arg_metadata = func_metadata(
-            fn,
+            fn_callable,
             skip_names=[context_kwarg] if context_kwarg is not None else [],
         )
         parameters = func_arg_metadata.arg_model.model_json_schema()
 
         return cls(
-            fn=fn,
+            fn=fn_callable,
             name=func_name,
             description=func_doc,
             parameters=parameters,
@@ -87,10 +93,10 @@ class Tool(BaseModel):
         self,
         arguments: dict[str, Any],
         context: Context[ServerSessionT, LifespanContextT] | None = None,
-    ) -> Any:
+    ) -> list[TextContent | ImageContent | EmbeddedResource]:
         """Run the tool with arguments."""
         try:
-            return await self.fn_metadata.call_fn_with_arg_validation(
+            result = await self.fn_metadata.call_fn_with_arg_validation(
                 self.fn,
                 self.is_async,
                 arguments,
@@ -98,10 +104,64 @@ class Tool(BaseModel):
                 if self.context_kwarg is not None
                 else None,
             )
+            return _convert_to_content(result)
         except Exception as e:
             raise ToolError(f"Error executing tool {self.name}: {e}") from e
 
+    def to_mcp_tool(self, **overrides: Any) -> MCPTool:
+        kwargs = {
+            "name": self.name,
+            "description": self.description,
+            "inputSchema": self.parameters,
+        }
+        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,
+    _process_as_single_item: bool = False,
+) -> list[TextContent | ImageContent | EmbeddedResource]:
+    """Convert a result to a sequence of content objects."""
+    if result is None:
+        return []
+
+    if isinstance(result, TextContent | ImageContent | EmbeddedResource):
+        return [result]
+
+    if isinstance(result, Image):
+        return [result.to_image_content()]
+
+    if isinstance(result, list | tuple) and not _process_as_single_item:
+        # if the result is a list, then it could either be a list of MCP types,
+        # or a "regular" list that the tool is returning, or a mix of both.
+        #
+        # so we extract all the MCP types / images and convert them as individual content elements,
+        # and aggregate the rest as a single content element
+
+        mcp_types = []
+        other_content = []
+
+        for item in result:
+            if isinstance(item, TextContent | ImageContent | EmbeddedResource | Image):
+                mcp_types.append(_convert_to_content(item)[0])
+            else:
+                other_content.append(item)
+        if other_content:
+            other_content = _convert_to_content(
+                other_content, _process_as_single_item=True
+            )
+
+        return other_content + mcp_types
+
+    if not isinstance(result, str):
+        try:
+            result = json.dumps(pydantic_core.to_jsonable_python(result))
+        except Exception:
+            result = str(result)
+
+    return [TextContent(type="text", text=result)]

fastmcp/tools/tool_manager.py

@@ -1,12 +1,12 @@
 from __future__ import annotations as _annotations
 
-import copy
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
 from mcp.shared.context import LifespanContextT
+from mcp.types import EmbeddedResource, ImageContent, TextContent
 
-from fastmcp.exceptions import ToolError
+from fastmcp.exceptions import NotFoundError
 from fastmcp.settings import DuplicateBehavior
 from fastmcp.tools.tool import Tool
 from fastmcp.utilities.logging import get_logger
@@ -22,17 +22,38 @@ logger = get_logger(__name__)
 class ToolManager:
     """Manages FastMCP tools."""
 
-    def __init__(self, duplicate_behavior: DuplicateBehavior = DuplicateBehavior.WARN):
+    def __init__(self, duplicate_behavior: DuplicateBehavior | None = None):
         self._tools: dict[str, Tool] = {}
+
+        # Default to "warn" if None is provided
+        if duplicate_behavior is None:
+            duplicate_behavior = "warn"
+
+        if duplicate_behavior not in DuplicateBehavior.__args__:
+            raise ValueError(
+                f"Invalid duplicate_behavior: {duplicate_behavior}. "
+                f"Must be one of: {', '.join(DuplicateBehavior.__args__)}"
+            )
+
         self.duplicate_behavior = duplicate_behavior
 
-    def get_tool(self, name: str) -> Tool | None:
-        """Get tool by name."""
-        return self._tools.get(name)
+    def has_tool(self, key: str) -> bool:
+        """Check if a tool exists."""
+        return key in self._tools
+
+    def get_tool(self, key: str) -> Tool:
+        """Get tool by key."""
+        if key in self._tools:
+            return self._tools[key]
+        raise NotFoundError(f"Unknown tool: {key}")
+
+    def get_tools(self) -> dict[str, Tool]:
+        """Get all registered tools, indexed by registered key."""
+        return self._tools
 
     def list_tools(self) -> list[Tool]:
         """List all registered tools."""
-        return list(self._tools.values())
+        return list(self.get_tools().values())
 
     def add_tool_from_fn(
         self,
@@ -45,55 +66,33 @@ class ToolManager:
         tool = Tool.from_function(fn, name=name, description=description, tags=tags)
         return self.add_tool(tool)
 
-    def add_tool(self, tool: Tool) -> Tool:
+    def add_tool(self, tool: Tool, key: str | None = None) -> Tool:
         """Register a tool with the server."""
-        existing = self._tools.get(tool.name)
+        key = key or tool.name
+        existing = self._tools.get(key)
         if existing:
-            if self.duplicate_behavior == DuplicateBehavior.WARN:
-                logger.warning(f"Tool already exists: {tool.name}")
-                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
+            if self.duplicate_behavior == "warn":
+                logger.warning(f"Tool already exists: {key}")
+                self._tools[key] = tool
+            elif self.duplicate_behavior == "replace":
+                self._tools[key] = tool
+            elif self.duplicate_behavior == "error":
+                raise ValueError(f"Tool already exists: {key}")
+            elif self.duplicate_behavior == "ignore":
+                return existing
+        else:
+            self._tools[key] = tool
         return tool
 
     async def call_tool(
         self,
-        name: str,
+        key: str,
         arguments: dict[str, Any],
         context: Context[ServerSessionT, LifespanContextT] | None = None,
-    ) -> Any:
+    ) -> list[TextContent | ImageContent | EmbeddedResource]:
         """Call a tool by name with arguments."""
-        tool = self.get_tool(name)
+        tool = self.get_tool(key)
         if not tool:
-            raise ToolError(f"Unknown tool: {name}")
+            raise NotFoundError(f"Unknown tool: {key}")
 
         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
-
-            new_tool = copy.copy(tool)
-            new_tool.name = prefixed_name
-
-            # Store the copied tool
-            self.add_tool(new_tool)
-            logger.debug(f'Imported tool "{name}" as "{prefixed_name}"')

{fastmcp-2.1.2.dist-info → fastmcp-2.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.1.2
+Version: 2.2.1
 Summary: The fast, Pythonic way to build MCP servers.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp
@@ -17,10 +17,11 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
-Requires-Dist: dotenv>=0.9.9
-Requires-Dist: fastapi>=0.115.12
+Requires-Dist: exceptiongroup>=1.2.2
+Requires-Dist: httpx>=0.28.1
 Requires-Dist: mcp<2.0.0,>=1.6.0
 Requires-Dist: openapi-pydantic>=0.5.1
+Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: rich>=13.9.4
 Requires-Dist: typer>=0.15.2
 Requires-Dist: websockets>=15.0.1
@@ -94,6 +95,7 @@ FastMCP handles the complex protocol details and server management, letting you
   - [Proxy Servers](#proxy-servers)
   - [Composing MCP Servers](#composing-mcp-servers)
   - [OpenAPI \& FastAPI Generation](#openapi--fastapi-generation)
+  - [Handling `stderr`](#handling-stderr)
 - [Running Your Server](#running-your-server)
   - [Development Mode (Recommended for Building \& Testing)](#development-mode-recommended-for-building--testing)
   - [Claude Desktop Integration (For Regular Use)](#claude-desktop-integration-for-regular-use)
@@ -121,7 +123,7 @@ FastMCP provides a high-level, Pythonic interface for building and interacting w
 
 ## Why FastMCP?
 
-The MCP protocol is powerful but implementing it involves a lot of boilerplate - server setup, protocol handlers, content types, error management. FastMCP handles all the complex protocol details and server management, so you can focus on building great tools. It’s designed to be high-level and Pythonic; in most cases, decorating a function is all you need.
+The MCP protocol is powerful but implementing it involves a lot of boilerplate - server setup, protocol handlers, content types, error management. FastMCP handles all the complex protocol details and server management, so you can focus on building great tools. It's designed to be high-level and Pythonic; in most cases, decorating a function is all you need.
 
 FastMCP aims to be:
 
@@ -580,13 +582,13 @@ proxy_client = Client(
 )
 
 # Create a proxy server that connects to the client and exposes its capabilities
-proxy = FastMCP.as_proxy(proxy_client, name="Stdio-to-SSE Proxy")
+proxy = FastMCP.from_client(proxy_client, name="Stdio-to-SSE Proxy")
 
 if __name__ == "__main__":
     proxy.run(transport='sse')
 ```
 
-`FastMCP.as_proxy` is an `async` classmethod. It connects to the target, discovers its capabilities, and dynamically builds the proxy server instance.
+`FastMCP.from_client` is a class method that connects to the target, discovers its capabilities, and dynamically builds the proxy server instance.
 
 
 
@@ -694,6 +696,12 @@ mcp_server = FastMCP.from_openapi(openapi_spec, client=http_client)
 if __name__ == "__main__":
     mcp_server.run()
 ```
+
+### Handling `stderr`
+The MCP spec allows for the server to write anything it wants to `stderr`, and it
+doesn't specify the format in any way. FastMCP will forward the server's `stderr`
+to the client's `stderr`.
+
 ## Running Your Server
 
 Choose the method that best suits your needs:

{fastmcp-2.1.2.dist-info → fastmcp-2.2.1.dist-info}/RECORD

@@ -1,40 +1,40 @@
 fastmcp/__init__.py,sha256=2bwhjiyLJisyobp1O9tVYMjriHZAx_f4bIKJYOL-Rpk,399
-fastmcp/exceptions.py,sha256=9_KfANmugNdfZTCSZrohSeVmFmILZX5zz1LXI3wr_pw,508
+fastmcp/exceptions.py,sha256=QKVHbftoZp4YZQ2NxA-t1SjztqspFdX95YTFOAmr5EE,640
 fastmcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastmcp/settings.py,sha256=r5LT5yAZmwS1Lppro_fzdrCUJ0otnAmgtjsNgDdQIvs,1980
+fastmcp/settings.py,sha256=VCjc-3011pKRYjt2h9rZ68XhVEekbpyLyVUREVBTSrg,1955
 fastmcp/cli/__init__.py,sha256=Ii284TNoG5lxTP40ETMGhHEq3lQZWxu9m9JuU57kUpQ,87
 fastmcp/cli/claude.py,sha256=IAlcZ4qZKBBj09jZUMEx7EANZE_IR3vcu7zOBJmMOuU,4567
-fastmcp/cli/cli.py,sha256=M3BAkCjtnoGbyorUgaiqmCVSQg7S7_uEXerY-pqnOhk,13997
+fastmcp/cli/cli.py,sha256=vdnJi_zz4ZYoPxp9xlJbh6RlGogaFY3icaOPzO_xsLE,14874
 fastmcp/client/__init__.py,sha256=BXO9NUhntZ5GnUACfaRCzDJ5IzxqFJs8qKG-CRMSco4,490
 fastmcp/client/base.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-fastmcp/client/client.py,sha256=OMJ1FzrlcRRYKQg3DFxiQpaNDo4uYK3Acs23rxPyE-g,7941
+fastmcp/client/client.py,sha256=1WxEaBqyAvYGhS6y_Xzei173Ufjd4rZ_REfbNFNWJnE,8033
 fastmcp/client/roots.py,sha256=IxI_bHwHTmg6c2H-s1av1ZgrRnNDieHtYwdGFbzXT5c,2471
 fastmcp/client/sampling.py,sha256=WdRhIZbWv54rXYI8lWHv0thXmGCloZYPFpwJK9El_sQ,1613
-fastmcp/client/transports.py,sha256=WVChsDV1UF0I3reiefsT3dipIh-P_K262TXpucwH-YY,14602
+fastmcp/client/transports.py,sha256=lEE1PbqbntbFFKlVbrJtOpWzZa6N0_d1UXwixLgcpg0,15474
 fastmcp/prompts/__init__.py,sha256=LtPAv2JKIu54AwUd3iwv-HUd4DPcwgEqy6itEd3BH_E,194
-fastmcp/prompts/prompt.py,sha256=TCjIn0RyYsKDKjBYMuzSvmZPzigw4Y05EOvM0u_WBuk,5992
-fastmcp/prompts/prompt_manager.py,sha256=fX8Ckha0byC2VEgwRoM8_w8orNAkcdxEZRCd6oRtvo4,3533
+fastmcp/prompts/prompt.py,sha256=mQ6iRnt7J8oKBUhlgPDYXnIzwwDNWCk4heTqCmv1sco,6622
+fastmcp/prompts/prompt_manager.py,sha256=tMob9a-igjuzf6oTPLPGidFpJdg5JaPJVlYgyNkiCbE,2901
 fastmcp/resources/__init__.py,sha256=t0x1j8lc74rjUKtXe9H5Gs4fpQt82K4NgBK6Y7A0xTg,467
-fastmcp/resources/resource.py,sha256=qTAj6v_NrOhI_Hd1Mc6VfsmgSNFAxsBdCJTF9W-nU_s,1755
-fastmcp/resources/resource_manager.py,sha256=Ei1QthTUgjvSXIN-qXQeBd7aQiBNNsv0SY_lMtV9tfw,10997
-fastmcp/resources/template.py,sha256=_4JaMeYqtQYs1IO-lgBehaHJqp16G1pQ1Qe1f9YYoNg,3455
+fastmcp/resources/resource.py,sha256=5FN2a7dpNwf7FSEYTNvQvkTxtodu1OPxSlJL-U-8yrM,2413
+fastmcp/resources/resource_manager.py,sha256=_0itubfjYvfkA_wXKa4DQN5YpE7ejXhsE1hdt7m8XwU,9072
+fastmcp/resources/template.py,sha256=Xed7mmCNHUPG2lR9YOZ2MJ1jLiHP_Cp8Osms0b69ExM,5761
 fastmcp/resources/types.py,sha256=tigil7z-SUJMakGXzDLIGSqTepPrAsRpwqwtBA4yoUY,6168
 fastmcp/server/__init__.py,sha256=pdkghG11VLMZiluQ-4_rl2JK1LMWmV003m9dDRUN8W4,92
 fastmcp/server/context.py,sha256=s1885AZRipKB3VltfaO3VEtMxGefKs8fdZByj-4tbNI,7120
-fastmcp/server/openapi.py,sha256=J7HrAlRziaB2a6pwB0wStbjRJ1E5Lf818yMqD762s5U,22693
-fastmcp/server/proxy.py,sha256=gYcoQFDIBraqWMOpWSsZLqefKjL_v0v74juLW1SU1AU,8058
-fastmcp/server/server.py,sha256=ryN7o7G1gNFE1NsAuZVc3WpcmsBtcKOo-mXACN5NCoc,28814
+fastmcp/server/openapi.py,sha256=DVdUfs-rbBF_CIlxrI6HJ5aYbzuyDqGLAhT1TeyxwFc,22424
+fastmcp/server/proxy.py,sha256=in-ZGwd7I8h7fITKMyHXaJRqODudn7MXsG0hVv9M0rA,8580
+fastmcp/server/server.py,sha256=PFhnwa24diSKCz8KO39q43yuSHSbqYrzgnSspc-SPfg,31721
 fastmcp/tools/__init__.py,sha256=ocw-SFTtN6vQ8fgnlF8iNAOflRmh79xS1xdO0Bc3QPE,96
-fastmcp/tools/tool.py,sha256=pD3xOtryldu6lYsM5cOHnS05tJq9EwmQaoNUCZzLcoY,3598
-fastmcp/tools/tool_manager.py,sha256=p-L1KK8ecwP2psoyrcaSwHmeUKQZf-2pLPv6S_qgIcM,3525
+fastmcp/tools/tool.py,sha256=FGihp_hzKLj4hK7EdHNUwe8o3NMzCngw4ftMmL_X4XI,5797
+fastmcp/tools/tool_manager.py,sha256=hClv7fwj0cQSSwW0i-Swt7xiVqR4T9LVmr1Tp704nW4,3283
 fastmcp/utilities/__init__.py,sha256=-imJ8S-rXmbXMWeDamldP-dHDqAPg_wwmPVz-LNX14E,31
 fastmcp/utilities/decorators.py,sha256=AjhjsetQZF4YOPV5MTZmIxO21iFp_4fDIS3O2_KNCEg,2990
 fastmcp/utilities/func_metadata.py,sha256=uh-u3gAjLD4kCcGf0ZkZZwBTTl-84JuANZTnDqP5ztI,7841
 fastmcp/utilities/logging.py,sha256=zav8pnFxG_fvGJHUV2XpobmT9WVrmv1mlQBSCz-CPx4,1159
 fastmcp/utilities/openapi.py,sha256=PrH3usbTblaVC6jIH1UGiPEfgB2sSCLj33zA5dH7o_s,45193
 fastmcp/utilities/types.py,sha256=m2rPYMzO-ZFvvZ46N-1-Xqyw693K7yq9Z2xR4pVELyk,2091
-fastmcp-2.1.2.dist-info/METADATA,sha256=I3ePFWEbVbqKFh3UG6bnScng4t5WEhpbq3YNR-VET34,27467
-fastmcp-2.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fastmcp-2.1.2.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
-fastmcp-2.1.2.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-fastmcp-2.1.2.dist-info/RECORD,,
+fastmcp-2.2.1.dist-info/METADATA,sha256=DSlO410ImcFq2nxjE-BfQaqzXLkkThKE9yLe-pTKA1k,27760
+fastmcp-2.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fastmcp-2.2.1.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
+fastmcp-2.2.1.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+fastmcp-2.2.1.dist-info/RECORD,,