fastmcp 2.12.1__py3-none-any.whl → 2.12.3__py3-none-any.whl

fastmcp/client/transports.py

@@ -609,7 +609,7 @@ class UvStdioTransport(StdioTransport):
         uv_args: list[str] = []
 
         # Check if we need any environment setup
-        if env_config.needs_uv():
+        if env_config._must_run_with_uv():
             # Use the config to build args, but we need to handle the command differently
             # since transport has specific needs
             uv_args = ["run"]

fastmcp/contrib/component_manager/component_service.py

@@ -174,7 +174,7 @@ class ComponentService:
             key: The key of the prompt to enable
 
         Returns:
-            The prompt that was enable
+            The prompt that was enabled
         """
         logger.debug("Enabling prompt: %s", key)
 

fastmcp/contrib/mcp_mixin/README.md

@@ -16,7 +16,7 @@ Prompts:
 * [enable/disable](https://gofastmcp.com/servers/prompts#disabling-prompts)
 
 Resources:
-* [enable/disabe](https://gofastmcp.com/servers/resources#disabling-resources)
+* [enable/disable](https://gofastmcp.com/servers/resources#disabling-resources)
   
 ## Usage
 

fastmcp/contrib/mcp_mixin/mcp_mixin.py

@@ -8,6 +8,7 @@ from mcp.types import ToolAnnotations
 from fastmcp.prompts.prompt import Prompt
 from fastmcp.resources.resource import Resource
 from fastmcp.tools.tool import Tool
+from fastmcp.utilities.types import get_fn_name
 
 if TYPE_CHECKING:
     from fastmcp.server import FastMCP
@@ -34,7 +35,7 @@ def mcp_tool(
 
     def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
         call_args = {
-            "name": name or func.__name__,
+            "name": name or get_fn_name(func),
             "description": description,
             "tags": tags,
             "annotations": annotations,
@@ -63,7 +64,7 @@ def mcp_resource(
     def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
         call_args = {
             "uri": uri,
-            "name": name or func.__name__,
+            "name": name or get_fn_name(func),
             "description": description,
             "mime_type": mime_type,
             "tags": tags,
@@ -88,7 +89,7 @@ def mcp_prompt(
 
     def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
         call_args = {
-            "name": name or func.__name__,
+            "name": name or get_fn_name(func),
             "description": description,
             "tags": tags,
             "enabled": enabled,
@@ -146,7 +147,21 @@ class MCPMixin:
                 registration_info["name"] = (
                     f"{prefix}{separator}{registration_info['name']}"
                 )
-            tool = Tool.from_function(fn=method, **registration_info)
+
+            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"),
+                exclude_args=registration_info.get("exclude_args"),
+                serializer=registration_info.get("serializer"),
+                output_schema=registration_info.get("output_schema"),
+                meta=registration_info.get("meta"),
+                enabled=registration_info.get("enabled"),
+            )
+
             mcp_server.add_tool(tool)
 
     def register_resources(
@@ -175,7 +190,19 @@ class MCPMixin:
                 registration_info["uri"] = (
                     f"{prefix}{separator}{registration_info['uri']}"
                 )
-            resource = Resource.from_function(fn=method, **registration_info)
+
+            resource = Resource.from_function(
+                fn=method,
+                uri=registration_info["uri"],
+                name=registration_info.get("name"),
+                description=registration_info.get("description"),
+                mime_type=registration_info.get("mime_type"),
+                tags=registration_info.get("tags"),
+                enabled=registration_info.get("enabled"),
+                annotations=registration_info.get("annotations"),
+                meta=registration_info.get("meta"),
+            )
+
             mcp_server.add_resource(resource)
 
     def register_prompts(
@@ -200,7 +227,15 @@ class MCPMixin:
                 registration_info["name"] = (
                     f"{prefix}{separator}{registration_info['name']}"
                 )
-            prompt = Prompt.from_function(fn=method, **registration_info)
+            prompt = Prompt.from_function(
+                fn=method,
+                name=registration_info.get("name"),
+                title=registration_info.get("title"),
+                description=registration_info.get("description"),
+                tags=registration_info.get("tags"),
+                enabled=registration_info.get("enabled"),
+                meta=registration_info.get("meta"),
+            )
             mcp_server.add_prompt(prompt)
 
     def register_all(

fastmcp/experimental/utilities/openapi/director.py

@@ -69,7 +69,14 @@ class RequestDirector:
                 request_data["content"] = body
 
         # Step 5: Create httpx.Request
-        return httpx.Request(**{k: v for k, v in request_data.items() if v is not None})
+        return httpx.Request(
+            method=request_data["method"],
+            url=request_data["url"],
+            params=request_data.get("params"),
+            headers=request_data.get("headers"),
+            json=request_data.get("json"),
+            content=request_data.get("content"),
+        )
 
     def _unflatten_arguments(
         self, route: HTTPRoute, flat_args: dict[str, Any]

fastmcp/prompts/prompt.py

@@ -100,14 +100,16 @@ class Prompt(FastMCPComponent, ABC):
             )
             for arg in self.arguments or []
         ]
-        kwargs = {
-            "name": self.name,
-            "description": self.description,
-            "arguments": arguments,
-            "title": self.title,
-            "_meta": self.get_meta(include_fastmcp_meta=include_fastmcp_meta),
-        }
-        return MCPPrompt(**kwargs | overrides)
+
+        return MCPPrompt(
+            name=overrides.get("name", self.name),
+            description=overrides.get("description", self.description),
+            arguments=arguments,
+            title=overrides.get("title", self.title),
+            _meta=overrides.get(
+                "_meta", self.get_meta(include_fastmcp_meta=include_fastmcp_meta)
+            ),
+        )
 
     @staticmethod
     def from_function(

fastmcp/resources/resource.py

@@ -24,6 +24,7 @@ from fastmcp.server.dependencies import get_context
 from fastmcp.utilities.components import FastMCPComponent
 from fastmcp.utilities.types import (
     find_kwarg_by_type,
+    get_fn_name,
 )
 
 if TYPE_CHECKING:
@@ -122,16 +123,18 @@ class Resource(FastMCPComponent, abc.ABC):
         **overrides: Any,
     ) -> MCPResource:
         """Convert the resource to an MCPResource."""
-        kwargs = {
-            "uri": self.uri,
-            "name": self.name,
-            "description": self.description,
-            "mimeType": self.mime_type,
-            "title": self.title,
-            "annotations": self.annotations,
-            "_meta": self.get_meta(include_fastmcp_meta=include_fastmcp_meta),
-        }
-        return MCPResource(**kwargs | overrides)
+
+        return MCPResource(
+            name=overrides.get("name", self.name),
+            uri=overrides.get("uri", self.uri),
+            description=overrides.get("description", self.description),
+            mimeType=overrides.get("mimeType", self.mime_type),
+            title=overrides.get("title", self.title),
+            annotations=overrides.get("annotations", self.annotations),
+            _meta=overrides.get(
+                "_meta", self.get_meta(include_fastmcp_meta=include_fastmcp_meta)
+            ),
+        )
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}(uri={self.uri!r}, name={self.name!r}, description={self.description!r}, tags={self.tags})"
@@ -182,7 +185,7 @@ class FunctionResource(Resource):
         return cls(
             fn=fn,
             uri=uri,
-            name=name or fn.__name__,
+            name=name or get_fn_name(fn),
             title=title,
             description=description or inspect.getdoc(fn),
             mime_type=mime_type or "text/plain",

fastmcp/resources/template.py

@@ -154,16 +154,18 @@ class ResourceTemplate(FastMCPComponent):
         **overrides: Any,
     ) -> MCPResourceTemplate:
         """Convert the resource template to an MCPResourceTemplate."""
-        kwargs = {
-            "uriTemplate": self.uri_template,
-            "name": self.name,
-            "description": self.description,
-            "mimeType": self.mime_type,
-            "title": self.title,
-            "annotations": self.annotations,
-            "_meta": self.get_meta(include_fastmcp_meta=include_fastmcp_meta),
-        }
-        return MCPResourceTemplate(**kwargs | overrides)
+
+        return MCPResourceTemplate(
+            name=overrides.get("name", self.name),
+            uriTemplate=overrides.get("uriTemplate", self.uri_template),
+            description=overrides.get("description", self.description),
+            mimeType=overrides.get("mimeType", self.mime_type),
+            title=overrides.get("title", self.title),
+            annotations=overrides.get("annotations", self.annotations),
+            _meta=overrides.get(
+                "_meta", self.get_meta(include_fastmcp_meta=include_fastmcp_meta)
+            ),
+        )
 
     @classmethod
     def from_mcp_template(cls, mcp_template: MCPResourceTemplate) -> ResourceTemplate:

fastmcp/server/auth/auth.py

@@ -353,10 +353,16 @@ class OAuthProvider(
 
         # Add protected resource routes if this server is also acting as a resource server
         if resource_url:
+            supported_scopes = (
+                self.client_registration_options.valid_scopes
+                if self.client_registration_options
+                and self.client_registration_options.valid_scopes
+                else self.required_scopes
+            )
             protected_routes = create_protected_resource_routes(
                 resource_url=resource_url,
                 authorization_servers=[self.issuer_url],
-                scopes_supported=self.required_scopes,
+                scopes_supported=supported_scopes,
             )
             oauth_routes.extend(protected_routes)
 

fastmcp/server/auth/oauth_proxy.py

@@ -250,6 +250,10 @@ class OAuthProxy(OAuthProvider):
         forward_pkce: bool = True,
         # Token endpoint authentication
         token_endpoint_auth_method: str | None = None,
+        # Extra parameters to forward to authorization endpoint
+        extra_authorize_params: dict[str, str] | None = None,
+        # Extra parameters to forward to token endpoint
+        extra_token_params: dict[str, str] | None = None,
     ):
         """Initialize the OAuth proxy provider.
 
