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

fastmcp/client/transports.py

@@ -6,9 +6,9 @@ import os
 import shutil
 import sys
 import warnings
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Callable
 from pathlib import Path
-from typing import Any, Literal, TypeVar, cast, overload
+from typing import Any, Literal, TextIO, TypeVar, cast, overload
 
 import anyio
 import httpx
@@ -36,6 +36,7 @@ from fastmcp.client.auth.oauth import OAuth
 from fastmcp.mcp_config import MCPConfig, infer_transport_type_from_url
 from fastmcp.server.dependencies import get_http_headers
 from fastmcp.server.server import FastMCP
+from fastmcp.server.tasks.capabilities import get_task_capabilities
 from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.mcp_server_config.v1.environments.uv import UVEnvironment
 
@@ -46,16 +47,16 @@ ClientTransportT = TypeVar("ClientTransportT", bound="ClientTransport")
 
 __all__ = [
     "ClientTransport",
-    "SSETransport",
-    "StreamableHttpTransport",
-    "StdioTransport",
-    "PythonStdioTransport",
     "FastMCPStdioTransport",
+    "FastMCPTransport",
     "NodeStdioTransport",
-    "UvxStdioTransport",
-    "UvStdioTransport",
     "NpxStdioTransport",
-    "FastMCPTransport",
+    "PythonStdioTransport",
+    "SSETransport",
+    "StdioTransport",
+    "StreamableHttpTransport",
+    "UvStdioTransport",
+    "UvxStdioTransport",
     "infer_transport",
 ]
 
@@ -109,9 +110,8 @@ class ClientTransport(abc.ABC):
         # Basic representation for subclasses
         return f"<{self.__class__.__name__}>"
 
-    async def close(self):
+    async def close(self):  # noqa: B027
         """Close the transport."""
-        pass
 
     def _set_auth(self, auth: httpx.Auth | Literal["oauth"] | str | None):
         if auth is not None:
@@ -141,10 +141,10 @@ class WSTransport(ClientTransport):
     ) -> AsyncIterator[ClientSession]:
         try:
             from mcp.client.websocket import websocket_client
-        except ImportError:
+        except ImportError as e:
             raise ImportError(
                 "The websocket transport is not available. Please install fastmcp[websockets] or install the websockets package manually."
-            )
+            ) from e
 
         async with websocket_client(self.url) as transport:
             read_stream, write_stream = transport
@@ -178,8 +178,8 @@ class SSETransport(ClientTransport):
 
         self.url = url
         self.headers = headers or {}
-        self._set_auth(auth)
         self.httpx_client_factory = httpx_client_factory
+        self._set_auth(auth)
 
         if isinstance(sse_read_timeout, int | float):
             sse_read_timeout = datetime.timedelta(seconds=float(sse_read_timeout))
@@ -187,7 +187,7 @@ class SSETransport(ClientTransport):
 
     def _set_auth(self, auth: httpx.Auth | Literal["oauth"] | str | None):
         if auth == "oauth":
-            auth = OAuth(self.url)
+            auth = OAuth(self.url, httpx_client_factory=self.httpx_client_factory)
         elif isinstance(auth, str):
             auth = BearerAuth(auth)
         self.auth = auth
@@ -207,7 +207,7 @@ class SSETransport(ClientTransport):
         # instead we simply leave the kwarg out if it's not provided
         if self.sse_read_timeout is not None:
             client_kwargs["sse_read_timeout"] = self.sse_read_timeout.total_seconds()
-        if session_kwargs.get("read_timeout_seconds", None) is not None:
+        if session_kwargs.get("read_timeout_seconds") is not None:
             read_timeout_seconds = cast(
                 datetime.timedelta, session_kwargs.get("read_timeout_seconds")
             )
@@ -248,16 +248,18 @@ class StreamableHttpTransport(ClientTransport):
 
         self.url = url
         self.headers = headers or {}
-        self._set_auth(auth)
         self.httpx_client_factory = httpx_client_factory
+        self._set_auth(auth)
 
         if isinstance(sse_read_timeout, int | float):
             sse_read_timeout = datetime.timedelta(seconds=float(sse_read_timeout))
         self.sse_read_timeout = sse_read_timeout
 
+        self._get_session_id_cb: Callable[[], str | None] | None = None
+
     def _set_auth(self, auth: httpx.Auth | Literal["oauth"] | str | None):
         if auth == "oauth":
