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

fastmcp/server/server.py

@@ -46,10 +46,10 @@ from mcp.types import (
     GetPromptResult,
     ToolAnnotations,
 )
-from mcp.types import Prompt as MCPPrompt
-from mcp.types import Resource as MCPResource
-from mcp.types import ResourceTemplate as MCPResourceTemplate
-from mcp.types import Tool as MCPTool
+from mcp.types import Prompt as SDKPrompt
+from mcp.types import Resource as SDKResource
+from mcp.types import ResourceTemplate as SDKResourceTemplate
+from mcp.types import Tool as SDKTool
 from pydantic import AnyUrl
 from starlette.middleware import Middleware as ASGIMiddleware
 from starlette.requests import Request
@@ -94,34 +94,17 @@ from fastmcp.utilities.types import NotSet, NotSetT
 if TYPE_CHECKING:
     from fastmcp.client import Client
     from fastmcp.client.client import FastMCP1Server
+    from fastmcp.client.sampling import SamplingHandler
     from fastmcp.client.transports import ClientTransport, ClientTransportT
     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
-    from fastmcp.server.sampling.handler import ServerSamplingHandler
     from fastmcp.tools.tool import ToolResultSerializerType
 
 logger = get_logger(__name__)
 
 
-def _create_named_fn_wrapper(fn: Callable[..., Any], name: str) -> Callable[..., Any]:
-    """Create a wrapper function with a custom __name__ for Docket registration.
-
-    Docket uses fn.__name__ as the key for function registration and lookup.
-    When mounting servers, we need unique names to avoid collisions between
-    mounted servers that have identically-named functions.
-    """
-    import functools
-
-    @functools.wraps(fn)
-    async def wrapper(*args: Any, **kwargs: Any) -> Any:
-        return await fn(*args, **kwargs)
-
-    wrapper.__name__ = name
-    return wrapper
-
-
 DuplicateBehavior = Literal["warn", "error", "replace", "ignore"]
 Transport = Literal["stdio", "http", "sse", "streamable-http"]
 
@@ -208,7 +191,7 @@ class FastMCP(Generic[LifespanResultT]):
         streamable_http_path: str | None = None,
         json_response: bool | None = None,
         stateless_http: bool | None = None,
-        sampling_handler: ServerSamplingHandler[LifespanResultT] | None = None,
+        sampling_handler: SamplingHandler | None = None,
         sampling_handler_behavior: Literal["always", "fallback"] | None = None,
     ):
         # Resolve server default for background task support
@@ -288,9 +271,7 @@ class FastMCP(Generic[LifespanResultT]):
         # Set up MCP protocol handlers
         self._setup_handlers()
 
-        self.sampling_handler: ServerSamplingHandler[LifespanResultT] | None = (
-            sampling_handler
-        )
+        self.sampling_handler: SamplingHandler | None = sampling_handler
         self.sampling_handler_behavior: Literal["always", "fallback"] = (
             sampling_handler_behavior or "fallback"
         )
@@ -439,7 +420,7 @@ class FastMCP(Generic[LifespanResultT]):
                         isinstance(tool, FunctionTool)
                         and tool.task_config.mode != "forbidden"
                     ):
-                        docket.register(tool.fn)
+                        docket.register(tool.fn, names=[tool.key])
 
                 for prompt in self._prompt_manager._prompts.values():
                     if (
@@ -447,27 +428,30 @@ class FastMCP(Generic[LifespanResultT]):
                         and prompt.task_config.mode != "forbidden"
                     ):
                         # task execution requires async fn (validated at creation time)
-                        docket.register(cast(Callable[..., Awaitable[Any]], prompt.fn))
+                        docket.register(
+                            cast(Callable[..., Awaitable[Any]], prompt.fn),
+                            names=[prompt.key],
+                        )
 
                 for resource in self._resource_manager._resources.values():
                     if (
                         isinstance(resource, FunctionResource)
                         and resource.task_config.mode != "forbidden"
                     ):
