fastmcp 2.10.6__py3-none-any.whl → 2.11.1__py3-none-any.whl

fastmcp/server/server.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import datetime
 import inspect
 import re
 import warnings
@@ -25,7 +24,9 @@ from mcp.server.lowlevel.helper_types import ReadResourceContents
 from mcp.server.lowlevel.server import LifespanResultT, NotificationOptions
 from mcp.server.stdio import stdio_server
 from mcp.types import (
+    Annotations,
     AnyFunction,
+    CallToolRequestParams,
     ContentBlock,
     GetPromptResult,
     ToolAnnotations,
@@ -48,8 +49,8 @@ from fastmcp.prompts import Prompt, PromptManager
 from fastmcp.prompts.prompt import FunctionPrompt
 from fastmcp.resources import Resource, ResourceManager
 from fastmcp.resources.template import ResourceTemplate
-from fastmcp.server.auth.auth import OAuthProvider
-from fastmcp.server.auth.providers.bearer_env import EnvBearerAuthProvider
+from fastmcp.server.auth.auth import AuthProvider
+from fastmcp.server.auth.registry import get_registered_provider
 from fastmcp.server.http import (
     StarletteWithLifespan,
     create_sse_app,
@@ -60,7 +61,7 @@ from fastmcp.server.middleware import Middleware, MiddlewareContext
 from fastmcp.settings import Settings
 from fastmcp.tools import ToolManager
 from fastmcp.tools.tool import FunctionTool, Tool, ToolResult
-from fastmcp.utilities.cache import TimedCache
+from fastmcp.tools.tool_transform import ToolTransformConfig
 from fastmcp.utilities.cli import log_server_banner
 from fastmcp.utilities.components import FastMCPComponent
 from fastmcp.utilities.logging import get_logger
@@ -69,10 +70,19 @@ from fastmcp.utilities.types import NotSet, NotSetT
 if TYPE_CHECKING:
     from fastmcp.client import Client
     from fastmcp.client.transports import ClientTransport, ClientTransportT
+    from fastmcp.experimental.server.openapi import FastMCPOpenAPI as FastMCPOpenAPINew
+    from fastmcp.experimental.server.openapi.routing import (
+        ComponentFn as OpenAPIComponentFnNew,
+    )
+    from fastmcp.experimental.server.openapi.routing import RouteMap as RouteMapNew
+    from fastmcp.experimental.server.openapi.routing import (
+        RouteMapFn as OpenAPIRouteMapFnNew,
+    )
     from fastmcp.server.openapi import ComponentFn as OpenAPIComponentFn
     from fastmcp.server.openapi import FastMCPOpenAPI, RouteMap
     from fastmcp.server.openapi import RouteMapFn as OpenAPIRouteMapFn
     from fastmcp.server.proxy import FastMCPProxy
+
 logger = get_logger(__name__)
 
 DuplicateBehavior = Literal["warn", "error", "replace", "ignore"]
@@ -121,7 +131,7 @@ class FastMCP(Generic[LifespanResultT]):
         instructions: str | None = None,
         *,
         version: str | None = None,
-        auth: OAuthProvider | None = None,
+        auth: AuthProvider | None | NotSetT = NotSet,
         middleware: list[Middleware] | None = None,
         lifespan: (
             Callable[
@@ -138,9 +148,11 @@ class FastMCP(Generic[LifespanResultT]):
         resource_prefix_format: Literal["protocol", "path"] | None = None,
         mask_error_details: bool | None = None,
         tools: list[Tool | Callable[..., Any]] | None = None,
+        tool_transformations: dict[str, ToolTransformConfig] | None = None,
         dependencies: list[str] | None = None,
         include_tags: set[str] | None = None,
         exclude_tags: set[str] | None = None,
+        include_fastmcp_meta: bool | None = None,
         # ---
         # ---
         # --- The following arguments are DEPRECATED ---
@@ -160,13 +172,11 @@ class FastMCP(Generic[LifespanResultT]):
             resource_prefix_format or fastmcp.settings.resource_prefix_format
         )
 
-        self._cache = TimedCache(
-            expiration=datetime.timedelta(seconds=cache_expiration_seconds or 0)
-        )
         self._additional_http_routes: list[BaseRoute] = []
         self._tool_manager = ToolManager(
             duplicate_behavior=on_duplicate_tools,
             mask_error_details=mask_error_details,
+            transformations=tool_transformations,
         )
         self._resource_manager = ResourceManager(
             duplicate_behavior=on_duplicate_resources,
@@ -190,9 +200,14 @@ class FastMCP(Generic[LifespanResultT]):
             lifespan=_lifespan_wrapper(self, lifespan),
         )
 
-        if auth is None and fastmcp.settings.default_auth_provider == "bearer_env":
-            auth = EnvBearerAuthProvider()
-        self.auth = auth
+        # if auth is `NotSet`, try to create a provider from the environment
+        if auth is NotSet:
+            if fastmcp.settings.server_auth is not None:
+                provider_cls = get_registered_provider(fastmcp.settings.server_auth)
+                auth = provider_cls()
+            else:
+                auth = None
+        self.auth = cast(AuthProvider | None, auth)
 
         if tools:
             for tool in tools:
@@ -209,6 +224,12 @@ class FastMCP(Generic[LifespanResultT]):
         self._setup_handlers()
         self.dependencies = dependencies or fastmcp.settings.server_dependencies
 
+        self.include_fastmcp_meta = (
+            include_fastmcp_meta
+            if include_fastmcp_meta is not None
+            else fastmcp.settings.include_fastmcp_meta
+        )
+
         # handle deprecated settings
         self._handle_deprecated_settings(
             log_level=log_level,
@@ -407,7 +428,10 @@ class FastMCP(Generic[LifespanResultT]):
         methods: list[str],
         name: str | None = None,
         include_in_schema: bool = True,
-    ):
+    ) -> Callable[
+        [Callable[[Request], Awaitable[Response]]],
+        Callable[[Request], Awaitable[Response]],
+    ]:
         """
         Decorator to register a custom HTTP route on the FastMCP server.
 
@@ -453,7 +477,13 @@ class FastMCP(Generic[LifespanResultT]):
 
         async with fastmcp.server.context.Context(fastmcp=self):
             tools = await self._list_tools()
-            return [tool.to_mcp_tool(name=tool.key) for tool in tools]
+            return [
+                tool.to_mcp_tool(
+                    name=tool.key,
+                    include_fastmcp_meta=self.include_fastmcp_meta,
+                )
+                for tool in tools
+            ]
 
     async def _list_tools(self) -> list[Tool]:
         """
@@ -492,7 +522,11 @@ class FastMCP(Generic[LifespanResultT]):
         async with fastmcp.server.context.Context(fastmcp=self):
             resources = await self._list_resources()
             return [
-                resource.to_mcp_resource(uri=resource.key) for resource in resources
+                resource.to_mcp_resource(
+                    uri=resource.key,
+                    include_fastmcp_meta=self.include_fastmcp_meta,
+                )
+                for resource in resources
             ]
 
     async def _list_resources(self) -> list[Resource]:
@@ -533,7 +567,10 @@ class FastMCP(Generic[LifespanResultT]):
         async with fastmcp.server.context.Context(fastmcp=self):
             templates = await self._list_resource_templates()
             return [
-                template.to_mcp_template(uriTemplate=template.key)
+                template.to_mcp_template(
+                    uriTemplate=template.key,
+                    include_fastmcp_meta=self.include_fastmcp_meta,
+                )
                 for template in templates
             ]
 
@@ -574,7 +611,13 @@ class FastMCP(Generic[LifespanResultT]):
 
         async with fastmcp.server.context.Context(fastmcp=self):
             prompts = await self._list_prompts()
-            return [prompt.to_mcp_prompt(name=prompt.key) for prompt in prompts]
+            return [
+                prompt.to_mcp_prompt(
+                    name=prompt.key,
+                    include_fastmcp_meta=self.include_fastmcp_meta,
+                )
+                for prompt in prompts
+            ]
 
     async def _list_prompts(self) -> list[Prompt]:
         """
@@ -650,7 +693,7 @@ class FastMCP(Generic[LifespanResultT]):
                 key=context.message.name, arguments=context.message.arguments or {}
             )
 
-        mw_context = MiddlewareContext(
+        mw_context = MiddlewareContext[CallToolRequestParams](
             message=mcp.types.CallToolRequestParams(name=key, arguments=arguments),
             source="client",
             type="request",
@@ -772,7 +815,6 @@ class FastMCP(Generic[LifespanResultT]):
             The tool instance that was added to the server.
         """
         self._tool_manager.add_tool(tool)
-        self._cache.clear()
 
         # Send notification if we're in a request context
         try:
@@ -795,7 +837,6 @@ class FastMCP(Generic[LifespanResultT]):
             NotFoundError: If the tool is not found
         """
         self._tool_manager.remove_tool(name)
-        self._cache.clear()
 
         # Send notification if we're in a request context
         try:
@@ -806,6 +847,16 @@ class FastMCP(Generic[LifespanResultT]):
         except RuntimeError:
             pass  # No context available
 
+    def add_tool_transformation(
+        self, tool_name: str, transformation: ToolTransformConfig
+    ) -> None:
+        """Add a tool transformation."""
+        self._tool_manager.add_tool_transformation(tool_name, transformation)
+
+    def remove_tool_transformation(self, tool_name: str) -> None:
+        """Remove a tool transformation."""
+        self._tool_manager.remove_tool_transformation(tool_name)
+
     @overload
     def tool(
         self,
@@ -818,6 +869,7 @@ class FastMCP(Generic[LifespanResultT]):
         output_schema: dict[str, Any] | None | NotSetT = NotSet,
         annotations: ToolAnnotations | dict[str, Any] | None = None,
         exclude_args: list[str] | None = None,
+        meta: dict[str, Any] | None = None,
         enabled: bool | None = None,
     ) -> FunctionTool: ...
 
@@ -833,6 +885,7 @@ class FastMCP(Generic[LifespanResultT]):
         output_schema: dict[str, Any] | None | NotSetT = NotSet,
         annotations: ToolAnnotations | dict[str, Any] | None = None,
         exclude_args: list[str] | None = None,
+        meta: dict[str, Any] | None = None,
         enabled: bool | None = None,
     ) -> Callable[[AnyFunction], FunctionTool]: ...
 
@@ -847,6 +900,7 @@ class FastMCP(Generic[LifespanResultT]):
         output_schema: dict[str, Any] | None | NotSetT = NotSet,
         annotations: ToolAnnotations | dict[str, Any] | None = None,
         exclude_args: list[str] | None = None,
+        meta: dict[str, Any] | None = None,
         enabled: bool | None = None,
     ) -> Callable[[AnyFunction], FunctionTool] | FunctionTool:
         """Decorator to register a tool.
@@ -870,6 +924,7 @@ class FastMCP(Generic[LifespanResultT]):
             output_schema: Optional JSON schema for the tool's output
             annotations: Optional annotations about the tool's behavior
             exclude_args: Optional list of argument names to exclude from the tool schema
+            meta: Optional meta information about the tool
             enabled: Optional boolean to enable or disable the tool
 
         Examples:
@@ -928,6 +983,7 @@ class FastMCP(Generic[LifespanResultT]):
                 output_schema=output_schema,
                 annotations=annotations,
                 exclude_args=exclude_args,
+                meta=meta,
                 serializer=self._tool_serializer,
                 enabled=enabled,
             )
@@ -960,6 +1016,7 @@ class FastMCP(Generic[LifespanResultT]):
             output_schema=output_schema,
             annotations=annotations,
             exclude_args=exclude_args,
+            meta=meta,
             enabled=enabled,
         )
 
