mainsequence 9.0.15.dev57__tar.gz → 9.0.15.dev58__tar.gz

{mainsequence-9.0.15.dev57 → mainsequence-9.0.15.dev58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 9.0.15.dev57
+Version: 9.0.15.dev58
 Summary: Main Sequence SDK
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT
@@ -31,6 +31,8 @@ Requires-Dist: requests>=2.33.0
 Requires-Dist: structlog
 Requires-Dist: typer
 Requires-Dist: urllib3>=2.7.0
+Provides-Extra: mcp
+Requires-Dist: mcp<2,>=1.28; extra == "mcp"
 Dynamic: license-file
 
 <p align="center">

{mainsequence-9.0.15.dev57 → mainsequence-9.0.15.dev58}/agent_scaffold/skills/application_surfaces/api_surfaces/SKILL.md

@@ -211,6 +211,16 @@ what people are told:
 See also
 [Requester-bound calls](https://mainsequence-sdk.github.io/mainsequence-sdk/knowledge/fastapi/#requester-bound-calls).
 
+### MCP tools
+
+To serve MCP tools from the same application, add the `mcp` extra and call
+`install_mcp(app, mcp.streamable_http_app(), lifespan=mcp.session_manager.run)`
+after `install_request_identity(app)`, with a stateless FastMCP server that
+returns JSON. Tools authorize with `User.get_logged_user()` and
+`User.get_requester()` exactly like REST handlers; admission to the release
+does not authorize every tool. See
+[Serving MCP](https://mainsequence-sdk.github.io/mainsequence-sdk/knowledge/fastapi/#serving-mcp).
+
 ### Public provider callbacks and webhooks
 
 An external OAuth redirect or webhook cannot supply a Main Sequence Bearer token.

{mainsequence-9.0.15.dev57 → mainsequence-9.0.15.dev58}/mainsequence/client/models_helpers.py

@@ -822,6 +822,34 @@ class ResourceReleaseRuntimeAccess(BasePydanticModel):
     access: dict[str, Any] | None = Field(default=None, repr=False)
 
 
+class ResourceReleaseMcpConnection(BasePydanticModel):
+    """How to connect to the MCP endpoint of a FastAPI release's active revision."""
+
+    url: str = Field(
+        ...,
+        description="Public MCP endpoint: the release URL plus `/mcp`.",
+        examples=["https://prices.example.test/mcp"],
+    )
+    transport: OpenValueSet[Literal["streamable-http"]] = Field(
+        ...,
+        description=(
+            "MCP transport of the endpoint. A value this SDK does not declare is kept "
+            "but is not a transport to connect with."
+        ),
+        examples=["streamable-http"],
+    )
+    resource_metadata_url: str | None = Field(
+        None,
+        description="OAuth protected-resource metadata URL the endpoint's challenge points to.",
+    )
+    organization_environment_uid: str | None = Field(
+        None, description="Public UID of the connection's Organization Environment."
+    )
+    active_revision_uid: str | None = Field(
+        None, description="Public UID of the revision that advertises the endpoint."
+    )
+
+
 class ResourceRelease(
     CurrentCodeRepositoryBranchCollectionMixin,
     EnvironmentLogSearchMixin,
@@ -853,6 +881,7 @@ class ResourceRelease(
         "resource__uid": ["exact", "in"],
         "related_job__uid": ["exact", "in"],
         "release_kind": ["exact", "in"],
+        "mcp_available": ["exact"],
     }
     FILTER_VALUE_NORMALIZERS: ClassVar[dict[str, str]] = {
         "uid": "uid",
@@ -861,6 +890,7 @@ class ResourceRelease(
         "resource__uid": "uid",
         "related_job__uid": "uid",
         "release_kind": "str",
+        "mcp_available": "bool",
     }
 
     @classmethod
@@ -1005,6 +1035,23 @@ class ResourceRelease(
         ),
         examples=["88888888-8888-4888-8888-888888888888"],
     )
+    mcp_enabled: bool = Field(
+        False,
+        title="MCP Enabled",
+        description=(
+            "Desired MCP capability of a FastAPI release, applied by its next successful "
+            "deployment. False when the response does not carry it."
+        ),
+        examples=[True],
+    )
+    mcp_connection: ResourceReleaseMcpConnection | None = Field(
+        None,
+        title="MCP Connection",
+        description=(
+            "MCP endpoint of the active MCP-enabled revision; None when no active revision "
+            "advertises one. An advertised capability, not a health check."
+        ),
+    )
     observability: ObservabilityLinks | None = Field(
         default=None,
         description="Backend-owned runtime observability and related-history capabilities.",

{mainsequence-9.0.15.dev57 → mainsequence-9.0.15.dev58}/mainsequence/server/fastapi.py

@@ -6,12 +6,18 @@ import asyncio
 import json
 import os
 import re
-from contextlib import contextmanager
+from contextlib import asynccontextmanager, contextmanager
+from urllib.parse import urlsplit
 from uuid import UUID
 
 import requests
 
-from mainsequence._request_identity import _reads_as_caller, _request_scope
+from mainsequence._request_identity import (
+    RequestIdentityError,
+    _get_request_identity,
+    _reads_as_caller,
+    _request_scope,
+)
 from mainsequence.client.models_user import RequestUserIdentity
 
 from .caller_assertions import (
@@ -296,4 +302,154 @@ def reads_as_caller():
         yield
 
 
-__all__ = ["install_request_identity", "reads_as_caller"]
+_MCP_INSTALLATION = "mainsequence_mcp"
+_MCP_PATH = "/mcp"
+_WILDCARD_ORIGIN = re.compile(r"(https?)://\*\.([a-z0-9.-]+)(?::([0-9]{1,5}))?", flags=re.ASCII)
+
+
+def _mcp_allowed_origins():
+    """The release's public origin and its CORS origins, read once at installation."""
+    entries = [os.environ.get("FASTAPI_PUBLIC_BASE_URL", "")]
+    entries += os.environ.get("FASTAPI_CORS_ALLOW_ORIGINS", "").split(",")
+    exact, patterns = set(), []
+    for entry in entries:
+        entry = entry.strip().rstrip("/").lower()
+        wildcard = _WILDCARD_ORIGIN.fullmatch(entry)
+        if wildcard:
+            scheme, host, port = wildcard.groups()
+            pattern = rf"{scheme}://[a-z0-9-]+\.{re.escape(host)}"
+            patterns.append(re.compile(pattern + (rf":{port}" if port else ""), flags=re.ASCII))
+            continue
+        parts = urlsplit(entry)
+        if parts.scheme in {"http", "https"} and parts.netloc and "*" not in parts.netloc:
+            exact.add(f"{parts.scheme}://{parts.netloc}")
+    return frozenset(exact), tuple(patterns)
+
+
+def _mcp_conflicts(routes, *, installed=None):
+    for route in routes:
+        path = getattr(route, "path", None)
+        if route is not installed and isinstance(path, str):
+            if path == _MCP_PATH or path.startswith(_MCP_PATH + "/"):
+                raise RuntimeError(f"Route {path} conflicts with the MCP endpoint at {_MCP_PATH}.")
+
+
+async def _reply(send, status, detail, headers=()):
+    await send(
+        {
+            "type": "http.response.start",
+            "status": status,
+            "headers": [
+                (b"content-type", b"application/json"),
+                (b"cache-control", b"no-store"),
+                *headers,
+            ],
+        }
+    )
+    await send({"type": "http.response.body", "body": json.dumps({"detail": detail}).encode()})
+
+
+class _McpEndpoint:
+    """Admit authenticated POSTs from an allowed Origin to the application's MCP app."""
+
+    def __init__(self, app, *, allowed_origins):
+        self.app = app
+        self.exact_origins, self.origin_patterns = allowed_origins
+
+    def _origin_allowed(self, origin):
+        origin = origin.strip().rstrip("/").lower()
+        return origin in self.exact_origins or any(
+            pattern.fullmatch(origin) for pattern in self.origin_patterns
+        )
+
+    async def __call__(self, scope, receive, send):
+        if scope.get("method") != "POST":
+            # Stateless profile: no standalone GET stream and no session to delete.
+            await _reply(send, 405, "Method Not Allowed.", headers=[(b"allow", b"POST")])
+            return
+        origins = [value for key, value in scope.get("headers", ()) if key.lower() == b"origin"]
+        if len(origins) > 1 or (origins and not self._origin_allowed(origins[0].decode("latin-1"))):
+            await _reply(send, 403, "Origin is not allowed.")
+            return
+        try:
+            _get_request_identity()
+        except RequestIdentityError:
+            await _reply(send, 401, "Authenticated request user could not be resolved.")
+            return
+        # Stateless profile: a session identifier never selects server-side state.
+        scope = dict(scope)
+        scope["headers"] = [
+            (key, value)
+            for key, value in scope.get("headers", ())
+            if key.lower() != b"mcp-session-id"
+        ]
+        await self.app(scope, receive, send)
+
+
+def install_mcp(app, mcp_app, *, lifespan):
+    """Serve an application-owned MCP server at ``/mcp`` inside request identity.
+
+    ``mcp_app`` is the server's ASGI application, answering Streamable HTTP at
+    ``/mcp`` statelessly with JSON responses. ``lifespan`` is a zero-argument
+    callable returning its async context manager. With the official MCP Python
+    SDK, pass ``mcp.streamable_http_app()`` and ``mcp.session_manager.run``.
+
+    Install request identity first. Tools read the caller with
+    ``User.get_logged_user()`` and, on a requester-bound call, the person it
+    works for with ``User.get_requester()``. Only authenticated POSTs reach the
+    server; other methods answer 405 and an ``Origin`` other than the release's
+    own or its CORS origins answers 403. See ADR 0038.
+    """
+    from starlette.routing import Route
+
+    identity = getattr(app.state, _INSTALLATION, None)
+    if not isinstance(identity, dict) or identity.get("installed") is not True:
+        raise RuntimeError(
+            "Install request identity before MCP: call install_request_identity(app)."
+        )
+    if getattr(app.state, _MCP_INSTALLATION, None) is not None:
+        raise RuntimeError("MCP is already installed.")
+    if any(
+        path == _MCP_PATH or path.startswith(_MCP_PATH + "/")
+        for _, path in identity.get("public_ingress", ())
+    ):
+        raise RuntimeError(f"{_MCP_PATH} cannot be public ingress; MCP requests are authenticated.")
+    if not callable(mcp_app) or not callable(lifespan):
+        raise TypeError("install_mcp needs the MCP ASGI app and its lifespan factory.")
+    _mcp_conflicts(app.router.routes)
+
+    route = Route(
+        _MCP_PATH,
+        endpoint=_McpEndpoint(mcp_app, allowed_origins=_mcp_allowed_origins()),
+        include_in_schema=False,
+    )
+    app.router.routes.insert(0, route)
+    application_lifespan = app.router.lifespan_context
+    started = False
+
+    @asynccontextmanager
+    async def composed_lifespan(application):
+        nonlocal started
+        if started:
+            raise RuntimeError("The MCP lifespan runs once per application.")
+        started = True
+        _mcp_conflicts(app.router.routes, installed=route)
+        async with application_lifespan(application) as state:
+            async with lifespan():
+                yield state
+
+    app.router.lifespan_context = composed_lifespan
+    setattr(
+        app.state,
+        _MCP_INSTALLATION,
+        {
+            "installed": True,
+            "path": _MCP_PATH,
+            "transport": "streamable-http",
+            "stateless": True,
+            "request_identity": True,
+        },
+    )
+
+
+__all__ = ["install_mcp", "install_request_identity", "reads_as_caller"]

{mainsequence-9.0.15.dev57 → mainsequence-9.0.15.dev58}/mainsequence.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 9.0.15.dev57
+Version: 9.0.15.dev58
 Summary: Main Sequence SDK
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT
@@ -31,6 +31,8 @@ Requires-Dist: requests>=2.33.0
 Requires-Dist: structlog
 Requires-Dist: typer
 Requires-Dist: urllib3>=2.7.0
+Provides-Extra: mcp
+Requires-Dist: mcp<2,>=1.28; extra == "mcp"
 Dynamic: license-file
 
 <p align="center">

{mainsequence-9.0.15.dev57 → mainsequence-9.0.15.dev58}/mainsequence.egg-info/SOURCES.txt

@@ -80,6 +80,7 @@ tests/test_dependency_extras.py
 tests/test_dev_release_version.py
 tests/test_environment_resource_context.py
 tests/test_environment_response_contracts.py
+tests/test_fastapi_mcp.py
 tests/test_fastapi_request_identity.py
 tests/test_github_issues_client.py
 tests/test_http_retry_budget.py

{mainsequence-9.0.15.dev57 → mainsequence-9.0.15.dev58}/mainsequence.egg-info/requires.txt

@@ -16,3 +16,6 @@ requests>=2.33.0
 structlog
 typer
 urllib3>=2.7.0
+
+[mcp]
+mcp<2,>=1.28

{mainsequence-9.0.15.dev57 → mainsequence-9.0.15.dev58}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence"
-version = "9.0.15.dev57"
+version = "9.0.15.dev58"
 description = "Main Sequence SDK"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -42,6 +42,12 @@ dependencies = [
   "urllib3>=2.7.0",
 ]
 
+[project.optional-dependencies]
+# Serving an application-owned MCP server with install_mcp (ADR 0038).
+mcp = [
+  "mcp>=1.28,<2",
+]
+
 [project.urls]
 Homepage = "https://github.com/mainsequence-sdk/mainsequence-sdk"
 Issues = "https://github.com/mainsequence-sdk/mainsequence-sdk/issues"
@@ -54,6 +60,7 @@ ms = "mainsequence.cli.cli:app"
 dev = [
   "fastapi>=0.110,<1",
   "httpx>=0.27,<1",
+  "mcp>=1.28,<2",
   "black>=26.3.1",
   "IPython",
   "mkdocs",

mainsequence-9.0.15.dev58/tests/test_fastapi_mcp.py

@@ -0,0 +1,339 @@
+"""An application-owned MCP server served by install_mcp (ADR 0038)."""
+
+import asyncio
+import json
+from contextlib import asynccontextmanager
+from unittest.mock import Mock
+from uuid import uuid4
+
+import anyio
+import httpx
+import pytest
+from fastapi import FastAPI, Request
+from fastapi.testclient import TestClient
+from mcp.server.fastmcp import FastMCP
+from mcp.server.transport_security import TransportSecuritySettings
+
+import tests.test_fastapi_request_identity as identity_tests
+from mainsequence.client import User
+from mainsequence.server.caller_assertions import ASSERTION_HEADER
+from mainsequence.server.fastapi import install_mcp, install_request_identity
+
+USER, OTHER, ISSUER = identity_tests.USER, identity_tests.OTHER, identity_tests.ISSUER
+clean_environment = identity_tests.clean_environment
+signed = identity_tests.signed
+
+MCP_HEADERS = {
+    "accept": "application/json, text/event-stream",
+    "content-type": "application/json",
+    "mcp-protocol-version": "2025-11-25",
+}
+
+
+@pytest.fixture(autouse=True)
+def no_cors_origins(monkeypatch):
+    monkeypatch.delenv("FASTAPI_CORS_ALLOW_ORIGINS", raising=False)
+
+
+def _call(name):
+    return {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "tools/call",
+        "params": {"name": name, "arguments": {}},
+    }
+
+
+def _text(response):
+    assert response.status_code == 200, response.text
+    result = response.json()["result"]
+    assert result.get("isError") is not True, result
+    return result["content"][0]["text"]
+
+
+def _server():
+    """A stateless JSON server; the SDK checks Origin and the platform routes Host."""
+    return FastMCP(
+        "identity",
+        stateless_http=True,
+        json_response=True,
+        transport_security=TransportSecuritySettings(enable_dns_rebinding_protection=False),
+    )
+
+
+def _identity_server():
+    server = _server()
+
+    @server.tool()
+    async def caller() -> str:
+        return User.get_logged_user().uid
+
+    @server.tool()
+    async def caller_in_thread() -> str:
+        return await anyio.to_thread.run_sync(lambda: User.get_logged_user().uid)
+
+    @server.tool()
+    async def requester() -> str:
+        person = User.get_requester()
+        return person.uid if person is not None else "none"
+
+    return server
+
+
+def _install(app, server):
+    install_request_identity(app)
+    install_mcp(app, server.streamable_http_app(), lifespan=server.session_manager.run)
+    return app
+
+
+async def _fake_mcp(scope, receive, send):
+    await send(
+        {
+            "type": "http.response.start",
+            "status": 200,
+            "headers": [(b"content-type", b"application/json")],
+        }
+    )
+    headers = {key.decode("latin-1"): value.decode("latin-1") for key, value in scope["headers"]}
+    await send({"type": "http.response.body", "body": json.dumps(headers).encode()})
+
+
+@asynccontextmanager
+async def _no_lifespan():
+    yield
+
+
+def test_tools_read_the_verified_caller_and_rest_routes_keep_working(signed):
+    token, _, _ = signed
+    app = FastAPI()
+
+    @app.get("/prices")
+    def prices():
+        return {"caller": User.get_logged_user().uid}
+
+    _install(app, _identity_server())
+    proof = {**MCP_HEADERS, ASSERTION_HEADER: token()}
+    requester_bound = {
+        **MCP_HEADERS,
+        ASSERTION_HEADER: token(requester={"sub": OTHER, "team_uids": []}),
+    }
+
+    with TestClient(app) as client:
+        assert _text(client.post("/mcp", json=_call("caller"), headers=proof)) == USER
+        assert _text(client.post("/mcp", json=_call("caller_in_thread"), headers=proof)) == USER
+        assert _text(client.post("/mcp", json=_call("requester"), headers=proof)) == "none"
+        assert _text(client.post("/mcp", json=_call("requester"), headers=requester_bound)) == OTHER
+        assert client.get("/prices", headers={ASSERTION_HEADER: token()}).json() == {"caller": USER}
+        missing = client.post("/mcp", json=_call("caller"), headers=MCP_HEADERS)
+        forged = client.post(
+            "/mcp",
+            json=_call("caller"),
+            headers={**MCP_HEADERS, ASSERTION_HEADER: token(aud="urn:other:" + str(uuid4()))},
+        )
+
+    assert (missing.status_code, forged.status_code) == (401, 401)
+    assert "/mcp" not in app.openapi()["paths"]
+
+
+def test_concurrent_callers_keep_their_own_identity(signed):
+    token, _, _ = signed
+    server = _server()
+    both_inside = asyncio.Barrier(2)
+
+    @server.tool()
+    async def caller_after_peer() -> str:
+        await asyncio.wait_for(both_inside.wait(), 5)
+        return User.get_logged_user().uid
+
+    app = _install(FastAPI(), server)
+
+    async def run():
+        async with app.router.lifespan_context(app):
+            transport = httpx.ASGITransport(app=app)
+            async with httpx.AsyncClient(
+                transport=transport, base_url="http://testserver"
+            ) as client:
+
+                async def call(user):
+                    headers = {**MCP_HEADERS, ASSERTION_HEADER: token(user)}
+                    return _text(
+                        await client.post("/mcp", json=_call("caller_after_peer"), headers=headers)
+                    )
+
+                return await asyncio.gather(call(USER), call(OTHER))
+
+    assert asyncio.run(run()) == [USER, OTHER]
+
+
+def test_endpoint_declines_streams_sessions_and_foreign_origins(signed, monkeypatch):
+    token, _, _ = signed
+    monkeypatch.setenv("FASTAPI_PUBLIC_BASE_URL", "https://prices.example.test/")
+    monkeypatch.setenv(
+        "FASTAPI_CORS_ALLOW_ORIGINS", "https://app.example.test, https://*.tenant.example.test"
+    )
+    app = FastAPI()
+    install_request_identity(app)
+    install_mcp(app, _fake_mcp, lifespan=_no_lifespan)
+    proof = {ASSERTION_HEADER: token()}
+
+    with TestClient(app) as client:
+        stream = client.get("/mcp", headers=proof)
+        delete = client.delete("/mcp", headers=proof)
+        allowed = [
+            client.post("/mcp", json={}, headers={**proof, "origin": origin}).status_code
+            for origin in (
+                "https://prices.example.test",
+                "https://app.example.test",
+                "https://east.tenant.example.test",
+            )
+        ]
+        refused = [
+            client.post("/mcp", json={}, headers={**proof, "origin": origin}).status_code
+            for origin in (
+                "https://evil.example.test",
+                "https://a.b.tenant.example.test",
+                "null",
+            )
+        ]
+        duplicated = client.post(
+            "/mcp",
+            json={},
+            headers=[
+                (ASSERTION_HEADER, proof[ASSERTION_HEADER]),
+                ("origin", "https://app.example.test"),
+                ("origin", "https://evil.example.test"),
+            ],
+        )
+        with_session = client.post("/mcp", json={}, headers={**proof, "mcp-session-id": "abc"})
+
+    assert (stream.status_code, stream.headers["allow"]) == (405, "POST")
+    assert delete.status_code == 405
+    assert allowed == [200, 200, 200]
+    assert refused == [403, 403, 403]
+    assert duplicated.status_code == 403
+    assert with_session.status_code == 200
+    assert "mcp-session-id" not in with_session.json()
+
+
+def test_installation_rejects_unsafe_or_conflicting_setups(signed, monkeypatch):
+    with pytest.raises(RuntimeError, match="request identity"):
+        install_mcp(FastAPI(), _fake_mcp, lifespan=_no_lifespan)
+
+    routed = FastAPI()
+    routed.get("/mcp/tools")(lambda: {})
+    install_request_identity(routed)
+    with pytest.raises(RuntimeError, match="conflicts"):
+        install_mcp(routed, _fake_mcp, lifespan=_no_lifespan)
+
+    mounted = FastAPI()
+    mounted.mount("/mcp", _fake_mcp)
+    install_request_identity(mounted)
+    with pytest.raises(RuntimeError, match="conflicts"):
+        install_mcp(mounted, _fake_mcp, lifespan=_no_lifespan)
+
+    app = FastAPI()
+    install_request_identity(app)
+    with pytest.raises(TypeError):
+        install_mcp(app, _fake_mcp, lifespan=None)
+    install_mcp(app, _fake_mcp, lifespan=_no_lifespan)
+    with pytest.raises(RuntimeError, match="already installed"):
+        install_mcp(app, _fake_mcp, lifespan=_no_lifespan)
+    assert app.state.mainsequence_mcp == {
+        "installed": True,
+        "path": "/mcp",
+        "transport": "streamable-http",
+        "stateless": True,
+        "request_identity": True,
+    }
+    assert app.state.mainsequence_request_identity["installed"] is True
+
+    app.get("/mcp/late")(lambda: {})
+    with pytest.raises(RuntimeError, match="conflicts"):
+        with TestClient(app):
+            pass
+
+    monkeypatch.setenv("FASTAPI_PUBLIC_INGRESS", json.dumps([{"method": "POST", "path": "/mcp"}]))
+    public = FastAPI()
+    install_request_identity(public)
+    with pytest.raises(RuntimeError, match="public ingress"):
+        install_mcp(public, _fake_mcp, lifespan=_no_lifespan)
+
+
+def test_lifespans_start_once_in_order_and_unwind_on_failure(signed):
+    token, _, _ = signed
+    events = []
+
+    @asynccontextmanager
+    async def application_lifespan(app):
+        events.append("app start")
+        try:
+            yield {"greeting": "hello"}
+        finally:
+            events.append("app stop")
+
+    @asynccontextmanager
+    async def mcp_lifespan():
+        events.append("mcp start")
+        yield
+        events.append("mcp stop")
+
+    app = FastAPI(lifespan=application_lifespan)
+
+    @app.get("/greeting")
+    def greeting(request: Request):
+        return {"greeting": request.state.greeting}
+
+    install_request_identity(app)
+    install_mcp(app, _fake_mcp, lifespan=mcp_lifespan)
+    with TestClient(app) as client:
+        assert client.get("/greeting", headers={ASSERTION_HEADER: token()}).json() == {
+            "greeting": "hello"
+        }
+    assert events == ["app start", "mcp start", "mcp stop", "app stop"]
+    with pytest.raises(RuntimeError, match="once"):
+        with TestClient(app):
+            pass
+
+    @asynccontextmanager
+    async def failing_mcp_lifespan():
+        raise RuntimeError("MCP server failed to start")
+        yield
+
+    events.clear()
+    broken = FastAPI(lifespan=application_lifespan)
+    install_request_identity(broken)
+    install_mcp(broken, _fake_mcp, lifespan=failing_mcp_lifespan)
+    with pytest.raises(RuntimeError, match="failed to start"):
+        with TestClient(broken):
+            pass
+    assert events == ["app start", "app stop"]
+
+
+def test_local_mode_admits_mcp_through_the_same_bearer_validation(monkeypatch):
+    monkeypatch.setenv("MAINSEQUENCE_ENDPOINT", ISSUER)
+
+    def users_me(url, **kwargs):
+        if kwargs["headers"] == {"Authorization": "Bearer developer-token"}:
+            response = Mock(status_code=200)
+            response.json.return_value = {"uid": USER, "username": "developer"}
+            return response
+        # The platform refuses a token issued for another resource, such as an MCP URL.
+        return Mock(status_code=401)
+
+    monkeypatch.setattr("mainsequence.server.fastapi.requests.get", users_me)
+    app = _install(FastAPI(), _identity_server())
+
+    with TestClient(app) as client:
+        developer = client.post(
+            "/mcp",
+            json=_call("caller"),
+            headers={**MCP_HEADERS, "Authorization": "Bearer developer-token"},
+        )
+        other_resource = client.post(
+            "/mcp",
+            json=_call("caller"),
+            headers={**MCP_HEADERS, "Authorization": "Bearer token-for-a-project-mcp-url"},
+        )
+
+    assert _text(developer) == USER
+    assert other_resource.status_code == 401