fix

Author: dsp-ant

examples/clients/simple-chatbot/mcp_simple_chatbot/main.py

@@ -322,8 +322,7 @@ async def process_llm_response(self, llm_response: str) -> str:
                                 total = result["total"]
                                 percentage = (progress / total) * 100
                                 logging.info(
-                                    f"Progress: {progress}/{total} "
-                                    f"({percentage:.1f}%)"
+                                    f"Progress: {progress}/{total} ({percentage:.1f}%)"
                                 )
 
                             return f"Tool execution result: {result}"

pyproject.toml

@@ -43,7 +43,7 @@ mcp = "mcp.cli:app [cli]"
 [tool.uv]
 resolution = "lowest-direct"
 dev-dependencies = [
-    "pyright>=1.1.391",
+    "pyright>=1.1.396",
     "pytest>=8.3.4",
     "ruff>=0.8.5",
     "trio>=0.26.2",

src/mcp/client/auth/oauth.py

@@ -385,15 +385,15 @@ async def open_user_agent(self, url: AnyHttpUrl) -> None:
         ...
 
     async def client_registration(
-        self, endpoint: AnyHttpUrl
+        self, issuer: AnyHttpUrl
     ) -> DynamicClientRegistration | None:
         """
         Loads the client registration for the given endpoint.
         """
         ...
 
     async def store_client_registration(
-        self, endpoint: AnyHttpUrl, metadata: DynamicClientRegistration
+        self, issuer: AnyHttpUrl, metadata: DynamicClientRegistration
     ) -> None:
         """
         Stores the client registration to be retreived for the next session

src/mcp/server/auth/errors.py

@@ -146,5 +146,9 @@ class InsufficientScopeError(OAuthError):
 
     error_code = "insufficient_scope"
 
+
 def stringify_pydantic_error(validation_error: ValidationError) -> str:
-    return "\n".join(f"{'.'.join(str(loc) for loc in e['loc'])}: {e['msg']}" for e in validation_error.errors())
+    return "\n".join(
+        f"{'.'.join(str(loc) for loc in e['loc'])}: {e['msg']}"
+        for e in validation_error.errors()
+    )

src/mcp/server/auth/handlers/authorize.py

@@ -4,25 +4,27 @@
 Corresponds to TypeScript file: src/server/auth/handlers/authorize.ts
 """
 
+import logging
 from typing import Callable, Literal, Optional, Union
-from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
+from urllib.parse import urlencode, urlparse, urlunparse
 
 from pydantic import AnyHttpUrl, AnyUrl, BaseModel, Field, RootModel, ValidationError
 from starlette.datastructures import FormData, QueryParams
 from starlette.requests import Request
 from starlette.responses import RedirectResponse, Response
 
 from mcp.server.auth.errors import (
-    InvalidClientError,
     InvalidRequestError,
     OAuthError,
     stringify_pydantic_error,
 )
-from mcp.server.auth.provider import AuthorizationParams, OAuthServerProvider, construct_redirect_uri
-from mcp.shared.auth import OAuthClientInformationFull
 from mcp.server.auth.json_response import PydanticJSONResponse
-
-import logging
+from mcp.server.auth.provider import (
+    AuthorizationParams,
+    OAuthServerProvider,
+    construct_redirect_uri,
+)
+from mcp.shared.auth import OAuthClientInformationFull
 
 logger = logging.getLogger(__name__)
 
@@ -48,7 +50,6 @@ class AuthorizationRequest(BaseModel):
         description="Optional scope; if specified, should be "
         "a space-separated list of scope strings",
     )