-                        docket.register(resource.fn)
+                        docket.register(resource.fn, names=[resource.name])
 
                 for template in self._resource_manager._templates.values():
                     if (
                         isinstance(template, FunctionResourceTemplate)
                         and template.task_config.mode != "forbidden"
                     ):
-                        docket.register(template.fn)
+                        docket.register(template.fn, names=[template.name])
 
                 # Also register functions from mounted servers so tasks can
                 # execute in the parent's Docket context
                 for mounted in self._mounted_servers:
                     await self._register_mounted_server_functions(
-                        mounted.server, docket, mounted.prefix
+                        mounted.server, docket, mounted.prefix, mounted.tool_names
                     )
 
                 # Set Docket in ContextVar so CurrentDocket can access it
@@ -491,12 +475,9 @@ class FastMCP(Generic[LifespanResultT]):
                             try:
                                 yield
                             finally:
-                                # Cancel worker task on exit with timeout to prevent hanging
                                 worker_task.cancel()
-                                with suppress(
-                                    asyncio.CancelledError, asyncio.TimeoutError
-                                ):
-                                    await asyncio.wait_for(worker_task, timeout=2.0)
+                                with suppress(asyncio.CancelledError):
+                                    await worker_task
                         finally:
                             _current_worker.reset(worker_token)
                 finally:
@@ -509,7 +490,11 @@ class FastMCP(Generic[LifespanResultT]):
             _current_server.reset(server_token)
 
     async def _register_mounted_server_functions(
-        self, server: FastMCP, docket: Docket, prefix: str | None
+        self,
+        server: FastMCP,
+        docket: Docket,
+        prefix: str | None,
+        tool_names: dict[str, str] | None = None,
     ) -> None:
         """Register task-enabled functions from a mounted server with Docket.
 
@@ -521,14 +506,19 @@ class FastMCP(Generic[LifespanResultT]):
             docket: The Docket instance to register with
             prefix: The mount prefix to prepend to function names (matches
                     client-facing tool/prompt names)
+            tool_names: Optional mapping of original tool names to custom names
         """
         # Register tools with prefixed names to avoid collisions
         for tool in server._tool_manager._tools.values():
             if isinstance(tool, FunctionTool) and tool.task_config.mode != "forbidden":
-                # Use same naming as client-facing tool keys
-                fn_name = f"{prefix}_{tool.key}" if prefix else tool.key
-                named_fn = _create_named_fn_wrapper(tool.fn, fn_name)
-                docket.register(named_fn)
+                # Apply tool_names override first, then prefix (matches get_tools logic)
+                if tool_names and tool.key in tool_names:
+                    fn_name = tool_names[tool.key]
+                elif prefix:
+                    fn_name = f"{prefix}_{tool.key}"
+                else:
+                    fn_name = tool.key
+                docket.register(tool.fn, names=[fn_name])
 
         # Register prompts with prefixed names
         for prompt in server._prompt_manager._prompts.values():
@@ -537,10 +527,10 @@ class FastMCP(Generic[LifespanResultT]):
                 and prompt.task_config.mode != "forbidden"
             ):
                 fn_name = f"{prefix}_{prompt.key}" if prefix else prompt.key
-                named_fn = _create_named_fn_wrapper(
-                    cast(Callable[..., Awaitable[Any]], prompt.fn), fn_name
+                docket.register(
+                    cast(Callable[..., Awaitable[Any]], prompt.fn),
+                    names=[fn_name],
                 )
-                docket.register(named_fn)
 
         # Register resources with prefixed names (use name, not key/URI)
         for resource in server._resource_manager._resources.values():
@@ -549,8 +539,7 @@ class FastMCP(Generic[LifespanResultT]):
                 and resource.task_config.mode != "forbidden"
             ):
                 fn_name = f"{prefix}_{resource.name}" if prefix else resource.name
