Skip to content

πŸš€ The fast, Pythonic way to build MCP servers and clients.

4.0 KB
Raw Blame
"""Header forwarding across ProxyProvider HTTP hops."""

import json
from typing import Any

import httpx2
from mcp import MCPError
from mcp_types import METHOD_NOT_FOUND
from mcp_types.version import LATEST_HANDSHAKE_VERSION, LATEST_MODERN_VERSION

from fastmcp import FastMCP
from fastmcp.server.middleware import Middleware
from fastmcp.server.providers.proxy import ProxyClient, ProxyProvider
from fastmcp.utilities.tests import asgi_server


async def test_proxy_does_not_forward_frontend_mcp_headers_to_legacy_backend():
    """A modern frontend's transport state does not contaminate a legacy backend."""
    captured_requests: list[httpx2.Request] = []

    class RejectDiscovery(Middleware):
        async def on_discover(self, context, call_next):
            raise MCPError(code=METHOD_NOT_FOUND, message="Method not found")

    backend = FastMCP("Legacy Backend", middleware=[RejectDiscovery()])

    @backend.tool
    def legacy_ping() -> str:
        return "pong"

    async with asgi_server(backend) as running_backend:

        async def capture_request(request: httpx2.Request) -> None:
            captured_requests.append(request)

        def backend_http_client(
            headers: dict[str, str] | None = None,
            timeout: httpx2.Timeout | None = None,
            auth: httpx2.Auth | None = None,
            **kwargs: Any,
        ) -> httpx2.AsyncClient:
            return running_backend.http_client(
                headers=headers,
                timeout=timeout,
                auth=auth,
                event_hooks={"request": [capture_request]},
                **kwargs,
            )

        backend_transport = running_backend.transport(
            httpx_client_factory=backend_http_client
        )
        proxy = FastMCP(
            "Proxy",
            providers=[
                ProxyProvider(lambda: ProxyClient(backend_transport, mode="auto"))
            ],
        )

        async with asgi_server(proxy) as running_proxy:
            async with running_proxy.client(
                mode="auto",
                headers={
                    "Authorization": "Bearer frontend-token",
                    "X-Proxy-Custom": "preserved",
                    "Mcp-Name": "frontend-name",
                    "Mcp-Param-Tenant": "frontend-tenant",
                    "Mcp-Session-Id": "frontend-session",
                    "Last-Event-ID": "frontend-event",
                },
            ) as client:
                assert client.protocol_version == LATEST_MODERN_VERSION
                tools = await client.list_tools()

    assert [tool.name for tool in tools] == ["legacy_ping"]

    def request_for(method: str) -> httpx2.Request:
        return next(
            request
            for request in captured_requests
            if request.method == "POST"
            and json.loads(request.content).get("method") == method
        )

    discover = request_for("server/discover")
    initialize = request_for("initialize")
    list_tools = request_for("tools/list")

    assert discover.headers["mcp-protocol-version"] == LATEST_MODERN_VERSION
    assert discover.headers["mcp-method"] == "server/discover"

    assert "mcp-protocol-version" not in initialize.headers
    assert "mcp-method" not in initialize.headers
    initialize_body = json.loads(initialize.content)
    assert initialize_body["params"]["protocolVersion"] == LATEST_HANDSHAKE_VERSION

    assert list_tools.headers["mcp-protocol-version"] == LATEST_HANDSHAKE_VERSION
    assert "mcp-method" not in list_tools.headers
    assert list_tools.headers["mcp-session-id"] != "frontend-session"

    for request in (discover, initialize, list_tools):
        assert request.headers["authorization"] == "Bearer frontend-token"
        assert request.headers["x-proxy-custom"] == "preserved"
        assert "mcp-name" not in request.headers
        assert "mcp-param-tenant" not in request.headers
        assert request.headers.get("mcp-session-id") != "frontend-session"
        assert "last-event-id" not in request.headers