🚀 The fast, Pythonic way to build MCP servers and clients.
Forward-port HTTP host guard compatibility (#4474)
Jeremiah Lowin4ad78a60efaa
diff --git a/docs/deployment/http.mdx b/docs/deployment/http.mdxindex f7ce7da08..16c9fadfa 100644--- a/docs/deployment/http.mdx+++ b/docs/deployment/http.mdx@@ -103,11 +103,11 @@ If you're mounting an authenticated server under a path prefix, see [Mounting Au### Host and Origin Protection-FastMCP validates `Host` and browser `Origin` headers for Streamable HTTP requests by default. This protects localhost-bound servers from DNS rebinding attacks and rejects browser requests from origins you have not trusted.+FastMCP can validate `Host` and browser `Origin` headers for Streamable HTTP requests before they reach MCP session handling. This request guard protects localhost-bound servers from DNS rebinding attacks, and it remains opt-in in FastMCP 3.x to preserve compatibility with existing ASGI, serverless, and reverse-proxy deployments.Think of this as a request guard rather than CORS middleware. It decides whether a request can reach MCP session handling. CORS remains a separate browser response-header policy; configure CORS middleware separately when browser JavaScript must read cross-origin responses.-When you deploy behind a public hostname, add the hostname clients use to reach your MCP endpoint. If a browser-based MCP client runs on a separate origin, add that origin as well:+Enable strict validation with `host_origin_protection=True`. When you deploy behind a public hostname, add the hostname clients use to reach your MCP endpoint. If a browser-based MCP client runs on a separate origin, add that origin as well:```pythonfrom fastmcp import FastMCP@@ -115,6 +115,7 @@ from fastmcp import FastMCPmcp = FastMCP("My Server")app = mcp.http_app(+ host_origin_protection=True,allowed_hosts=["mcp.example.com"],allowed_origins=["https://app.example.com"],)@@ -132,6 +133,7 @@ if __name__ == "__main__":transport="http",host="0.0.0.0",port=8000,+ host_origin_protection=True,allowed_hosts=["mcp.example.com"],allowed_origins=["https://app.example.com"],)@@ -140,11 +142,12 @@ if __name__ == "__main__":You can also configure these values with environment variables:```bash+export FASTMCP_HTTP_HOST_ORIGIN_PROTECTION=trueexport FASTMCP_HTTP_ALLOWED_HOSTS='["mcp.example.com"]'export FASTMCP_HTTP_ALLOWED_ORIGINS='["https://app.example.com"]'```-Use `host_origin_protection=False` only for trusted internal deployments that provide equivalent validation at another layer, such as an ingress proxy.+Use `host_origin_protection="auto"` to protect localhost-bound direct servers while allowing ASGI, serverless, and reverse-proxy deployments to keep their existing Host handling unless they configure explicit trust rules. Use `host_origin_protection=False` to keep the request guard disabled.### Health Checks@@ -201,7 +204,7 @@ Most MCP clients, including those that you access through a browser like ChatGPTCORS (Cross-Origin Resource Sharing) is needed when JavaScript running in a web browser connects directly to your MCP server. This is different from using an LLM through a browser—in that case, the browser connects to the LLM service, and the LLM service connects to your MCP server (no CORS needed).-Host and Origin protection runs before CORS. Add browser client origins to `allowed_origins` so trusted browser requests reach the CORS middleware, then configure CORS to let browser JavaScript read the MCP response headers it needs. Setting `allowed_origins` trusts the request; it does not emit `Access-Control-Allow-Origin` or other CORS response headers.+Host and Origin protection runs before CORS when it is active for a request. Add browser client origins to `allowed_origins` so trusted browser requests reach the CORS middleware, then configure CORS to let browser JavaScript read the MCP response headers it needs. Setting `allowed_origins` trusts the request; it does not emit `Access-Control-Allow-Origin` or other CORS response headers.Browser-based MCP clients that need CORS include:diff --git a/docs/more/settings.mdx b/docs/more/settings.mdxindex fab6117a9..a50cca6e1 100644--- a/docs/more/settings.mdx+++ b/docs/more/settings.mdx@@ -43,9 +43,9 @@ These control how the server listens when running with an HTTP transport.| `FASTMCP_STREAMABLE_HTTP_PATH` | `str` | `/mcp` | Path for Streamable HTTP endpoint. || `FASTMCP_STATELESS_HTTP` | `bool` | `false` | Enable stateless HTTP mode (new transport per request). Useful for multi-worker deployments. || `FASTMCP_JSON_RESPONSE` | `bool` | `false` | Use JSON responses instead of SSE for Streamable HTTP. |-| `FASTMCP_HTTP_HOST_ORIGIN_PROTECTION` | `bool` | `true` | Validate `Host` and browser `Origin` headers for Streamable HTTP requests. |-| `FASTMCP_HTTP_ALLOWED_HOSTS` | `list[str] \| null` | `null` | Additional trusted hostnames for Streamable HTTP requests. Use a JSON array, such as `["mcp.example.com"]`. |-| `FASTMCP_HTTP_ALLOWED_ORIGINS` | `list[str] \| null` | `null` | Browser origins trusted by the Streamable HTTP request guard. Configure CORS separately for cross-origin browser reads. Use a JSON array, such as `["https://app.example.com"]`. |+| `FASTMCP_HTTP_HOST_ORIGIN_PROTECTION` | `bool \| "auto"` | `false` | Validate `Host` and browser `Origin` headers for Streamable HTTP requests. `auto` protects localhost-bound servers and explicit host/origin allowlists. |+| `FASTMCP_HTTP_ALLOWED_HOSTS` | `list[str] \| null` | `null` | Additional trusted hostnames when Host and Origin protection is enabled. Use a JSON array, such as `["mcp.example.com"]`. |+| `FASTMCP_HTTP_ALLOWED_ORIGINS` | `list[str] \| null` | `null` | Browser origins trusted when Host and Origin protection is enabled. Configure CORS separately for cross-origin browser reads. Use a JSON array, such as `["https://app.example.com"]`. || `FASTMCP_HTTP_SESSION_IDLE_TIMEOUT` | `float \| null` | `null` | Seconds a Streamable HTTP session may remain idle before it is terminated. The deadline resets on every request. When `null`, sessions never expire from inactivity. Not supported in stateless mode. || `FASTMCP_DEBUG` | `bool` | `false` | Enable debug mode. |diff --git a/fastmcp_slim/fastmcp/server/http.py b/fastmcp_slim/fastmcp/server/http.pyindex 9611fad0b..2421badb4 100644--- a/fastmcp_slim/fastmcp/server/http.py+++ b/fastmcp_slim/fastmcp/server/http.py@@ -5,7 +5,7 @@ from contextlib import asynccontextmanager, contextmanagerfrom contextvars import ContextVarfrom fnmatch import fnmatchcasefrom ipaddress import ip_address-from typing import TYPE_CHECKING, Any+from typing import TYPE_CHECKING, Any, Literalfrom urllib.parse import urlsplitfrom uuid import uuid4@@ -36,6 +36,8 @@ if TYPE_CHECKING:logger = get_logger(__name__)DEFAULT_HOSTS = ("127.0.0.1", "localhost", "::1")+HostOriginProtection = bool | Literal["auto"]+HostOriginProtectionMode = Literal["auto", "strict"]class FastMCPStreamableHTTPSessionManager(StreamableHTTPSessionManager):@@ -230,34 +232,81 @@ class HostOriginGuardMiddleware:app: ASGIApp,allowed_hosts: Sequence[str] | None = None,allowed_origins: Sequence[str] | None = None,+ mode: HostOriginProtectionMode = "auto",) -> None:self.app = appself.allowed_hosts = tuple(allowed_hosts or ())self.allowed_origins = tuple(allowed_origins or ())+ self.mode = mode+ self.has_explicit_allowed_hosts = allowed_hosts is not None+ self.has_explicit_allowed_origins = allowed_origins is not Noneasync def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:if scope["type"] != "http":await self.app(scope, receive, send)return- allowed_hosts = self._allowed_hosts_for_scope(scope)headers = Headers(scope=scope)host = headers.get("host", "")- if not _host_matches(host, allowed_hosts):+ if self._should_validate_host(scope) and not _host_matches(+ host,+ self._allowed_hosts_for_scope(scope),+ ):response = Response("Misdirected Request", status_code=421)await response(scope, receive, send)returnorigin = headers.get("origin")request_origin = _request_origin(scope, host)- if origin and not self._origin_allowed(origin, request_origin, host):+ if (+ origin+ and self._should_validate_origin(scope, host)+ and not self._origin_allowed(+ origin,+ request_origin,+ host,+ allow_same_origin_fallback=self._allow_same_origin_fallback(+ scope,+ host,+ ),+ )+ ):response = Response("Forbidden Origin", status_code=403)await response(scope, receive, send)returnawait self.app(scope, receive, send)+ def _should_validate_host(self, scope: Scope) -> bool:+ if self.mode == "strict" or self.has_explicit_allowed_hosts:+ return True++ server = scope.get("server")+ return bool(server and _is_loopback_host(server[0]))++ def _should_validate_origin(self, scope: Scope, host: str) -> bool:+ if (+ self.mode == "strict"+ or self.has_explicit_allowed_hosts+ or self.has_explicit_allowed_origins+ or _is_loopback_host(host)+ ):+ return True++ server = scope.get("server")+ return bool(server and _is_loopback_host(server[0]))++ def _allow_same_origin_fallback(self, scope: Scope, host: str) -> bool:+ if not self.has_explicit_allowed_origins:+ return True++ if self.mode == "strict" or self.has_explicit_allowed_hosts:+ return True++ server = scope.get("server")+ return _is_loopback_host(host) or bool(server and _is_loopback_host(server[0]))+def _allowed_hosts_for_scope(self, scope: Scope) -> tuple[str, ...]:allowed_hosts = list(DEFAULT_HOSTS)allowed_hosts.extend(self.allowed_hosts)@@ -270,10 +319,19 @@ class HostOriginGuardMiddleware:return tuple(allowed_hosts)- def _origin_allowed(self, origin: str, request_origin: str, host: str) -> bool:+ def _origin_allowed(+ self,+ origin: str,+ request_origin: str,+ host: str,+ allow_same_origin_fallback: bool,+ ) -> bool:if _origin_matches(origin, self.allowed_origins):return True+ if not allow_same_origin_fallback:+ return False+origin_host = _origin_host(origin)if _is_loopback_host(origin_host) and _is_loopback_host(host):return True@@ -493,7 +551,7 @@ def create_streamable_http_app(debug: bool = False,routes: list[BaseRoute] | None = None,middleware: list[Middleware] | None = None,- host_origin_protection: bool = True,+ host_origin_protection: HostOriginProtection = False,allowed_hosts: Sequence[str] | None = None,allowed_origins: Sequence[str] | None = None,session_idle_timeout: float | None = None,@@ -514,7 +572,9 @@ def create_streamable_http_app(routes: Optional list of custom routesmiddleware: Optional list of middlewarehost_origin_protection: Whether to validate Host and Origin headers- before requests reach the MCP endpoint.+ before requests reach the MCP endpoint. Defaults to False for+ compatibility. "auto" protects localhost-bound servers and explicit+ host/origin allowlists.allowed_hosts: Additional hostnames that may appear in the Host header.allowed_origins: Additional browser origins trusted by the request guard.Configure CORS separately when browser JavaScript must read@@ -583,13 +643,17 @@ def create_streamable_http_app(server_routes.extend(server._get_additional_http_routes())# Add middleware- if host_origin_protection:+ if host_origin_protection not in (True, False, "auto"):+ raise ValueError("host_origin_protection must be True, False, or 'auto'.")++ if host_origin_protection is not False:server_middleware.insert(0,Middleware(HostOriginGuardMiddleware,allowed_hosts=allowed_hosts,allowed_origins=allowed_origins,+ mode="strict" if host_origin_protection is True else "auto",),)if middleware:diff --git a/fastmcp_slim/fastmcp/server/mixins/transport.py b/fastmcp_slim/fastmcp/server/mixins/transport.pyindex 8938aacec..ddc96db20 100644--- a/fastmcp_slim/fastmcp/server/mixins/transport.py+++ b/fastmcp_slim/fastmcp/server/mixins/transport.py@@ -19,7 +19,9 @@ from starlette.routing import BaseRoute, Routeimport fastmcpfrom fastmcp.server.event_store import EventStorefrom fastmcp.server.http import (+ HostOriginProtection,StarletteWithLifespan,+ _is_loopback_host,create_sse_app,create_streamable_http_app,)@@ -48,6 +50,22 @@ def _format_host_for_url(host: str) -> str:return host+def _resolve_allowed_hosts_for_run(+ *,+ host: str,+ host_origin_protection: HostOriginProtection,+ allowed_hosts: list[str] | None,+ configured_allowed_hosts: list[str] | None,+) -> list[str] | None:+ if allowed_hosts is not None:+ return allowed_hosts++ if host_origin_protection == "auto" and _is_loopback_host(host):+ return [*(configured_allowed_hosts or []), host]++ return configured_allowed_hosts++class TransportMixin:"""Mixin providing transport-related methods for FastMCP.@@ -249,7 +267,7 @@ class TransportMixin:json_response: bool | None = None,stateless_http: bool | None = None,stateless: bool | None = None,- host_origin_protection: bool | None = None,+ host_origin_protection: HostOriginProtection | None = None,allowed_hosts: list[str] | None = None,allowed_origins: list[str] | None = None,sockets: list[socket.socket] | None = None,@@ -268,7 +286,9 @@ class TransportMixin:stateless_http: Whether to use stateless HTTP (defaults to settings.stateless_http)stateless: Alias for stateless_http for CLI consistencyhost_origin_protection: Whether to validate Host and Origin headers- before requests reach the MCP endpoint.+ before requests reach the MCP endpoint. Defaults to+ settings.http_host_origin_protection. "auto" protects+ localhost-bound servers and explicit host/origin allowlists.allowed_hosts: Additional hostnames that may appear in the Host header.allowed_origins: Additional browser origins trusted by the request guard.Configure CORS separately when browser JavaScript must read@@ -289,6 +309,17 @@ class TransportMixin:host = host if host is not None else fastmcp.settings.hostport = port if port is not None else fastmcp.settings.port+ resolved_host_origin_protection = (+ host_origin_protection+ if host_origin_protection is not None+ else fastmcp.settings.http_host_origin_protection+ )+ resolved_allowed_hosts = _resolve_allowed_hosts_for_run(+ host=host,+ host_origin_protection=resolved_host_origin_protection,+ allowed_hosts=allowed_hosts,+ configured_allowed_hosts=fastmcp.settings.http_allowed_hosts,+ )default_log_level_to_use = (log_level if log_level is not None else fastmcp.settings.log_level).lower()@@ -299,8 +330,8 @@ class TransportMixin:middleware=middleware,json_response=json_response,stateless_http=stateless_http,- host_origin_protection=host_origin_protection,- allowed_hosts=allowed_hosts,+ host_origin_protection=resolved_host_origin_protection,+ allowed_hosts=resolved_allowed_hosts,allowed_origins=allowed_origins,)@@ -344,7 +375,7 @@ class TransportMixin:transport: Literal["http", "streamable-http", "sse"] = "http",event_store: EventStore | None = None,retry_interval: int | None = None,- host_origin_protection: bool | None = None,+ host_origin_protection: HostOriginProtection | None = None,allowed_hosts: list[str] | None = None,allowed_origins: list[str] | None = None,session_idle_timeout: float | None = None,@@ -365,7 +396,9 @@ class TransportMixin:disconnections. Requires event_store to be set. Only used withstreamable-http transport.host_origin_protection: Whether to validate Host and Origin headers- before requests reach the MCP endpoint.+ before requests reach the MCP endpoint. Defaults to+ settings.http_host_origin_protection. "auto" protects+ localhost-bound servers and explicit host/origin allowlists.allowed_hosts: Additional hostnames that may appear in the Host header.allowed_origins: Additional browser origins trusted by the request guard.Configure CORS separately when browser JavaScript must readdiff --git a/fastmcp_slim/fastmcp/settings.py b/fastmcp_slim/fastmcp/settings.pyindex be933ee56..dccfcf5f1 100644--- a/fastmcp_slim/fastmcp/settings.py+++ b/fastmcp_slim/fastmcp/settings.py@@ -336,7 +336,7 @@ class Settings(BaseSettings):stateless_http: bool = (False # If True, uses true stateless mode (new transport per request))- http_host_origin_protection: bool = True+ http_host_origin_protection: bool | Literal["auto"] = Falsehttp_allowed_hosts: list[str] | None = Nonehttp_allowed_origins: list[str] | None = Nonehttp_session_idle_timeout: Annotated[diff --git a/tests/conformance/expected-failures.yml b/tests/conformance/expected-failures.ymlindex d00d4ed31..46b2081de 100644--- a/tests/conformance/expected-failures.yml+++ b/tests/conformance/expected-failures.yml@@ -3,3 +3,4 @@ server:- server-sse-polling- resources-subscribe- resources-unsubscribe+ - dns-rebinding-protectiondiff --git a/tests/server/http/test_http_auth_middleware.py b/tests/server/http/test_http_auth_middleware.pyindex c25c2e587..6a2340f8a 100644--- a/tests/server/http/test_http_auth_middleware.py+++ b/tests/server/http/test_http_auth_middleware.py@@ -1,11 +1,16 @@+from collections.abc import MutableMapping+from typing import Any, Literal+import pytestfrom mcp.server.auth.middleware.bearer_auth import RequireAuthMiddleware+from starlette.responses import Responsefrom starlette.routing import Routefrom starlette.testclient import TestClient+from starlette.types import Receive, Scope, Sendfrom fastmcp.server import FastMCPfrom fastmcp.server.auth.providers.jwt import JWTVerifier, RSAKeyPair-from fastmcp.server.http import create_streamable_http_app+from fastmcp.server.http import HostOriginGuardMiddleware, create_streamable_http_appINITIALIZE_REQUEST = {"jsonrpc": "2.0",@@ -19,6 +24,59 @@ INITIALIZE_REQUEST = {}+async def _ok_app(scope: Scope, receive: Receive, send: Send) -> None:+ response = Response("OK")+ await response(scope, receive, send)+++async def _empty_receive() -> dict[str, Any]:+ return {"type": "http.request", "body": b"", "more_body": False}+++async def _guard_status(+ *,+ host: str,+ origin: str | None = None,+ server: tuple[str, int] | None = None,+ mode: Literal["auto", "strict"] = "auto",+ allowed_hosts: list[str] | None = None,+ allowed_origins: list[str] | None = None,+) -> int:+ app = HostOriginGuardMiddleware(+ _ok_app,+ allowed_hosts=allowed_hosts,+ allowed_origins=allowed_origins,+ mode=mode,+ )+ headers = [(b"host", host.encode())]+ if origin is not None:+ headers.append((b"origin", origin.encode()))++ scope: Scope = {+ "type": "http",+ "asgi": {"version": "3.0"},+ "http_version": "1.1",+ "method": "POST",+ "scheme": "https",+ "path": "/mcp",+ "raw_path": b"/mcp",+ "query_string": b"",+ "headers": headers,+ "client": ("127.0.0.1", 12345),+ "server": server,+ }+ sent_messages: list[MutableMapping[str, Any]] = []++ async def send(message: MutableMapping[str, Any]) -> None:+ sent_messages.append(message)++ await app(scope, _empty_receive, send)+ response_start = next(+ message for message in sent_messages if message["type"] == "http.response.start"+ )+ return response_start["status"]++class TestStreamableHTTPAppResourceMetadataURL:"""Test resource_metadata_url logic in create_streamable_http_app."""@@ -108,11 +166,84 @@ class TestStreamableHTTPAppResourceMetadataURL:class TestStreamableHTTPHostOriginProtection:"""Test host and origin validation for streamable HTTP apps."""- def test_rejects_untrusted_host_before_session_initialization(self):+ def test_default_allows_untrusted_host_for_compatibility(self):+ server = FastMCP(name="TestServer")+ app = create_streamable_http_app(+ server=server,+ streamable_http_path="/mcp",+ allowed_hosts=["apps.example.com"],+ )++ with TestClient(app, base_url="http://127.0.0.1") as client:+ response = client.post(+ "/mcp",+ headers={+ "accept": "application/json, text/event-stream",+ "host": "internal-upstream",+ "x-forwarded-host": "apps.example.com",+ },+ json=INITIALIZE_REQUEST,+ )++ assert response.status_code == 200+ assert "mcp-session-id" in response.headers++ async def test_auto_allows_public_host_when_server_scope_is_ambiguous(self):+ status = await _guard_status(+ host="mcp.example.com",+ origin="https://app.example.com",+ server=None,+ )++ assert status == 200++ async def test_auto_rejects_untrusted_host_when_server_scope_is_loopback(self):+ status = await _guard_status(+ host="attacker.example",+ origin="https://attacker.example",+ server=("127.0.0.1", 8000),+ )++ assert status == 421++ async def test_strict_rejects_public_host_when_server_scope_is_ambiguous(self):+ status = await _guard_status(+ host="mcp.example.com",+ origin="https://app.example.com",+ server=None,+ mode="strict",+ )++ assert status == 421++ async def test_auto_rejects_same_origin_fallback_without_trusted_host_boundary(+ self,+ ):+ status = await _guard_status(+ host="attacker.example",+ origin="https://attacker.example",+ server=None,+ allowed_origins=["https://app.example.com"],+ )++ assert status == 403++ async def test_auto_allows_configured_origin_without_trusted_host_boundary(self):+ status = await _guard_status(+ host="mcp.example.com",+ origin="https://app.example.com",+ server=None,+ allowed_origins=["https://app.example.com"],+ )++ assert status == 200++ def test_auto_rejects_untrusted_host_before_session_initialization(self):server = FastMCP(name="TestServer")app = create_streamable_http_app(server=server,streamable_http_path="/mcp",+ host_origin_protection="auto",)with TestClient(app, base_url="http://127.0.0.1") as client:@@ -128,11 +259,12 @@ class TestStreamableHTTPHostOriginProtection:assert response.status_code == 421assert "mcp-session-id" not in response.headers- def test_rejects_untrusted_origin_before_session_initialization(self):+ def test_auto_rejects_untrusted_origin_before_session_initialization(self):server = FastMCP(name="TestServer")app = create_streamable_http_app(server=server,streamable_http_path="/mcp",+ host_origin_protection="auto",)with TestClient(app, base_url="http://127.0.0.1") as client:@@ -153,6 +285,7 @@ class TestStreamableHTTPHostOriginProtection:app = create_streamable_http_app(server=server,streamable_http_path="/mcp",+ host_origin_protection="auto",allowed_hosts=["mcp.example.com"],allowed_origins=["https://app.example.com"],)@@ -176,6 +309,7 @@ class TestStreamableHTTPHostOriginProtection:app = create_streamable_http_app(server=server,streamable_http_path="/mcp",+ host_origin_protection="auto",allowed_hosts=["mcp.example.com"],)@@ -197,6 +331,7 @@ class TestStreamableHTTPHostOriginProtection:app = create_streamable_http_app(server=server,streamable_http_path="/mcp",+ host_origin_protection="auto",)with TestClient(app, base_url="http://127.0.0.1") as client:@@ -217,6 +352,7 @@ class TestStreamableHTTPHostOriginProtection:app = create_streamable_http_app(server=server,streamable_http_path="/mcp",+ host_origin_protection="auto",allowed_hosts=["mcp.example.com"],)@@ -238,6 +374,7 @@ class TestStreamableHTTPHostOriginProtection:app = create_streamable_http_app(server=server,streamable_http_path="/mcp",+ host_origin_protection="auto",allowed_hosts=["mcp.example.com"],allowed_origins=["http://localhost:3000"],)@@ -267,6 +404,7 @@ class TestStreamableHTTPHostOriginProtection:app = create_streamable_http_app(server=server,streamable_http_path="/mcp",+ host_origin_protection="auto",allowed_hosts=["mcp.example.com"],)diff --git a/tests/server/test_transport.py b/tests/server/test_transport.pyindex 7baa87078..8f18861c8 100644--- a/tests/server/test_transport.py+++ b/tests/server/test_transport.py@@ -1,6 +1,9 @@import pytest-from fastmcp.server.mixins.transport import _format_host_for_url+from fastmcp.server.mixins.transport import (+ _format_host_for_url,+ _resolve_allowed_hosts_for_run,+)@pytest.mark.parametrize(@@ -18,3 +21,30 @@ from fastmcp.server.mixins.transport import _format_host_for_urldef test_format_host_for_url(host: str, expected: str):"""IPv6 hosts are bracketed for use in a URL; everything else is unchanged."""assert _format_host_for_url(host) == expected+++def test_resolve_allowed_hosts_for_run_merges_configured_hosts_with_loopback_host():+ assert _resolve_allowed_hosts_for_run(+ host="127.0.0.1",+ host_origin_protection="auto",+ allowed_hosts=None,+ configured_allowed_hosts=["mcp.example.com"],+ ) == ["mcp.example.com", "127.0.0.1"]+++def test_resolve_allowed_hosts_for_run_preserves_configured_hosts_when_disabled():+ assert _resolve_allowed_hosts_for_run(+ host="127.0.0.1",+ host_origin_protection=False,+ allowed_hosts=None,+ configured_allowed_hosts=["mcp.example.com"],+ ) == ["mcp.example.com"]+++def test_resolve_allowed_hosts_for_run_preserves_explicit_hosts():+ assert _resolve_allowed_hosts_for_run(+ host="127.0.0.1",+ host_origin_protection="auto",+ allowed_hosts=["mcp.example.com"],+ configured_allowed_hosts=["settings.example.com"],+ ) == ["mcp.example.com"]diff --git a/tests/test_settings.py b/tests/test_settings.pyindex 75c0d46d2..3052a0d35 100644--- a/tests/test_settings.py+++ b/tests/test_settings.py@@ -37,3 +37,21 @@ def test_get_setting_raises_for_missing_nested_parent():test_settings.get_setting("docket__missing__value")assert str(exc_info.value) == "Setting missing does not exist."+++def test_http_host_origin_protection_defaults_to_false():+ assert Settings().http_host_origin_protection is False+++ ("value", "expected"),+ [+ ("auto", "auto"),+ ("true", True),+ ("false", False),+ ],+)+def test_http_host_origin_protection_env_var(value, expected, monkeypatch):+ monkeypatch.setenv("FASTMCP_HTTP_HOST_ORIGIN_PROTECTION", value)++ assert Settings().http_host_origin_protection == expected