changes meddleware

echo_server.py

@@ -1,133 +1,127 @@
 from mcp.server.fastmcp import FastMCP
-from typing import Optional, Literal
-import httpx
-import os
-import re
+from typing import Dict, Any, Optional
 from contextvars import ContextVar
-
-try:
-    from fastmcp.server.auth.verifier import TokenVerifier  # type: ignore
-except Exception:  # pragma: no cover - fallback for alternate installs
-    TokenVerifier = object  # type: ignore
-
-# Context variable to store the verified bearer token per-request
-_current_bearer_token: ContextVar[Optional[str]] = ContextVar("current_bearer_token", default=None)
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from fastmcp.server.middleware import Middleware, MiddlewareContext
+import requests
+
+mcp = FastMCP(name="OpenWeatherServer", stateless_http=True)
+
+OPENWEATHER_BASE_URL = "https://api.openweathermap.org/data/2.5"
+
+# Context variable to hold the token for the current request
+_current_token: ContextVar[Optional[str]] = ContextVar("openweather_token", default=None)
+
+
+class AuthorizationHeaderMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        auth_header = request.headers.get("Authorization", "").strip()
+        token: Optional[str] = None
+        if auth_header:
+            lower = auth_header.lower()
+            if lower.startswith("bearer "):
+                token = auth_header[7:].strip()
+            else:
+                token = auth_header
+        _current_token.set(token)
+        response = await call_next(request)
+        return response
+
+
+class RequireAuthMiddleware(Middleware):
+    async def on_request(self, context: MiddlewareContext, call_next):
+        # Enforce a token is present for any MCP request (tool calls, listings, etc.)
+        token = _current_token.get()
+        if not token:
+            raise ValueError(
+                "Missing OpenWeather API key. Provide it as a Bearer token in the Authorization header."
+            )
+        return await call_next(context)
 
 
-class OpenWeatherTokenVerifier(TokenVerifier):  # type: ignore[misc]
-    """Minimal verifier that accepts an OpenWeather API key as the bearer token.
+# Register FastMCP middleware
+mcp.add_middleware(RequireAuthMiddleware())
 
-    For safety, we perform a lightweight format check (32 hex chars typical for OpenWeather keys).
-    On success, we stash the token in a contextvar and return claims including it.
-    """
 
-    _hex32 = re.compile(r"^[a-fA-F0-9]{32}$")
+def _require_api_key_from_header() -> str:
+    token = _current_token.get()
+    if not token:
+        raise ValueError(
+            "Missing OpenWeather API key. Provide it as a Bearer token in the Authorization header."
+        )
+    return token
 
-    def verify_token(self, token: str) -> dict:  # type: ignore[override]
-        if not token:
-            raise ValueError("Missing bearer token")
-        # Basic format validation (doesn't call OpenWeather)
-        if not self._hex32.match(token):
-            # Allow override via env to support alternative key formats if needed
-            allow_any = os.getenv("OPENWEATHER_ALLOW_ANY_TOKEN", "false").lower() in {"1", "true", "yes"}
-            if not allow_any:
-                raise ValueError("Invalid OpenWeather token format; expected 32 hex characters")
-        _current_bearer_token.set(token)
-        return {"auth_type": "openweather", "openweather_token": token}
 
+def _request(path: str, params: Dict[str, Any]) -> Dict[str, Any]:
+    url = f"{OPENWEATHER_BASE_URL}/{path}"
+    try:
+        response = requests.get(url, params=params, timeout=15)
+    except requests.RequestException as exc:
+        raise RuntimeError(f"Failed to call OpenWeather: {exc}") from exc
 
-mcp = FastMCP(name="OpenWeatherServer", stateless_http=True, auth=OpenWeatherTokenVerifier())
+    if response.status_code != 200:
+        try:
+            payload = response.json()
+        except Exception:
+            payload = {"message": response.text}
+        message = payload.get("message") or payload
+        raise ValueError(f"OpenWeather error {response.status_code}: {message}")
 