-            auth = OAuth(self.url)
+            auth = OAuth(self.url, httpx_client_factory=self.httpx_client_factory)
         elif isinstance(auth, str):
             auth = BearerAuth(auth)
         self.auth = auth
@@ -277,7 +279,7 @@ class StreamableHttpTransport(ClientTransport):
         # instead we simply leave the kwarg out if it's not provided
         if self.sse_read_timeout is not None:
             client_kwargs["sse_read_timeout"] = self.sse_read_timeout
-        if session_kwargs.get("read_timeout_seconds", None) is not None:
+        if session_kwargs.get("read_timeout_seconds") is not None:
             client_kwargs["timeout"] = session_kwargs.get("read_timeout_seconds")
 
         if self.httpx_client_factory is not None:
@@ -288,12 +290,25 @@ class StreamableHttpTransport(ClientTransport):
             auth=self.auth,
             **client_kwargs,
         ) as transport:
-            read_stream, write_stream, _ = transport
+            read_stream, write_stream, get_session_id = transport
+            self._get_session_id_cb = get_session_id
             async with ClientSession(
                 read_stream, write_stream, **session_kwargs
             ) as session:
                 yield session
 
+    def get_session_id(self) -> str | None:
+        if self._get_session_id_cb:
+            try:
+                return self._get_session_id_cb()
+            except Exception:
+                return None
+        return None
+
+    async def close(self):
+        # Reset the session id callback
+        self._get_session_id_cb = None
+
     def __repr__(self) -> str:
         return f"<StreamableHttpTransport(url='{self.url}')>"
 
@@ -313,6 +328,7 @@ class StdioTransport(ClientTransport):
         env: dict[str, str] | None = None,
         cwd: str | None = None,
         keep_alive: bool | None = None,
+        log_file: Path | TextIO | None = None,
     ):
         """
         Initialize a Stdio transport.
@@ -326,6 +342,11 @@ class StdioTransport(ClientTransport):
                        Defaults to True. When True, the subprocess remains active
                        after the connection context exits, allowing reuse in
                        subsequent connections.
+            log_file: Optional path or file-like object where subprocess stderr will
+                   be written. Can be a Path or TextIO object. Defaults to sys.stderr
+                   if not provided. When a Path is provided, the file will be created
+                   if it doesn't exist, or appended to if it does. When set, server
+                   errors will be written to this file instead of appearing in the console.
         """
         self.command = command
         self.args = args
@@ -334,6 +355,7 @@ class StdioTransport(ClientTransport):
         if keep_alive is None:
             keep_alive = True
         self.keep_alive = keep_alive
+        self.log_file = log_file
 
         self._session: ClientSession | None = None
         self._connect_task: asyncio.Task | None = None
@@ -368,7 +390,9 @@ class StdioTransport(ClientTransport):
                 args=self.args,
                 env=self.env,
                 cwd=self.cwd,
-                session_kwargs=session_kwargs,
+                log_file=self.log_file,
+                # TODO(ty): remove when ty supports Unpack[TypedDict] inference
+                session_kwargs=session_kwargs,  # type: ignore[arg-type]
                 ready_event=self._ready_event,
                 stop_event=self._stop_event,
                 session_future=session_future,
