alloc-context 0.1.0__py3-none-any.whl

alloccontext/mcp/http.py

@@ -0,0 +1,250 @@
+from __future__ import annotations
+
+import contextlib
+import os
+from collections.abc import AsyncIterator
+from typing import Any
+
+from starlette.applications import Starlette
+from starlette.middleware import Middleware
+from starlette.responses import JSONResponse, PlainTextResponse
+from starlette.routing import Mount, Route
+
+from alloccontext.mcp.bazaar import (
+    build_llms_txt,
+    build_well_known_x402,
+    resolve_public_base_url,
+)
+from alloccontext.mcp.server import create_server
+from alloccontext.mcp.x402_config import (
+    CDP_FACILITATOR_URL,
+    X402Settings,
+    build_x402_resource_server,
+    build_x402_routes,
+    load_x402_settings,
+)
+from alloccontext.mcp.x402_stables import effective_accepted_stable_symbols
+
+
+def _health_verbose_enabled() -> bool:
+    return os.environ.get("ALLOC_CONTEXT_HEALTH_VERBOSE", "").lower() in (
+        "1",
+        "true",
+        "yes",
+    )
+
+
+def _discovery_link_headers() -> dict[str, str]:
+    if resolve_public_base_url():
+        return {"Link": '</llms.txt>; rel="describedby"'}
+    return {}
+
+
+def _make_health_handler(config_path: str | None) -> Any:
+    def _health(_: Any) -> JSONResponse:
+        payload: dict[str, Any] = {"ok": True, "service": "alloc-context-mcp"}
+        verbose = _health_verbose_enabled()
+        try:
+            from alloccontext.config import load_config
+            from alloccontext.store.db import connect
+            from alloccontext.status_report import mcp_health_ingest_summary
+
+            config = load_config(config_path)
+            conn = connect(config.paths.db)
+            try:
+                summary = mcp_health_ingest_summary(config, conn)
+                payload["ingest_ok"] = summary["ingest_ok"]
+                optional_failures = summary.get("optional_feed_failures") or []
+                if optional_failures:
+                    payload["optional_feed_failures"] = optional_failures
+                if verbose:
+                    payload["source_health"] = summary.get("source_health")
+                    required_failures = summary.get("required_failures") or []
+                    if required_failures:
+                        payload["required_failures"] = required_failures
+            finally:
+                conn.close()
+        except Exception:
+            payload["status_detail"] = "database_unavailable"
+            payload["ok"] = False
+            payload["ingest_ok"] = False
+        return JSONResponse(payload, headers=_discovery_link_headers())
+
+    return _health
+
+
+def _health(_: Any) -> JSONResponse:
+    """Default handler for tests; production apps use _make_health_handler."""
+    return _make_health_handler(None)(_)
+
+
+def _llms_txt(settings: X402Settings) -> PlainTextResponse:
+    public_base = resolve_public_base_url()
+    if not public_base:
+        return PlainTextResponse(
+            "Set X402_PUBLIC_URL for discovery metadata.\n",
+            status_code=404,
+        )
+    stables = effective_accepted_stable_symbols(settings.accepted_stables)
+    body = build_llms_txt(
+        public_url=public_base,
+        mcp_path=settings.mcp_path,
+        accepted_stables=stables,
+    )
+    return PlainTextResponse(body, media_type="text/plain; charset=utf-8")
+
+
+def _well_known_x402(settings: X402Settings) -> JSONResponse:
+    public_base = resolve_public_base_url()
+    if not public_base or not settings.pay_to:
+        return JSONResponse({"error": "discovery metadata unavailable"}, status_code=404)
+    stables = effective_accepted_stable_symbols(settings.accepted_stables)
+    payload = build_well_known_x402(
+        public_url=public_base,
+        mcp_path=settings.mcp_path,
+        pay_to=settings.pay_to,
+        price_light=settings.mcp_price,
+        price_heavy=settings.mcp_price_heavy,
+        network=settings.network,
+        accepted_stables=stables,
+    )
+    return JSONResponse(payload)
+
+
+def _is_loopback_host(host: str) -> bool:
+    normalized = host.strip().lower()
+    return normalized in {"127.0.0.1", "localhost", "::1"}
+
+
+def build_http_app(
+    *,
+    config_path: str | None = None,
+    host: str = "127.0.0.1",
+    port: int = 8000,
+    stateless_http: bool = True,
+    x402: bool = False,
+) -> Starlette:
+    if not _is_loopback_host(host) and not x402:
+        raise RuntimeError(
+            "HTTP MCP on a non-loopback host requires x402 payment protection"
+        )
+    mcp = create_server(
+        config_path=config_path,
+        host=host,
+        port=port,
+        stateless_http=stateless_http,
+    )
+    inner = mcp.streamable_http_app()
+    settings = load_x402_settings(require_payment=x402)
+
+    @contextlib.asynccontextmanager
+    async def mcp_lifespan(_app: Starlette) -> AsyncIterator[None]:
+        async with mcp.session_manager.run():
+            yield
+
+    discovery_routes = [
+        Route("/health", _make_health_handler(config_path)),
+        Route("/llms.txt", lambda req: _llms_txt(settings)),
+        Route("/.well-known/x402.json", lambda req: _well_known_x402(settings)),
+    ]
+
+    if not settings.enabled:
+        return Starlette(
+            routes=[
+                *discovery_routes,
+                Mount("/", app=inner),
+            ],
+            lifespan=mcp_lifespan,
+        )
+
+    from alloccontext.mcp.payment_middleware import AllocContextPaymentMiddlewareASGI
+
+    resource_server = build_x402_resource_server(settings)
+    routes = build_x402_routes(settings)
+    return Starlette(
+        middleware=[
+            Middleware(
+                AllocContextPaymentMiddlewareASGI,
+                routes=routes,
+                server=resource_server,
+            ),
+        ],
+        routes=[
+            *discovery_routes,
+            Mount("/", app=inner),
+        ],
+        lifespan=mcp_lifespan,
+    )
+
+
+def run_http(
+    *,
+    config_path: str | None = None,
+    host: str = "127.0.0.1",
+    port: int = 8000,
+    x402: bool = False,
+) -> None:
+    import uvicorn
+
+    app = build_http_app(
+        config_path=config_path,
+        host=host,
+        port=port,
+        x402=x402,
+    )
+    uvicorn.run(app, host=host, port=port, log_level="info")
+
+
+async def run_http_async(
+    *,
+    config_path: str | None = None,
+    host: str = "127.0.0.1",
+    port: int = 8000,
+    x402: bool = False,
+) -> None:
+    import uvicorn
+
+    app = build_http_app(
+        config_path=config_path,
+        host=host,
+        port=port,
+        x402=x402,
+    )
+    config = uvicorn.Config(app, host=host, port=port, log_level="info")
+    server = uvicorn.Server(config)
+    await server.serve()
+
+
+def _parse_mcp_port(raw: str) -> int:
+    try:
+        port = int(raw)
+    except ValueError as exc:
+        raise SystemExit(
+            f"ALLOC_CONTEXT_MCP_PORT must be an integer, got {raw!r}"
+        ) from exc
+    if not 1 <= port <= 65535:
+        raise SystemExit(f"ALLOC_CONTEXT_MCP_PORT out of range: {port}")
+    return port
+
+
+def main() -> None:
+    import logging
+
+    logger = logging.getLogger(__name__)
+    host = os.environ.get("ALLOC_CONTEXT_MCP_HOST", "127.0.0.1")
+    port = _parse_mcp_port(os.environ.get("ALLOC_CONTEXT_MCP_PORT", "8000"))
+    x402 = os.environ.get("X402_ENABLED", "").lower() in ("1", "true", "yes")
+    payment_env = (
+        os.environ.get("X402_FACILITATOR_URL", "").startswith(CDP_FACILITATOR_URL)
+        and os.environ.get("X402_PAY_TO", "").strip()
+    )
+    if payment_env and not x402:
+        logger.warning(
+            "X402 payment env vars are set but X402 is not enabled; "
+            "set X402_ENABLED=1 or pass --x402 to require payment"
+        )
+    run_http(host=host, port=port, x402=x402)
+
+
+if __name__ == "__main__":
+    main()

