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

fastmcp/experimental/sampling/handlers/openai.py

@@ -1,170 +1,5 @@
-from collections.abc import Iterator, Sequence
-from typing import get_args
+# Re-export for backwards compatibility
+# The canonical location is now fastmcp.client.sampling.handlers.openai
+from fastmcp.client.sampling.handlers.openai import OpenAISamplingHandler
 
-from mcp import ClientSession, ServerSession
-from mcp.shared.context import LifespanContextT, RequestContext
-from mcp.types import CreateMessageRequestParams as SamplingParams
-from mcp.types import (
-    CreateMessageResult,
-    ModelPreferences,
-    SamplingMessage,
-    TextContent,
-)
-
-try:
-    from openai import NOT_GIVEN, OpenAI
-    from openai.types.chat import (
-        ChatCompletion,
-        ChatCompletionAssistantMessageParam,
-        ChatCompletionMessageParam,
-        ChatCompletionSystemMessageParam,
-        ChatCompletionUserMessageParam,
-    )
-    from openai.types.shared.chat_model import ChatModel
-except ImportError as e:
-    raise ImportError(
-        "The `openai` package is not installed. Please install `fastmcp[openai]` or add `openai` to your dependencies manually."
-    ) from e
-
-from typing_extensions import override
-
-from fastmcp.experimental.sampling.handlers.base import BaseLLMSamplingHandler
-
-
-class OpenAISamplingHandler(BaseLLMSamplingHandler):
-    def __init__(self, default_model: ChatModel, client: OpenAI | None = None):
-        self.client: OpenAI = client or OpenAI()
-        self.default_model: ChatModel = default_model
-
-    @override
-    async def __call__(
-        self,
-        messages: list[SamplingMessage],
-        params: SamplingParams,
-        context: RequestContext[ServerSession, LifespanContextT]
-        | RequestContext[ClientSession, LifespanContextT],
-    ) -> CreateMessageResult:
-        openai_messages: list[ChatCompletionMessageParam] = (
-            self._convert_to_openai_messages(
-                system_prompt=params.systemPrompt,
-                messages=messages,
-            )
-        )
-
-        model: ChatModel = self._select_model_from_preferences(params.modelPreferences)
-
-        response = self.client.chat.completions.create(
-            model=model,
-            messages=openai_messages,
-            temperature=params.temperature or NOT_GIVEN,
-            max_tokens=params.maxTokens,
-            stop=params.stopSequences or NOT_GIVEN,
-        )
-
-        return self._chat_completion_to_create_message_result(response)
-
-    @staticmethod
-    def _iter_models_from_preferences(
-        model_preferences: ModelPreferences | str | list[str] | None,
-    ) -> Iterator[str]:
-        if model_preferences is None:
-            return
-
-        if isinstance(model_preferences, str) and model_preferences in get_args(
-            ChatModel
-        ):
-            yield model_preferences
-
-        if isinstance(model_preferences, list):
-            yield from model_preferences
-
-        if isinstance(model_preferences, ModelPreferences):
-            if not (hints := model_preferences.hints):
-                return
-
-            for hint in hints:
-                if not (name := hint.name):
-                    continue
-
-                yield name
-
-    @staticmethod
-    def _convert_to_openai_messages(
-        system_prompt: str | None, messages: Sequence[SamplingMessage]
-    ) -> list[ChatCompletionMessageParam]:
-        openai_messages: list[ChatCompletionMessageParam] = []
-
-        if system_prompt:
-            openai_messages.append(
-                ChatCompletionSystemMessageParam(
-                    role="system",
-                    content=system_prompt,
-                )
-            )
-
-        if isinstance(messages, str):
-            openai_messages.append(
-                ChatCompletionUserMessageParam(
-                    role="user",
-                    content=messages,
-                )
-            )
-
-        if isinstance(messages, list):
-            for message in messages:
-                if isinstance(message, str):
-                    openai_messages.append(
-                        ChatCompletionUserMessageParam(
-                            role="user",
-                            content=message,
-                        )
-                    )
-                    continue
-
-                if not isinstance(message.content, TextContent):
-                    raise ValueError("Only text content is supported")
-
-                if message.role == "user":
-                    openai_messages.append(
-                        ChatCompletionUserMessageParam(
-                            role="user",
-                            content=message.content.text,
-                        )
-                    )
-                else:
-                    openai_messages.append(
-                        ChatCompletionAssistantMessageParam(
-                            role="assistant",
-                            content=message.content.text,
-                        )
-                    )
-
-        return openai_messages
-
-    @staticmethod
-    def _chat_completion_to_create_message_result(
-        chat_completion: ChatCompletion,
-    ) -> CreateMessageResult:
-        if len(chat_completion.choices) == 0:
-            raise ValueError("No response for completion")
-
-        first_choice = chat_completion.choices[0]
-
-        if content := first_choice.message.content:
-            return CreateMessageResult(
-                content=TextContent(type="text", text=content),
-                role="assistant",
-                model=chat_completion.model,
-            )
-
-        raise ValueError("No content in response from completion")
-
-    def _select_model_from_preferences(
-        self, model_preferences: ModelPreferences | str | list[str] | None
-    ) -> ChatModel:
-        for model_option in self._iter_models_from_preferences(model_preferences):
-            if model_option in get_args(ChatModel):
-                chosen_model: ChatModel = model_option  # type: ignore[assignment]
-                return chosen_model
-
-        return self.default_model
+__all__ = ["OpenAISamplingHandler"]