-BASE_URL = "https://api.openweathermap.org"
-DEFAULT_TIMEOUT_SECONDS = 15.0
+    return response.json()
 
 
-def _require_token() -> str:
-    # Priority: verified bearer token → env var → error
-    token = _current_bearer_token.get()
-    if token:
-        return token
-    env_token = os.getenv("OPENWEATHER_API_KEY")
-    if env_token:
-        return env_token
-    raise ValueError(
-        "OpenWeather token required. Provide as HTTP Authorization: Bearer <token> or set OPENWEATHER_API_KEY."
-    )
+@mcp.tool(description="Get current weather by city name. Token must be in Authorization: Bearer <token> header.")
+def get_current_weather_city(
+    city: str,
+    country_code: str = "",
+    units: str = "metric",
+    lang: str = "en",
+) -> Dict[str, Any]:
+    key = _require_api_key_from_header()
+    q = city if not country_code else f"{city},{country_code}"
+    params = {"q": q, "appid": key, "units": units, "lang": lang}
+    return _request("weather", params)
 
 
-def _get(path: str, params: dict) -> dict:
-    try:
-        with httpx.Client(timeout=httpx.Timeout(DEFAULT_TIMEOUT_SECONDS)) as client:
-            resp = client.get(f"{BASE_URL}{path}", params=params)
-            resp.raise_for_status()
-            return resp.json()
-    except httpx.HTTPStatusError as e:
-        status = e.response.status_code if e.response is not None else None
-        text = e.response.text if e.response is not None else str(e)
-        raise ValueError(f"OpenWeather API error (status={status}): {text}")
-    except Exception as e:
-        raise RuntimeError(f"OpenWeather request failed: {e}")
-
-
-@mcp.tool(description="Get current weather using One Call 3.0 (current segment). Token is taken from Authorization bearer or OPENWEATHER_API_KEY env.")
-def current_weather(
+@mcp.tool(description="Get current weather by geographic coordinates. Token must be in Authorization header.")
+def get_current_weather_coords(
     lat: float,
     lon: float,
-    units: Literal["standard", "metric", "imperial"] = "metric",
+    units: str = "metric",
     lang: str = "en",
-) -> dict:
-    token = _require_token()
-    params = {
-        "lat": lat,
-        "lon": lon,
-        "appid": token,
-        "units": units,
-        "lang": lang,
-        "exclude": "minutely,hourly,daily,alerts",
-    }
-    data = _get("/data/3.0/onecall", params)
-    return {
-        "coord": {"lat": lat, "lon": lon},
-        "units": units,
-        "lang": lang,
-        "current": data.get("current", data),
-    }
-
-
-@mcp.tool(description="Get One Call 3.0 data for coordinates. Use 'exclude' to omit segments (comma-separated). Token comes from bearer or env.")
-def onecall(
+) -> Dict[str, Any]:
+    key = _require_api_key_from_header()
+    params = {"lat": lat, "lon": lon, "appid": key, "units": units, "lang": lang}
+    return _request("weather", params)
+
+
+@mcp.tool(description="Get 5 day / 3 hour forecast by city. Token must be in Authorization header.")
+def get_forecast_city(
+    city: str,
+    country_code: str = "",
+    units: str = "metric",
+    lang: str = "en",
+) -> Dict[str, Any]:
+    key = _require_api_key_from_header()
+    q = city if not country_code else f"{city},{country_code}"
+    params = {"q": q, "appid": key, "units": units, "lang": lang}
+    return _request("forecast", params)
+
+
+@mcp.tool(description="Get 5 day / 3 hour forecast by coordinates. Token must be in Authorization header.")
+def get_forecast_coords(
     lat: float,
     lon: float,
-    exclude: Optional[str] = None,
-    units: Literal["standard", "metric", "imperial"] = "metric",
-    lang: str = "en",
-) -> dict:
-    token = _require_token()
-    params = {
-        "lat": lat,
-        "lon": lon,
-        "appid": token,
-        "units": units,
-        "lang": lang,
-    }
-    if exclude:
-        params["exclude"] = exclude
-    return _get("/data/3.0/onecall", params)
-
-
-@mcp.tool(description="Get 5-day/3-hour forecast by city name. Token comes from bearer or env.")
-def forecast_city(
-    city: str,
-    units: Literal["standard", "metric", "imperial"] = "metric",
+    units: str = "metric",
     lang: str = "en",
-) -> dict:
-    token = _require_token()
-    params = {"q": city, "appid": token, "units": units, "lang": lang}
-    return _get("/data/2.5/forecast", params)
+) -> Dict[str, Any]:
+    key = _require_api_key_from_header()
+    params = {"lat": lat, "lon": lon, "appid": key, "units": units, "lang": lang}
+    return _request("forecast", params)
 
 
-@mcp.tool(description="Get air pollution data for coordinates. Token comes from bearer or env.")
-def air_pollution(lat: float, lon: float) -> dict:
-    token = _require_token()
-    params = {"lat": lat, "lon": lon, "appid": token}
-    return _get("/data/2.5/air_pollution", params)
+def openweather_http_app():
+    app = mcp.streamable_http_app()
+    app.add_middleware(AuthorizationHeaderMiddleware)
+    return app

server.py

@@ -4,6 +4,7 @@ from fastapi.responses import HTMLResponse, FileResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from echo_server import mcp as echo_mcp
+from echo_server import openweather_http_app
 from math_server import mcp as math_mcp
 import os
 
@@ -39,10 +40,10 @@ async def index(request: Request):
     return templates.TemplateResponse("index.html", {"request": request, "base_url": base_url})
 
 
-app.mount("/echo", echo_mcp.streamable_http_app())
+app.mount("/echo", openweather_http_app())
 app.mount("/math", math_mcp.streamable_http_app())
 
-PORT = int(os.environ.get("PORT", "7860"))
+PORT = int(os.environ.get("PORT", "10000"))
 
 if __name__ == "__main__":
     import uvicorn

templates/index.html

@@ -89,9 +89,10 @@ Math MCP  = {{ base_url }}/math/mcp
         </ul>
         <h3>Use in clients</h3>
         <p class="muted">Point your MCP client to the endpoints below:</p>
-        <pre><code>HTTP streaming endpoints:
-Echo:  {{ base_url }}/echo/mcp
-Math:  {{ base_url }}/math/mcp
+        <pre><code>HTTP streaming endpoints
+
+Echo: GET {{ base_url }}/echo
+Math: GET {{ base_url }}/math
 </code></pre>
       </div>
     </div>