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

fastmcp/contrib/component_manager/component_manager.py

@@ -1,186 +1,121 @@
 """
-Routes and helpers for managing tools, resources, and prompts in FastMCP.
-Provides endpoints for enabling/disabling components via HTTP, with optional authentication scopes.
-"""
+HTTP routes for enabling/disabling components in FastMCP.
 
-from typing import Any
+Provides REST endpoints for controlling component enabled state with optional
+authentication scopes.
+"""
 
 from mcp.server.auth.middleware.bearer_auth import RequireAuthMiddleware
 from starlette.applications import Starlette
-from starlette.exceptions import HTTPException as StarletteHTTPException
 from starlette.requests import Request
 from starlette.responses import JSONResponse
 from starlette.routing import Mount, Route
 
-from fastmcp.contrib.component_manager.component_service import ComponentService
-from fastmcp.exceptions import NotFoundError
 from fastmcp.server.server import FastMCP
 
 
 def set_up_component_manager(
     server: FastMCP, path: str = "/", required_scopes: list[str] | None = None
-):
-    """Set up routes for enabling/disabling tools, resources, and prompts.
+) -> None:
+    """Set up HTTP routes for enabling/disabling tools, resources, and prompts.
+
     Args:
-        server: The FastMCP server instance
-        path: Path used to mount all component-related routes on the server
-        required_scopes: Optional list of scopes required for these routes. Applies only if authentication is enabled.
+        server: The FastMCP server instance.
+        path: Base path for component management routes.
+        required_scopes: Optional list of scopes required for these routes.
+            Applies only if authentication is enabled.
+
+    Routes created:
+        POST /tools/{name}/enable[?version=v1]
+        POST /tools/{name}/disable[?version=v1]
+        POST /resources/{uri}/enable[?version=v1]
+        POST /resources/{uri}/disable[?version=v1]
+        POST /prompts/{name}/enable[?version=v1]
+        POST /prompts/{name}/disable[?version=v1]
     """
-
-    service = ComponentService(server)
-    routes: list[Route] = []
-    mounts: list[Mount] = []
-    route_configs = {
-        "tool": {
-            "param": "tool_name",
-            "enable": service._enable_tool,
-            "disable": service._disable_tool,
-        },
-        "resource": {
-            "param": "uri:path",
-            "enable": service._enable_resource,
-            "disable": service._disable_resource,
-        },
-        "prompt": {
-            "param": "prompt_name",
-            "enable": service._enable_prompt,
-            "disable": service._disable_prompt,
-        },
-    }
-
     if required_scopes is None:
-        routes.extend(build_component_manager_endpoints(route_configs, path))
+        # No auth - include path prefix in routes
+        routes = _build_routes(server, path)
+        server._additional_http_routes.extend(routes)
     else:
