fastmcp 2.12.5__py3-none-any.whl → 2.14.0__py3-none-any.whl

fastmcp/__init__.py

@@ -27,30 +27,9 @@ if settings.deprecation_warnings:
     warnings.simplefilter("default", DeprecationWarning)
 
 
-def __getattr__(name: str):
-    """
-    Used to deprecate the module-level Image class; can be removed once it is no longer imported to root.
-    """
-    if name == "Image":
-        # Deprecated in 2.8.1
-        if settings.deprecation_warnings:
-            warnings.warn(
-                "The top-level `fastmcp.Image` import is deprecated "
-                "and will be removed in a future version. "
-                "Please use `fastmcp.utilities.types.Image` instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-        from fastmcp.utilities.types import Image
-
-        return Image
-    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
-
-
 __all__ = [
-    "FastMCP",
-    "Context",
-    "client",
     "Client",
+    "Context",
+    "FastMCP",
     "settings",
 ]

fastmcp/cli/__init__.py

@@ -1,6 +1,3 @@
 """FastMCP CLI package."""
 
 from .cli import app
-
-if __name__ == "__main__":
-    app()

fastmcp/cli/__main__.py

@@ -0,0 +1,5 @@
+"""FastMCP CLI as a runnable package"""
+
+from .cli import app
+
+app()

fastmcp/cli/cli.py

@@ -19,7 +19,7 @@ from rich.table import Table
 import fastmcp
 from fastmcp.cli import run as run_module
 from fastmcp.cli.install import install_app
-from fastmcp.server.server import FastMCP
+from fastmcp.cli.tasks import tasks_app
 from fastmcp.utilities.cli import is_already_in_uv_subprocess, load_and_merge_config
 from fastmcp.utilities.inspect import (
     InspectFormat,
@@ -28,7 +28,6 @@ from fastmcp.utilities.inspect import (
 )
 from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.mcp_server_config import MCPServerConfig
-from fastmcp.utilities.mcp_server_config.v1.environments.uv import UVEnvironment
 
 logger = get_logger("cli")
 console = Console()
@@ -46,9 +45,7 @@ def _get_npx_command():
         # Try both npx.cmd and npx.exe on Windows
         for cmd in ["npx.cmd", "npx.exe", "npx"]:
             try:
-                subprocess.run(
-                    [cmd, "--version"], check=True, capture_output=True, shell=True
-                )
+                subprocess.run([cmd, "--version"], check=True, capture_output=True)
                 return cmd
             except subprocess.CalledProcessError:
                 continue
@@ -80,7 +77,7 @@ def with_argv(args: list[str] | None):
         original = sys.argv[:]
         try:
             # Preserve the script name (sys.argv[0]) and replace the rest
-            sys.argv = [sys.argv[0]] + args
+            sys.argv = [sys.argv[0], *args]
             yield
         finally:
             sys.argv = original
@@ -106,7 +103,7 @@ def version(
         "MCP version": importlib.metadata.version("mcp"),
         "Python version": platform.python_version(),
         "Platform": platform.platform(),
-        "FastMCP root path": Path(fastmcp.__file__).resolve().parents[1],
+        "FastMCP root path": Path(fastmcp.__file__ or ".").resolve().parents[1],
     }
 
     g = Table.grid(padding=(0, 1))
@@ -226,29 +223,11 @@ async def dev(
     )
 
     try:
-        # Load server to check for deprecated dependencies
         if not config:
             logger.error("No configuration available")
             sys.exit(1)
         assert config is not None  # For type checker
-        server: FastMCP = await config.source.load_server()
-        if server.dependencies:
-            import warnings
-
-            warnings.warn(
-                f"Server '{server.name}' uses deprecated 'dependencies' parameter (deprecated in FastMCP 2.11.4). "
-                "Please migrate to fastmcp.json configuration file. "
-                "See https://gofastmcp.com/docs/deployment/server-configuration for details.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            # Merge server dependencies with environment dependencies
-            env_deps = config.environment.dependencies or []
-            all_deps = list(set(env_deps + server.dependencies))
-            if not config.environment:
-                config.environment = UVEnvironment(dependencies=all_deps)
-            else:
-                config.environment.dependencies = all_deps
+        await config.source.load_server()
 
         env_vars = {}
         if ui_port:
@@ -277,12 +256,10 @@ async def dev(
         # Set marker to prevent infinite loops when subprocess calls FastMCP
         env = dict(os.environ.items()) | env_vars | {"FASTMCP_UV_SPAWNED": "1"}
 
-        # Run the MCP Inspector command with shell=True on Windows
-        shell = sys.platform == "win32"
+        # Run the MCP Inspector command
         process = subprocess.run(
-            [npx_cmd, inspector_cmd] + uv_cmd,
+            [npx_cmd, inspector_cmd, *uv_cmd],
             check=True,
-            shell=shell,
             env=env,
         )
         sys.exit(process.returncode)
@@ -506,7 +483,7 @@ async def run(
             process = subprocess.run(cmd, check=True, env=env)
             sys.exit(process.returncode)
         except subprocess.CalledProcessError as e:
-            logger.error(
+            logger.exception(
                 f"Failed to run: {e}",
                 extra={
                     "server_spec": server_spec,
@@ -530,7 +507,7 @@ async def run(
                 skip_source=skip_source,
             )
         except Exception as e:
-            logger.error(
+            logger.exception(
                 f"Failed to run: {e}",
                 extra={
                     "server_spec": server_spec,
@@ -717,6 +694,10 @@ async def inspect(
             console.print(f"  Name:         {info.name}")
             if info.version:
                 console.print(f"  Version:      {info.version}")
+            if info.website_url:
+                console.print(f"  Website:      {info.website_url}")
+            if info.icons:
+                console.print(f"  Icons:        {len(info.icons)}")
             console.print(f"  Generation:   {info.server_generation}")
             if info.instructions:
                 console.print(f"  Instructions: {info.instructions}")
@@ -766,7 +747,7 @@ async def inspect(
             console.print(formatted_json.decode("utf-8"))
 
     except Exception as e:
-        logger.error(
+        logger.exception(
             f"Failed to inspect server: {e}",
             extra={
                 "server_spec": server_spec,
@@ -838,11 +819,13 @@ async def prepare(
             )
             sys.exit(1)
 
+    assert config_path is not None
     config_file = Path(config_path)
     if not config_file.exists():
         logger.error(f"Configuration file not found: {config_path}")
         sys.exit(1)
 
+    assert output_dir is not None
     output_path = Path(output_dir)
 
     try:
@@ -873,6 +856,9 @@ app.command(project_app)
 # Add install subcommands using proper Cyclopts pattern
 app.command(install_app)
 
+# Add tasks subcommand group
+app.command(tasks_app)
+
 
 if __name__ == "__main__":
     app()

fastmcp/cli/install/claude_code.py

@@ -110,9 +110,9 @@ def install_claude_code(
     env_config = UVEnvironment(
         python=python_version,
         dependencies=(with_packages or []) + ["fastmcp"],
-        requirements=str(with_requirements) if with_requirements else None,
-        project=str(project) if project else None,
-        editable=[str(p) for p in with_editable] if with_editable else None,
+        requirements=with_requirements,
+        project=project,
+        editable=with_editable,
     )
 
     # Build server spec from parsed components
@@ -125,15 +125,15 @@ def install_claude_code(
     full_command = env_config.build_command(["fastmcp", "run", server_spec])
 
     # Build claude mcp add command
-    cmd_parts = [claude_cmd, "mcp", "add"]
+    cmd_parts = [claude_cmd, "mcp", "add", name]
 
-    # Add environment variables if specified (before the name and command)
+    # Add environment variables if specified
     if env_vars:
         for key, value in env_vars.items():
             cmd_parts.extend(["-e", f"{key}={value}"])
 
     # Add server name and command
-    cmd_parts.extend([name, "--"])
+    cmd_parts.append("--")
     cmd_parts.extend(full_command)
 
     try:

fastmcp/cli/install/claude_desktop.py

@@ -76,9 +76,9 @@ def install_claude_desktop(
     env_config = UVEnvironment(
         python=python_version,
         dependencies=(with_packages or []) + ["fastmcp"],
-        requirements=str(with_requirements) if with_requirements else None,
-        project=str(project) if project else None,
-        editable=[str(p) for p in with_editable] if with_editable else None,
+        requirements=with_requirements,
+        project=project,
+        editable=with_editable,
     )
     # Build server spec from parsed components
     if server_object:

fastmcp/cli/install/cursor.py

@@ -1,10 +1,12 @@
 """Cursor integration for FastMCP install using Cyclopts."""
 
 import base64
+import os
 import subprocess
 import sys
 from pathlib import Path
 from typing import Annotated
+from urllib.parse import quote, urlparse
 
 import cyclopts
 from rich import print
@@ -36,8 +38,9 @@ def generate_cursor_deeplink(
     config_json = server_config.model_dump_json(exclude_none=True)
     config_b64 = base64.urlsafe_b64encode(config_json.encode()).decode()
 
-    # Generate the deeplink URL
-    deeplink = f"cursor://anysphere.cursor-deeplink/mcp/install?name={server_name}&config={config_b64}"
+    # Generate the deeplink URL with properly encoded server name
+    encoded_name = quote(server_name, safe="")
+    deeplink = f"cursor://anysphere.cursor-deeplink/mcp/install?name={encoded_name}&config={config_b64}"
 
     return deeplink
 
@@ -51,17 +54,20 @@ def open_deeplink(deeplink: str) -> bool:
     Returns:
         True if the command succeeded, False otherwise
     """
+    parsed = urlparse(deeplink)
+    if parsed.scheme != "cursor":
+        logger.warning(f"Invalid deeplink scheme: {parsed.scheme}")
+        return False
+
     try:
         if sys.platform == "darwin":  # macOS
             subprocess.run(["open", deeplink], check=True, capture_output=True)
         elif sys.platform == "win32":  # Windows
-            subprocess.run(
-                ["start", deeplink], shell=True, check=True, capture_output=True
-            )
+            os.startfile(deeplink)
         else:  # Linux and others
             subprocess.run(["xdg-open", deeplink], check=True, capture_output=True)
         return True
-    except (subprocess.CalledProcessError, FileNotFoundError):
+    except (subprocess.CalledProcessError, FileNotFoundError, OSError):
         return False
 
 
@@ -110,9 +116,9 @@ def install_cursor_workspace(
     env_config = UVEnvironment(
         python=python_version,
         dependencies=(with_packages or []) + ["fastmcp"],
-        requirements=str(with_requirements.resolve()) if with_requirements else None,
-        project=str(project.resolve()) if project else None,
-        editable=[str(p.resolve()) for p in with_editable] if with_editable else None,
+        requirements=with_requirements,
+        project=project,
+        editable=with_editable,
     )
     # Build server spec from parsed components
     if server_object:
@@ -180,9 +186,9 @@ def install_cursor(
     env_config = UVEnvironment(
         python=python_version,
         dependencies=(with_packages or []) + ["fastmcp"],
-        requirements=str(with_requirements.resolve()) if with_requirements else None,
-        project=str(project.resolve()) if project else None,
-        editable=[str(p.resolve()) for p in with_editable] if with_editable else None,
+        requirements=with_requirements,
+        project=project,
+        editable=with_editable,
     )
     # Build server spec from parsed components
     if server_object:

fastmcp/cli/install/gemini_cli.py

@@ -107,9 +107,9 @@ def install_gemini_cli(
     env_config = UVEnvironment(
         python=python_version,
         dependencies=(with_packages or []) + ["fastmcp"],
-        requirements=str(with_requirements) if with_requirements else None,
-        project=str(project) if project else None,
-        editable=[str(p) for p in with_editable] if with_editable else None,
+        requirements=with_requirements,
+        project=project,
+        editable=with_editable,
     )
 
     # Build server spec from parsed components

fastmcp/cli/install/mcp_json.py

@@ -51,9 +51,9 @@ def install_mcp_json(
         env_config = UVEnvironment(
             python=python_version,
             dependencies=(with_packages or []) + ["fastmcp"],
-            requirements=str(with_requirements) if with_requirements else None,
-            project=str(project) if project else None,
-            editable=[str(p) for p in with_editable] if with_editable else None,
+            requirements=with_requirements,
+            project=project,
+            editable=with_editable,
         )
         # Build server spec from parsed components
         if server_object:

fastmcp/cli/install/shared.py

@@ -105,21 +105,6 @@ async def process_common_args(
             )
             name = file.stem
 
-    # Get server dependencies if available
-    # TODO: Remove dependencies handling (deprecated in v2.11.4)
-    server_dependencies = getattr(server, "dependencies", []) if server else []
-    if server_dependencies:
-        import warnings
-
-        warnings.warn(
-            "Server uses deprecated 'dependencies' parameter (deprecated in FastMCP 2.11.4). "
-            "Please migrate to fastmcp.json configuration file. "
-            "See https://gofastmcp.com/docs/deployment/server-configuration for details.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        with_packages = list(set(with_packages + server_dependencies))
-
     # Process environment variables if provided
     env_dict: dict[str, str] | None = None
     if env_file or env_vars:

fastmcp/cli/run.py

@@ -172,7 +172,7 @@ async def run_command(
 
     # handle v1 servers
     if isinstance(server, FastMCP1x):
-        run_v1_server(server, host=host, port=port, transport=transport)
+        await run_v1_server_async(server, host=host, port=port, transport=transport)
         return
 
     kwargs = {}
@@ -197,24 +197,29 @@ async def run_command(
         sys.exit(1)
 
 
-def run_v1_server(
+async def run_v1_server_async(
     server: FastMCP1x,
     host: str | None = None,
     port: int | None = None,
     transport: TransportType | None = None,
 ) -> None:
-    from functools import partial
+    """Run a FastMCP 1.x server using async methods.
 
+    Args:
+        server: FastMCP 1.x server instance
+        host: Host to bind to
+        port: Port to bind to
+        transport: Transport protocol to use
+    """
     if host:
         server.settings.host = host
     if port:
         server.settings.port = port
+
     match transport:
         case "stdio":
-            runner = partial(server.run)
+            await server.run_stdio_async()
         case "http" | "streamable-http" | None:
-            runner = partial(server.run, transport="streamable-http")
+            await server.run_streamable_http_async()
         case "sse":
-            runner = partial(server.run, transport="sse")
-
-    runner()
+            await server.run_sse_async()

fastmcp/cli/tasks.py

@@ -0,0 +1,110 @@
+"""FastMCP tasks CLI for Docket task management."""
+
+import asyncio
+import sys
+from typing import Annotated
+
+import cyclopts
+from rich.console import Console
+
+from fastmcp.utilities.cli import load_and_merge_config
+from fastmcp.utilities.logging import get_logger
+
+logger = get_logger("cli.tasks")
+console = Console()
+
+tasks_app = cyclopts.App(
+    name="tasks",
+    help="Manage FastMCP background tasks using Docket",
+)
+
+
+def check_distributed_backend() -> None:
+    """Check if Docket is configured with a distributed backend.
+
+    The CLI worker runs as a separate process, so it needs Redis/Valkey
+    to coordinate with the main server process.
+
+    Raises:
+        SystemExit: If using memory:// URL
+    """
+    import fastmcp
+
+    docket_url = fastmcp.settings.docket.url
+
+    # Check for memory:// URL and provide helpful error
+    if docket_url.startswith("memory://"):
+        console.print(
+            "[bold red]✗ In-memory backend not supported by CLI[/bold red]\n\n"
+            "Your Docket configuration uses an in-memory backend (memory://) which\n"
+            "only works within a single process.\n\n"
+            "To use [cyan]fastmcp tasks[/cyan] CLI commands (which run in separate\n"
+            "processes), you need a distributed backend:\n\n"
+            "[bold]1. Install Redis or Valkey:[/bold]\n"
+            "   [dim]macOS:[/dim]     brew install redis\n"
+            "   [dim]Ubuntu:[/dim]    apt install redis-server\n"
+            "   [dim]Valkey:[/dim]    See https://valkey.io/\n\n"
+            "[bold]2. Start the service:[/bold]\n"
+            "   redis-server\n\n"
+            "[bold]3. Configure Docket URL:[/bold]\n"
+            "   [dim]Environment variable:[/dim]\n"
+            "   export FASTMCP_DOCKET_URL=redis://localhost:6379/0\n\n"
+            "[bold]4. Try again[/bold]\n\n"
+            "The memory backend works great for single-process servers, but the CLI\n"
+            "commands need a distributed backend to coordinate across processes.\n\n"
+            "Need help? See: [cyan]https://gofastmcp.com/docs/tasks[/cyan]"
+        )
+        sys.exit(1)
+
+
+@tasks_app.command
+def worker(
+    server_spec: Annotated[
+        str | None,
+        cyclopts.Parameter(
+            help="Python file to run, optionally with :object suffix, or None to auto-detect fastmcp.json"
+        ),
+    ] = None,
+) -> None:
+    """Start an additional worker to process background tasks.
+
+    Connects to your Docket backend and processes tasks in parallel with
+    any other running workers. Configure via environment variables
+    (FASTMCP_DOCKET_*).
+
+    Example:
+        fastmcp tasks worker server.py
+        fastmcp tasks worker examples/tasks/server.py
+    """
+    import fastmcp
+
+    check_distributed_backend()
+
+    # Load server to get task functions
+    try:
+        config, _resolved_spec = load_and_merge_config(server_spec)
+    except FileNotFoundError:
+        sys.exit(1)
+
+    # Load the server
+    server = asyncio.run(config.source.load_server())
+
+    async def run_worker():
+        """Enter server lifespan and camp forever."""
+        async with server._lifespan_manager():
+            console.print(
+                f"[bold green]✓[/bold green] Starting worker for [cyan]{server.name}[/cyan]"
+            )
+            console.print(f"  Docket: {fastmcp.settings.docket.name}")
+            console.print(f"  Backend: {fastmcp.settings.docket.url}")
+            console.print(f"  Concurrency: {fastmcp.settings.docket.concurrency}")
+
+            # Server's lifespan has started its worker - just camp here forever
+            while True:
+                await asyncio.sleep(3600)
+
+    try:
+        asyncio.run(run_worker())
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Worker stopped[/yellow]")
+        sys.exit(0)

fastmcp/client/__init__.py

@@ -15,18 +15,18 @@ from .transports import (
 from .auth import OAuth, BearerAuth
 
 __all__ = [
+    "BearerAuth",
     "Client",
     "ClientTransport",
-    "WSTransport",
-    "SSETransport",
-    "StdioTransport",
-    "PythonStdioTransport",
+    "FastMCPTransport",
     "NodeStdioTransport",
-    "UvxStdioTransport",
-    "UvStdioTransport",
     "NpxStdioTransport",
-    "FastMCPTransport",
-    "StreamableHttpTransport",
     "OAuth",
-    "BearerAuth",
+    "PythonStdioTransport",
+    "SSETransport",
+    "StdioTransport",
+    "StreamableHttpTransport",
+    "UvStdioTransport",
+    "UvxStdioTransport",
+    "WSTransport",
 ]