fastmcp 2.5.0__tar.gz → 2.5.1__tar.gz

{fastmcp-2.5.0 → fastmcp-2.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastmcp
-Version: 2.5.0
+Version: 2.5.1
 Summary: The fast, Pythonic way to build MCP servers.
 Project-URL: Homepage, https://gofastmcp.com
 Project-URL: Repository, https://github.com/jlowin/fastmcp

{fastmcp-2.5.0 → fastmcp-2.5.1}/docs/patterns/http-requests.mdx

@@ -23,7 +23,7 @@ from fastmcp import FastMCP
 from fastmcp.server.dependencies import get_http_request
 from starlette.requests import Request
 
-mcp = FastMCP(name="HTTPRequestDemo")
+mcp = FastMCP(name="HTTP Request Demo")
 
 @mcp.tool()
 async def user_agent_info() -> dict:
@@ -48,32 +48,40 @@ This approach works anywhere within a request's execution flow, not just within
 2. You're calling nested functions that need HTTP request data
 3. You're working with middleware or other request processing code
 
-## Important Notes
-
-- HTTP requests are only available when FastMCP is running as part of a web application
-- Accessing the HTTP request outside of a web request context will raise a `RuntimeError`
-- The `get_http_request()` function returns a standard [Starlette Request](https://www.starlette.io/requests/) object
+## Accessing HTTP Headers Only
 
-## Common Use Cases
+If you only need request headers and want to avoid potential errors, you can use the `get_http_headers()` helper:
 
-### Accessing Request Headers
+```python {2}
+from fastmcp import FastMCP
+from fastmcp.server.dependencies import get_http_headers
 
-```python
-from fastmcp.server.dependencies import get_http_request
+mcp = FastMCP(name="Headers Demo")
 
 @mcp.tool()
-async def get_auth_info() -> dict:
-    """Get authentication information from request headers."""
-    request = get_http_request()
+async def safe_header_info() -> dict:
+    """Safely get header information without raising errors."""
+    # Get headers (returns empty dict if no request context)
+    headers = get_http_headers()
     
     # Get authorization header
-    auth_header = request.headers.get("authorization", "")
-    
-    # Check for Bearer token
+    auth_header = headers.get("authorization", "")
     is_bearer = auth_header.startswith("Bearer ")
     
     return {
+        "user_agent": headers.get("user-agent", "Unknown"),
+        "content_type": headers.get("content-type", "Unknown"),
         "has_auth": bool(auth_header),
-        "auth_type": "Bearer" if is_bearer else "Other" if auth_header else "None"
+        "auth_type": "Bearer" if is_bearer else "Other" if auth_header else "None",
+        "headers_count": len(headers)
     }
 ```
+
+By default, `get_http_headers()` excludes problematic headers like `content-length`. To include all headers, use `get_http_headers(include_all=True)`.
+
+## Important Notes
+
+- HTTP requests are only available when FastMCP is running as part of a web application
+- Accessing the HTTP request with `get_http_request()` outside of a web request context will raise a `RuntimeError`
+- The `get_http_headers()` function **never raises errors** - it returns an empty dict when no request context is available
+- The `get_http_request()` function returns a standard [Starlette Request](https://www.starlette.io/requests/) object

{fastmcp-2.5.0 → fastmcp-2.5.1}/docs/servers/openapi.mdx

@@ -51,13 +51,7 @@ FastMCP analyzes your API specification and automatically creates MCP components
 | `GET` without path params | `GET /stats` | **Resource** |
 | `POST`, `PUT`, `PATCH`, `DELETE`, etc. | `POST /users` | **Tool** |
 
-
-
-### Custom Route Maps
-
-<VersionBadge version="2.5.0" />
-
-FastMCP uses an ordered list of `RouteMap` objects to determine how to map OpenAPI routes to various MCP component types.
+Interally, FastMCP uses an ordered list of `RouteMap` objects to determine how to map OpenAPI routes to various MCP component types.
 
 Each `RouteMap` specifies a combination of methods, patterns, and tags, as well as a corresponding MCP component type. Each OpenAPI route is checked against each `RouteMap` in order, and the first one that matches every criteria is used to determine its converted MCP type. A special type, `EXCLUDE`, can be used to exclude routes from the MCP server entirely.
 
@@ -66,7 +60,7 @@ Each `RouteMap` specifies a combination of methods, patterns, and tags, as well
 - **Tags**: A set of OpenAPI tags that must all be present. An empty set (`{}`) means no tag filtering, so the route matches regardless of its tags.
 - **MCP type**: What MCP component type to create (`TOOL`, `RESOURCE`, `RESOURCE_TEMPLATE`, or `EXCLUDE`)
 
-To illustrate this in practice, here are FastMCP's default route mappings as a list of `RouteMap` objects:
+To illustrate this in practice, here are FastMCP's default rules as a list of `RouteMap` objects:
 
 ```python
 from fastmcp.server.openapi import RouteMap, MCPType

{fastmcp-2.5.0 → fastmcp-2.5.1}/src/fastmcp/client/transports.py

@@ -25,7 +25,7 @@ from pydantic import AnyUrl
 from typing_extensions import Unpack
 
 from fastmcp.server import FastMCP as FastMCPServer
-from fastmcp.server.dependencies import get_http_request
+from fastmcp.server.dependencies import get_http_headers
 from fastmcp.server.server import FastMCP
 from fastmcp.utilities.logging import get_logger
 from fastmcp.utilities.mcp_config import MCPConfig, infer_transport_type_from_url
@@ -35,11 +35,6 @@ if TYPE_CHECKING:
 
 logger = get_logger(__name__)
 
-# these headers, when forwarded to the remote server, can cause issues
-EXCLUDE_HEADERS = {
-    "content-length",
-}
-
 
 class SessionKwargs(TypedDict, total=False):
     """Keyword arguments for the MCP ClientSession constructor."""
@@ -138,23 +133,12 @@ class SSETransport(ClientTransport):
     async def connect_session(
         self, **session_kwargs: Unpack[SessionKwargs]
     ) -> AsyncIterator[ClientSession]:
-        client_kwargs: dict[str, Any] = {
-            "headers": self.headers,
-        }
+        client_kwargs: dict[str, Any] = {}
 
         # load headers from an active HTTP request, if available. This will only be true
         # if the client is used in a FastMCP Proxy, in which case the MCP client headers
         # need to be forwarded to the remote server.
-        try:
-            active_request = get_http_request()
-            for name, value in active_request.headers.items():
-                name = name.lower()
-                if name not in self.headers and name not in {
-                    h.lower() for h in EXCLUDE_HEADERS
-                }:
-                    client_kwargs["headers"][name] = str(value)
-        except RuntimeError:
-            client_kwargs["headers"] = self.headers
+        client_kwargs["headers"] = get_http_headers() | self.headers
 
         # sse_read_timeout has a default value set, so we can't pass None without overriding it
         # instead we simply leave the kwarg out if it's not provided
@@ -201,25 +185,12 @@ class StreamableHttpTransport(ClientTransport):
     async def connect_session(
         self, **session_kwargs: Unpack[SessionKwargs]
     ) -> AsyncIterator[ClientSession]:
-        client_kwargs: dict[str, Any] = {
-            "headers": self.headers,
-        }
+        client_kwargs: dict[str, Any] = {}
 
         # load headers from an active HTTP request, if available. This will only be true
         # if the client is used in a FastMCP Proxy, in which case the MCP client headers
         # need to be forwarded to the remote server.
-        try:
-            active_request = get_http_request()
-            for name, value in active_request.headers.items():
-                name = name.lower()
-                if name not in self.headers and name not in {
-                    h.lower() for h in EXCLUDE_HEADERS
-                }:
-                    client_kwargs["headers"][name] = str(value)
-
-        except RuntimeError:
-            client_kwargs["headers"] = self.headers
-        print(client_kwargs)
+        client_kwargs["headers"] = get_http_headers() | self.headers
 
         # sse_read_timeout has a default value set, so we can't pass None without overriding it
         # instead we simply leave the kwarg out if it's not provided

fastmcp-2.5.1/src/fastmcp/server/dependencies.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ParamSpec, TypeVar
+
+from starlette.requests import Request
+
+if TYPE_CHECKING:
+    from fastmcp.server.context import Context
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+# --- Context ---
+
+
+def get_context() -> Context:
+    from fastmcp.server.context import _current_context
+
+    context = _current_context.get()
+    if context is None:
+        raise RuntimeError("No active context found.")
+    return context
+
+
+# --- HTTP Request ---
+
+
+def get_http_request() -> Request:
+    from fastmcp.server.http import _current_http_request
+
+    request = _current_http_request.get()
+    if request is None:
+        raise RuntimeError("No active HTTP request found.")
+    return request
+
+
+def get_http_headers(include_all: bool = False) -> dict[str, str]:
+    """
+    Extract headers from the current HTTP request if available.
+
+    Never raises an exception, even if there is no active HTTP request (in which case
+    an empty dict is returned).
+
+    By default, strips problematic headers like `content-length` that cause issues if forwarded to downstream clients.
+    If `include_all` is True, all headers are returned.
+    """
+    if include_all:
+        exclude_headers = set()
+    else:
+        exclude_headers = {"content-length"}
+
+    # ensure all lowercase!
+    # (just in case)
+    exclude_headers = {h.lower() for h in exclude_headers}
+
+    headers = {}
+
+    try:
+        request = get_http_request()
+        for name, value in request.headers.items():
+            lower_name = name.lower()
+            if lower_name not in exclude_headers:
+                headers[lower_name] = str(value)
+        return headers
+    except RuntimeError:
+        return {}

{fastmcp-2.5.0 → fastmcp-2.5.1}/src/fastmcp/server/openapi.py

@@ -18,7 +18,7 @@ from pydantic.networks import AnyUrl
 
 from fastmcp.exceptions import ToolError
 from fastmcp.resources import Resource, ResourceTemplate
-from fastmcp.server.dependencies import get_http_request
+from fastmcp.server.dependencies import get_http_headers
 from fastmcp.server.server import FastMCP
 from fastmcp.tools.tool import Tool, _convert_to_content
 from fastmcp.utilities import openapi
@@ -60,25 +60,6 @@ def _slugify(text: str) -> str:
     return slug
 
 
-def _get_mcp_client_headers() -> dict[str, str]:
-    """
-    Extract headers from the current MCP client HTTP request if available.
-
-    These headers will take precedence over OpenAPI-defined headers when both are present.
-
-    Returns:
-        Dictionary of header name-value pairs (lowercased names), or empty dict if no HTTP request is active.
-    """
-    try:
-        http_request = get_http_request()
-        return {
-            name.lower(): str(value) for name, value in http_request.headers.items()
-        }
-    except RuntimeError:
-        # No active HTTP request (e.g., STDIO transport), return empty dict
-        return {}
-
-
 # Type definitions for the mapping functions
 RouteMapFn = Callable[[HTTPRoute, "MCPType"], "MCPType | None"]
 ComponentFn = Callable[
@@ -423,7 +404,7 @@ class OpenAPITool(Tool):
         headers.update(openapi_headers)
 
         # Add headers from the current MCP client HTTP request (these take precedence)
-        mcp_headers = _get_mcp_client_headers()
+        mcp_headers = get_http_headers()
         headers.update(mcp_headers)
 
         # Prepare request body
@@ -574,7 +555,7 @@ class OpenAPIResource(Resource):
 
             # Prepare headers from MCP client request if available
             headers = {}
-            mcp_headers = _get_mcp_client_headers()
+            mcp_headers = get_http_headers()
             headers.update(mcp_headers)
 
             response = await self._client.request(

{fastmcp-2.5.0 → fastmcp-2.5.1}/tests/client/test_openapi.py

@@ -185,7 +185,6 @@ class TestClientHeaders:
         Test that client headers are passed through the proxy to the remove server.
         """
         async with Client(transport=StreamableHttpTransport(proxy_server)) as client:
-            await client.ping()
             result = await client.read_resource("resource://get_headers_headers_get")
             assert isinstance(result[0], TextResourceContents)
             headers = json.loads(result[0].text)

fastmcp-2.5.0/src/fastmcp/server/dependencies.py

@@ -1,35 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, ParamSpec, TypeVar
-
-from starlette.requests import Request
-
-if TYPE_CHECKING:
-    from fastmcp.server.context import Context
-
-P = ParamSpec("P")
-R = TypeVar("R")
-
-
-# --- Context ---
-
-
-def get_context() -> Context:
-    from fastmcp.server.context import _current_context
-
-    context = _current_context.get()
-    if context is None:
-        raise RuntimeError("No active context found.")
-    return context
-
-
-# --- HTTP Request ---
-
-
-def get_http_request() -> Request:
-    from fastmcp.server.http import _current_http_request
-
-    request = _current_http_request.get()
-    if request is None:
-        raise RuntimeError("No active HTTP request found.")
-    return request