fastmcp 2.10.1__py3-none-any.whl → 2.10.2__py3-none-any.whl

fastmcp/cli/cli.py

@@ -64,6 +64,7 @@ def _build_uv_command(
     server_spec: str,
     with_editable: Path | None = None,
     with_packages: list[str] | None = None,
+    no_banner: bool = False,
 ) -> list[str]:
     """Build the uv run command that runs a MCP server through mcp run."""
     cmd = ["uv"]
@@ -80,6 +81,10 @@ def _build_uv_command(
 
     # Add mcp run command
     cmd.extend(["fastmcp", "run", server_spec])
+
+    if no_banner:
+        cmd.append("--no-banner")
+
     return cmd
 
 
@@ -192,7 +197,9 @@ def dev(
         if inspector_version:
             inspector_cmd += f"@{inspector_version}"
 
-        uv_cmd = _build_uv_command(server_spec, with_editable, with_packages)
+        uv_cmd = _build_uv_command(
+            server_spec, with_editable, with_packages, no_banner=True
+        )
 
         # Run the MCP Inspector command with shell=True on Windows
         shell = sys.platform == "win32"
@@ -261,6 +268,13 @@ def run(
             help="Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
         ),
     ] = None,
+    no_banner: Annotated[
+        bool,
+        typer.Option(
+            "--no-banner",
+            help="Don't show the server banner",
+        ),
+    ] = False,
 ) -> None:
     """Run a MCP server or connect to a remote one.
 
@@ -297,6 +311,7 @@ def run(
             port=port,
             log_level=log_level,
             server_args=server_args,
+            show_banner=not no_banner,
         )
     except Exception as e:
         logger.error(

fastmcp/cli/run.py

@@ -169,6 +169,7 @@ def run_command(
     port: int | None = None,
     log_level: str | None = None,
     server_args: list[str] | None = None,
+    show_banner: bool = True,
 ) -> None:
     """Run a MCP server or connect to a remote one.
 