@@ -973,7 +1030,6 @@ class FastMCP(Generic[LifespanResultT]):
             The resource instance that was added to the server.
         """
         self._resource_manager.add_resource(resource)
-        self._cache.clear()
 
         # Send notification if we're in a request context
         try:
@@ -1045,7 +1101,6 @@ class FastMCP(Generic[LifespanResultT]):
             mime_type=mime_type,
             tags=tags,
         )
-        self._cache.clear()
 
     def resource(
         self,
@@ -1057,6 +1112,8 @@ class FastMCP(Generic[LifespanResultT]):
         mime_type: str | None = None,
         tags: set[str] | None = None,
         enabled: bool | None = None,
+        annotations: Annotations | dict[str, Any] | None = None,
+        meta: dict[str, Any] | None = None,
     ) -> Callable[[AnyFunction], Resource | ResourceTemplate]:
         """Decorator to register a function as a resource.
 
@@ -1080,6 +1137,8 @@ class FastMCP(Generic[LifespanResultT]):
             mime_type: Optional MIME type for the resource
             tags: Optional set of tags for categorizing the resource
             enabled: Optional boolean to enable or disable the resource
+            annotations: Optional annotations about the resource's behavior
+            meta: Optional meta information about the resource
 
         Examples:
             Register a resource with a custom name:
@@ -1108,6 +1167,9 @@ class FastMCP(Generic[LifespanResultT]):
                 return f"Weather for {city}: {data}"
             ```
         """
+        if isinstance(annotations, dict):
+            annotations = Annotations(**annotations)
+
         # Check if user passed function directly instead of calling decorator
         if inspect.isroutine(uri):
             raise TypeError(
@@ -1149,6 +1211,8 @@ class FastMCP(Generic[LifespanResultT]):
                     mime_type=mime_type,
                     tags=tags,
                     enabled=enabled,
+                    annotations=annotations,
+                    meta=meta,
                 )
                 self.add_template(template)
                 return template
@@ -1162,6 +1226,8 @@ class FastMCP(Generic[LifespanResultT]):
                     mime_type=mime_type,
                     tags=tags,
                     enabled=enabled,
+                    annotations=annotations,
+                    meta=meta,
                 )
                 self.add_resource(resource)
                 return resource
@@ -1183,7 +1249,6 @@ class FastMCP(Generic[LifespanResultT]):
             The prompt instance that was added to the server.
         """
         self._prompt_manager.add_prompt(prompt)
-        self._cache.clear()
 
         # Send notification if we're in a request context
         try:
@@ -1206,6 +1271,7 @@ class FastMCP(Generic[LifespanResultT]):
         description: str | None = None,
         tags: set[str] | None = None,
         enabled: bool | None = None,
+        meta: dict[str, Any] | None = None,
     ) -> FunctionPrompt: ...
 
     @overload
@@ -1218,6 +1284,7 @@ class FastMCP(Generic[LifespanResultT]):
         description: str | None = None,
         tags: set[str] | None = None,
         enabled: bool | None = None,
+        meta: dict[str, Any] | None = None,
     ) -> Callable[[AnyFunction], FunctionPrompt]: ...
 
     def prompt(
@@ -1229,6 +1296,7 @@ class FastMCP(Generic[LifespanResultT]):
         description: str | None = None,
         tags: set[str] | None = None,
         enabled: bool | None = None,
+        meta: dict[str, Any] | None = None,
     ) -> Callable[[AnyFunction], FunctionPrompt] | FunctionPrompt:
         """Decorator to register a prompt.
 
@@ -1249,6 +1317,7 @@ class FastMCP(Generic[LifespanResultT]):
             description: Optional description of what the prompt does
             tags: Optional set of tags for categorizing the prompt
             enabled: Optional boolean to enable or disable the prompt
+            meta: Optional meta information about the prompt
 
         Examples:
 
@@ -1326,6 +1395,7 @@ class FastMCP(Generic[LifespanResultT]):
                 description=description,
                 tags=tags,
                 enabled=enabled,
+                meta=meta,
             )
             self.add_prompt(prompt)
 
@@ -1355,6 +1425,7 @@ class FastMCP(Generic[LifespanResultT]):
             description=description,
             tags=tags,
             enabled=enabled,
+            meta=meta,
         )
 
     async def run_stdio_async(self, show_banner: bool = True) -> None:
@@ -1726,8 +1797,6 @@ class FastMCP(Generic[LifespanResultT]):
         self._resource_manager.mount(mounted_server)
         self._prompt_manager.mount(mounted_server)
 
-        self._cache.clear()
-
     async def import_server(
         self,
         server: FastMCP[LifespanResultT],
@@ -1850,55 +1919,72 @@ class FastMCP(Generic[LifespanResultT]):
         else:
             logger.debug(f"Imported server {server.name}")
 
-        self._cache.clear()
-
     @classmethod
     def from_openapi(
         cls,
         openapi_spec: dict[str, Any],
         client: httpx.AsyncClient,
-        route_maps: list[RouteMap] | None = None,
-        route_map_fn: OpenAPIRouteMapFn | None = None,
-        mcp_component_fn: OpenAPIComponentFn | None = None,
+        route_maps: list[RouteMap] | list[RouteMapNew] | None = None,
+        route_map_fn: OpenAPIRouteMapFn | OpenAPIRouteMapFnNew | None = None,
+        mcp_component_fn: OpenAPIComponentFn | OpenAPIComponentFnNew | None = None,
         mcp_names: dict[str, str] | None = None,
         tags: set[str] | None = None,
         **settings: Any,
-    ) -> FastMCPOpenAPI:
+    ) -> FastMCPOpenAPI | FastMCPOpenAPINew:
         """
         Create a FastMCP server from an OpenAPI specification.
         """
-        from .openapi import FastMCPOpenAPI
-
-        return FastMCPOpenAPI(
-            openapi_spec=openapi_spec,
-            client=client,
-            route_maps=route_maps,
-            route_map_fn=route_map_fn,
-            mcp_component_fn=mcp_component_fn,
-            mcp_names=mcp_names,
-            tags=tags,
-            **settings,
-        )
+
+        # Check if experimental parser is enabled
+        if fastmcp.settings.experimental.enable_new_openapi_parser:
+            from fastmcp.experimental.server.openapi import FastMCPOpenAPI
+
+            return FastMCPOpenAPI(
+                openapi_spec=openapi_spec,
+                client=client,
+                route_maps=cast(Any, route_maps),
+                route_map_fn=cast(Any, route_map_fn),
+                mcp_component_fn=cast(Any, mcp_component_fn),
+                mcp_names=mcp_names,
+                tags=tags,
+                **settings,
+            )
+        else:
+            logger.info(
+                "Using legacy OpenAPI parser. To use the new parser, set "
+                "FASTMCP_EXPERIMENTAL_ENABLE_NEW_OPENAPI_PARSER=true. The new parser "
+                "was introduced for testing in 2.11 and will become the default soon."
+            )
+            from .openapi import FastMCPOpenAPI
+
+            return FastMCPOpenAPI(
+                openapi_spec=openapi_spec,
+                client=client,
+                route_maps=cast(Any, route_maps),
+                route_map_fn=cast(Any, route_map_fn),
+                mcp_component_fn=cast(Any, mcp_component_fn),
+                mcp_names=mcp_names,
+                tags=tags,
+                **settings,
+            )
 
     @classmethod
     def from_fastapi(
         cls,
         app: Any,
         name: str | None = None,
-        route_maps: list[RouteMap] | None = None,
-        route_map_fn: OpenAPIRouteMapFn | None = None,
-        mcp_component_fn: OpenAPIComponentFn | None = None,
+        route_maps: list[RouteMap] | list[RouteMapNew] | None = None,
+        route_map_fn: OpenAPIRouteMapFn | OpenAPIRouteMapFnNew | None = None,
+        mcp_component_fn: OpenAPIComponentFn | OpenAPIComponentFnNew | None = None,
         mcp_names: dict[str, str] | None = None,
         httpx_client_kwargs: dict[str, Any] | None = None,
         tags: set[str] | None = None,
         **settings: Any,
-    ) -> FastMCPOpenAPI:
+    ) -> FastMCPOpenAPI | FastMCPOpenAPINew:
         """
         Create a FastMCP server from a FastAPI application.
         """
 
-        from .openapi import FastMCPOpenAPI
-
         if httpx_client_kwargs is None:
             httpx_client_kwargs = {}
         httpx_client_kwargs.setdefault("base_url", "http://fastapi")
@@ -1910,17 +1996,40 @@ class FastMCP(Generic[LifespanResultT]):
 
         name = name or app.title
 
-        return FastMCPOpenAPI(
-            openapi_spec=app.openapi(),
-            client=client,
-            name=name,
-            route_maps=route_maps,
-            route_map_fn=route_map_fn,
-            mcp_component_fn=mcp_component_fn,
-            mcp_names=mcp_names,
-            tags=tags,
-            **settings,
-        )
+        # Check if experimental parser is enabled
+        if fastmcp.settings.experimental.enable_new_openapi_parser:
+            from fastmcp.experimental.server.openapi import FastMCPOpenAPI
+
+            return FastMCPOpenAPI(
+                openapi_spec=app.openapi(),
+                client=client,
+                name=name,
+                route_maps=cast(Any, route_maps),
+                route_map_fn=cast(Any, route_map_fn),
+                mcp_component_fn=cast(Any, mcp_component_fn),
+                mcp_names=mcp_names,
+                tags=tags,
+                **settings,
+            )
+        else:
+            logger.info(
+                "Using legacy OpenAPI parser. To use the new parser, set "
+                "FASTMCP_EXPERIMENTAL_ENABLE_NEW_OPENAPI_PARSER=true. The new parser "
+                "was introduced for testing in 2.11 and will become the default soon."
+            )
+            from .openapi import FastMCPOpenAPI
+
+            return FastMCPOpenAPI(
+                openapi_spec=app.openapi(),
+                client=client,
+                name=name,
+                route_maps=cast(Any, route_maps),
+                route_map_fn=cast(Any, route_map_fn),
+                mcp_component_fn=cast(Any, mcp_component_fn),
+                mcp_names=mcp_names,
+                tags=tags,
+                **settings,
+            )
 
     @classmethod
     def as_proxy(

fastmcp/settings.py

@@ -55,6 +55,25 @@ class ExtendedSettingsConfigDict(SettingsConfigDict, total=False):
     env_prefixes: list[str] | None
 
 
+class ExperimentalSettings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_prefix="FASTMCP_EXPERIMENTAL_",
+        extra="ignore",
+    )
+
+    enable_new_openapi_parser: Annotated[
+        bool,
+        Field(
+            description=inspect.cleandoc(
+                """
+                Whether to use the new OpenAPI parser. This parser was introduced
+                for testing in 2.11 and will become the default soon.
+                """
+            ),
+        ),
+    ] = False
+
+
 class Settings(BaseSettings):
     """FastMCP settings."""
 
@@ -64,8 +83,35 @@ class Settings(BaseSettings):
         extra="ignore",
         env_nested_delimiter="__",
         nested_model_default_partial_update=True,
+        validate_assignment=True,
     )
 
+    def get_setting(self, attr: str) -> Any:
+        """
+        Get a setting. If the setting contains one or more `__`, it will be
+        treated as a nested setting.
+        """
+        settings = self
+        while "__" in attr:
+            parent_attr, attr = attr.split("__", 1)
+            if not hasattr(settings, parent_attr):
+                raise AttributeError(f"Setting {parent_attr} does not exist.")
+            settings = getattr(settings, parent_attr)
+        return getattr(settings, attr)
+
+    def set_setting(self, attr: str, value: Any) -> None:
+        """
+        Set a setting. If the setting contains one or more `__`, it will be
+        treated as a nested setting.
+        """
+        settings = self
+        while "__" in attr:
+            parent_attr, attr = attr.split("__", 1)
+            if not hasattr(settings, parent_attr):
+                raise AttributeError(f"Setting {parent_attr} does not exist.")
+            settings = getattr(settings, parent_attr)
+        setattr(settings, attr, value)
+
     @classmethod
     def settings_customise_sources(
         cls,
@@ -109,6 +155,8 @@ class Settings(BaseSettings):
             return v.upper()
         return v
 
+    experimental: ExperimentalSettings = ExperimentalSettings()
+
     enable_rich_tracebacks: Annotated[
         bool,
         Field(
@@ -211,19 +259,23 @@ class Settings(BaseSettings):
     )
 
     # Auth settings
-    default_auth_provider: Annotated[
-        Literal["bearer_env"] | None,
+    server_auth: Annotated[
+        str | None,
         Field(
             description=inspect.cleandoc(
                 """
-                Configure the authentication provider. This setting is intended only to
-                be used for remote confirugation of providers that fully support
-                environment variable configuration.
+                Configure the authentication provider for the server. Auth
+                providers are registered with a specific key, and providing that
+                key here will cause the server to automatically configure the
+                provider from the environment.
 
                 If None, no automatic configuration will take place.
 
                 This setting is *always* overriden by any auth provider passed to the
                 FastMCP constructor.
+
+                Note that most auth providers require additional configuration
+                that must be provided via env vars.
                 """
             ),
         ),
@@ -256,6 +308,21 @@ class Settings(BaseSettings):
         ),
     ] = None
 
+    include_fastmcp_meta: Annotated[
+        bool,
+        Field(
+            default=True,
+            description=inspect.cleandoc(
+                """
+                Whether to include FastMCP meta in the server's MCP responses.
+                If True, a `_fastmcp` key will be added to the `meta` field of
+                all MCP component responses. This key will contain a dict of
+                various FastMCP-specific metadata, such as tags. 
+                """
+            ),
+        ),
+    ] = True
+
 
 def __getattr__(name: str):
     """
@@ -268,7 +335,7 @@ def __getattr__(name: str):
         # Deprecated in 2.10.2
         if settings.deprecation_warnings:
             warnings.warn(
-                "`from fastmcp.settings import settings` is deprecated. use `fasmtpc.settings` instead.",
+                "`from fastmcp.settings import settings` is deprecated. use `fastmcp.settings` instead.",
                 DeprecationWarning,
                 stacklevel=2,
             )