Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
94 changes: 69 additions & 25 deletions src/late/mcp/auth.py
Original file line number Diff line number Diff line change
@@ -1,8 +1,10 @@
"""Authentication module for Zernio MCP HTTP server."""

import asyncio
import hashlib
import logging
import os
import threading
import time
from collections import OrderedDict
from enum import Enum
Expand Down Expand Up @@ -88,11 +90,11 @@ def is_allowed_origin(request: Request) -> bool:
# --workers), and a shared store would put a new dependency in front of auth,
# which is how you rebuild this same outage.
_VERIFIED_AT: OrderedDict[str, float] = OrderedDict()
_VERIFIED_CACHE_LOCK = threading.Lock()
_VERIFIED_CACHE_MAX = 10_000
# Mirrors the 60s Redis TTL the API itself keeps on apikey:{keyHash}
# (Schedule-Posts-API libs/api-auth.ts:471), so this adds no revocation window
# the platform does not already have.
_FRESH_TTL_SECONDS = 60.0
_FRESH_TTL_SECONDS = 600.0
_VERIFY_KEEPALIVE_SECONDS = 60.0
_IN_FLIGHT: dict[str, "asyncio.Task[Verification]"] = {}
# Only used when upstream could not answer. Blast radius is bounded to
# nothing: the MCP stores no data and every tool call re-presents the same
# key to the same API, so a revoked key honoured here still cannot read or
Expand Down Expand Up @@ -140,10 +142,32 @@ def token_cache_key(token: str) -> str:


def _remember(token_key: str, now: float) -> None:
_VERIFIED_AT[token_key] = now
_VERIFIED_AT.move_to_end(token_key)
while len(_VERIFIED_AT) > _VERIFIED_CACHE_MAX:
_VERIFIED_AT.popitem(last=False)
with _VERIFIED_CACHE_LOCK:
_VERIFIED_AT[token_key] = now
_VERIFIED_AT.move_to_end(token_key)
while len(_VERIFIED_AT) > _VERIFIED_CACHE_MAX:
_VERIFIED_AT.popitem(last=False)


def _touch(token_key: str) -> None:
with _VERIFIED_CACHE_LOCK:
if token_key in _VERIFIED_AT:
_VERIFIED_AT.move_to_end(token_key)


def _forget(token_key: str) -> None:
with _VERIFIED_CACHE_LOCK:
_VERIFIED_AT.pop(token_key, None)


def forget_rejected_token(token: str) -> None:
_forget(token_cache_key(token))


def _new_verify_client() -> httpx.AsyncClient:
return httpx.AsyncClient(
limits=httpx.Limits(keepalive_expiry=_VERIFY_KEEPALIVE_SECONDS)
)