@@ -421,6 +445,7 @@ async def _stdio_transport_connect_task(
     args: list[str],
     env: dict[str, str] | None,
     cwd: str | None,
+    log_file: Path | TextIO | None,
     session_kwargs: SessionKwargs,
     ready_event: anyio.Event,
     stop_event: anyio.Event,
@@ -438,7 +463,18 @@ async def _stdio_transport_connect_task(
                     env=env,
                     cwd=cwd,
                 )
-                transport = await stack.enter_async_context(stdio_client(server_params))
+                # Handle log_file: Path needs to be opened, TextIO used as-is
+                if log_file is None:
+                    log_file_handle = sys.stderr
+                elif isinstance(log_file, Path):
+                    log_file_handle = stack.enter_context(log_file.open("a"))
+                else:
+                    # Must be TextIO - use it directly
+                    log_file_handle = log_file
+
+                transport = await stack.enter_async_context(
+                    stdio_client(server_params, errlog=log_file_handle)
+                )
                 read_stream, write_stream = transport
                 session_future.set_result(
                     await stack.enter_async_context(
@@ -471,6 +507,7 @@ class PythonStdioTransport(StdioTransport):
         cwd: str | None = None,
         python_cmd: str = sys.executable,
         keep_alive: bool | None = None,
+        log_file: Path | TextIO | None = None,
     ):
         """
         Initialize a Python transport.
@@ -485,6 +522,11 @@ class PythonStdioTransport(StdioTransport):
                        Defaults to True. When True, the subprocess remains active
                        after the connection context exits, allowing reuse in
                        subsequent connections.
+            log_file: Optional path or file-like object where subprocess stderr will
+                   be written. Can be a Path or TextIO object. Defaults to sys.stderr
+                   if not provided. When a Path is provided, the file will be created
+                   if it doesn't exist, or appended to if it does. When set, server
+                   errors will be written to this file instead of appearing in the console.
         """
         script_path = Path(script_path).resolve()
         if not script_path.is_file():
@@ -502,6 +544,7 @@ class PythonStdioTransport(StdioTransport):
             env=env,
             cwd=cwd,
             keep_alive=keep_alive,
+            log_file=log_file,
         )
         self.script_path = script_path
 
@@ -516,6 +559,7 @@ class FastMCPStdioTransport(StdioTransport):
         env: dict[str, str] | None = None,
         cwd: str | None = None,
         keep_alive: bool | None = None,
+        log_file: Path | TextIO | None = None,
     ):
         script_path = Path(script_path).resolve()
         if not script_path.is_file():
@@ -529,6 +573,7 @@ class FastMCPStdioTransport(StdioTransport):
             env=env,
             cwd=cwd,
             keep_alive=keep_alive,
+            log_file=log_file,
         )
         self.script_path = script_path
 
@@ -544,6 +589,7 @@ class NodeStdioTransport(StdioTransport):
         cwd: str | None = None,
         node_cmd: str = "node",
         keep_alive: bool | None = None,
+        log_file: Path | TextIO | None = None,
     ):
         """
         Initialize a Node transport.
@@ -558,6 +604,11 @@ class NodeStdioTransport(StdioTransport):
                        Defaults to True. When True, the subprocess remains active
                        after the connection context exits, allowing reuse in
                        subsequent connections.
+            log_file: Optional path or file-like object where subprocess stderr will
+                   be written. Can be a Path or TextIO object. Defaults to sys.stderr
+                   if not provided. When a Path is provided, the file will be created
+                   if it doesn't exist, or appended to if it does. When set, server
+                   errors will be written to this file instead of appearing in the console.
         """
         script_path = Path(script_path).resolve()
         if not script_path.is_file():
@@ -570,7 +621,12 @@ class NodeStdioTransport(StdioTransport):
             full_args.extend(args)
 
         super().__init__(
-            command=node_cmd, args=full_args, env=env, cwd=cwd, keep_alive=keep_alive
+            command=node_cmd,
+            args=full_args,
+            env=env,
+            cwd=cwd,
+            keep_alive=keep_alive,
+            log_file=log_file,
         )
         self.script_path = script_path
 
@@ -583,15 +639,15 @@ class UvStdioTransport(StdioTransport):
         command: str,
         args: list[str] | None = None,
         module: bool = False,
-        project_directory: str | None = None,
+        project_directory: Path | None = None,
         python_version: str | None = None,
         with_packages: list[str] | None = None,
-        with_requirements: str | None = None,
+        with_requirements: Path | None = None,
         env_vars: dict[str, str] | None = None,
         keep_alive: bool | None = None,
     ):
         # Basic validation
-        if project_directory and not Path(project_directory).exists():
+        if project_directory and not project_directory.exists():
             raise NotADirectoryError(
                 f"Project directory not found: {project_directory}"
             )
@@ -707,6 +763,7 @@ class UvxStdioTransport(StdioTransport):
         env: dict[str, str] | None = None
         if env_vars:
             env = os.environ.copy()