fastmcp/prompts/prompt.py

@@ -9,8 +9,8 @@ from typing import Annotated, Any
 
 import pydantic_core
 from mcp.types import ContentBlock, Icon, PromptMessage, Role, TextContent
-from mcp.types import Prompt as MCPPrompt
-from mcp.types import PromptArgument as MCPPromptArgument
+from mcp.types import Prompt as SDKPrompt
+from mcp.types import PromptArgument as SDKPromptArgument
 from pydantic import Field, TypeAdapter
 
 from fastmcp.exceptions import PromptError
@@ -89,10 +89,10 @@ class Prompt(FastMCPComponent):
         *,
         include_fastmcp_meta: bool | None = None,
         **overrides: Any,
-    ) -> MCPPrompt:
+    ) -> SDKPrompt:
         """Convert the prompt to an MCP prompt."""
         arguments = [
-            MCPPromptArgument(
+            SDKPromptArgument(
                 name=arg.name,
                 description=arg.description,
                 required=arg.required,
@@ -100,7 +100,7 @@ class Prompt(FastMCPComponent):
             for arg in self.arguments or []
         ]
 
-        return MCPPrompt(
+        return SDKPrompt(
             name=overrides.get("name", self.name),
             description=overrides.get("description", self.description),
             arguments=arguments,

fastmcp/prompts/prompt_manager.py

@@ -7,7 +7,7 @@ from typing import Any
 from mcp import GetPromptResult
 
 from fastmcp import settings
-from fastmcp.exceptions import NotFoundError, PromptError
+from fastmcp.exceptions import FastMCPError, NotFoundError, PromptError
 from fastmcp.prompts.prompt import FunctionPrompt, Prompt, PromptResult
 from fastmcp.settings import DuplicateBehavior
 from fastmcp.utilities.logging import get_logger
@@ -107,9 +107,8 @@ class PromptManager:
         try:
             messages = await prompt.render(arguments)
             return GetPromptResult(description=prompt.description, messages=messages)
-        except PromptError as e:
-            logger.exception(f"Error rendering prompt {name!r}")
-            raise e
+        except FastMCPError:
+            raise
         except Exception as e:
             logger.exception(f"Error rendering prompt {name!r}")
             if self.mask_error_details:

fastmcp/resources/resource.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, Annotated, Any
 
 import pydantic_core
 from mcp.types import Annotations, Icon
-from mcp.types import Resource as MCPResource
+from mcp.types import Resource as SDKResource
 from pydantic import (
     AnyUrl,
     ConfigDict,
@@ -126,10 +126,10 @@ class Resource(FastMCPComponent):
         *,
         include_fastmcp_meta: bool | None = None,
         **overrides: Any,
-    ) -> MCPResource:
-        """Convert the resource to an MCPResource."""
+    ) -> SDKResource:
+        """Convert the resource to an SDKResource."""
 
-        return MCPResource(
+        return SDKResource(
             name=overrides.get("name", self.name),
             uri=overrides.get("uri", self.uri),
             description=overrides.get("description", self.description),

fastmcp/resources/resource_manager.py

@@ -10,7 +10,7 @@ from typing import Any
 from pydantic import AnyUrl
 
 from fastmcp import settings
-from fastmcp.exceptions import NotFoundError, ResourceError
+from fastmcp.exceptions import FastMCPError, NotFoundError, ResourceError
 from fastmcp.resources.resource import Resource
 from fastmcp.resources.template import (
     ResourceTemplate,
@@ -268,10 +268,9 @@ class ResourceManager:
                         uri_str,
                         params=params,
                     )
-                # Pass through ResourceErrors as-is
-                except ResourceError as e:
-                    logger.error(f"Error creating resource from template: {e}")
-                    raise e
+                # Pass through FastMCPErrors as-is
+                except FastMCPError:
+                    raise
                 # Handle other exceptions
                 except Exception as e:
                     logger.error(f"Error creating resource from template: {e}")
@@ -299,10 +298,9 @@ class ResourceManager:
             try:
                 return await resource.read()
 
-            # raise ResourceErrors as-is
-            except ResourceError as e:
-                logger.exception(f"Error reading resource {uri_str!r}")
-                raise e
+            # raise FastMCPErrors as-is
+            except FastMCPError:
+                raise
 
             # Handle other exceptions
             except Exception as e:
@@ -322,11 +320,8 @@ class ResourceManager:
                 try:
                     resource = await template.create_resource(uri_str, params=params)
                     return await resource.read()
-                except ResourceError as e:
-                    logger.exception(
-                        f"Error reading resource from template {uri_str!r}"
-                    )
-                    raise e
+                except FastMCPError:
+                    raise
                 except Exception as e:
                     logger.exception(
                         f"Error reading resource from template {uri_str!r}"

fastmcp/resources/template.py

@@ -9,7 +9,7 @@ from typing import Annotated, Any
 from urllib.parse import parse_qs, unquote
 
 from mcp.types import Annotations, Icon
-from mcp.types import ResourceTemplate as MCPResourceTemplate
+from mcp.types import ResourceTemplate as SDKResourceTemplate
 from pydantic import (
     Field,
     field_validator,
@@ -188,10 +188,10 @@ class ResourceTemplate(FastMCPComponent):
         *,
         include_fastmcp_meta: bool | None = None,
         **overrides: Any,
-    ) -> MCPResourceTemplate:
-        """Convert the resource template to an MCPResourceTemplate."""
+    ) -> SDKResourceTemplate:
+        """Convert the resource template to an SDKResourceTemplate."""
 
-        return MCPResourceTemplate(
+        return SDKResourceTemplate(
             name=overrides.get("name", self.name),
             uriTemplate=overrides.get("uriTemplate", self.uri_template),
             description=overrides.get("description", self.description),
@@ -205,7 +205,7 @@ class ResourceTemplate(FastMCPComponent):
         )
 
     @classmethod
-    def from_mcp_template(cls, mcp_template: MCPResourceTemplate) -> ResourceTemplate:
+    def from_mcp_template(cls, mcp_template: SDKResourceTemplate) -> ResourceTemplate:
         """Creates a FastMCP ResourceTemplate from a raw MCP ResourceTemplate object."""
         # Note: This creates a simple ResourceTemplate instance. For function-based templates,
         # the original function is lost, which is expected for remote templates.

fastmcp/server/auth/auth.py

@@ -114,6 +114,8 @@ class AuthProvider(TokenVerifierProtocol):
             base_url = AnyHttpUrl(base_url)
         self.base_url = base_url
         self.required_scopes = required_scopes or []
+        self._mcp_path: str | None = None
+        self._resource_url: AnyHttpUrl | None = None
 
     async def verify_token(self, token: str) -> AccessToken | None:
         """Verify a bearer token and return access info if valid.
@@ -128,6 +130,20 @@ class AuthProvider(TokenVerifierProtocol):
         """
         raise NotImplementedError("Subclasses must implement verify_token")
 
+    def set_mcp_path(self, mcp_path: str | None) -> None:
+        """Set the MCP endpoint path and compute resource URL.
+
+        This method is called by get_routes() to configure the expected
+        resource URL before route creation. Subclasses can override to
+        perform additional initialization that depends on knowing the
+        MCP endpoint path.
+
+        Args:
+            mcp_path: The path where the MCP endpoint is mounted (e.g., "/mcp")
+        """
+        self._mcp_path = mcp_path
+        self._resource_url = self._get_resource_url(mcp_path)
+
     def get_routes(
         self,
         mcp_path: str | None = None,
@@ -407,6 +423,8 @@ class OAuthProvider(
         Returns:
             List of OAuth routes
         """
+        # Configure resource URL before creating routes
+        self.set_mcp_path(mcp_path)
 
         # Create standard OAuth authorization server routes
         # Pass base_url as issuer_url to ensure metadata declares endpoints where
@@ -451,11 +469,8 @@ class OAuthProvider(
             else:
                 oauth_routes.append(route)
 
-        # Get the resource URL based on the MCP path
-        resource_url = self._get_resource_url(mcp_path)
-
         # Add protected resource routes if this server is also acting as a resource server
-        if resource_url:
+        if self._resource_url:
             supported_scopes = (
                 self.client_registration_options.valid_scopes
                 if self.client_registration_options
@@ -463,7 +478,7 @@ class OAuthProvider(
                 else self.required_scopes
             )
             protected_routes = create_protected_resource_routes(
-                resource_url=resource_url,
+                resource_url=self._resource_url,
                 authorization_servers=[cast(AnyHttpUrl, self.issuer_url)],
                 scopes_supported=supported_scopes,
             )

fastmcp/server/auth/oauth_proxy.py

@@ -34,7 +34,6 @@ from authlib.integrations.httpx_client import AsyncOAuth2Client
 from cryptography.fernet import Fernet
 from key_value.aio.adapters.pydantic import PydanticAdapter
 from key_value.aio.protocols import AsyncKeyValue
-from key_value.aio.stores.disk import DiskStore
 from key_value.aio.wrappers.encryption import FernetEncryptionWrapper
 from mcp.server.auth.provider import (
     AccessToken,
@@ -805,14 +804,16 @@ class OAuthProxy(OAuthProvider):
                 salt="fastmcp-jwt-signing-key",
             )
 
-        self._jwt_issuer: JWTIssuer = JWTIssuer(
-            issuer=str(self.base_url),
-            audience=f"{str(self.base_url).rstrip('/')}/mcp",
-            signing_key=jwt_signing_key,
-        )
+        # Store JWT signing key for deferred JWTIssuer creation in set_mcp_path()
+        self._jwt_signing_key: bytes = jwt_signing_key
+        # JWTIssuer will be created in set_mcp_path() with correct audience
+        self._jwt_issuer: JWTIssuer | None = None
 
         # If the user does not provide a store, we will provide an encrypted disk store
         if client_storage is None:
+            # Import lazily to avoid sqlite3 dependency when not using OAuthProxy
+            from key_value.aio.stores.disk import DiskStore
+
             storage_encryption_key = derive_jwt_key(
                 high_entropy_material=jwt_signing_key.decode(),
                 salt="fastmcp-storage-encryption-key",
@@ -897,6 +898,47 @@ class OAuthProxy(OAuthProvider):
             self._upstream_authorization_endpoint,
         )
 
+    # -------------------------------------------------------------------------
+    # MCP Path Configuration
+    # -------------------------------------------------------------------------
+
+    def set_mcp_path(self, mcp_path: str | None) -> None:
+        """Set the MCP endpoint path and create JWTIssuer with correct audience.
+
+        This method is called by get_routes() to configure the resource URL
+        and create the JWTIssuer. The JWT audience is set to the full resource
+        URL (e.g., http://localhost:8000/mcp) to ensure tokens are bound to
+        this specific MCP endpoint.
+
+        Args:
+            mcp_path: The path where the MCP endpoint is mounted (e.g., "/mcp")
+        """
+        super().set_mcp_path(mcp_path)
+
+        # Create JWT issuer with correct audience based on actual MCP path
+        # This ensures tokens are bound to the specific resource URL
+        self._jwt_issuer = JWTIssuer(
+            issuer=str(self.base_url),
+            audience=str(self._resource_url),
+            signing_key=self._jwt_signing_key,
+        )
+
+        logger.debug("Configured OAuth proxy for resource URL: %s", self._resource_url)
+
+    @property
+    def jwt_issuer(self) -> JWTIssuer:
+        """Get the JWT issuer, ensuring it has been initialized.
+
+        The JWT issuer is created when set_mcp_path() is called (via get_routes()).
+        This property ensures a clear error if used before initialization.
+        """
+        if self._jwt_issuer is None:
+            raise RuntimeError(
+                "JWT issuer not initialized. Ensure get_routes() is called "
+                "before token operations."
+            )
+        return self._jwt_issuer
+
     # -------------------------------------------------------------------------
     # PKCE Helper Methods
     # -------------------------------------------------------------------------
@@ -998,13 +1040,29 @@ class OAuthProxy(OAuthProvider):
         """Start OAuth transaction and route through consent interstitial.
 
         Flow:
-        1. Store transaction with client details and PKCE (if forwarding)
-        2. Return local /consent URL; browser visits consent first
-        3. Consent handler redirects to upstream IdP if approved/already approved
+        1. Validate client's resource matches server's resource URL (security check)
+        2. Store transaction with client details and PKCE (if forwarding)
+        3. Return local /consent URL; browser visits consent first
+        4. Consent handler redirects to upstream IdP if approved/already approved
 
         If consent is disabled (require_authorization_consent=False), skip the consent screen
         and redirect directly to the upstream IdP.
         """
+        # Security check: validate client's requested resource matches this server
+        # This prevents tokens intended for one server from being used on another
+        client_resource = getattr(params, "resource", None)
+        if client_resource and self._resource_url:
+            if str(client_resource) != str(self._resource_url):
+                logger.warning(
+                    "Resource mismatch: client requested %s but server is %s",
+                    client_resource,
+                    self._resource_url,
+                )
+                raise AuthorizeError(
+                    error="invalid_target",  # type: ignore[arg-type]
+                    error_description="Resource does not match this server",
+                )
+
         # Generate transaction ID for this authorization request
         txn_id = secrets.token_urlsafe(32)
 
@@ -1216,7 +1274,7 @@ class OAuthProxy(OAuthProvider):
         # Issue minimal FastMCP access token (just a reference via JTI)
         if client.client_id is None:
             raise TokenError("invalid_client", "Client ID is required")
-        fastmcp_access_token = self._jwt_issuer.issue_access_token(
+        fastmcp_access_token = self.jwt_issuer.issue_access_token(
             client_id=client.client_id,
             scopes=authorization_code.scopes,
             jti=access_jti,
@@ -1227,7 +1285,7 @@ class OAuthProxy(OAuthProvider):
         # Use upstream refresh token expiry to align lifetimes
         fastmcp_refresh_token = None
         if refresh_jti and refresh_expires_in:
-            fastmcp_refresh_token = self._jwt_issuer.issue_refresh_token(
+            fastmcp_refresh_token = self.jwt_issuer.issue_refresh_token(
                 client_id=client.client_id,
                 scopes=authorization_code.scopes,
                 jti=refresh_jti,
@@ -1352,7 +1410,7 @@ class OAuthProxy(OAuthProvider):
         """
         # Verify FastMCP refresh token
         try:
-            refresh_payload = self._jwt_issuer.verify_token(refresh_token.token)
+            refresh_payload = self.jwt_issuer.verify_token(refresh_token.token)
             refresh_jti = refresh_payload["jti"]
         except Exception as e:
             logger.debug("FastMCP refresh token validation failed: %s", e)
@@ -1461,7 +1519,7 @@ class OAuthProxy(OAuthProvider):
         if client.client_id is None:
             raise TokenError("invalid_client", "Client ID is required")
         new_access_jti = secrets.token_urlsafe(32)
-        new_fastmcp_access = self._jwt_issuer.issue_access_token(
+        new_fastmcp_access = self.jwt_issuer.issue_access_token(
             client_id=client.client_id,
             scopes=scopes,
             jti=new_access_jti,
@@ -1482,7 +1540,7 @@ class OAuthProxy(OAuthProvider):
         # Issue NEW minimal FastMCP refresh token (rotation for security)
         # Use upstream refresh token expiry to align lifetimes
         new_refresh_jti = secrets.token_urlsafe(32)
-        new_fastmcp_refresh = self._jwt_issuer.issue_refresh_token(
+        new_fastmcp_refresh = self.jwt_issuer.issue_refresh_token(
             client_id=client.client_id,
             scopes=scopes,
             jti=new_refresh_jti,
@@ -1558,7 +1616,7 @@ class OAuthProxy(OAuthProvider):
         """
         try:
             # 1. Verify FastMCP JWT signature and claims
-            payload = self._jwt_issuer.verify_token(token)
+            payload = self.jwt_issuer.verify_token(token)
             jti = payload["jti"]
 
             # 2. Look up upstream token via JTI mapping

fastmcp/server/auth/providers/supabase.py

@@ -34,6 +34,7 @@ class SupabaseProviderSettings(BaseSettings):
 
     project_url: AnyHttpUrl
     base_url: AnyHttpUrl
+    auth_route: str = "/auth/v1"
     algorithm: Literal["HS256", "RS256", "ES256"] = "ES256"
     required_scopes: list[str] | None = None
 
@@ -59,8 +60,8 @@ class SupabaseProvider(RemoteAuthProvider):
        - Asymmetric keys (RS256/ES256) are recommended for production
 
     2. JWT Verification:
-       - FastMCP verifies JWTs using the JWKS endpoint at {project_url}/auth/v1/.well-known/jwks.json
-       - JWTs are issued by {project_url}/auth/v1
+       - FastMCP verifies JWTs using the JWKS endpoint at {project_url}{auth_route}/.well-known/jwks.json
+       - JWTs are issued by {project_url}{auth_route}
        - Tokens are cached for up to 10 minutes by Supabase's edge servers
        - Algorithm must match your Supabase Auth configuration
 
@@ -93,6 +94,7 @@ class SupabaseProvider(RemoteAuthProvider):
         *,
         project_url: AnyHttpUrl | str | NotSetT = NotSet,
         base_url: AnyHttpUrl | str | NotSetT = NotSet,
+        auth_route: str | NotSetT = NotSet,
         algorithm: Literal["HS256", "RS256", "ES256"] | NotSetT = NotSet,
         required_scopes: list[str] | NotSetT | None = NotSet,
         token_verifier: TokenVerifier | None = None,
@@ -102,6 +104,7 @@ class SupabaseProvider(RemoteAuthProvider):
         Args:
             project_url: Your Supabase project URL (e.g., "https://abc123.supabase.co")
             base_url: Public URL of this FastMCP server
+            auth_route: Supabase Auth route. Defaults to "/auth/v1".
             algorithm: JWT signing algorithm (HS256, RS256, or ES256). Must match your
                 Supabase Auth configuration. Defaults to ES256.
             required_scopes: Optional list of scopes to require for all requests.
@@ -115,6 +118,7 @@ class SupabaseProvider(RemoteAuthProvider):
                 for k, v in {
                     "project_url": project_url,
                     "base_url": base_url,
+                    "auth_route": auth_route,
                     "algorithm": algorithm,
                     "required_scopes": required_scopes,
                 }.items()
@@ -124,12 +128,13 @@ class SupabaseProvider(RemoteAuthProvider):
 
         self.project_url = str(settings.project_url).rstrip("/")
         self.base_url = AnyHttpUrl(str(settings.base_url).rstrip("/"))
+        self.auth_route = settings.auth_route.strip("/")
 
         # Create default JWT verifier if none provided
         if token_verifier is None:
             token_verifier = JWTVerifier(
-                jwks_uri=f"{self.project_url}/auth/v1/.well-known/jwks.json",
-                issuer=f"{self.project_url}/auth/v1",
+                jwks_uri=f"{self.project_url}/{self.auth_route}/.well-known/jwks.json",
+                issuer=f"{self.project_url}/{self.auth_route}",
                 algorithm=settings.algorithm,
                 required_scopes=settings.required_scopes,
             )
@@ -137,7 +142,7 @@ class SupabaseProvider(RemoteAuthProvider):
         # Initialize RemoteAuthProvider with Supabase as the authorization server
         super().__init__(
             token_verifier=token_verifier,
-            authorization_servers=[AnyHttpUrl(f"{self.project_url}/auth/v1")],
+            authorization_servers=[AnyHttpUrl(f"{self.project_url}/{self.auth_route}")],
             base_url=self.base_url,
         )
 
@@ -162,7 +167,7 @@ class SupabaseProvider(RemoteAuthProvider):
             try:
                 async with httpx.AsyncClient() as client:
                     response = await client.get(
-                        f"{self.project_url}/auth/v1/.well-known/oauth-authorization-server"
+                        f"{self.project_url}/{self.auth_route}/.well-known/oauth-authorization-server"
                     )
                     response.raise_for_status()
                     metadata = response.json()