-                named_fn = _create_named_fn_wrapper(resource.fn, fn_name)
-                docket.register(named_fn)
+                docket.register(resource.fn, names=[fn_name])
 
         # Register resource templates with prefixed names (use name, not key/URI)
         for template in server._resource_manager._templates.values():
@@ -559,8 +548,7 @@ class FastMCP(Generic[LifespanResultT]):
                 and template.task_config.mode != "forbidden"
             ):
                 fn_name = f"{prefix}_{template.name}" if prefix else template.name
-                named_fn = _create_named_fn_wrapper(template.fn, fn_name)
-                docket.register(named_fn)
+                docket.register(template.fn, names=[fn_name])
 
         # Recursively register from nested mounted servers with accumulated prefix
         for nested in server._mounted_servers:
@@ -570,7 +558,7 @@ class FastMCP(Generic[LifespanResultT]):
                 else (prefix or nested.prefix)
             )
             await self._register_mounted_server_functions(
-                nested.server, docket, nested_prefix
+                nested.server, docket, nested_prefix, nested.tool_names
             )
 
     @asynccontextmanager
@@ -938,7 +926,13 @@ class FastMCP(Generic[LifespanResultT]):
             try:
                 child_tools = await mounted.server.get_tools()
                 for key, tool in child_tools.items():