+            env.update(env_vars)
 
         super().__init__(
             command="uvx",
@@ -809,13 +866,25 @@ class FastMCPTransport(ClientTransport):
             client_read, client_write = client_streams
             server_read, server_write = server_streams
 
-            # Create a cancel scope for the server task
-            async with anyio.create_task_group() as tg:
+            # Capture exceptions to re-raise after task group cleanup.
+            # anyio task groups can suppress exceptions when cancel_scope.cancel()
+            # is called during cleanup, so we capture and re-raise manually.
+            exception_to_raise: BaseException | None = None
+
+            async with (
+                anyio.create_task_group() as tg,
+                _enter_server_lifespan(server=self.server),
+            ):
+                # Build experimental capabilities
+                experimental_capabilities = get_task_capabilities()
+
                 tg.start_soon(
                     lambda: self.server._mcp_server.run(
                         server_read,
                         server_write,
-                        self.server._mcp_server.create_initialization_options(),
+                        self.server._mcp_server.create_initialization_options(
+                            experimental_capabilities=experimental_capabilities
+                        ),
                         raise_exceptions=self.raise_exceptions,
                     )
                 )
@@ -827,13 +896,31 @@ class FastMCPTransport(ClientTransport):
                         **session_kwargs,
                     ) as client_session:
                         yield client_session
+                except BaseException as e:
+                    exception_to_raise = e
                 finally:
                     tg.cancel_scope.cancel()
 
+            # Re-raise after task group has exited cleanly
+            if exception_to_raise is not None:
+                raise exception_to_raise
+
     def __repr__(self) -> str:
         return f"<FastMCPTransport(server='{self.server.name}')>"
 
 