-    
 
 
 def validate_scope(
@@ -80,30 +81,38 @@ def validate_redirect_uri(
         raise InvalidRequestError(
             "redirect_uri must be specified when client has multiple registered URIs"
         )
+
+
 ErrorCode = Literal[
-        "invalid_request",
-        "unauthorized_client",
-        "access_denied",
-        "unsupported_response_type",
-        "invalid_scope",
-        "server_error",
-        "temporarily_unavailable"
-    ]
+    "invalid_request",
+    "unauthorized_client",
+    "access_denied",
+    "unsupported_response_type",
+    "invalid_scope",
+    "server_error",
+    "temporarily_unavailable",
+]
+
+
 class ErrorResponse(BaseModel):
     error: ErrorCode
     error_description: str
     error_uri: Optional[AnyUrl] = None
     # must be set if provided in the request
     state: Optional[str]
 
-def best_effort_extract_string(key: str, params: None | FormData | QueryParams) -> Optional[str]:
+
+def best_effort_extract_string(
+    key: str, params: None | FormData | QueryParams
+) -> Optional[str]:
     if params is None:
         return None
     value = params.get(key)
     if isinstance(value, str):
         return value
     return None
 
+
 class AnyHttpUrlModel(RootModel):
     root: AnyHttpUrl
 
@@ -118,18 +127,24 @@ async def authorization_handler(request: Request) -> Response:
         client = None
         params = None
 
-        async def error_response(error: ErrorCode, error_description: str, attempt_load_client: bool = True):
+        async def error_response(
+            error: ErrorCode, error_description: str, attempt_load_client: bool = True
+        ):
             nonlocal client, redirect_uri, state
             if client is None and attempt_load_client:
                 # make last-ditch attempt to load the client
                 client_id = best_effort_extract_string("client_id", params)
-                client = client_id and await provider.clients_store.get_client(client_id)
+                client = client_id and await provider.clients_store.get_client(
+                    client_id
+                )
             if redirect_uri is None and client:
                 # make last-ditch effort to load the redirect uri
                 if params is not None and "redirect_uri" not in params:
                     raw_redirect_uri = None
                 else:
-                    raw_redirect_uri = AnyHttpUrlModel.model_validate(best_effort_extract_string("redirect_uri", params)).root
+                    raw_redirect_uri = AnyHttpUrlModel.model_validate(
+                        best_effort_extract_string("redirect_uri", params)
+                    ).root
                 try:
                     redirect_uri = validate_redirect_uri(raw_redirect_uri, client)
                 except (ValidationError, InvalidRequestError):
@@ -146,7 +161,9 @@ async def error_response(error: ErrorCode, error_description: str, attempt_load_
 
             if redirect_uri and client:
                 return RedirectResponse(
-                    url=construct_redirect_uri(str(redirect_uri), **error_resp.model_dump(exclude_none=True)),
+                    url=construct_redirect_uri(
+                        str(redirect_uri), **error_resp.model_dump(exclude_none=True)
+                    ),
                     status_code=302,
                     headers={"Cache-Control": "no-store"},
                 )
@@ -156,7 +173,7 @@ async def error_response(error: ErrorCode, error_description: str, attempt_load_
                     content=error_resp,
                     headers={"Cache-Control": "no-store"},
                 )
-        
+
         try:
             # Parse request parameters
             if request.method == "GET":
@@ -165,20 +182,22 @@ async def error_response(error: ErrorCode, error_description: str, attempt_load_
             else:
                 # Parse form data for POST requests
                 params = await request.form()
-                
+
             # Save state if it exists, even before validation
             state = best_effort_extract_string("state", params)
-                
+
             try:
                 auth_request = AuthorizationRequest.model_validate(params)
                 state = auth_request.state  # Update with validated state
             except ValidationError as validation_error:
                 error: ErrorCode = "invalid_request"
                 for e in validation_error.errors():
-                    if e['loc'] == ('response_type',) and e['type'] == 'literal_error':
+                    if e["loc"] == ("response_type",) and e["type"] == "literal_error":
                         error = "unsupported_response_type"
                         break
-                return await error_response(error, stringify_pydantic_error(validation_error))
+                return await error_response(
+                    error, stringify_pydantic_error(validation_error)
+                )
 
             # Get client information
             client = await provider.clients_store.get_client(auth_request.client_id)
@@ -190,7 +209,6 @@ async def error_response(error: ErrorCode, error_description: str, attempt_load_
                     attempt_load_client=False,
                 )
 
-                
             # Validate redirect_uri against client's registered URIs
             try:
                 redirect_uri = validate_redirect_uri(auth_request.redirect_uri, client)
@@ -200,7 +218,7 @@ async def error_response(error: ErrorCode, error_description: str, attempt_load_
                     error="invalid_request",
                     error_description=validation_error.message,
                 )
-                
+
             # Validate scope - for scope errors, we can redirect
             try:
                 scopes = validate_scope(auth_request.scope, client)
@@ -210,28 +228,30 @@ async def error_response(error: ErrorCode, error_description: str, attempt_load_
                     error="invalid_scope",
                     error_description=validation_error.message,
                 )
-                
+
             # Setup authorization parameters
             auth_params = AuthorizationParams(
                 state=state,
                 scopes=scopes,
                 code_challenge=auth_request.code_challenge,
                 redirect_uri=redirect_uri,
             )
-            
+
             # Let the provider pick the next URI to redirect to
             response = RedirectResponse(
                 url="", status_code=302, headers={"Cache-Control": "no-store"}
             )
-            response.headers["location"] = await provider.authorize(
-                client, auth_params
-            )
+            response.headers["location"] = await provider.authorize(client, auth_params)
             return response
-                
+
         except Exception as validation_error:
             # Catch-all for unexpected errors
-            logger.exception("Unexpected error in authorization_handler", exc_info=validation_error)
-            return await error_response(error="server_error", error_description="An unexpected error occurred")
+            logger.exception(
+                "Unexpected error in authorization_handler", exc_info=validation_error
+            )
+            return await error_response(
+                error="server_error", error_description="An unexpected error occurred"
+            )
 
     return authorization_handler
 
@@ -240,7 +260,7 @@ def create_error_redirect(
     redirect_uri: AnyUrl, error: Union[Exception, ErrorResponse]
 ) -> str:
     parsed_uri = urlparse(str(redirect_uri))
-    
+
     if isinstance(error, ErrorResponse):
         # Convert ErrorResponse to dict
         error_dict = error.model_dump(exclude_none=True)
@@ -251,7 +271,7 @@ def create_error_redirect(
                     query_params[key] = str(value)
                 else:
                     query_params[key] = value
-                    
+
     elif isinstance(error, OAuthError):
         query_params = {"error": error.error_code, "error_description": str(error)}
     else:

src/mcp/server/auth/handlers/register.py

@@ -11,20 +11,24 @@
 
 from pydantic import BaseModel, ValidationError
 from starlette.requests import Request
-from starlette.responses import JSONResponse, Response
+from starlette.responses import Response
 
 from mcp.server.auth.errors import (
     InvalidRequestError,
-    OAuthError,
-    ServerError,
     stringify_pydantic_error,
 )
 from mcp.server.auth.json_response import PydanticJSONResponse
 from mcp.server.auth.provider import OAuthRegisteredClientsStore
 from mcp.shared.auth import OAuthClientInformationFull, OAuthClientMetadata
 
+
 class ErrorResponse(BaseModel):
-    error: Literal["invalid_redirect_uri", "invalid_client_metadata", "invalid_software_statement", "unapproved_software_statement"]
+    error: Literal[
+        "invalid_redirect_uri",
+        "invalid_client_metadata",
+        "invalid_software_statement",
+        "unapproved_software_statement",
+    ]
     error_description: str
 
 
@@ -38,10 +42,13 @@ async def registration_handler(request: Request) -> Response:
             body = await request.json()
             client_metadata = OAuthClientMetadata.model_validate(body)
         except ValidationError as validation_error:
-            return PydanticJSONResponse(content=ErrorResponse(
-                error="invalid_client_metadata",
-                error_description=stringify_pydantic_error(validation_error)
-            ), status_code=400)
+            return PydanticJSONResponse(
+                content=ErrorResponse(
+                    error="invalid_client_metadata",
+                    error_description=stringify_pydantic_error(validation_error),
+                ),
+                status_code=400,
+            )
             raise InvalidRequestError(f"Invalid client metadata: {str(e)}")
 
         client_id = str(uuid4())

src/mcp/server/auth/handlers/revoke.py

@@ -4,23 +4,21 @@
 Corresponds to TypeScript file: src/server/auth/handlers/revoke.ts
 """
 
-from tokenize import Token
 from typing import Callable
 
 from pydantic import ValidationError
 from starlette.requests import Request
 from starlette.responses import Response
 
 from mcp.server.auth.errors import (
-    InvalidRequestError,
     stringify_pydantic_error,
 )
+from mcp.server.auth.json_response import PydanticJSONResponse
 from mcp.server.auth.middleware.client_auth import (
     ClientAuthenticator,
     ClientAuthRequest,
 )
 from mcp.server.auth.provider import OAuthServerProvider, OAuthTokenRevocationRequest
-from mcp.server.auth.json_response import PydanticJSONResponse
 from mcp.shared.auth import TokenErrorResponse
 
 
@@ -39,10 +37,13 @@ async def revocation_handler(request: Request) -> Response:
             form_data = await request.form()
             revocation_request = RevocationRequest.model_validate(dict(form_data))
         except ValidationError as e:
-            return PydanticJSONResponse(status_code=400,content=TokenErrorResponse(
-                error="invalid_request",
-                error_description=stringify_pydantic_error(e)
-            ))
+            return PydanticJSONResponse(
+                status_code=400,
+                content=TokenErrorResponse(
+                    error="invalid_request",
+                    error_description=stringify_pydantic_error(e),
+                ),
+            )
 
         # Authenticate client
         client_auth_result = await client_authenticator(revocation_request)