alloccontext/mcp/payment_middleware.py

@@ -0,0 +1,211 @@
+"""AllocContext payment middleware with per-tool Bazaar discovery."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING, Any
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import HTMLResponse, JSONResponse, Response
+from starlette.types import ASGIApp
+
+from alloccontext.mcp.x402_bazaar_dynamic import (
+    AllocContextHTTPResourceServer,
+    patch_resource_info_for_bazaar,
+)
+from x402.http.constants import SETTLEMENT_OVERRIDES_HEADER
+from x402.http.facilitator_client_base import FacilitatorResponseError
+from x402.http.middleware.fastapi import (
+    FastAPIAdapter,
+    _check_if_bazaar_needed,
+    _facilitator_error_response,
+    _register_bazaar_extension,
+)
+from x402.http.types import HTTPRequestContext, HTTPTransportContext, PaywallConfig, RoutesConfig
+from x402.schemas.hooks import VerifiedPaymentCancelOptions
+
+if TYPE_CHECKING:
+    from x402.http.x402_http_server import PaywallProvider
+    from x402.server import x402ResourceServer
+
+
+def alloc_payment_middleware(
+    routes: RoutesConfig,
+    server: x402ResourceServer,
+    paywall_config: PaywallConfig | None = None,
+    paywall_provider: PaywallProvider | None = None,
+    sync_facilitator_on_start: bool = True,
+) -> Callable[[Request, Callable[[Request], Awaitable[Response]]], Awaitable[Response]]:
+    """Like x402 fastapi payment_middleware but with per-tool Bazaar metadata."""
+    patch_resource_info_for_bazaar()
+    if _check_if_bazaar_needed(routes):
+        _register_bazaar_extension(server)
+
+    http_server = AllocContextHTTPResourceServer(server, routes)
+    if paywall_provider:
+        http_server.register_paywall_provider(paywall_provider)
+
+    init_done = False
+    init_lock = asyncio.Lock()
+
+    async def middleware(
+        request: Request,
+        call_next: Callable[[Request], Awaitable[Response]],
+    ) -> Response:
+        nonlocal init_done
+
+        adapter = FastAPIAdapter(request)
+        context = HTTPRequestContext(
+            adapter=adapter,
+            path=request.url.path,
+            method=request.method,
+            payment_header=(
+                adapter.get_header("payment-signature") or adapter.get_header("x-payment")
+            ),
+        )
+
+        if not http_server.requires_payment(context):
+            return await call_next(request)
+
+        if sync_facilitator_on_start and not init_done:
+            async with init_lock:
+                if not init_done:
+                    try:
+                        http_server.initialize()
+                    except FacilitatorResponseError as error:
+                        return _facilitator_error_response(error)
+                    init_done = True
+
+        try:
+            result = await http_server.process_http_request(context, paywall_config)
+        except FacilitatorResponseError as error:
+            return _facilitator_error_response(error)
+
+        if result.type == "no-payment-required":
+            return await call_next(request)
+
+        if result.type == "payment-error":
+            response = result.response
+            if response is None:
+                return JSONResponse(content={"error": "Payment required"}, status_code=402)
+            if response.is_html:
+                return HTMLResponse(
+                    content=response.body,
+                    status_code=response.status,
+                    headers=response.headers,
+                )
+            return JSONResponse(
+                content=response.body or {},
+                status_code=response.status,
+                headers=response.headers,
+            )
+
+        if result.type == "payment-verified":
+            request.state.payment_payload = result.payment_payload
+            request.state.payment_requirements = result.payment_requirements
+            dispatcher = result.cancellation_dispatcher
+            transport_context = HTTPTransportContext(request=context)
+
+            try:
+                response = await call_next(request)
+            except Exception as error:
+                if dispatcher is not None:
+                    await dispatcher.cancel(
+                        VerifiedPaymentCancelOptions(reason="handler_threw", error=error)
+                    )
+                raise
+
+            if response.status_code >= 400:
+                if dispatcher is not None:
+                    await dispatcher.cancel(
+                        VerifiedPaymentCancelOptions(
+                            reason="handler_failed",
+                            response_status=response.status_code,
+                        )
+                    )
+                return response
+
+            body = b""
+            async for chunk in response.body_iterator:
+                body += chunk
+
+            overrides = http_server._extract_settlement_overrides(dict(response.headers))
+            if overrides is not None:
+                for key in list(response.headers.keys()):
+                    if key.lower() == SETTLEMENT_OVERRIDES_HEADER.lower():
+                        del response.headers[key]
+
+            transport_context.response_headers = dict(response.headers)
+
+            try:
+                settle_result = await http_server.process_settlement(
+                    result.payment_payload,
+                    result.payment_requirements,
+                    context=context,
+                    settlement_overrides=overrides,
+                    declared_extensions=result.declared_extensions,
+                    transport_context=transport_context,
+                )
+            except FacilitatorResponseError as error:
+                return _facilitator_error_response(error)
+            except Exception:
+                return JSONResponse(content={}, status_code=402)
+
+            if not settle_result.success:
+                resp = settle_result.response
+                if resp is None:
+                    return JSONResponse(content={}, status_code=402)
+                if resp.is_html:
+                    return Response(
+                        content=resp.body,
+                        status_code=resp.status,
+                        headers=resp.headers,
+                        media_type="text/html",
+                    )
+                return JSONResponse(
+                    content=resp.body or {},
+                    status_code=resp.status,
+                    headers=resp.headers,
+                )
+
+            headers = dict(response.headers)
+            headers.update(settle_result.headers)
+            return Response(
+                content=body,
+                status_code=response.status_code,
+                headers=headers,
+                media_type=response.media_type,
+            )
+
+        return await call_next(request)
+
+    return middleware
+
+
+class AllocContextPaymentMiddlewareASGI(BaseHTTPMiddleware):
+    """Starlette middleware with AllocContext Bazaar discovery behavior."""
+
+    def __init__(
+        self,
+        app: ASGIApp,
+        routes: RoutesConfig,
+        server: x402ResourceServer,
+        paywall_config: PaywallConfig | None = None,
+        paywall_provider: PaywallProvider | None = None,
+    ) -> None:
+        super().__init__(app)
+        self._middleware = alloc_payment_middleware(
+            routes,
+            server,
+            paywall_config,
+            paywall_provider,
+        )
+
+    async def dispatch(
+        self,
+        request: Request,
+        call_next: Callable[[Request], Awaitable[Response]],
+    ) -> Response:
+        return await self._middleware(request, call_next)