+@contextlib.asynccontextmanager
+async def _enter_server_lifespan(
+    server: FastMCP | FastMCP1Server,
+) -> AsyncIterator[None]:
+    """Enters the server's lifespan context for FastMCP servers and does nothing for FastMCP 1 servers."""
+    if isinstance(server, FastMCP):
+        async with server._lifespan_manager():
+            yield
+    else:
+        yield
+
+
 class MCPConfigTransport(ClientTransport):
     """Transport for connecting to one or more MCP servers defined in an MCPConfig.
 
@@ -897,7 +984,7 @@ class MCPConfigTransport(ClientTransport):
 
         # if there's exactly one server, create a client for that server
         elif len(self.config.mcpServers) == 1:
-            self.transport = list(self.config.mcpServers.values())[0].to_transport()
+            self.transport = next(iter(self.config.mcpServers.values())).to_transport()
             self._underlying_transports.append(self.transport)
 
         # otherwise create a composite client

fastmcp/contrib/component_manager/__init__.py

@@ -1,4 +1,4 @@
 from .component_manager import set_up_component_manager
 from .component_service import ComponentService
 
-__all__ = ["set_up_component_manager", "ComponentService"]
+__all__ = ["ComponentService", "set_up_component_manager"]

fastmcp/contrib/component_manager/component_manager.py

@@ -97,11 +97,11 @@ def make_endpoint(action, component, config):
             return JSONResponse(
                 {"message": f"{action.capitalize()}d {component}: {name}"}
             )
-        except NotFoundError:
+        except NotFoundError as e:
             raise StarletteHTTPException(
                 status_code=404,
                 detail=f"Unknown {component}: {name}",
-            )
+            ) from e
 
     return endpoint
 

fastmcp/contrib/component_manager/component_service.py

@@ -41,7 +41,7 @@ class ComponentService:
             return tool
 
         # 2. Check mounted servers using the filtered protocol path.
-        for mounted in reversed(self._tool_manager._mounted_servers):
+        for mounted in reversed(self._server._mounted_servers):
             if mounted.prefix:
                 if key.startswith(f"{mounted.prefix}_"):
                     tool_key = key.removeprefix(f"{mounted.prefix}_")
@@ -70,7 +70,7 @@ class ComponentService:
             return tool
 
         # 2. Check mounted servers using the filtered protocol path.
-        for mounted in reversed(self._tool_manager._mounted_servers):
+        for mounted in reversed(self._server._mounted_servers):
             if mounted.prefix:
                 if key.startswith(f"{mounted.prefix}_"):
                     tool_key = key.removeprefix(f"{mounted.prefix}_")
@@ -103,18 +103,10 @@ class ComponentService:
             return template
 
         # 2. Check mounted servers using the filtered protocol path.
-        for mounted in reversed(self._resource_manager._mounted_servers):
+        for mounted in reversed(self._server._mounted_servers):
             if mounted.prefix:
-                if has_resource_prefix(
-                    key,
-                    mounted.prefix,
-                    mounted.resource_prefix_format,
-                ):
-                    key = remove_resource_prefix(
-                        key,
-                        mounted.prefix,
-                        mounted.resource_prefix_format,
-                    )
+                if has_resource_prefix(key, mounted.prefix):
+                    key = remove_resource_prefix(key, mounted.prefix)
                     mounted_service = ComponentService(mounted.server)
                     mounted_resource: (
                         Resource | ResourceTemplate
@@ -146,18 +138,10 @@ class ComponentService:
             return template
 
         # 2. Check mounted servers using the filtered protocol path.
-        for mounted in reversed(self._resource_manager._mounted_servers):
+        for mounted in reversed(self._server._mounted_servers):
             if mounted.prefix:
-                if has_resource_prefix(
-                    key,
-                    mounted.prefix,
-                    mounted.resource_prefix_format,
-                ):
-                    key = remove_resource_prefix(
-                        key,
-                        mounted.prefix,
-                        mounted.resource_prefix_format,
-                    )
+                if has_resource_prefix(key, mounted.prefix):
+                    key = remove_resource_prefix(key, mounted.prefix)
                     mounted_service = ComponentService(mounted.server)
                     mounted_resource: (
                         Resource | ResourceTemplate
@@ -185,7 +169,7 @@ class ComponentService:
             return prompt
 
         # 2. Check mounted servers using the filtered protocol path.
-        for mounted in reversed(self._prompt_manager._mounted_servers):
+        for mounted in reversed(self._server._mounted_servers):
             if mounted.prefix:
                 if key.startswith(f"{mounted.prefix}_"):
                     prompt_key = key.removeprefix(f"{mounted.prefix}_")
@@ -213,7 +197,7 @@ class ComponentService:
             return prompt
 
         # 2. Check mounted servers using the filtered protocol path.
-        for mounted in reversed(self._prompt_manager._mounted_servers):
+        for mounted in reversed(self._server._mounted_servers):
             if mounted.prefix:
                 if key.startswith(f"{mounted.prefix}_"):
                     prompt_key = key.removeprefix(f"{mounted.prefix}_")

fastmcp/contrib/mcp_mixin/README.md

@@ -11,12 +11,15 @@ Tools:
 * [enable/disable](https://gofastmcp.com/servers/tools#disabling-tools)
 * [annotations](https://gofastmcp.com/servers/tools#annotations-2)
 * [excluded arguments](https://gofastmcp.com/servers/tools#excluding-arguments)
+* [meta](https://gofastmcp.com/servers/tools#param-meta)
 
 Prompts:
 * [enable/disable](https://gofastmcp.com/servers/prompts#disabling-prompts)
+* [meta](https://gofastmcp.com/servers/prompts#param-meta)
 
 Resources:
 * [enable/disable](https://gofastmcp.com/servers/resources#disabling-resources)
+* [meta](https://gofastmcp.com/servers/resources#param-meta)
   
 ## Usage
 
@@ -78,7 +81,16 @@ class MyComponent(MCPMixin):
         if delete_all:
             return "99 records deleted. I bet you're not a tool :)"
         return "Tool executed, but you might be a tool!"
-    
+
+    # example tool w/ meta
+    @mcp_tool(
+        name="data_tool",
+        description="Fetches user data from database",
+        meta={"version": "2.0", "category": "database", "author": "dev-team"}
+    )
+    def data_tool_method(self, user_id: int):
+        return f"Fetching data for user {user_id}"
+
     @mcp_resource(uri="component://data")
     def resource_method(self):
         return {"data": "some data"}
@@ -88,6 +100,15 @@ class MyComponent(MCPMixin):
     def resource_method(self):
         return {"data": "some data"}
 
+    # example resource w/meta and title
+    @mcp_resource(
+        uri="component://config",
+        title="Data resource Title,
+        meta={"internal": True, "cache_ttl": 3600, "priority": "high"}
+    )
+    def config_resource_method(self):
+        return {"config": "data"}
+
     # prompt
     @mcp_prompt(name="A prompt")
     def prompt_method(self, name):
@@ -98,6 +119,16 @@ class MyComponent(MCPMixin):
     def prompt_method(self, name):
         return f"What's up {name}?"
 
+    # example prompt w/title and meta
+    @mcp_prompt(
+        name="analysis_prompt",
+        title="Data Analysis Prompt",
+        description="Analyzes data patterns",
+        meta={"complexity": "high", "domain": "analytics", "requires_context": True}
+    )
+    def analysis_prompt_method(self, dataset: str):
+        return f"Analyze the patterns in {dataset}"
+
 mcp_server = FastMCP()
 component = MyComponent()
 

fastmcp/contrib/mcp_mixin/__init__.py

@@ -2,7 +2,7 @@ from .mcp_mixin import MCPMixin, mcp_tool, mcp_resource, mcp_prompt
 
 __all__ = [
     "MCPMixin",
-    "mcp_tool",
-    "mcp_resource",
     "mcp_prompt",
+    "mcp_resource",
+    "mcp_tool",
 ]

fastmcp/contrib/mcp_mixin/mcp_mixin.py

@@ -3,7 +3,7 @@
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
-from mcp.types import ToolAnnotations
+from mcp.types import Annotations, ToolAnnotations
 
 from fastmcp.prompts.prompt import Prompt
 from fastmcp.resources.resource import Resource
@@ -29,6 +29,7 @@ def mcp_tool(
     annotations: ToolAnnotations | dict[str, Any] | None = None,
     exclude_args: list[str] | None = None,
     serializer: Callable[[Any], str] | None = None,
+    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."""
@@ -41,6 +42,7 @@ def mcp_tool(
             "annotations": annotations,
             "exclude_args": exclude_args,
             "serializer": serializer,
+            "meta": meta,
             "enabled": enabled,
         }
         call_args = {k: v for k, v in call_args.items() if v is not None}
