Skip to content

BrainAPI is a knowledge graph–powered AI memory layer that transforms unstructured data into structured knowledge, enabling intelligent search, recommendations, and contextual memory for AI agents and applications.

fix(mcp): oauth flow + pat

Christian45caaffdff08
diff --git a/src/services/mcp/app.py b/src/services/mcp/app.py
index d1fe0fa..d7c1221 100644
--- a/src/services/mcp/app.py
+++ b/src/services/mcp/app.py
@@ -7,7 +7,7 @@ import dotenv
from starlette.applications import Starlette
from starlette.middleware import Middleware
from starlette.responses import JSONResponse
-from starlette.routing import Route
+from starlette.routing import Mount, Route
_project_root = Path(__file__).resolve().parent.parent.parent.parent
dotenv.load_dotenv(_project_root / ".env")
@@ -100,9 +100,13 @@ class AuthContextMiddleware:
async def __call__(self, scope, receive, send):
if scope["type"] in ("http", "websocket"):
- headers = dict(scope.get("headers", []))
+ raw_headers = list(scope.get("headers", []))
+ headers = dict(raw_headers)
token = None
brainpat = headers.get(b"brainpat")
+ if brainpat and b"authorization" not in headers:
+ raw_headers.append((b"authorization", b"Bearer " + brainpat))
+ scope = {**scope, "headers": raw_headers}
if brainpat:
token = brainpat.decode()
else:
@@ -150,7 +154,7 @@ _custom_routes = [
Route("/mcp/info", _mcp_info, methods=["GET"]),
]
app = Starlette(
- routes=_custom_routes + list(_mcp_app.routes),
+ routes=_custom_routes + [Mount("/", app=_mcp_app)],
middleware=[
Middleware(TraceMiddleware, service_name="brainapi-mcp"),
Middleware(AuthContextMiddleware),
diff --git a/src/services/mcp/oauth_provider.py b/src/services/mcp/oauth_provider.py
index 6f31e95..e0d6686 100644
--- a/src/services/mcp/oauth_provider.py
+++ b/src/services/mcp/oauth_provider.py
@@ -30,6 +30,7 @@ class BrainapiMcpOAuthProvider(
refresh_token_ttl_seconds: int | None,
auth_code_ttl_seconds: int,
redis_client=None,
+ pat_verifier=None,
):
self._issuer_url = issuer_url.rstrip("/")
self._resource_server_url = resource_server_url.rstrip("/")
@@ -37,6 +38,11 @@ class BrainapiMcpOAuthProvider(
self._access_token_ttl = access_token_ttl_seconds
self._refresh_token_ttl = refresh_token_ttl_seconds
self._auth_code_ttl = auth_code_ttl_seconds
+ if pat_verifier is None:
+ from src.services.mcp.utils import guard_brainpat
+
+ pat_verifier = guard_brainpat
+ self._pat_verifier = pat_verifier
if redis_client is None:
from src.lib.redis.client import _redis_client
@@ -263,6 +269,14 @@ class BrainapiMcpOAuthProvider(
async def load_access_token(self, token: str) -> AccessToken | None:
at = self._get_model(self._access_key(token), AccessToken)
if at is None:
+ if self._pat_verifier(token):
+ return AccessToken(
+ token=token,
+ client_id="brainpat",
+ scopes=list(self._valid_scopes),
+ expires_at=None,
+ resource=self._resource_server_url,
+ )
return None
if at.expires_at and at.expires_at < int(time.time()):
self._delete_access_token(token, at.client_id)
diff --git a/tests/test_mcp_oauth_redis_storage.py b/tests/test_mcp_oauth_redis_storage.py
index ae3a136..294a46e 100644
--- a/tests/test_mcp_oauth_redis_storage.py
+++ b/tests/test_mcp_oauth_redis_storage.py
@@ -60,7 +60,7 @@ class FakeRedis:
return True
-def make_provider(redis_client):
+def make_provider(redis_client, pat_verifier=lambda _pat: False):
return BrainapiMcpOAuthProvider(
issuer_url="https://brainapi.example",
resource_server_url="https://brainapi.example/mcp",
@@ -69,6 +69,7 @@ def make_provider(redis_client):
refresh_token_ttl_seconds=7200,
auth_code_ttl_seconds=600,
redis_client=redis_client,
+ pat_verifier=pat_verifier,
)
@@ -139,6 +140,21 @@ class BrainapiMcpOAuthProviderRedisTests(unittest.TestCase):
self.assertEqual(query["redirect_uri_provided_explicitly"], ["0"])
+ def test_valid_pat_can_be_used_as_bearer_token(self):
+ provider = make_provider(FakeRedis(), pat_verifier=lambda pat: pat == "brain-pat")
+
+ access_token = asyncio.run(provider.load_access_token("brain-pat"))
+
+ self.assertIsNotNone(access_token)
+ self.assertEqual(access_token.token, "brain-pat")
+ self.assertEqual(access_token.client_id, "brainpat")
+ self.assertEqual(access_token.scopes, ["brainapi"])
+
+ def test_invalid_pat_is_not_accepted_as_bearer_token(self):
+ provider = make_provider(FakeRedis(), pat_verifier=lambda _pat: False)
+
+ self.assertIsNone(asyncio.run(provider.load_access_token("bad-pat")))
+
def test_refresh_exchange_survives_provider_recreation_and_revokes_old_access_token(self):
redis_client = FakeRedis()
provider = make_provider(redis_client)