-        if path != "/":
-            mounts.append(
-                build_component_manager_mount(route_configs, path, required_scopes)
-            )
-        else:
-            mounts.append(
-                build_component_manager_mount(
-                    {"tool": route_configs["tool"]}, "/tools", required_scopes
-                )
-            )
-            mounts.append(
-                build_component_manager_mount(
-                    {"resource": route_configs["resource"]},
-                    "/resources",
-                    required_scopes,
-                )
-            )
-            mounts.append(
-                build_component_manager_mount(
-                    {"prompt": route_configs["prompt"]}, "/prompts", required_scopes
-                )
-            )
-
-    server._additional_http_routes.extend(routes)
-    server._additional_http_routes.extend(mounts)
-
-
-def make_endpoint(action, component, config):
-    """
-    Factory for creating Starlette endpoint functions for enabling/disabling a component.
-    Args:
-        action: 'enable' or 'disable'
-        component: The component type (e.g., 'tool', 'resource', or 'prompt')
-        config: Dict with param and handler functions for the component
-    Returns:
-        An async endpoint function for Starlette.
-    """
-
-    async def endpoint(request: Request):
-        name = request.path_params[config["param"].split(":")[0]]
+        # With auth - Mount handles path prefix, routes shouldn't have it
+        routes = _build_routes(server, "/")
+        mount = Mount(
+            path if path != "/" else "",
+            app=RequireAuthMiddleware(Starlette(routes=routes), required_scopes),
+        )
+        server._additional_http_routes.append(mount)
+
+
+def _build_routes(server: FastMCP, base_path: str) -> list[Route]:
+    """Build all component management routes."""
+    prefix = base_path.rstrip("/") if base_path != "/" else ""
+
+    return [
+        # Tools
+        Route(
+            f"{prefix}/tools/{{name}}/enable",
+            endpoint=_make_endpoint(server, "tool", "enable"),
+            methods=["POST"],
+        ),
+        Route(
+            f"{prefix}/tools/{{name}}/disable",
+            endpoint=_make_endpoint(server, "tool", "disable"),
+            methods=["POST"],
+        ),
+        # Resources
+        Route(
+            f"{prefix}/resources/{{uri:path}}/enable",
+            endpoint=_make_endpoint(server, "resource", "enable"),
+            methods=["POST"],
+        ),
+        Route(
+            f"{prefix}/resources/{{uri:path}}/disable",
+            endpoint=_make_endpoint(server, "resource", "disable"),
+            methods=["POST"],
+        ),
+        # Prompts
+        Route(
+            f"{prefix}/prompts/{{name}}/enable",
+            endpoint=_make_endpoint(server, "prompt", "enable"),
+            methods=["POST"],
+        ),
+        Route(
+            f"{prefix}/prompts/{{name}}/disable",
+            endpoint=_make_endpoint(server, "prompt", "disable"),
+            methods=["POST"],
+        ),
+    ]
 
-        try:
-            await config[action](name)
-            return JSONResponse(
-                {"message": f"{action.capitalize()}d {component}: {name}"}
-            )
-        except NotFoundError as e:
-            raise StarletteHTTPException(
-                status_code=404,
-                detail=f"Unknown {component}: {name}",
-            ) from e
 
-    return endpoint
+def _make_endpoint(server: FastMCP, component_type: str, action: str):
+    """Create an endpoint function for enabling/disabling a component type."""
 
+    async def endpoint(request: Request) -> JSONResponse:
+        # Get name from path params (tools/prompts use 'name', resources use 'uri')
+        name = request.path_params.get("name") or request.path_params.get("uri")
+        version = request.query_params.get("version")
 
-def make_route(action, component, config, required_scopes, root_path) -> Route:
-    """
-    Creates a Starlette Route for enabling/disabling a component.
-    Args:
-        action: 'enable' or 'disable'
-        component: The component type
-        config: Dict with param and handler functions
-        required_scopes: Optional list of required auth scopes
-        root_path: The base path for the route
-    Returns:
-        A Starlette Route object.
-    """
-    endpoint = make_endpoint(action, component, config)
-
-    if required_scopes is not None and root_path in [
-        "/tools",
-        "/resources",
-        "/prompts",
-    ]:
-        path = f"/{{{config['param']}}}/{action}"
-    else:
-        if root_path != "/" and required_scopes is None:
-            path = f"{root_path}/{component}s/{{{config['param']}}}/{action}"
+        # Map component type to components list
+        # Note: "resource" in the route can refer to either a resource or template
+        # We need to check if it's a template (contains {}) and use "template" if so
+        if component_type == "resource" and name is not None and "{" in name:
+            components = ["template"]
+        elif component_type == "resource":
+            components = ["resource"]
         else:
-            path = f"/{component}s/{{{config['param']}}}/{action}"
-
-    return Route(path, endpoint=endpoint, methods=["POST"])
-
-
-def build_component_manager_endpoints(
-    route_configs, root_path, required_scopes=None
-) -> list[Route]:
-    """
-    Build a list of Starlette Route objects for all components/actions.
-    Args:
-        route_configs: Dict describing component types and their handlers
-        root_path: The base path for the routes
-        required_scopes: Optional list of required auth scopes
-    Returns:
-        List of Starlette Route objects for component management.
-    """
-    component_management_routes: list[Route] = []
+            component_map = {
+                "tool": ["tool"],
+                "prompt": ["prompt"],
+            }
+            components = component_map[component_type]
 