@@ -278,6 +282,11 @@ class OAuthProxy(OAuthProvider):
             token_endpoint_auth_method: Token endpoint authentication method for upstream server.
                 Common values: "client_secret_basic", "client_secret_post", "none".
                 If None, authlib will use its default (typically "client_secret_basic").
+            extra_authorize_params: Additional parameters to forward to the upstream authorization endpoint.
+                Useful for provider-specific parameters like Auth0's "audience".
+                Example: {"audience": "https://api.example.com"}
+            extra_token_params: Additional parameters to forward to the upstream token endpoint.
+                Useful for provider-specific parameters during token exchange.
         """
         # Always enable DCR since we implement it locally for MCP clients
         client_registration_options = ClientRegistrationOptions(
@@ -319,6 +328,10 @@ class OAuthProxy(OAuthProvider):
         # Token endpoint authentication
         self._token_endpoint_auth_method = token_endpoint_auth_method
 
+        # Extra parameters for authorization and token endpoints
+        self._extra_authorize_params = extra_authorize_params or {}
+        self._extra_token_params = extra_token_params or {}
+
         # Local state for DCR and token bookkeeping
         self._clients: dict[str, OAuthClientInformationFull] = {}
         self._access_tokens: dict[str, AccessToken] = {}
@@ -485,6 +498,24 @@ class OAuthProxy(OAuthProvider):
                 txn_id,
             )
 
+        # Forward resource parameter if provided (RFC 8707)
+        if params.resource:
+            query_params["resource"] = params.resource
+            logger.debug(
+                "Forwarding resource indicator '%s' to upstream for transaction %s",
+                params.resource,
+                txn_id,
+            )
+
+        # Add any extra authorization parameters configured for this proxy
+        if self._extra_authorize_params:
+            query_params.update(self._extra_authorize_params)
+            logger.debug(
+                "Adding extra authorization parameters for transaction %s: %s",
+                txn_id,
+                list(self._extra_authorize_params.keys()),
+            )
+
         # Build the upstream authorization URL
         separator = "&" if "?" in self._upstream_authorization_endpoint else "?"
         upstream_url = f"{self._upstream_authorization_endpoint}{separator}{urlencode(query_params)}"
@@ -870,26 +901,35 @@ class OAuthProxy(OAuthProvider):
                     f"Exchanging IdP code for tokens with redirect_uri: {idp_redirect_uri}"
                 )
 
+                # Build token exchange parameters
+                token_params = {
+                    "url": self._upstream_token_endpoint,
+                    "code": idp_code,
+                    "redirect_uri": idp_redirect_uri,
+                }
+
                 # Include proxy's code_verifier if we forwarded PKCE
                 proxy_code_verifier = transaction.get("proxy_code_verifier")
                 if proxy_code_verifier:
+                    token_params["code_verifier"] = proxy_code_verifier
                     logger.debug(
                         "Including proxy code_verifier in token exchange for transaction %s",
                         txn_id,
                     )
-                    idp_tokens: dict[str, Any] = await oauth_client.fetch_token(  # type: ignore[misc]
-                        url=self._upstream_token_endpoint,
-                        code=idp_code,
-                        redirect_uri=idp_redirect_uri,
-                        code_verifier=proxy_code_verifier,
-                    )
-                else:
-                    idp_tokens: dict[str, Any] = await oauth_client.fetch_token(  # type: ignore[misc]
-                        url=self._upstream_token_endpoint,
-                        code=idp_code,
-                        redirect_uri=idp_redirect_uri,
+
+                # Add any extra token parameters configured for this proxy
+                if self._extra_token_params:
+                    token_params.update(self._extra_token_params)
+                    logger.debug(
+                        "Adding extra token parameters for transaction %s: %s",
+                        txn_id,
+                        list(self._extra_token_params.keys()),
                     )
 
+                idp_tokens: dict[str, Any] = await oauth_client.fetch_token(
+                    **token_params
+                )  # type: ignore[misc]
+
                 logger.debug(
                     f"Successfully exchanged IdP code for tokens (transaction: {txn_id}, PKCE: {bool(proxy_code_verifier)})"
                 )

fastmcp/server/context.py

@@ -85,18 +85,18 @@ class Context:
 
     ```python
     @server.tool
-    def my_tool(x: int, ctx: Context) -> str:
+    async def my_tool(x: int, ctx: Context) -> str:
         # Log messages to the client
-        ctx.info(f"Processing {x}")
-        ctx.debug("Debug info")
-        ctx.warning("Warning message")
-        ctx.error("Error message")
+        await ctx.info(f"Processing {x}")
+        await ctx.debug("Debug info")
+        await ctx.warning("Warning message")
+        await ctx.error("Error message")
 
         # Report progress
-        ctx.report_progress(50, 100, "Processing")
+        await ctx.report_progress(50, 100, "Processing")
 
         # Access resources
-        data = ctx.read_resource("resource://data")
+        data = await ctx.read_resource("resource://data")
 
         # Get request info
         request_id = ctx.request_id
@@ -449,7 +449,7 @@ class Context:
         AcceptedElicitation[dict[str, Any]] | DeclinedElicitation | CancelledElicitation
     ): ...
 
-    """When response_type is None, the accepted elicitaiton will contain an
+    """When response_type is None, the accepted elicitation will contain an
     empty dict"""
 
     @overload