async def verify_late_api_key(
Expand All @@ -155,8 +179,8 @@ async def verify_late_api_key(
Returns a three-valued Verification, NOT a bool: never write
``if await verify_late_api_key(...)``, every Enum member is truthy.

client is injected by tests (httpx.MockTransport); production opens a
per-call client and must not close an injected one.
Without a client this opens and closes one per call; ZernioTokenVerifier
passes its long-lived client so verifications reuse warm connections.
"""
owns_client = client is None
client = client or httpx.AsyncClient()
Expand Down Expand Up @@ -198,25 +222,28 @@ class ZernioTokenVerifier(TokenVerifier):

def __init__(self, *, client: httpx.AsyncClient | None = None) -> None:
super().__init__()
self._client = client
self._client = client or _new_verify_client()

async def verify_token(self, token: str) -> AccessToken | None:
token_key = token_cache_key(token)
now = time.monotonic()
verified_at = _VERIFIED_AT.get(token_key)

if verified_at is not None and now - verified_at < _FRESH_TTL_SECONDS:
_VERIFIED_AT.move_to_end(token_key)
return self._grant(token)
_touch(token_key)
return self._grant(token, resolved_by="cache")

verdict = await verify_late_api_key(token, client=self._client)
joined = token_key in _IN_FLIGHT
verdict = await self._verify_once(token, token_key)
waited_ms = round((time.monotonic() - now) * 1000)
resolved_by = "joined" if joined else "upstream"

if verdict is Verification.VALID:
_remember(token_key, now)
return self._grant(token)
return self._grant(token, resolved_by=resolved_by, waited_ms=waited_ms)

if verdict is Verification.INVALID:
_VERIFIED_AT.pop(token_key, None)
_forget(token_key)
return None

# UNKNOWN. Honour a token upstream confirmed recently; refuse to
Expand All @@ -228,24 +255,41 @@ async def verify_token(self, token: str) -> AccessToken | None:
# type OTHER than AuthenticationError escapes as a 500 with the
# message swallowed.
if verified_at is not None and now - verified_at < _GRACE_TTL_SECONDS:
# Guarded because the await above can suspend for the full verify
# timeout, and a concurrent request may LRU-evict this key while
# we are parked. A bare move_to_end would raise KeyError, which is
# not AuthenticationError and so escapes as a 500.
if token_key in _VERIFIED_AT:
_VERIFIED_AT.move_to_end(token_key)
_touch(token_key)
logger.warning(
"Granting %s... from cache: upstream unreachable",
token_key[:12],
)
return self._grant(token)
return self._grant(token, resolved_by="grace", waited_ms=waited_ms)
raise AuthenticationError(
"Zernio API is temporarily unreachable, so this token could not "
"be verified. Your credentials are fine; retry in a moment."
)

def _grant(self, token: str) -> AccessToken:
return AccessToken(token=token, client_id="zernio", scopes=list(OAUTH_SCOPES))
async def _verify_once(self, token: str, token_key: str) -> Verification:
task = _IN_FLIGHT.get(token_key)
if task is None:
task = asyncio.ensure_future(
verify_late_api_key(token, client=self._client)
)
_IN_FLIGHT[token_key] = task
task.add_done_callback(lambda done: _release_in_flight(token_key, done))
return await asyncio.shield(task)

def _grant(
self, token: str, *, resolved_by: str, waited_ms: int = 0
) -> AccessToken:
return AccessToken(
token=token,
client_id="zernio",
scopes=list(OAUTH_SCOPES),
claims={"resolved_by": resolved_by, "waited_ms": waited_ms},
)


def _release_in_flight(token_key: str, task: "asyncio.Task[Verification]") -> None:
if _IN_FLIGHT.get(token_key) is task:
del _IN_FLIGHT[token_key]


class VerbatimIssuerRemoteAuthProvider(RemoteAuthProvider):
Expand Down
7 changes: 5 additions & 2 deletions src/late/mcp/chatgpt_server.py
Original file line number Diff line number Diff line change
Expand Up @@ -23,7 +23,7 @@
from mcp.types import TextContent, ToolAnnotations
from pydantic import BaseModel, Field

from late.mcp.auth import build_auth_provider
from late.mcp.auth import build_auth_provider, forget_rejected_token

API_BASE = (
os.getenv("ZERNIO_BASE_URL")
Expand Down Expand Up @@ -231,11 +231,14 @@ def _error_message(response: httpx.Response) -> str:
async def _api(
method: str, path: str, *, params: dict[str, Any] | None = None, json: Any = None
) -> Any:
headers = {"Authorization": f"Bearer {_bearer()}", "Accept": "application/json"}
bearer = _bearer()
headers = {"Authorization": f"Bearer {bearer}", "Accept": "application/json"}
async with httpx.AsyncClient(base_url=API_BASE, timeout=_TIMEOUT) as client:
response = await client.request(
method, path, params=params, json=json, headers=headers
)
if response.status_code == 401:
forget_rejected_token(bearer)
if response.status_code >= 400:
raise ToolError(_error_message(response))
return response.json() if response.content else {}
Expand Down
21 changes: 18 additions & 3 deletions src/late/mcp/server.py
Original file line number Diff line number Diff line change
Expand Up @@ -47,7 +47,7 @@
from late import Late, MediaType, PostStatus
from late.client.exceptions import LateAPIError, LateError, LateRateLimitError

from .auth import build_auth_provider
from .auth import build_auth_provider, forget_rejected_token
from .feedback_source import FEEDBACK_TOOL, FeedbackSourceMiddleware
from .idempotency import same_arguments_key
from .resources import register_resources
Expand Down Expand Up @@ -86,10 +86,25 @@
_thread_state = threading.local()


def _api_transport() -> httpx.HTTPTransport:
class _ApiTransport(httpx.BaseTransport):
def __init__(self, inner: httpx.BaseTransport | None = None) -> None:
self._inner = inner or httpx.HTTPTransport()

def handle_request(self, request: httpx.Request) -> httpx.Response:
response = self._inner.handle_request(request)
if response.status_code == 401:
bearer = request.headers.get("Authorization", "")
forget_rejected_token(bearer.removeprefix("Bearer "))
return response

def close(self) -> None:
self._inner.close()


def _api_transport() -> httpx.BaseTransport:
transport = getattr(_thread_state, "transport", None)
if transport is None:
transport = _thread_state.transport = httpx.HTTPTransport()
transport = _thread_state.transport = _ApiTransport()
return transport

# Always-visible core: the 20 hand-written ergonomic tools (guardrails +
Expand Down
22 changes: 20 additions & 2 deletions src/late/mcp/telemetry.py
Original file line number Diff line number Diff line change
Expand Up @@ -11,6 +11,7 @@

import sentry_sdk
from fastmcp.exceptions import FastMCPError, NotFoundError, ToolError
from fastmcp.server.auth import AccessToken
from fastmcp.server.dependencies import get_access_token, get_http_headers
from fastmcp.server.middleware import CallNext, Middleware, MiddlewareContext
from mcp.types import CallToolRequestParams, TextContent
Expand Down Expand Up @@ -115,14 +116,26 @@ def quiet_routine_logs() -> None:
logging.getLogger("fastmcp.server.server").addFilter(ToolFailureLogFilter())


def _caller_key() -> str | None:
def _current_token() -> AccessToken | None:
try:
token = get_access_token()
return get_access_token()
except Exception:
return None


def _caller_key() -> str | None:
token = _current_token()
return token_cache_key(token.token)[:12] if token and token.token else None


def _auth_fields() -> dict[str, Any]:
token = _current_token()
claims = token.claims if token else {}
if "resolved_by" not in claims:
return {}
return {"auth": claims["resolved_by"], "auth_wait_ms": claims.get("waited_ms", 0)}


def _request_fields(arguments: dict[str, Any] | None) -> dict[str, Any]:
fields: dict[str, Any] = {}
limit = (arguments or {}).get("limit")
Expand Down Expand Up @@ -198,6 +211,7 @@ async def _record(
tool = context.message.name
caller = _caller_key()
request = _request_fields(context.message.arguments)
auth = _auth_fields()
fields: dict[str, Any] = {"outcome": "ok"}
stats: dict[str, Any] = {}
stats_token = format_stats.set(stats)
Expand All @@ -212,6 +226,9 @@ async def _record(
transaction.set_tag("mcp.caller", caller)
for name, value in request.items():
transaction.set_tag(f"mcp.{name}", value)
if auth:
transaction.set_tag("mcp.auth", auth["auth"])
transaction.set_data("mcp.auth.wait_ms", auth["auth_wait_ms"])
try:
result = await call_next(context)
if _is_rejected(result):
Expand Down Expand Up @@ -258,6 +275,7 @@ async def _record(
),
"caller": caller,
**request,
**auth,
**fields,
}
)
Expand Down
15 changes: 14 additions & 1 deletion tests/test_chatgpt_server.py
Original file line number Diff line number Diff line change
Expand Up @@ -17,7 +17,7 @@
import respx
from fastmcp import Client

from late.mcp import chatgpt_server
from late.mcp import auth, chatgpt_server
from late.mcp.chatgpt_server import chatgpt_mcp

API = chatgpt_server.API_BASE
Expand Down Expand Up @@ -328,3 +328,16 @@ async def test_best_time_returns_named_days_best_first():
"post_count": 1,
}
assert result.structured_content["based_on_posts"] == 3


@respx.mock
async def test_an_api_401_evicts_the_cached_token_so_chatgpt_gets_a_401_and_refreshes():
auth._VERIFIED_AT[auth.token_cache_key("sk_test")] = 0.0
respx.get(f"{API}/v1/accounts").mock(
return_value=httpx.Response(401, json={"error": "Invalid API key"})
)

result = await _call("list_social_accounts")

assert result.is_error
assert auth.token_cache_key("sk_test") not in auth._VERIFIED_AT
Loading
Loading