-    for component in route_configs:
-        config: dict[str, Any] = route_configs[component]
-        for action in ["enable", "disable"]:
-            component_management_routes.append(
-                make_route(action, component, config, required_scopes, root_path)
-            )
+        # Call server.enable() or server.disable()
+        method = getattr(server, action)
+        method(names={name} if name else None, version=version, components=components)
 
-    return component_management_routes
+        return JSONResponse(
+            {"message": f"{action.capitalize()}d {component_type}: {name}"}
+        )
 
-
-def build_component_manager_mount(route_configs, root_path, required_scopes) -> Mount:
-    """
-    Build a Starlette Mount with authentication for component management routes.
-    Args:
-        route_configs: Dict describing component types and their handlers
-        root_path: The base path for the mount
-        required_scopes: List of required auth scopes
-    Returns:
-        A Starlette Mount object with authentication middleware.
-    """
-    component_management_routes: list[Route] = []
-
-    for component in route_configs:
-        config: dict[str, Any] = route_configs[component]
-        for action in ["enable", "disable"]:
-            component_management_routes.append(
-                make_route(action, component, config, required_scopes, root_path)
-            )
-
-    return Mount(
-        f"{root_path}",
-        app=RequireAuthMiddleware(
-            Starlette(routes=component_management_routes), required_scopes
-        ),
-    )
+    return endpoint

fastmcp/contrib/component_manager/example.py

@@ -44,7 +44,7 @@ mounted = FastMCP(
 set_up_component_manager(server=mounted, required_scopes=["mounted:write"])
 
 # Mount
-mcp.mount(server=mounted, prefix="mo")
+mcp.mount(server=mounted, namespace="mo")
 
 
 @mcp.resource("resource://greeting")

fastmcp/contrib/mcp_mixin/example.py

@@ -40,11 +40,11 @@ first_sample.register_all(mcp_server=mcp, prefix="first")
 second_sample.register_all(mcp_server=mcp, prefix="second")
 
 
-async def list_components():
+async def list_components() -> None:
     print("MCP Server running with registered components...")
-    print("Tools:", list(await mcp.get_tools()))
-    print("Resources:", list(await mcp.get_resources()))
-    print("Prompts:", list(await mcp.get_prompts()))
+    print("Tools:", list(await mcp.list_tools()))
+    print("Resources:", list(await mcp.list_resources()))
+    print("Prompts:", list(await mcp.list_prompts()))
 
 
 if __name__ == "__main__":

fastmcp/contrib/mcp_mixin/mcp_mixin.py

@@ -1,10 +1,12 @@
 """Provides a base mixin class and decorators for easy registration of class methods with FastMCP."""
 
+import warnings
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
 from mcp.types import Annotations, ToolAnnotations
 
+import fastmcp
 from fastmcp.prompts.prompt import Prompt
 from fastmcp.resources.resource import Resource
 from fastmcp.tools.tool import Tool
@@ -28,11 +30,19 @@ def mcp_tool(
     tags: set[str] | None = None,
     annotations: ToolAnnotations | dict[str, Any] | None = None,
     exclude_args: list[str] | None = None,
-    serializer: Callable[[Any], str] | None = None,
+    serializer: Callable[[Any], str] | None = None,  # Deprecated
     meta: dict[str, Any] | None = None,
     enabled: bool | None = None,
 ) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
     """Decorator to mark a method as an MCP tool for later registration."""
+    if serializer is not None and fastmcp.settings.deprecation_warnings:
+        warnings.warn(
+            "The `serializer` parameter is deprecated. "
+            "Return ToolResult from your tools for full control over serialization. "
+            "See https://gofastmcp.com/servers/tools#custom-serialization for migration examples.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
 
     def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
         call_args = {
@@ -170,7 +180,6 @@ class MCPMixin:
                 serializer=registration_info.get("serializer"),
                 output_schema=registration_info.get("output_schema"),
                 meta=registration_info.get("meta"),
-                enabled=registration_info.get("enabled"),
             )
 
             mcp_server.add_tool(tool)
@@ -210,7 +219,6 @@ class MCPMixin:
                 description=registration_info.get("description"),
                 mime_type=registration_info.get("mime_type"),
                 tags=registration_info.get("tags"),
-                enabled=registration_info.get("enabled"),
                 annotations=registration_info.get("annotations"),
                 meta=registration_info.get("meta"),
             )
@@ -245,7 +253,6 @@ class MCPMixin:
                 title=registration_info.get("title"),
                 description=registration_info.get("description"),
                 tags=registration_info.get("tags"),
-                enabled=registration_info.get("enabled"),
                 meta=registration_info.get("meta"),
             )
             mcp_server.add_prompt(prompt)