@@ -459,7 +459,7 @@ class Context:
         response_type: type[T],
     ) -> AcceptedElicitation[T] | DeclinedElicitation | CancelledElicitation: ...
 
-    """When response_type is not None, the accepted elicitaiton will contain the
+    """When response_type is not None, the accepted elicitation will contain the
     response data"""
 
     @overload
@@ -469,7 +469,7 @@ class Context:
         response_type: list[str],
     ) -> AcceptedElicitation[str] | DeclinedElicitation | CancelledElicitation: ...
 
-    """When response_type is a list of strings, the accepted elicitaiton will
+    """When response_type is a list of strings, the accepted elicitation will
     contain the selected string response"""
 
     async def elicit(

fastmcp/server/dependencies.py

@@ -5,6 +5,9 @@ from typing import TYPE_CHECKING
 from mcp.server.auth.middleware.auth_context import (
     get_access_token as _sdk_get_access_token,
 )
+from mcp.server.auth.provider import (
+    AccessToken as _SDKAccessToken,
+)
 from starlette.requests import Request
 
 from fastmcp.server.auth import AccessToken
@@ -107,17 +110,27 @@ def get_access_token() -> AccessToken | None:
         The access token if an authenticated user is available, None otherwise.
     """
     #
-    obj = _sdk_get_access_token()
-    if obj is None or isinstance(obj, AccessToken):
-        return obj
+    access_token: _SDKAccessToken | None = _sdk_get_access_token()
+
+    if access_token is None or isinstance(access_token, AccessToken):
+        return access_token
 
     # If the object is not a FastMCP AccessToken, convert it to one if the fields are compatible
     # This is a workaround for the case where the SDK returns a different type
     # If it fails, it will raise a TypeError
     try:
-        return AccessToken(**obj.model_dump())
+        access_token_as_dict = access_token.model_dump()
+        return AccessToken(
+            token=access_token_as_dict["token"],
+            client_id=access_token_as_dict["client_id"],
+            scopes=access_token_as_dict["scopes"],
+            # Optional fields
+            expires_at=access_token_as_dict.get("expires_at"),
+            resource_owner=access_token_as_dict.get("resource_owner"),
+            claims=access_token_as_dict.get("claims"),
+        )
     except Exception as e:
         raise TypeError(
-            f"Expected fastmcp.server.auth.auth.AccessToken, got {type(obj).__name__}. "
+            f"Expected fastmcp.server.auth.auth.AccessToken, got {type(access_token).__name__}. "
             "Ensure the SDK is using the correct AccessToken type."
         ) from e

fastmcp/server/server.py

@@ -812,6 +812,8 @@ class FastMCP(Generic[LifespanResultT]):
 
         Delegates to _get_prompt, which should be overridden by FastMCP subclasses.
         """
+        import fastmcp.server.context
+
         logger.debug(
             f"[{self.name}] Handler called: get_prompt %s with %s", name, arguments
         )
@@ -1208,8 +1210,8 @@ class FastMCP(Generic[LifespanResultT]):
                 return f"Weather for {city}"
 
             @server.resource("resource://{city}/weather")
-            def get_weather_with_context(city: str, ctx: Context) -> str:
-                ctx.info(f"Fetching weather for {city}")
+            async def get_weather_with_context(city: str, ctx: Context) -> str:
+                await ctx.info(f"Fetching weather for {city}")
                 return f"Weather for {city}"
 
             @server.resource("resource://{city}/weather")
@@ -1384,8 +1386,8 @@ class FastMCP(Generic[LifespanResultT]):
                 ]
 
             @server.prompt()