@@ -201,6 +202,9 @@ def run_command(
     if log_level:
         kwargs["log_level"] = log_level
 
+    if not show_banner:
+        kwargs["show_banner"] = False
+
     try:
         server.run(**kwargs)
     except Exception as e:

fastmcp/client/elicitation.py

@@ -53,6 +53,11 @@ def create_elicitation_callback(
             if not isinstance(result, ElicitResult):
                 result = ElicitResult(action="accept", content=result)
             content = to_jsonable_python(result.content)
+            if not isinstance(content, dict | None):
+                raise ValueError(
+                    "Elicitation responses must be serializable as a JSON object (dict). Received: "
+                    f"{result.content!r}"
+                )
             return MCPElicitResult(**result.model_dump() | {"content": content})
         except Exception as e:
             return mcp.types.ErrorData(

fastmcp/client/transports.py

@@ -773,8 +773,6 @@ class MCPConfigTransport(ClientTransport):
     """
 
     def __init__(self, config: MCPConfig | dict):
-        from fastmcp.client.client import Client
-
         if isinstance(config, dict):
             config = MCPConfig.from_dict(config)
         self.config = config
@@ -792,9 +790,9 @@ class MCPConfigTransport(ClientTransport):
             composite_server = FastMCP()
 
             for name, server in self.config.mcpServers.items():
-                server_client = Client(transport=server.to_transport())
                 composite_server.mount(
-                    prefix=name, server=FastMCP.as_proxy(server_client)
+                    prefix=name,
+                    server=FastMCP.as_proxy(backend=server.to_transport()),
                 )
 
             self.transport = FastMCPTransport(mcp=composite_server)

fastmcp/server/auth/providers/bearer.py

@@ -399,12 +399,21 @@ class BearerAuthProvider(OAuthProvider):
             return None
 
     def _extract_scopes(self, claims: dict[str, Any]) -> list[str]:
-        """Extract scopes from JWT claims."""
-        scope_claim = claims.get("scope", "")
-        if isinstance(scope_claim, str):
-            return scope_claim.split()
-        elif isinstance(scope_claim, list):
-            return scope_claim
+        """
+        Extract scopes from JWT claims. Supports both 'scope' and 'scp'
+        claims.
+
+        Checks the `scope` claim first (standard OAuth2 claim), then the `scp`
+        claim (used by some Identity Providers).
+        """
+
+        for claim in ["scope", "scp"]:
+            if claim in claims:
+                if isinstance(claims[claim], str):
+                    return claims[claim].split()
+                elif isinstance(claims[claim], list):
+                    return claims[claim]
+
         return []
 
     async def verify_token(self, token: str) -> AccessToken | None:

fastmcp/server/proxy.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
 from urllib.parse import quote
 
 import mcp.types
+from mcp.client.session import ClientSession
+from mcp.shared.context import LifespanContextT, RequestContext
 from mcp.shared.exceptions import McpError
 from mcp.types import (
     METHOD_NOT_FOUND,
@@ -14,6 +17,10 @@ from mcp.types import (
 from pydantic.networks import AnyUrl
 
 from fastmcp.client import Client
+from fastmcp.client.elicitation import ElicitResult
+from fastmcp.client.logging import LogMessage
+from fastmcp.client.roots import RootsList
+from fastmcp.client.transports import ClientTransportT
 from fastmcp.exceptions import NotFoundError, ResourceError, ToolError
 from fastmcp.prompts import Prompt, PromptMessage
 from fastmcp.prompts.prompt import PromptArgument
@@ -21,10 +28,12 @@ from fastmcp.prompts.prompt_manager import PromptManager
 from fastmcp.resources import Resource, ResourceTemplate
 from fastmcp.resources.resource_manager import ResourceManager
 from fastmcp.server.context import Context
+from fastmcp.server.dependencies import get_context
 from fastmcp.server.server import FastMCP
 from fastmcp.tools.tool import Tool, ToolResult
 from fastmcp.tools.tool_manager import ToolManager
 from fastmcp.utilities.logging import get_logger
+from fastmcp.utilities.mcp_config import MCPConfig
 
 if TYPE_CHECKING:
     from fastmcp.server import Context
@@ -406,3 +415,110 @@ class FastMCPProxy(FastMCP):
         self._tool_manager = ProxyToolManager(client=self.client)
         self._resource_manager = ProxyResourceManager(client=self.client)
         self._prompt_manager = ProxyPromptManager(client=self.client)
+
+
+async def default_proxy_roots_handler(
+    context: RequestContext[ClientSession, LifespanContextT],
+) -> RootsList:
+    """
+    A handler that forwards the list roots request from the remote server to the proxy's connected clients and relays the response back to the remote server.
+    """
+    ctx = get_context()
+    return await ctx.list_roots()
+
+
+class ProxyClient(Client[ClientTransportT]):
+    """
+    A proxy client that forwards advanced interactions between a remote MCP server and the proxy's connected clients.
+    Supports forwarding roots, sampling, elicitation, logging, and progress.
+    """
+
+    def __init__(
+        self,
+        transport: (
+            ClientTransportT
+            | FastMCP
+            | AnyUrl
+            | Path
+            | MCPConfig
+            | dict[str, Any]
+            | str
+        ),
+        **kwargs,
+    ):
+        if "roots" not in kwargs:
+            kwargs["roots"] = default_proxy_roots_handler
+        if "sampling_handler" not in kwargs:
+            kwargs["sampling_handler"] = ProxyClient.default_sampling_handler
+        if "elicitation_handler" not in kwargs:
+            kwargs["elicitation_handler"] = ProxyClient.default_elicitation_handler
+        if "log_handler" not in kwargs:
+            kwargs["log_handler"] = ProxyClient.default_log_handler
+        if "progress_handler" not in kwargs:
+            kwargs["progress_handler"] = ProxyClient.default_progress_handler
+        super().__init__(transport, **kwargs)
+
+    @classmethod
+    async def default_sampling_handler(
+        cls,
+        messages: list[mcp.types.SamplingMessage],
+        params: mcp.types.CreateMessageRequestParams,
+        context: RequestContext[ClientSession, LifespanContextT],
+    ) -> mcp.types.CreateMessageResult:
+        """
+        A handler that forwards the sampling request from the remote server to the proxy's connected clients and relays the response back to the remote server.
+        """
+        ctx = get_context()
+        content = await ctx.sample(
+            [msg for msg in messages],
+            system_prompt=params.systemPrompt,
+            temperature=params.temperature,
+            max_tokens=params.maxTokens,
+            model_preferences=params.modelPreferences,
+        )
+        if isinstance(content, mcp.types.ResourceLink | mcp.types.EmbeddedResource):
+            raise RuntimeError("Content is not supported")
+        return mcp.types.CreateMessageResult(
+            role="assistant",
+            model="fastmcp-client",
+            content=content,
+        )
+
+    @classmethod
+    async def default_elicitation_handler(
+        cls,
+        message: str,
+        response_type: type,
+        params: mcp.types.ElicitRequestParams,
+        context: RequestContext[ClientSession, LifespanContextT],
+    ) -> ElicitResult:
+        """
+        A handler that forwards the elicitation request from the remote server to the proxy's connected clients and relays the response back to the remote server.
+        """
+        ctx = get_context()
+        result = await ctx.elicit(message, response_type)
+        if result.action == "accept":
+            return result.data
+        else:
+            return ElicitResult(action=result.action)
+
+    @classmethod
+    async def default_log_handler(cls, message: LogMessage) -> None:
+        """
+        A handler that forwards the log notification from the remote server to the proxy's connected clients.
+        """
+        ctx = get_context()
+        await ctx.log(message.data, level=message.level, logger_name=message.logger)
+
+    @classmethod
+    async def default_progress_handler(
+        cls,
+        progress: float,
+        total: float | None,
+        message: str | None,
+    ) -> None:
+        """
+        A handler that forwards the progress notification from the remote server to the proxy's connected clients.
+        """
+        ctx = get_context()
+        await ctx.report_progress(progress, total, message)

fastmcp/server/server.py

@@ -60,6 +60,7 @@ 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.utilities.cli import log_server_banner
 from fastmcp.utilities.components import FastMCPComponent
 from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.mcp_config import MCPConfig
@@ -285,6 +286,7 @@ class FastMCP(Generic[LifespanResultT]):
     async def run_async(
         self,
         transport: Transport | None = None,
+        show_banner: bool = True,
         **transport_kwargs: Any,
     ) -> None:
         """Run the FastMCP server asynchronously.
@@ -298,15 +300,23 @@ class FastMCP(Generic[LifespanResultT]):
             raise ValueError(f"Unknown transport: {transport}")
 
         if transport == "stdio":
-            await self.run_stdio_async(**transport_kwargs)
+            await self.run_stdio_async(
+                show_banner=show_banner,
+                **transport_kwargs,
+            )
         elif transport in {"http", "sse", "streamable-http"}:
-            await self.run_http_async(transport=transport, **transport_kwargs)
+            await self.run_http_async(
+                transport=transport,
+                show_banner=show_banner,
+                **transport_kwargs,
+            )
         else:
             raise ValueError(f"Unknown transport: {transport}")
 
     def run(
         self,
         transport: Transport | None = None,
+        show_banner: bool = True,
         **transport_kwargs: Any,
     ) -> None:
         """Run the FastMCP server. Note this is a synchronous function.
@@ -315,7 +325,14 @@ class FastMCP(Generic[LifespanResultT]):
             transport: Transport protocol to use ("stdio", "sse", or "streamable-http")
         """
 
-        anyio.run(partial(self.run_async, transport, **transport_kwargs))
+        anyio.run(
+            partial(
+                self.run_async,
+                transport,
+                show_banner=show_banner,
+                **transport_kwargs,
+            )
+        )
 
     def _setup_handlers(self) -> None:
         """Set up core MCP protocol handlers."""
@@ -1321,8 +1338,16 @@ class FastMCP(Generic[LifespanResultT]):
             enabled=enabled,
         )
 
-    async def run_stdio_async(self) -> None:
+    async def run_stdio_async(self, show_banner: bool = True) -> None:
         """Run the server using stdio transport."""
+
+        # Display server banner
+        if show_banner:
+            log_server_banner(
+                server=self,
+                transport="stdio",
+            )
+
         async with stdio_server() as (read_stream, write_stream):
             logger.info(f"Starting MCP server {self.name!r} with transport 'stdio'")
             await self._mcp_server.run(
@@ -1335,6 +1360,7 @@ class FastMCP(Generic[LifespanResultT]):
 
     async def run_http_async(
         self,
+        show_banner: bool = True,
         transport: Literal["http", "streamable-http", "sse"] = "http",
         host: str | None = None,
         port: int | None = None,
@@ -1342,6 +1368,7 @@ class FastMCP(Generic[LifespanResultT]):
         path: str | None = None,
         uvicorn_config: dict[str, Any] | None = None,
         middleware: list[ASGIMiddleware] | None = None,
+        stateless_http: bool | None = None,
     ) -> None:
         """Run the server using HTTP transport.
 
@@ -1352,15 +1379,39 @@ class FastMCP(Generic[LifespanResultT]):
             log_level: Log level for the server (defaults to settings.log_level)
             path: Path for the endpoint (defaults to settings.streamable_http_path or settings.sse_path)
             uvicorn_config: Additional configuration for the Uvicorn server
+            middleware: A list of middleware to apply to the app
+            stateless_http: Whether to use stateless HTTP (defaults to settings.stateless_http)
         """
+
         host = host or self._deprecated_settings.host
         port = port or self._deprecated_settings.port
         default_log_level_to_use = (
             log_level or self._deprecated_settings.log_level
         ).lower()
 
-        app = self.http_app(path=path, transport=transport, middleware=middleware)
+        app = self.http_app(
+            path=path,
+            transport=transport,
+            middleware=middleware,
+            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,
+            )
         _uvicorn_config_from_user = uvicorn_config or {}
 
         config_kwargs: dict[str, Any] = {
@@ -1378,6 +1429,7 @@ class FastMCP(Generic[LifespanResultT]):
         logger.info(
             f"Starting MCP server {self.name!r} with transport {transport!r} on http://{host}:{port}/{path}"
         )
+
         await server.serve()
 
     async def run_sse_async(
@@ -1591,9 +1643,8 @@ class FastMCP(Generic[LifespanResultT]):
             resource_separator: Deprecated. Separator character for resource URIs.
             prompt_separator: Deprecated. Separator character for prompt names.
         """
-        from fastmcp import Client
         from fastmcp.client.transports import FastMCPTransport
-        from fastmcp.server.proxy import FastMCPProxy
+        from fastmcp.server.proxy import FastMCPProxy, ProxyClient
 
         # Deprecated since 2.9.0
         # Prior to 2.9.0, the first positional argument was the prefix and the
@@ -1645,7 +1696,7 @@ class FastMCP(Generic[LifespanResultT]):
             as_proxy = server._has_lifespan
 
         if as_proxy and not isinstance(server, FastMCPProxy):
-            server = FastMCPProxy(Client(transport=FastMCPTransport(server)))
+            server = FastMCPProxy(ProxyClient(transport=FastMCPTransport(server)))
 
         # Delegate mounting to all three managers
         mounted_server = MountedServer(
@@ -1856,14 +1907,16 @@ class FastMCP(Generic[LifespanResultT]):
     @classmethod
     def as_proxy(
         cls,
-        backend: Client[ClientTransportT]
-        | ClientTransport
-        | FastMCP[Any]
-        | AnyUrl
-        | Path
-        | MCPConfig
-        | dict[str, Any]
-        | str,
+        backend: (
+            Client[ClientTransportT]
+            | ClientTransport
+            | FastMCP[Any]
+            | AnyUrl
+            | Path
+            | MCPConfig
+            | dict[str, Any]
+            | str
+        ),
         **settings: Any,
     ) -> FastMCPProxy:
         """Create a FastMCP proxy server for the given backend.
@@ -1874,12 +1927,12 @@ class FastMCP(Generic[LifespanResultT]):
         `fastmcp.client.Client` constructor.
         """
         from fastmcp.client.client import Client
-        from fastmcp.server.proxy import FastMCPProxy
+        from fastmcp.server.proxy import FastMCPProxy, ProxyClient
 
         if isinstance(backend, Client):
             client = backend
         else:
-            client = Client(backend)
+            client = ProxyClient(backend)
 
         return FastMCPProxy(client=client, **settings)
 

fastmcp/settings.py

@@ -1,6 +1,7 @@
 from __future__ import annotations as _annotations
 
 import inspect
+import warnings
 from pathlib import Path
 from typing import Annotated, Any, Literal
 
@@ -258,4 +259,21 @@ class Settings(BaseSettings):
     ] = None
 
 
-settings = Settings()
+def __getattr__(name: str):
+    """
+    Used to deprecate the module-level Image class; can be removed once it is no longer imported to root.
+    """
+    if name == "settings":
+        import fastmcp
+
+        settings = fastmcp.settings
+        # Deprecated in 2.10.2
+        if settings.deprecation_warnings:
+            warnings.warn(
+                "`from fastmcp.settings import settings` is deprecated. use `fasmtpc.settings` instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        return settings
+
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

fastmcp/utilities/cli.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from importlib.metadata import version
+from typing import TYPE_CHECKING, Any, Literal
+
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+import fastmcp
+
+if TYPE_CHECKING:
+    from fastmcp import FastMCP
+
+LOGO_ASCII = r"""
+    _ __ ___ ______           __  __  _____________       ____    ____ 
+   _ __ ___ / ____/___ ______/ /_/  |/  / ____/ __ \     |___ \  / __ \
+  _ __ ___ / /_  / __ `/ ___/ __/ /|_/ / /   / /_/ /     ___/ / / / / /
+ _ __ ___ / __/ / /_/ (__  ) /_/ /  / / /___/ ____/     /  __/_/ /_/ / 
+_ __ ___ /_/    \__,_/____/\__/_/  /_/\____/_/         /_____(_)____/  
+
+""".lstrip("\n")
+
+
+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)
+    """
+
+    # Create the logo text
+    logo_text = Text(LOGO_ASCII, style="bold green")
+
+    # Create the information table
+    info_table = Table.grid(padding=(0, 1))
+    info_table.add_column(style="bold", justify="center")  # Emoji column
+    info_table.add_column(style="bold cyan", justify="left")  # Label column
+    info_table.add_column(style="white", justify="left")  # Value column
+
+    match transport:
+        case "http" | "streamable-http":
+            display_transport = "Streamable-HTTP"
+        case "sse":
+            display_transport = "SSE"
+        case "stdio":
+            display_transport = "STDIO"
+
+    info_table.add_row("🖥️", "Server name:", server.name)
+    info_table.add_row("📦", "Transport:", display_transport)
+
+    # Show connection info based on transport
+    if transport in ("http", "streamable-http", "sse"):
+        if 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("🚀", "Deploy:", "https://fastmcp.cloud")
+
+    # Add version information with explicit style overrides
+    info_table.add_row("", "", "")
+    info_table.add_row(
+        "🏎️",
+        "FastMCP version:",
+        Text(fastmcp.__version__, style="dim white", no_wrap=True),
+    )
+    info_table.add_row(
+        "🤝",
+        "MCP version:",
+        Text(version("mcp"), style="dim white", no_wrap=True),
+    )
+    # Create panel with logo and information using Group
+    panel_content = Group(logo_text, "", info_table)
+
+    panel = Panel(
+        panel_content,
+        title="FastMCP 2.0",
+        title_align="left",
+        border_style="dim",
+        padding=(2, 5),
+        expand=False,
+    )
+
+    console = Console(stderr=True)
+    console.print(Group("\n", panel, "\n"))

fastmcp/utilities/logging.py

@@ -50,3 +50,6 @@ def configure_logging(
         logger.removeHandler(hdlr)
 
     logger.addHandler(handler)
+
+    # Don't propagate to the root logger
+    logger.propagate = False

fastmcp/utilities/mcp_config.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import datetime
 import re
 from typing import TYPE_CHECKING, Annotated, Any, Literal
 from urllib.parse import urlparse
@@ -65,6 +66,7 @@ class RemoteMCPServer(FastMCPBaseModel):
             description='Either a string representing a Bearer token, the literal "oauth" to use OAuth authentication, or an httpx.Auth instance for custom authentication.',
         ),
     ] = None
+    sse_read_timeout: datetime.timedelta | int | float | None = None
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
@@ -77,11 +79,19 @@ class RemoteMCPServer(FastMCPBaseModel):
             transport = self.transport
 
         if transport == "sse":
-            return SSETransport(self.url, headers=self.headers, auth=self.auth)
+            return SSETransport(
+                self.url,
+                headers=self.headers,
+                auth=self.auth,
+                sse_read_timeout=self.sse_read_timeout,
+            )
         else:
             # Both "http" and "streamable-http" map to StreamableHttpTransport
             return StreamableHttpTransport(
-                self.url, headers=self.headers, auth=self.auth
+                self.url,
+                headers=self.headers,
+                auth=self.auth,
+                sse_read_timeout=self.sse_read_timeout,
             )
 
 

fastmcp/utilities/tests.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import copy
+import logging
 import multiprocessing
 import socket
 import time
@@ -129,3 +130,15 @@ def run_server_in_process(
         proc.join(timeout=2)
         if proc.is_alive():
             raise RuntimeError("Server process failed to terminate even after kill")
+
+
+@contextmanager
+def caplog_for_fastmcp(caplog):
+    """Context manager to capture logs from FastMCP loggers even when propagation is disabled."""
+    caplog.clear()
+    logger = logging.getLogger("FastMCP")
+    logger.addHandler(caplog.handler)
+    try:
+        yield
+    finally:
+        logger.removeHandler(caplog.handler)

fastmcp/utilities/types.py

@@ -3,6 +3,7 @@
 import base64
 import inspect
 import mimetypes
+import os
 from collections.abc import Callable
 from functools import lru_cache
 from pathlib import Path
@@ -101,7 +102,7 @@ class Image:
         if path is not None and data is not None:
             raise ValueError("Only one of path or data can be provided")
 
-        self.path = Path(path) if path else None
+        self.path = Path(os.path.expandvars(str(path))).expanduser() if path else None
         self.data = data
         self._format = format
         self._mime_type = self._get_mime_type()
@@ -160,7 +161,7 @@ class Audio:
         if path is not None and data is not None:
             raise ValueError("Only one of path or data can be provided")
 
-        self.path = Path(path) if path else None
+        self.path = Path(os.path.expandvars(str(path))).expanduser() if path else None
         self.data = data
         self._format = format
         self._mime_type = self._get_mime_type()
@@ -219,7 +220,7 @@ class File:
         if path is not None and data is not None:
             raise ValueError("Only one of path or data can be provided")
 
-        self.path = Path(path) if path else None
+        self.path = Path(os.path.expandvars(str(path))).expanduser() if path else None
         self.data = data
         self._format = format
         self._mime_type = self._get_mime_type()

{fastmcp-2.10.1.dist-info → fastmcp-2.10.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.10.1
+Version: 2.10.2
 Summary: The fast, Pythonic way to build MCP servers.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp

{fastmcp-2.10.1.dist-info → fastmcp-2.10.2.dist-info}/RECORD

@@ -1,21 +1,21 @@
 fastmcp/__init__.py,sha256=5ChT4kg3srdFl0-9dZekGqpzCESlpc6ohrfPbWf1aTo,1300
 fastmcp/exceptions.py,sha256=-krEavxwddQau6T7MESCR4VjKNLfP9KHJrU1p3y72FU,744
 fastmcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastmcp/settings.py,sha256=yC3f0ITEWYeit37-wnF0G12klTw_hjrWjCr6oZtUT8o,8329
+fastmcp/settings.py,sha256=Ta0TKA75xda9sNkIOpPVIEEk4W9jf_2gwcmO26uDQpg,8946
 fastmcp/cli/__init__.py,sha256=Ii284TNoG5lxTP40ETMGhHEq3lQZWxu9m9JuU57kUpQ,87
 fastmcp/cli/claude.py,sha256=IAlcZ4qZKBBj09jZUMEx7EANZE_IR3vcu7zOBJmMOuU,4567
-fastmcp/cli/cli.py,sha256=598s1S-KdqIB85mwqvXJaBVen6xYY65ek4v-q3lmY4k,15933
-fastmcp/cli/run.py,sha256=Pw3vH5wKRHfbmHRn0saIbC4l450KPOzeQbzPFqG4AbY,6208
+fastmcp/cli/cli.py,sha256=uJqUvFuyN7uslaCe5FHKp-EKdIRY5mRr-81f0c1r4PA,16257
+fastmcp/cli/run.py,sha256=JKBcy935Jy59WInwEaKt1gZkRDIESB7CRw_Oj987PVw,6301
 fastmcp/client/__init__.py,sha256=kd2hhSuD8rZuF87c9zlPJP_icJ-Rx3exyNoK0EzfOtE,617
 fastmcp/client/client.py,sha256=8Sx7NxnnF5IMv9E-J0MXjTI_TfhlM3j0mD1Rh-LXQJI,29213
-fastmcp/client/elicitation.py,sha256=8eWZpXbRFctZGgulyJ_GGI4GYXqAFf5Zp47vYTRD4fc,2155
+fastmcp/client/elicitation.py,sha256=Jf9yqna8R7r1hqedXAyh9a2-QNVzbCSKUDZhkFHqHqg,2403
 fastmcp/client/logging.py,sha256=7GJ-BLFW16_IOJPlGTNEWPP0P-yqqRpmsLdiKrlVsw8,757
 fastmcp/client/messages.py,sha256=NIPjt-5js_DkI5BD4OVdTf6pz-nGjc2dtbgt-vAY234,4329
 fastmcp/client/oauth_callback.py,sha256=ODAnVX-ettL82RuI5KpfkKf8iDtYMDue3Tnab5sjQtM,10071
 fastmcp/client/progress.py,sha256=WjLLDbUKMsx8DK-fqO7AGsXb83ak-6BMrLvzzznGmcI,1043
 fastmcp/client/roots.py,sha256=IxI_bHwHTmg6c2H-s1av1ZgrRnNDieHtYwdGFbzXT5c,2471
 fastmcp/client/sampling.py,sha256=Q8PzYCERa1W3xGGI9I9QOhhDM-M4i3P5lESb0cp2iI8,1595
-fastmcp/client/transports.py,sha256=liHLuOcgKotdlhTJBOiSn73WX0v7mnFa853hJBdu-2E,33898
+fastmcp/client/transports.py,sha256=DNzvZGbe5q_rvk1C0bifejk7Gh561h-QTGGlyqwiSxM,33813
 fastmcp/client/auth/__init__.py,sha256=4DNsfp4iaQeBcpds0JDdMn6Mmfud44stWLsret0sVKY,91
 fastmcp/client/auth/bearer.py,sha256=MFEFqcH6u_V86msYiOsEFKN5ks1V9BnBNiPsPLHUTqo,399
 fastmcp/client/auth/oauth.py,sha256=pSyuI0FlRK1qkBA6mvq-bxKzl2B-pMCvPPzIByTJBEo,11745
@@ -48,12 +48,12 @@ fastmcp/server/elicitation.py,sha256=jZIHjV4NjhYbT-w8pBArwd0vNzP8OYwzmsnWDdk6Bd0
 fastmcp/server/http.py,sha256=d0Jij4HVTaAohluRXArSniXLb1HcHP3ytbe-mMHg6nE,11678
 fastmcp/server/low_level.py,sha256=LNmc_nU_wx-fRG8OEHdLPKopZpovcrWlyAxJzKss3TA,1239
 fastmcp/server/openapi.py,sha256=ALIbl0r2T1cvbSeFwz6HpIzut2akdngAtKDdWGyIWHs,36221
-fastmcp/server/proxy.py,sha256=Ofx7P5rU7mKVPDjvvIKjQS7_C1w4-1UiKc78x7AdjN8,15211
-fastmcp/server/server.py,sha256=XKt0vGwQNopBnYvciJtbJ_FVDt1uuwwuxrAcrVBJGa8,79703
+fastmcp/server/proxy.py,sha256=NNyxtbOCJeKM-zRoaPCkVk26c7LHViHXNFfy95aXnAM,19591
+fastmcp/server/server.py,sha256=KM1-dfwIoRiTYSLI5IvZ1Zy1imAkS3ILZ1QeRCgLNvY,81153
 fastmcp/server/auth/__init__.py,sha256=doHCLwOIElvH1NrTdpeP9JKfnNf3MDYPSpQfdsQ-uI0,84
 fastmcp/server/auth/auth.py,sha256=A00OKxglEMrGMMIiMbc6UmpGc2VoWDkEVU5g2pIzDIg,2119
 fastmcp/server/auth/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastmcp/server/auth/providers/bearer.py,sha256=iRExt5hRKmrwr7MjsUN-UdQDe-iCSjH7sNCURaK7HBs,16456
+fastmcp/server/auth/providers/bearer.py,sha256=rjwuKFgCm4fLsAQzUaIaE8OD6bml3sBaO7NYq3Wgs24,16718
 fastmcp/server/auth/providers/bearer_env.py,sha256=NYPCW363Q8u8BdiPPz1FdB3_kwmbCaWT5yKdAO-ZgwA,2081
 fastmcp/server/auth/providers/in_memory.py,sha256=Sb3GOtLL2bWbm8z-T8cEsMz1qcQUSHpPEEgYRvTOQi4,14251
 fastmcp/server/middleware/__init__.py,sha256=m1QJFQ7JW_2JHpJp1FurBNYaxbBUa_HyDn1Bw9mtyvc,367
@@ -68,19 +68,20 @@ fastmcp/tools/tool_manager.py,sha256=Sm_tOO-SY0m7tEN_dofP-tvBnC2HroPRKLU6sp8gnUw
 fastmcp/tools/tool_transform.py,sha256=YY2DZdJZ6fEGtgEP1Djrc49F8rAEyx6fgRGEyIGaxPE,32601
 fastmcp/utilities/__init__.py,sha256=-imJ8S-rXmbXMWeDamldP-dHDqAPg_wwmPVz-LNX14E,31
 fastmcp/utilities/cache.py,sha256=aV3oZ-ZhMgLSM9iAotlUlEy5jFvGXrVo0Y5Bj4PBtqY,707
+fastmcp/utilities/cli.py,sha256=n3HA8IXg7hKaizuM3SRCW65UMXlqjUDf5USRSuscTdY,3287
 fastmcp/utilities/components.py,sha256=WIxNVZ7YxCLpdIm_pbTYeP0lAxikvgptVYhIL0LVmCc,2535
 fastmcp/utilities/exceptions.py,sha256=7Z9j5IzM5rT27BC1Mcn8tkS-bjqCYqMKwb2MMTaxJYU,1350
 fastmcp/utilities/http.py,sha256=1ns1ymBS-WSxbZjGP6JYjSO52Wa_ls4j4WbnXiupoa4,245
 fastmcp/utilities/inspect.py,sha256=XNA0dfYM5G-FVbJaVJO8loSUUCNypyLA-QjqTOneJyU,10833
 fastmcp/utilities/json_schema.py,sha256=K0QH5UazBD_tweBi-TguWYjUu5Lgp9wcM-wT42Fet5w,5022
 fastmcp/utilities/json_schema_type.py,sha256=Sml03nJGOnUfxCGrHWRMwZMultV0X5JThMepUnHIUiA,22377
-fastmcp/utilities/logging.py,sha256=B1WNO-ZWFjd9wiFSh13YtW1hAKaNmbpscDZleIAhr-g,1317
-fastmcp/utilities/mcp_config.py,sha256=ryjAfJUPquDSoKdSymPH4M2B0WvuM3pWUGI3cOgAX80,2782
+fastmcp/utilities/logging.py,sha256=1y7oNmy8WrR0NsfNVw1LPoKu92OFdmzIO65syOKi_BI,1388
+fastmcp/utilities/mcp_config.py,sha256=uGmkepcNpS_7HEuaK3465OcwcmebHGyvUddOjLfw1jY,3075
 fastmcp/utilities/openapi.py,sha256=neeaXwwn1OWdUp0Gawhx4SJHLfV78gXU5OMMTFGeD24,45235
-fastmcp/utilities/tests.py,sha256=O9hRSjnyaYQqu1RJ-CFBw1cIjezlwSQtS-Ea_iqO4sY,3899
-fastmcp/utilities/types.py,sha256=SWtzKpIr9TMeOE6TyPgqSi-SBXpWBPUnA5QPiP4nDzw,10512
-fastmcp-2.10.1.dist-info/METADATA,sha256=I0_44sR-kc7BcTHdA1mLy4f9zASLk6hCiOWjrcxBfk8,17796
-fastmcp-2.10.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fastmcp-2.10.1.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
-fastmcp-2.10.1.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-fastmcp-2.10.1.dist-info/RECORD,,
+fastmcp/utilities/tests.py,sha256=kZH8HQAC702a5vNJb4K0tO1ll9CZADWQ_P-5ERWSvSA,4242
+fastmcp/utilities/types.py,sha256=c6HPvHCpkq8EXh0hWjaUlj9aCZklmxzAQHCXZy7llNo,10636
+fastmcp-2.10.2.dist-info/METADATA,sha256=zvfV88PXJiHci0YJfQIrgPsaOvDaVsMVHUIHB6mtgCU,17796
+fastmcp-2.10.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fastmcp-2.10.2.dist-info/entry_points.txt,sha256=ff8bMtKX1JvXyurMibAacMSKbJEPmac9ffAKU9mLnM8,44
+fastmcp-2.10.2.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+fastmcp-2.10.2.dist-info/RECORD,,