fastmcp/decorators.py

@@ -0,0 +1,41 @@
+"""Shared decorator utilities for FastMCP."""
+
+from __future__ import annotations
+
+import inspect
+from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    from fastmcp.prompts.function_prompt import PromptMeta
+    from fastmcp.resources.function_resource import ResourceMeta
+    from fastmcp.server.tasks.config import TaskConfig
+    from fastmcp.tools.function_tool import ToolMeta
+
+    FastMCPMeta = ToolMeta | ResourceMeta | PromptMeta
+
+
+def resolve_task_config(task: bool | TaskConfig | None) -> bool | TaskConfig:
+    """Resolve task config, defaulting None to False."""
+    return task if task is not None else False
+
+
+@runtime_checkable
+class HasFastMCPMeta(Protocol):
+    """Protocol for callables decorated with FastMCP metadata."""
+
+    __fastmcp__: Any
+
+
+def get_fastmcp_meta(fn: Any) -> Any | None:
+    """Extract FastMCP metadata from a function, handling bound methods and wrappers."""
+    if hasattr(fn, "__fastmcp__"):
+        return fn.__fastmcp__
+    if hasattr(fn, "__func__") and hasattr(fn.__func__, "__fastmcp__"):
+        return fn.__func__.__fastmcp__
+    try:
+        unwrapped = inspect.unwrap(fn)
+        if unwrapped is not fn and hasattr(unwrapped, "__fastmcp__"):
+            return unwrapped.__fastmcp__
+    except ValueError:
+        pass
+    return None

fastmcp/dependencies.py

@@ -3,9 +3,18 @@
 This module re-exports dependency injection symbols from Docket and FastMCP
 to provide a clean, centralized import location for all dependency-related
 functionality.
