meta-data-mcp 2.3.2__tar.gz → 2.3.3__tar.gz

{meta_data_mcp-2.3.2 → meta_data_mcp-2.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meta-data-mcp
-Version: 2.3.2
+Version: 2.3.3
 Summary: MCP server exposing 60+ open data providers to LLM clients via intelligent metadata routing.
 Project-URL: Homepage, https://github.com/derekslinz/meta-data-mcp
 Project-URL: Repository, https://github.com/derekslinz/meta-data-mcp

meta_data_mcp-2.3.3/meta_data_mcp/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.3.3"

{meta_data_mcp-2.3.2 → meta_data_mcp-2.3.3}/meta_data_mcp/server.py

@@ -281,11 +281,13 @@ class BearerAuthMiddleware:
         token: str | None = None,
         protected_prefixes: Sequence[str] = ("/sse", "/messages"),
         oauth_provider: Any = None,
+        resource_metadata_url: str | None = None,
     ) -> None:
         self.app = app
         self.token = token
         self.protected_prefixes = tuple(protected_prefixes)
         self.oauth_provider = oauth_provider
+        self.resource_metadata_url = resource_metadata_url
 
     async def __call__(self, scope: dict, receive: Callable, send: Callable) -> None:
         if scope.get("type") != "http" or not any(
@@ -320,10 +322,18 @@ class BearerAuthMiddleware:
 
         from starlette.responses import JSONResponse
 
+        if self.resource_metadata_url:
+            www_auth = (
+                f'Bearer realm="meta-data-mcp",'
+                f' resource_metadata="{self.resource_metadata_url}"'
+            )
+        else:
+            www_auth = 'Bearer realm="meta-data-mcp"'
+
         response = JSONResponse(
             {"error": "unauthorized"},
             status_code=401,
-            headers={"WWW-Authenticate": 'Bearer realm="meta-data-mcp"'},
+            headers={"WWW-Authenticate": www_auth},
         )
         await response(scope, receive, send)
 
@@ -353,24 +363,38 @@ async def run_server(
         from starlette.responses import JSONResponse
         from starlette.routing import Mount, Route
 
+        from contextlib import asynccontextmanager
+
+        from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
+
         sse = SseServerTransport("/messages")
+        streamable_manager = StreamableHTTPSessionManager(server, stateless=True)
 
         class SseApp:
             async def __call__(self, scope, receive, send):
-                log.info(f"New SSE connection request from {scope.get('client')}")
-                try:
-                    async with sse.connect_sse(scope, receive, send) as streams:
-                        log.info("SSE connection established, running server...")
-                        await server.run(
-                            streams[0],
-                            streams[1],
-                            server.create_initialization_options(),
-                        )
-                except Exception as e:
-                    # Connection closed by client is common and can be ignored or logged at debug
-                    log.debug(f"SSE connection error: {e}")
-                finally:
-                    log.info("SSE connection closed")
+                method = scope.get("method", "").upper()
+                if method == "POST":
+                    # StreamableHTTP transport — used by Claude.ai and newer clients.
+                    await streamable_manager.handle_request(scope, receive, send)
+                else:
+                    # Traditional SSE transport — GET /sse → long-lived event stream.
+                    log.info(f"New SSE connection from {scope.get('client')}")
+                    try:
+                        async with sse.connect_sse(scope, receive, send) as streams:
+                            await server.run(
+                                streams[0],
+                                streams[1],
+                                server.create_initialization_options(),
+                            )
+                    except Exception as e:
+                        log.debug(f"SSE connection error: {e}")
+                    finally:
+                        log.info("SSE connection closed")
+
+        @asynccontextmanager
+        async def lifespan(_app):
+            async with streamable_manager.run():
+                yield
 
         async def root(request):
             return JSONResponse(
@@ -552,6 +576,44 @@ async def run_server(
                     default_scopes=["opendata"],
                 ),
             )
+
+            # The MCP SDK hardcodes token_endpoint_auth_methods_supported to
+            # ["client_secret_post", "client_secret_basic"], omitting "none".
+            # Claude's OAuth client checks this list and refuses to proceed for
+            # public clients (PKCE-only, no secret) when "none" is missing.
+            # Override the well-known endpoint with a corrected copy before
+            # the SDK's route so Starlette's first-match wins.
+            _issuer_base = str(validated_oauth_issuer).rstrip("/")
+
+            async def patched_oauth_metadata(request: Request) -> JSONResponse:
+                payload = {
+                    "issuer": str(validated_oauth_issuer),
+                    "authorization_endpoint": f"{_issuer_base}/authorize",
+                    "token_endpoint": f"{_issuer_base}/token",
+                    "registration_endpoint": f"{_issuer_base}/register",
+                    "scopes_supported": ["opendata"],
+                    "response_types_supported": ["code"],
+                    "grant_types_supported": [
+                        "authorization_code",
+                        "refresh_token",
+                    ],
+                    "token_endpoint_auth_methods_supported": [
+                        "client_secret_post",
+                        "client_secret_basic",
+                        "none",
+                    ],
+                    "code_challenge_methods_supported": ["S256"],
+                }
+                return JSONResponse(
+                    payload,
+                    headers={
+                        "Access-Control-Allow-Origin": "*",
+                        "Access-Control-Allow-Methods": "GET, OPTIONS",
+                        "Access-Control-Allow-Headers": "Content-Type, Authorization",
+                        "Cache-Control": "no-store",
+                    },
+                )
+
             from starlette.responses import RedirectResponse as _RedirectResponse
 
             async def oidc_discovery(_request):
@@ -560,7 +622,16 @@ async def run_server(
                 )
 
             extra_routes = (
-                protected_resource_routes
+                [
+                    # Must precede oauth_routes so Starlette's first-match wins:
+                    # the SDK hardcodes "none" out of token_endpoint_auth_methods_supported.
+                    Route(
+                        "/.well-known/oauth-authorization-server",
+                        endpoint=patched_oauth_metadata,
+                        methods=["GET", "OPTIONS"],
+                    ),
+                ]
+                + protected_resource_routes
                 + oauth_routes
                 + [
                     Route(
@@ -580,6 +651,7 @@ async def run_server(
 
         app = Starlette(
             debug=False,
+            lifespan=lifespan,
             routes=[
                 Route("/", endpoint=root),
                 Route("/sse", endpoint=SseApp()),

meta_data_mcp-2.3.2/meta_data_mcp/__init__.py

@@ -1 +0,0 @@
-__version__ = "2.3.2"