@@ -54,9 +56,12 @@ def mcp_resource(
     uri: str,
     *,
     name: str | None = None,
+    title: str | None = None,
     description: str | None = None,
     mime_type: str | None = None,
     tags: set[str] | None = None,
+    annotations: Annotations | None = None,
+    meta: dict[str, Any] | None = None,
     enabled: bool | None = None,
 ) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
     """Decorator to mark a method as an MCP resource for later registration."""
@@ -65,9 +70,12 @@ def mcp_resource(
         call_args = {
             "uri": uri,
             "name": name or get_fn_name(func),
+            "title": title,
             "description": description,
             "mime_type": mime_type,
             "tags": tags,
+            "annotations": annotations,
+            "meta": meta,
             "enabled": enabled,
         }
         call_args = {k: v for k, v in call_args.items() if v is not None}
@@ -81,8 +89,10 @@ def mcp_resource(
 
 def mcp_prompt(
     name: str | None = None,
+    title: str | None = None,
     description: str | None = None,
     tags: set[str] | None = None,
+    meta: dict[str, Any] | None = None,
     enabled: bool | None = None,
 ) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
     """Decorator to mark a method as an MCP prompt for later registration."""
@@ -90,8 +100,10 @@ def mcp_prompt(
     def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
         call_args = {
             "name": name or get_fn_name(func),
+            "title": title,
             "description": description,
             "tags": tags,
+            "meta": meta,
             "enabled": enabled,
         }
 
@@ -151,7 +163,6 @@ class MCPMixin:
             tool = Tool.from_function(
                 fn=method,
                 name=registration_info.get("name"),
-                title=registration_info.get("title"),
                 description=registration_info.get("description"),
                 tags=registration_info.get("tags"),
                 annotations=registration_info.get("annotations"),
@@ -195,6 +206,7 @@ class MCPMixin:
                 fn=method,
                 uri=registration_info["uri"],
                 name=registration_info.get("name"),
+                title=registration_info.get("title"),
                 description=registration_info.get("description"),
                 mime_type=registration_info.get("mime_type"),
                 tags=registration_info.get("tags"),

fastmcp/dependencies.py

@@ -0,0 +1,25 @@
+"""Dependency injection exports for FastMCP.
+
+This module re-exports dependency injection symbols from Docket and FastMCP
+to provide a clean, centralized import location for all dependency-related
+functionality.
+"""
+
+from docket import Depends
+
+from fastmcp.server.dependencies import (
+    CurrentContext,
+    CurrentDocket,
+    CurrentFastMCP,
+    CurrentWorker,
+    Progress,
+)
+
+__all__ = [
+    "CurrentContext",
+    "CurrentDocket",
+    "CurrentFastMCP",
+    "CurrentWorker",
+    "Depends",
+    "Progress",
+]