+
+DI features (Depends, CurrentContext, CurrentFastMCP) work without pydocket
+using a vendored DI engine. Only task-related dependencies (CurrentDocket,
+CurrentWorker) and background task execution require fastmcp[tasks].
 """
 
-from docket import Depends
+# Try docket first for isinstance compatibility, fall back to vendored
+try:
+    from docket import Depends
+except ImportError:
+    from fastmcp._vendor.docket_di import Depends
+
 
 from fastmcp.server.dependencies import (
     CurrentContext,
@@ -13,6 +22,7 @@ from fastmcp.server.dependencies import (
     CurrentFastMCP,
     CurrentWorker,
     Progress,
+    ProgressLike,
 )
 
 __all__ = [
@@ -22,4 +32,5 @@ __all__ = [
     "CurrentWorker",
     "Depends",
     "Progress",
+    "ProgressLike",
 ]

fastmcp/exceptions.py

@@ -37,3 +37,7 @@ class NotFoundError(Exception):
 
 class DisabledError(Exception):
     """Object is disabled."""
+
+
+class AuthorizationError(FastMCPError):
+    """Error when authorization check fails."""

fastmcp/experimental/server/openapi/__init__.py

@@ -1,28 +1,31 @@
-"""Deprecated: Import from fastmcp.server.openapi instead."""
+"""Deprecated: Import from fastmcp.server.providers.openapi instead."""
 
 import warnings
 
-from fastmcp.server.openapi import (
-    ComponentFn,
-    DEFAULT_ROUTE_MAPPINGS,
-    FastMCPOpenAPI,
-    MCPType,
-    OpenAPIResource,
-    OpenAPIResourceTemplate,
-    OpenAPITool,
-    RouteMap,
-    RouteMapFn,
-    _determine_route_type,
-)
-
 # Deprecated in 2.14 when OpenAPI support was promoted out of experimental
 warnings.warn(
     "Importing from fastmcp.experimental.server.openapi is deprecated. "
-    "Import from fastmcp.server.openapi instead.",
+    "Import from fastmcp.server.providers.openapi instead.",
     DeprecationWarning,
     stacklevel=2,
 )
 
+# Import from canonical location
+from fastmcp.server.openapi.server import FastMCPOpenAPI as FastMCPOpenAPI  # noqa: E402
+from fastmcp.server.providers.openapi import (  # noqa: E402
+    ComponentFn as ComponentFn,
+    MCPType as MCPType,
+    OpenAPIResource as OpenAPIResource,
+    OpenAPIResourceTemplate as OpenAPIResourceTemplate,
+    OpenAPITool as OpenAPITool,
+    RouteMap as RouteMap,
+    RouteMapFn as RouteMapFn,
+)
+from fastmcp.server.providers.openapi.routing import (  # noqa: E402
+    DEFAULT_ROUTE_MAPPINGS as DEFAULT_ROUTE_MAPPINGS,
+    _determine_route_type as _determine_route_type,
+)
+
 __all__ = [
     "DEFAULT_ROUTE_MAPPINGS",
     "ComponentFn",

fastmcp/mcp_config.py

@@ -95,25 +95,30 @@ class _TransformingMCPServerMixin(FastMCPBaseModel):
         client_name: str | None = None,
     ) -> tuple[FastMCP[Any], ClientTransport]:
         """Turn the Transforming MCPServer into a FastMCP Server and also return the underlying transport."""
-        from fastmcp import FastMCP
         from fastmcp.client import Client
         from fastmcp.client.transports import (
             ClientTransport,  # pyright: ignore[reportUnusedImport]
         )
+        from fastmcp.server import create_proxy
 
         transport: ClientTransport = super().to_transport()  # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue, reportUnknownVariableType]  # ty: ignore[unresolved-attribute]
         transport = cast(ClientTransport, transport)
 
         client: Client[ClientTransport] = Client(transport=transport, name=client_name)
 
-        wrapped_mcp_server = FastMCP.as_proxy(
+        wrapped_mcp_server = create_proxy(
+            client,
             name=server_name,
-            backend=client,
-            tool_transformations=self.tools,
             include_tags=self.include_tags,
             exclude_tags=self.exclude_tags,
         )
 
+        # Apply tool transforms if configured
+        if self.tools:
+            from fastmcp.server.transforms import ToolTransform
+
+            wrapped_mcp_server.add_transform(ToolTransform(self.tools))
+
         return wrapped_mcp_server, transport
 
     def to_transport(self) -> ClientTransport:
@@ -143,6 +148,9 @@ class StdioMCPServer(BaseModel):
     # Execution context
     cwd: str | None = None  # Working directory for command execution
     timeout: int | None = None  # Maximum response time in milliseconds
+    keep_alive: bool | None = (
+        None  # Whether to keep the subprocess alive between connections
+    )
 
     # Metadata
     description: str | None = None  # Human-readable server description
@@ -161,6 +169,7 @@ class StdioMCPServer(BaseModel):
             args=self.args,
             env=self.env,
             cwd=self.cwd,
+            keep_alive=self.keep_alive,
         )
 
 

fastmcp/prompts/__init__.py

@@ -1,9 +1,12 @@
-from .prompt import Prompt, PromptMessage, Message
-from .prompt_manager import PromptManager
+from .function_prompt import FunctionPrompt, prompt
+from .prompt import Message, Prompt, PromptArgument, PromptMessage, PromptResult
 
 __all__ = [
+    "FunctionPrompt",
     "Message",
     "Prompt",
-    "PromptManager",
+    "PromptArgument",
     "PromptMessage",
+    "PromptResult",
+    "prompt",
 ]