-            def analyze_with_context(table_name: str, ctx: Context) -> list[Message]:
-                ctx.info(f"Analyzing table {table_name}")
+            async def analyze_with_context(table_name: str, ctx: Context) -> list[Message]:
+                await ctx.info(f"Analyzing table {table_name}")
                 schema = read_table_schema(table_name)
                 return [
                     {
@@ -1395,7 +1397,7 @@ class FastMCP(Generic[LifespanResultT]):
                 ]
 
             @server.prompt("custom_name")
-            def analyze_file(path: str) -> list[Message]:
+            async def analyze_file(path: str) -> list[Message]:
                 content = await read_file(path)
                 return [
                     {

fastmcp/settings.py

@@ -272,7 +272,7 @@ class Settings(BaseSettings):
 
                 If None, no automatic configuration will take place.
 
-                This setting is *always* overriden by any auth provider passed to the
+                This setting is *always* overridden by any auth provider passed to the
                 FastMCP constructor.
 
                 Note that most auth providers require additional configuration
@@ -343,6 +343,20 @@ class Settings(BaseSettings):
         ),
     ] = False
 
+    show_cli_banner: Annotated[
+        bool,
+        Field(
+            default=True,
+            description=inspect.cleandoc(
+                """
+                If True, the server banner will be displayed when running the server via CLI.
+                This setting can be overridden by the --no-banner CLI flag.
+                Set to False via FASTMCP_SHOW_CLI_BANNER=false to suppress the banner.
+                """
+            ),
+        ),
+    ] = True
+
 
 def __getattr__(name: str):
     """