-                    new_key = f"{mounted.prefix}_{key}" if mounted.prefix else key
+                    # Check for manual override first, then apply prefix
+                    if mounted.tool_names and key in mounted.tool_names:
+                        new_key = mounted.tool_names[key]
+                    elif mounted.prefix:
+                        new_key = f"{mounted.prefix}_{key}"
+                    else:
+                        new_key = key
                     all_tools[new_key] = tool.model_copy(key=new_key)
             except Exception as e:
                 logger.warning(
@@ -1153,7 +1147,7 @@ class FastMCP(Generic[LifespanResultT]):
 
         return routes
 
-    async def _list_tools_mcp(self) -> list[MCPTool]:
+    async def _list_tools_mcp(self) -> list[SDKTool]:
         """
         List all available tools, in the format expected by the low-level MCP
         server.
@@ -1218,9 +1212,15 @@ class FastMCP(Generic[LifespanResultT]):
                     if not self._should_enable_component(tool):
                         continue
 
-                    key = tool.key
-                    if mounted.prefix:
+                    # Check for manual override first, then apply prefix
+                    if mounted.tool_names and tool.key in mounted.tool_names:
+                        key = mounted.tool_names[tool.key]
+                    elif mounted.prefix:
                         key = f"{mounted.prefix}_{tool.key}"
+                    else:
+                        key = tool.key
+
+                    if key != tool.key:
                         tool = tool.model_copy(key=key)
                     # Later mounted servers override earlier ones
                     all_tools[key] = tool
@@ -1237,7 +1237,7 @@ class FastMCP(Generic[LifespanResultT]):
 
         return list(all_tools.values())
 
-    async def _list_resources_mcp(self) -> list[MCPResource]:
+    async def _list_resources_mcp(self) -> list[SDKResource]:
         """
         List all available resources, in the format expected by the low-level MCP
         server.
@@ -1326,7 +1326,7 @@ class FastMCP(Generic[LifespanResultT]):
 
         return list(all_resources.values())
 
-    async def _list_resource_templates_mcp(self) -> list[MCPResourceTemplate]:
+    async def _list_resource_templates_mcp(self) -> list[SDKResourceTemplate]:
         """
         List all available resource templates, in the format expected by the low-level MCP
         server.
@@ -1420,7 +1420,7 @@ class FastMCP(Generic[LifespanResultT]):
 
         return list(all_templates.values())
 
-    async def _list_prompts_mcp(self) -> list[MCPPrompt]:
+    async def _list_prompts_mcp(self) -> list[SDKPrompt]:
         """
         List all available prompts, in the format expected by the low-level MCP
         server.
@@ -1490,9 +1490,13 @@ class FastMCP(Generic[LifespanResultT]):
                     if not self._should_enable_component(prompt):
                         continue
 
-                    key = prompt.key
+                    # Apply prefix to prompt key
                     if mounted.prefix:
                         key = f"{mounted.prefix}_{prompt.key}"
+                    else:
+                        key = prompt.key
+
+                    if key != prompt.key:
                         prompt = prompt.model_copy(key=key)
                     # Later mounted servers override earlier ones
                     all_prompts[key] = prompt
@@ -1632,7 +1636,20 @@ class FastMCP(Generic[LifespanResultT]):
         # Try mounted servers in reverse order (later wins)
         for mounted in reversed(self._mounted_servers):
             try_name = tool_name
-            if mounted.prefix:
+
+            # First check if tool_name is an overridden name (reverse lookup)
+            if mounted.tool_names:
+                for orig_key, override_name in mounted.tool_names.items():
+                    if override_name == tool_name:
+                        try_name = orig_key
+                        break
+                else:
+                    # Not an override, try standard prefix stripping
+                    if mounted.prefix:
+                        if not tool_name.startswith(f"{mounted.prefix}_"):
+                            continue
+                        try_name = tool_name[len(mounted.prefix) + 1 :]
+            elif mounted.prefix:
                 if not tool_name.startswith(f"{mounted.prefix}_"):
                     continue
                 try_name = tool_name[len(mounted.prefix) + 1 :]
@@ -1968,8 +1985,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.
-                Note: `exclude_args` will be deprecated in FastMCP 2.14 in favor of dependency
-                injection with `Depends()` for better lifecycle management.
+                Deprecated: Use `Depends()` for dependency injection instead.
             meta: Optional meta information about the tool
             enabled: Optional boolean to enable or disable the tool
 
@@ -2480,10 +2496,7 @@ class FastMCP(Generic[LifespanResultT]):
         """
         # Display server banner
         if show_banner:
-            log_server_banner(
-                server=self,
-                transport="stdio",
-            )
+            log_server_banner(server=self)
 
         with temporary_log_level(log_level):
             async with self._lifespan_manager():
@@ -2546,22 +2559,9 @@ class FastMCP(Generic[LifespanResultT]):
             stateless_http=stateless_http,
         )
 
-        # Get the path for the server URL
-        server_path = (
-            app.state.path.lstrip("/")
-            if hasattr(app, "state") and hasattr(app.state, "path")
-            else path or ""
-        )
-
         # Display server banner
         if show_banner:
-            log_server_banner(
-                server=self,
-                transport=transport,
-                host=host,
-                port=port,
-                path=server_path,
-            )
+            log_server_banner(server=self)
         uvicorn_config_from_user = uvicorn_config or {}
 
         config_kwargs: dict[str, Any] = {
@@ -2651,6 +2651,7 @@ class FastMCP(Generic[LifespanResultT]):
         server: FastMCP[LifespanResultT],
         prefix: str | None = None,
         as_proxy: bool | None = None,
+        tool_names: dict[str, str] | None = None,
     ) -> None:
         """Mount another FastMCP server on this server with an optional prefix.
 
@@ -2695,6 +2696,9 @@ class FastMCP(Generic[LifespanResultT]):
             as_proxy: Whether to treat the mounted server as a proxy. If None (default),
                 automatically determined based on whether the server has a custom lifespan
                 (True if it has a custom lifespan, False otherwise).
+            tool_names: Optional mapping of original tool names to custom names. Use this
+                to override prefixed names. Keys are the original tool names from the
+                mounted server.
         """
         from fastmcp.server.proxy import FastMCPProxy
 
@@ -2715,6 +2719,7 @@ class FastMCP(Generic[LifespanResultT]):
         mounted_server = MountedServer(
             prefix=prefix,
             server=server,
+            tool_names=tool_names,
         )
         self._mounted_servers.append(mounted_server)
 
@@ -2974,6 +2979,7 @@ class FastMCP(Generic[LifespanResultT]):
 class MountedServer:
     prefix: str | None
     server: FastMCP[Any]
+    tool_names: dict[str, str] | None = None
 
 
 def add_resource_prefix(uri: str, prefix: str) -> str:

fastmcp/server/tasks/converters.py

@@ -123,7 +123,8 @@ async def convert_prompt_result(
     messages: list[mcp.types.PromptMessage] = []
     for msg in raw_value:
         if isinstance(msg, PromptMessage):
-            messages.append(msg.to_mcp())
+            # PromptMessage is imported from mcp.types - use directly
+            messages.append(msg)
         elif isinstance(msg, str):
             messages.append(
                 mcp.types.PromptMessage(

fastmcp/tools/tool.py

@@ -32,7 +32,7 @@ import fastmcp
 from fastmcp.server.dependencies import get_context, without_injected_parameters
 from fastmcp.server.tasks.config import TaskConfig
 from fastmcp.utilities.components import FastMCPComponent
-from fastmcp.utilities.json_schema import compress_schema
+from fastmcp.utilities.json_schema import compress_schema, resolve_root_ref
 from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.types import (
     Audio,
@@ -321,11 +321,9 @@ class FunctionTool(Tool):
         """Create a Tool from a function."""
         if exclude_args and fastmcp.settings.deprecation_warnings:
             warnings.warn(
-                "The `exclude_args` parameter will be deprecated in FastMCP 2.14. "
-                "We recommend using dependency injection with `Depends()` instead, which provides "
-                "better lifecycle management and is more explicit. "
-                "`exclude_args` will continue to work until then. "
-                "See https://gofastmcp.com/docs/servers/tools for examples.",
+                "The `exclude_args` parameter is deprecated as of FastMCP 2.14. "
+                "Use dependency injection with `Depends()` instead for better lifecycle management. "
+                "See https://gofastmcp.com/servers/dependencies for examples.",
                 DeprecationWarning,
                 stacklevel=2,
             )
@@ -561,6 +559,10 @@ class ParsedFunction:
 
                 output_schema = compress_schema(output_schema, prune_titles=True)
 
+                # Resolve root-level $ref to meet MCP spec requirement for type: object
+                # Self-referential Pydantic models generate schemas with $ref at root
+                output_schema = resolve_root_ref(output_schema)
+
             except PydanticSchemaGenerationError as e:
                 if "_UnserializableType" not in str(e):
                     logger.debug(f"Unable to generate schema for type {output_type!r}")

fastmcp/tools/tool_manager.py

@@ -8,7 +8,7 @@ from mcp.types import ToolAnnotations
 from pydantic import ValidationError
 
 from fastmcp import settings
-from fastmcp.exceptions import NotFoundError, ToolError
+from fastmcp.exceptions import FastMCPError, NotFoundError, ToolError
 from fastmcp.settings import DuplicateBehavior
 from fastmcp.tools.tool import Tool, ToolResult
 from fastmcp.tools.tool_transform import (
@@ -158,12 +158,10 @@ class ToolManager:
         tool = await self.get_tool(key)
         try:
             return await tool.run(arguments)
-        except ValidationError as e:
-            logger.exception(f"Error validating tool {key!r}: {e}")
-            raise e
-        except ToolError as e:
-            logger.exception(f"Error calling tool {key!r}")
-            raise e
+        except FastMCPError:
+            raise
+        except ValidationError:
+            raise
         except Exception as e:
             logger.exception(f"Error calling tool {key!r}")
             if self.mask_error_details:

fastmcp/utilities/cli.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 import os
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal
+from typing import TYPE_CHECKING, Any
 
 from pydantic import ValidationError
 from rich.align import Align
@@ -197,23 +197,8 @@ LOGO_ASCII_4 = (
 )
 
 
-def log_server_banner(
-    server: FastMCP[Any],
-    transport: Literal["stdio", "http", "sse", "streamable-http"],
-    *,
-    host: str | None = None,
-    port: int | None = None,
-    path: str | None = None,
-) -> None:
-    """Creates and logs a formatted banner with server information and logo.
-
-    Args:
-        transport: The transport protocol being used
-        server_name: Optional server name to display
-        host: Host address (for HTTP transports)
-        port: Port number (for HTTP transports)
-        path: Server path (for HTTP transports)
-    """
+def log_server_banner(server: FastMCP[Any]) -> None:
+    """Creates and logs a formatted banner with server information and logo."""
 
     # Create the logo text
     # Use Text with no_wrap and markup disabled to preserve ANSI escape codes
@@ -228,39 +213,34 @@ def log_server_banner(
     info_table.add_column(style="cyan", justify="left")  # Label column
     info_table.add_column(style="dim", justify="left")  # Value column
 
-    match transport:
-        case "http" | "streamable-http":
-            display_transport = "HTTP"
-        case "sse":
-            display_transport = "SSE"
-        case "stdio":
-            display_transport = "STDIO"
-
-    info_table.add_row("🖥", "Server name:", Text(server.name + "\n", style="bold blue"))
-    info_table.add_row("📦", "Transport:", display_transport)
-
-    # Show connection info based on transport
-    if transport in ("http", "streamable-http", "sse") and host and port:
-        server_url = f"http://{host}:{port}"
-        if path:
-            server_url += f"/{path.lstrip('/')}"
-        info_table.add_row("🔗", "Server URL:", server_url)
-
-    # Add documentation link
-    info_table.add_row("", "", "")
-    info_table.add_row("📚", "Docs:", "https://gofastmcp.com")
-    info_table.add_row("🚀", "Hosting:", "https://fastmcp.cloud")
+    info_table.add_row("🖥", "Server:", Text(server.name, style="dim"))
+    info_table.add_row("🚀", "Deploy free:", "https://fastmcp.cloud")
 
     # Create panel with logo, title, and information using Group
+    docs_url = Text("https://gofastmcp.com", style="dim")
     panel_content = Group(
+        "",
         Align.center(logo_text),
         "",
-        Align.center(title_text),
         "",
+        Align.center(title_text),
+        Align.center(docs_url),
         "",
         Align.center(info_table),
     )
 
+    # v3 notice banner (shown below main panel)
+    v3_line1 = Text("✨ FastMCP 3.0 is coming!", style="bold")
+    v3_line2 = Text(
+        "Pin fastmcp<3 in production, then upgrade when you're ready.", style="dim"
+    )
+    v3_notice = Panel(
+        Group(Align.center(v3_line1), Align.center(v3_line2)),
+        border_style="blue",
+        padding=(0, 2),
+        width=80,
+    )
+
     panel = Panel(
         panel_content,
         border_style="dim",
@@ -270,5 +250,5 @@ def log_server_banner(
     )
 
     console = Console(stderr=True)
-    # Center the panel itself
-    console.print(Group("\n", Align.center(panel), "\n"))
+    # Center both panels
+    console.print(Group("\n", Align.center(panel), Align.center(v3_notice), "\n"))

fastmcp/utilities/json_schema.py

@@ -1,6 +1,46 @@
 from __future__ import annotations
 
 from collections import defaultdict
+from typing import Any
+
+
+def resolve_root_ref(schema: dict[str, Any]) -> dict[str, Any]:
+    """Resolve $ref at root level to meet MCP spec requirements.
+
+    MCP specification requires outputSchema to have "type": "object" at the root level.
+    When Pydantic generates schemas for self-referential models, it uses $ref at the
+    root level pointing to $defs. This function resolves such references by inlining
+    the referenced definition while preserving $defs for nested references.
+
+    Args:
+        schema: JSON schema dict that may have $ref at root level
+
+    Returns:
+        A new schema dict with root-level $ref resolved, or the original schema
+        if no resolution is needed
+
+    Example:
+        >>> schema = {
+        ...     "$defs": {"Node": {"type": "object", "properties": {...}}},
+        ...     "$ref": "#/$defs/Node"
+        ... }
+        >>> resolved = resolve_root_ref(schema)
+        >>> # Result: {"type": "object", "properties": {...}, "$defs": {...}}
+    """
+    # Only resolve if we have $ref at root level with $defs but no explicit type
+    if "$ref" in schema and "$defs" in schema and "type" not in schema:
+        ref = schema["$ref"]
+        # Only handle local $defs references
+        if isinstance(ref, str) and ref.startswith("#/$defs/"):
+            def_name = ref.split("/")[-1]
+            defs = schema["$defs"]
+            if def_name in defs:
+                # Create a new schema by copying the referenced definition
+                resolved = dict(defs[def_name])
+                # Preserve $defs for nested references (other fields may still use them)
+                resolved["$defs"] = defs
+                return resolved
+    return schema
 
 
 def _prune_param(schema: dict, param: str) -> dict:

fastmcp/utilities/openapi/schemas.py

@@ -539,9 +539,9 @@ def extract_output_schema_from_responses(
                 # Replace $ref with the actual schema definition
                 output_schema = _replace_ref_with_defs(schema_definitions[schema_name])
 
-    # Convert OpenAPI schema to JSON Schema format
-    # Only needed for OpenAPI 3.0 - 3.1 uses standard JSON Schema null types
-    if openapi_version and openapi_version.startswith("3.0"):
+    if openapi_version and openapi_version.startswith("3"):
+        # Convert OpenAPI 3.x schema to JSON Schema format for proper handling
+        # of constructs like oneOf, anyOf, and nullable fields
         from .json_schema_converter import convert_openapi_schema_to_json_schema
 
         output_schema = convert_openapi_schema_to_json_schema(
@@ -570,7 +570,7 @@ def extract_output_schema_from_responses(
                 processed_defs[name] = _replace_ref_with_defs(schema)
 
         # Convert OpenAPI schema definitions to JSON Schema format if needed
-        if openapi_version and openapi_version.startswith("3.0"):
+        if openapi_version and openapi_version.startswith("3"):
             from .json_schema_converter import convert_openapi_schema_to_json_schema
 
             for def_name in list(processed_defs.keys()):

{fastmcp-2.14.0.dist-info → fastmcp-2.14.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.14.0
+Version: 2.14.2
 Summary: The fast, Pythonic way to build MCP servers and clients.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp
@@ -23,17 +23,19 @@ Requires-Dist: cyclopts>=4.0.0
 Requires-Dist: exceptiongroup>=1.2.2
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: jsonschema-path>=0.3.4
-Requires-Dist: mcp>=1.23.1
+Requires-Dist: mcp<2.0,>=1.24.0
 Requires-Dist: openapi-pydantic>=0.5.1
 Requires-Dist: platformdirs>=4.0.0
 Requires-Dist: py-key-value-aio[disk,keyring,memory]<0.4.0,>=0.3.0
 Requires-Dist: pydantic[email]>=2.11.7
-Requires-Dist: pydocket>=0.15.2
+Requires-Dist: pydocket>=0.16.3
 Requires-Dist: pyperclip>=1.9.0
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: rich>=13.9.4
 Requires-Dist: uvicorn>=0.35
 Requires-Dist: websockets>=15.0.1
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40.0; extra == 'anthropic'
 Provides-Extra: openai
 Requires-Dist: openai>=1.102.0; extra == 'openai'
 Description-Content-Type: text/markdown
@@ -73,6 +75,9 @@ Description-Content-Type: text/markdown
 >
 > **For production MCP applications, install FastMCP:** `pip install fastmcp`
 
+> [!Important]
+> FastMCP 3.0 is in development and may include breaking changes. To avoid unexpected issues, pin your dependency to v2: `fastmcp<3`
+
 ---
 
 **FastMCP is the standard framework for building MCP applications**, providing the fastest path from idea to production.