fastmcp 2.14.4__py3-none-any.whl → 3.0.0b1__py3-none-any.whl

fastmcp/_vendor/__init__.py

@@ -0,0 +1 @@
+"""Vendored third-party code for FastMCP."""

fastmcp/_vendor/docket_di/README.md

@@ -0,0 +1,7 @@
+# Vendored Docket DI
+
+This is a minimal vendored copy of the dependency injection engine from [Docket](https://github.com/chrisguidry/docket), pending its release as a standalone library.
+
+When `fastmcp[tasks]` is installed, FastMCP uses Docket's DI classes directly for `isinstance` compatibility in worker contexts. This vendored version is only used when Docket is not installed, allowing basic `Depends()` functionality without the full Docket dependency.
+
+Once the DI component is released separately, this vendored copy will be removed.

fastmcp/_vendor/docket_di/__init__.py

@@ -0,0 +1,163 @@
+"""Vendored dependency injection engine from Docket.
+
+This is a minimal subset of docket.dependencies for FastMCP's DI system.
+When docket is installed, FastMCP uses docket's classes directly for
+isinstance compatibility. This vendored version is only used when docket
+is not installed.
+
+Original source: https://github.com/chrisguidry/docket
+License: MIT
+"""
+
+from __future__ import annotations
+
+import abc
+import inspect
+from contextlib import AsyncExitStack
+from contextvars import ContextVar
+from collections.abc import Awaitable, Callable
+from contextlib import AbstractAsyncContextManager, AbstractContextManager
+from typing import (
+    Any,
+    Generic,
+    TypeVar,
+    cast,
+)
+
+R = TypeVar("R")
+
+# Cached signature lookup (simplified from docket.execution.get_signature)
+_signature_cache: dict[Callable[..., Any], inspect.Signature] = {}
+
+
+def get_signature(function: Callable[..., Any]) -> inspect.Signature:
+    """Get cached signature for a function."""
+    if function in _signature_cache:
+        return _signature_cache[function]
+
+    signature_attr = getattr(function, "__signature__", None)
+    if isinstance(signature_attr, inspect.Signature):
+        _signature_cache[function] = signature_attr
+        return signature_attr
+
+    signature = inspect.signature(function)
+    _signature_cache[function] = signature
+    return signature
+
+
+class Dependency(abc.ABC):
+    """Base class for all dependencies.
+
+    Subclasses must implement __aenter__ to provide the dependency value.
+    The __aexit__ method is optional for cleanup.
+    """
+
+    single: bool = False
+
+    @abc.abstractmethod
+    async def __aenter__(self) -> Any: ...
+
+    async def __aexit__(self, *args: object) -> None:  # noqa: B027
+        pass
+
+
+DependencyFunction = Callable[..., Any]
+
+_parameter_cache: dict[Callable[..., Any], dict[str, Dependency]] = {}
+
+
+def get_dependency_parameters(
+    function: Callable[..., Any],
+) -> dict[str, Dependency]:
+    """Find parameters with Dependency defaults."""
+    if function in _parameter_cache:
+        return _parameter_cache[function]
+
+    dependencies: dict[str, Dependency] = {}
+    signature = get_signature(function)
+
+    for parameter, param in signature.parameters.items():
+        if not isinstance(param.default, Dependency):
+            continue
+        dependencies[parameter] = param.default
+
+    _parameter_cache[function] = dependencies
+    return dependencies
+
+
+class _Depends(Dependency, Generic[R]):
+    """Wrapper for user-defined dependency functions."""
+
+    dependency: DependencyFunction
+
+    cache: ContextVar[dict[DependencyFunction, Any]] = ContextVar("cache")
+    stack: ContextVar[AsyncExitStack] = ContextVar("stack")
+
+    def __init__(self, dependency: DependencyFunction) -> None:
+        self.dependency = dependency
+
+    async def _resolve_parameters(self, function: DependencyFunction) -> dict[str, Any]:
+        stack = self.stack.get()
+        arguments: dict[str, Any] = {}
+        parameters = get_dependency_parameters(function)
+
+        for parameter, dependency in parameters.items():
+            arguments[parameter] = await stack.enter_async_context(dependency)
+
+        return arguments
+
+    async def __aenter__(self) -> R:
+        cache = self.cache.get()
+
+        if self.dependency in cache:
+            return cache[self.dependency]
+
+        stack = self.stack.get()
+        arguments = await self._resolve_parameters(self.dependency)
+
+        raw_value = self.dependency(**arguments)
+
+        # Handle different return types
+        resolved_value: R
+        if isinstance(raw_value, AbstractAsyncContextManager):
+            resolved_value = await stack.enter_async_context(raw_value)
+        elif isinstance(raw_value, AbstractContextManager):
+            resolved_value = stack.enter_context(raw_value)
+        elif inspect.iscoroutine(raw_value) or isinstance(raw_value, Awaitable):
+            resolved_value = await cast(Awaitable[R], raw_value)
+        else:
+            resolved_value = cast(R, raw_value)
+
+        cache[self.dependency] = resolved_value
+        return resolved_value
+
+
+def Depends(dependency: DependencyFunction) -> Any:
+    """Include a user-defined function as a dependency.
+
+    Dependencies may be:
+    - Synchronous functions returning a value
+    - Asynchronous functions returning a value (awaitable)
+    - Synchronous context managers (using @contextmanager)
+    - Asynchronous context managers (using @asynccontextmanager)
+
+    Example:
+        ```python
+        def get_config() -> dict:
+            return {"api_url": "https://api.example.com"}
+
+        @mcp.tool
+        def my_tool(config: dict = Depends(get_config)) -> str:
+            return config["api_url"]
+        ```
+    """
+    return cast(Any, _Depends(dependency))
+
+
+__all__ = [
+    "Dependency",
+    "Depends",
+    "_Depends",
+    "get_dependency_parameters",
+    "get_signature",
+]

fastmcp/cli/cli.py

@@ -13,6 +13,7 @@ from typing import Annotated, Literal
 
 import cyclopts
 import pyperclip
+from cyclopts import Parameter
 from rich.console import Console
 from rich.table import Table
 
@@ -37,6 +38,8 @@ app = cyclopts.App(
     name="fastmcp",
     help="FastMCP 2.0 - The fast, Pythonic way to build MCP servers and clients.",
     version=fastmcp.__version__,
+    # Disable automatic negative parameters by default
+    default_parameter=Parameter(negative=()),
 )
 
 
@@ -91,11 +94,7 @@ def version(
     *,
     copy: Annotated[
         bool,
-        cyclopts.Parameter(
-            "--copy",
-            help="Copy version information to clipboard",
-            negative="",
-        ),
+        cyclopts.Parameter("--copy", help="Copy version information to clipboard"),
     ] = False,
 ):
     """Display version information and platform details."""
@@ -141,15 +140,12 @@ async def dev(
         cyclopts.Parameter(
             "--with-editable",
             help="Directory containing pyproject.toml to install in editable mode (can be used multiple times)",
-            negative="",
         ),
     ] = None,
     with_packages: Annotated[
         list[str] | None,
         cyclopts.Parameter(
-            "--with",
-            help="Additional packages to install (can be used multiple times)",
-            negative="",
+            "--with", help="Additional packages to install (can be used multiple times)"
         ),
     ] = None,
     inspector_version: Annotated[
@@ -194,6 +190,21 @@ async def dev(
             help="Run the command within the given project directory",
         ),
     ] = None,
+    reload: Annotated[
+        bool,
+        cyclopts.Parameter(
+            "--reload",
+            help="Enable auto-reload on file changes (enabled by default)",
+            negative="--no-reload",
+        ),
+    ] = True,
+    reload_dir: Annotated[
+        list[Path] | None,
+        cyclopts.Parameter(
+            "--reload-dir",
+            help="Directories to watch for changes (default: current directory)",
+        ),
+    ] = None,
 ) -> None:
     """Run an MCP server with the MCP Inspector for development.
 
@@ -257,10 +268,18 @@ async def dev(
         if inspector_version:
             inspector_cmd += f"@{inspector_version}"
 
+        # Build the fastmcp run command
+        fastmcp_cmd = ["fastmcp", "run", server_spec, "--no-banner"]
+
+        # Add reload flags if enabled - the server will handle reloading
+        if reload:
+            fastmcp_cmd.append("--reload")
+            if reload_dir:
+                for dir_path in reload_dir:
+                    fastmcp_cmd.extend(["--reload-dir", str(dir_path)])
+
         # Use the environment from config (already has CLI overrides applied)
-        uv_cmd = config.environment.build_command(
-            ["fastmcp", "run", server_spec, "--no-banner"]
-        )
+        uv_cmd = config.environment.build_command(fastmcp_cmd)
 
         # Set marker to prevent infinite loops when subprocess calls FastMCP
         env = dict(os.environ.items()) | env_vars | {"FASTMCP_UV_SPAWNED": "1"}
@@ -333,11 +352,7 @@ async def run(
     ] = None,
     no_banner: Annotated[
         bool,
-        cyclopts.Parameter(
-            "--no-banner",
-            help="Don't show the server banner",
-            negative="",
-        ),
+        cyclopts.Parameter("--no-banner", help="Don't show the server banner"),
     ] = False,
     python: Annotated[
         str | None,
@@ -349,9 +364,7 @@ async def run(
     with_packages: Annotated[
         list[str] | None,
         cyclopts.Parameter(
-            "--with",
-            help="Additional packages to install (can be used multiple times)",
-            negative="",
+            "--with", help="Additional packages to install (can be used multiple times)"
         ),
     ] = None,
     project: Annotated[
@@ -373,7 +386,6 @@ async def run(
         cyclopts.Parameter(
             "--skip-source",
             help="Skip source preparation step (use when source is already prepared)",
-            negative="",
         ),
     ] = False,
     skip_env: Annotated[
@@ -381,7 +393,28 @@ async def run(
         cyclopts.Parameter(
             "--skip-env",
             help="Skip environment configuration (for internal use when already in a uv environment)",
-            negative="",
+        ),
+    ] = False,
+    reload: Annotated[
+        bool,
+        cyclopts.Parameter(
+            "--reload",
+            negative="--no-reload",
+            help="Enable auto-reload on file changes (development mode)",
+        ),
+    ] = False,
+    reload_dir: Annotated[
+        list[Path] | None,
+        cyclopts.Parameter(
+            "--reload-dir",
+            help="Directories to watch for changes (default: current directory)",
+        ),
+    ] = None,
+    stateless: Annotated[
+        bool,
+        cyclopts.Parameter(
+            "--stateless",
+            help="Run in stateless mode (no session, used internally for reload)",
         ),
     ] = False,
 ) -> None:
@@ -432,8 +465,10 @@ async def run(
     final_log_level = log_level or config.deployment.log_level
     final_server_args = server_args or config.deployment.args
     # Use CLI override if provided, otherwise use settings
-    # no_banner CLI flag overrides the show_cli_banner setting
-    final_no_banner = no_banner if no_banner else not fastmcp.settings.show_cli_banner
+    # no_banner CLI flag overrides the show_server_banner setting
+    final_no_banner = (
+        no_banner if no_banner else not fastmcp.settings.show_server_banner
+    )
 
     logger.debug(
         "Running server or client",
@@ -448,6 +483,57 @@ async def run(
         },
     )
 
+    # Handle reload mode
+    if reload:
+        # SSE is incompatible with reload (no stateless mode exists)
+        if final_transport == "sse":
+            logger.warning(
+                "--reload is not supported with SSE transport (sessions are lost on restart). "
+                "Use streamable-http transport instead, or use --no-reload. "
+                "Running without reload."
+            )
+            # Fall through to normal execution
+        else:
+            # Build command for subprocess (with --no-reload to prevent infinite spawning)
+            reload_cmd = ["fastmcp", "run", server_spec]
+            if final_transport:
+                reload_cmd.extend(["--transport", final_transport])
+            if final_transport != "stdio":
+                if final_host:
+                    reload_cmd.extend(["--host", final_host])
+                if final_port:
+                    reload_cmd.extend(["--port", str(final_port)])
+                if final_path:
+                    reload_cmd.extend(["--path", final_path])
+            if final_log_level:
+                reload_cmd.extend(["--log-level", final_log_level])
+            if final_no_banner:
+                reload_cmd.append("--no-banner")
+            reload_cmd.append("--no-reload")  # Prevent infinite spawning
+            reload_cmd.append("--stateless")  # Stateless mode for reload compatibility
+
+            # If environment setup is needed, wrap with uv
+            test_cmd = ["test"]
+            needs_uv = (
+                config.environment.build_command(test_cmd) != test_cmd and not skip_env
+            )
+            if needs_uv:
+                # Add --skip-env to prevent nested uv runs (child would spawn another uv)
+                reload_cmd.append("--skip-env")
+
+            if final_server_args:
+                reload_cmd.append("--")
+                reload_cmd.extend(final_server_args)
+
+            if needs_uv:
+                reload_cmd = config.environment.build_command(reload_cmd)
+
+            is_stdio = final_transport in ("stdio", None)
+            await run_module.run_with_reload(
+                reload_cmd, reload_dirs=reload_dir, is_stdio=is_stdio
+            )
+            return
+
     # Check if we need to use uv run (but skip if we're already in uv or user said to skip)
     # We check if the environment would modify the command
     test_cmd = ["test"]
@@ -514,6 +600,7 @@ async def run(
                 server_args=list(final_server_args) if final_server_args else [],
                 show_banner=not final_no_banner,
                 skip_source=skip_source,
+                stateless=stateless,
             )
         except Exception as e:
             logger.exception(
@@ -554,9 +641,7 @@ async def inspect(
     with_packages: Annotated[
         list[str] | None,
         cyclopts.Parameter(
-            "--with",
-            help="Additional packages to install (can be used multiple times)",
-            negative="",
+            "--with", help="Additional packages to install (can be used multiple times)"
         ),
     ] = None,
     project: Annotated[
@@ -578,7 +663,6 @@ async def inspect(
         cyclopts.Parameter(
             "--skip-env",
             help="Skip environment configuration (for internal use when already in a uv environment)",
-            negative="",
         ),
     ] = False,
 ) -> None:

fastmcp/cli/install/claude_code.py

@@ -165,15 +165,12 @@ async def claude_code_command(
         cyclopts.Parameter(
             "--with-editable",
             help="Directory with pyproject.toml to install in editable mode (can be used multiple times)",
-            negative="",
         ),
     ] = None,
     with_packages: Annotated[
         list[str] | None,
         cyclopts.Parameter(
-            "--with",
-            help="Additional packages to install (can be used multiple times)",
-            negative="",
+            "--with", help="Additional packages to install (can be used multiple times)"
         ),
     ] = None,
     env_vars: Annotated[
@@ -181,7 +178,6 @@ async def claude_code_command(
         cyclopts.Parameter(
             "--env",
             help="Environment variables in KEY=VALUE format (can be used multiple times)",
-            negative="",
         ),
     ] = None,
     env_file: Annotated[

fastmcp/cli/install/claude_desktop.py

@@ -137,15 +137,12 @@ async def claude_desktop_command(
         cyclopts.Parameter(
             "--with-editable",
             help="Directory with pyproject.toml to install in editable mode (can be used multiple times)",
-            negative="",
         ),
     ] = None,
     with_packages: Annotated[
         list[str] | None,
         cyclopts.Parameter(
-            "--with",
-            help="Additional packages to install (can be used multiple times)",
-            negative="",
+            "--with", help="Additional packages to install (can be used multiple times)"
         ),
     ] = None,
     env_vars: Annotated[
@@ -153,7 +150,6 @@ async def claude_desktop_command(
         cyclopts.Parameter(
             "--env",
             help="Environment variables in KEY=VALUE format (can be used multiple times)",
-            negative="",
         ),
     ] = None,
     env_file: Annotated[

fastmcp/cli/install/cursor.py

@@ -252,15 +252,12 @@ async def cursor_command(
         cyclopts.Parameter(
             "--with-editable",
             help="Directory with pyproject.toml to install in editable mode (can be used multiple times)",
-            negative="",
         ),
     ] = None,
     with_packages: Annotated[
         list[str] | None,
         cyclopts.Parameter(
-            "--with",
-            help="Additional packages to install (can be used multiple times)",
-            negative="",
+            "--with", help="Additional packages to install (can be used multiple times)"
         ),
     ] = None,
     env_vars: Annotated[
@@ -268,7 +265,6 @@ async def cursor_command(
         cyclopts.Parameter(
             "--env",
             help="Environment variables in KEY=VALUE format (can be used multiple times)",
-            negative="",
         ),
     ] = None,
     env_file: Annotated[

fastmcp/cli/install/gemini_cli.py

@@ -162,15 +162,12 @@ async def gemini_cli_command(
         cyclopts.Parameter(
             "--with-editable",
             help="Directory with pyproject.toml to install in editable mode (can be used multiple times)",
-            negative="",
         ),
     ] = None,
     with_packages: Annotated[
         list[str] | None,
         cyclopts.Parameter(
-            "--with",
-            help="Additional packages to install (can be used multiple times)",
-            negative="",
+            "--with", help="Additional packages to install (can be used multiple times)"
         ),
     ] = None,
     env_vars: Annotated[
@@ -178,7 +175,6 @@ async def gemini_cli_command(
         cyclopts.Parameter(
             "--env",
             help="Environment variables in KEY=VALUE format (can be used multiple times)",
-            negative="",
         ),
     ] = None,
     env_file: Annotated[

fastmcp/cli/install/mcp_json.py

@@ -110,15 +110,12 @@ async def mcp_json_command(
         cyclopts.Parameter(
             "--with-editable",
             help="Directory with pyproject.toml to install in editable mode (can be used multiple times)",
-            negative="",
         ),
     ] = None,
     with_packages: Annotated[
         list[str] | None,
         cyclopts.Parameter(
-            "--with",
-            help="Additional packages to install (can be used multiple times)",
-            negative="",
+            "--with", help="Additional packages to install (can be used multiple times)"
         ),
     ] = None,
     env_vars: Annotated[
@@ -126,7 +123,6 @@ async def mcp_json_command(
         cyclopts.Parameter(
             "--env",
             help="Environment variables in KEY=VALUE format (can be used multiple times)",
-            negative="",
         ),
     ] = None,
     env_file: Annotated[
@@ -141,7 +137,6 @@ async def mcp_json_command(
         cyclopts.Parameter(
             "--copy",
             help="Copy configuration to clipboard instead of printing to stdout",
-            negative="",
         ),
     ] = False,
     python: Annotated[