fastmcp 2.12.5__py3-none-any.whl → 2.14.0__py3-none-any.whl

fastmcp/server/middleware/logging.py

@@ -2,6 +2,7 @@
 
 import json
 import logging
+import time
 from collections.abc import Callable
 from logging import Logger
 from typing import Any
@@ -45,21 +46,21 @@ class BaseLoggingMiddleware(Middleware):
 
         return payload
 
-    def _format_message(self, message: dict[str, str | int]) -> str:
+    def _format_message(self, message: dict[str, str | int | float]) -> str:
         """Format a message for logging."""
         if self.structured_logging:
             return json.dumps(message)
         else:
             return " ".join([f"{k}={v}" for k, v in message.items()])
 
-    def _get_timestamp_from_context(self, context: MiddlewareContext[Any]) -> str:
-        """Get a timestamp from the context."""
-        return context.timestamp.isoformat()
-
     def _create_before_message(
-        self, context: MiddlewareContext[Any], event: str
-    ) -> dict[str, str | int]:
-        message = self._create_base_message(context, event)
+        self, context: MiddlewareContext[Any]
+    ) -> dict[str, str | int | float]:
+        message = {
+            "event": context.type + "_start",
+            "method": context.method or "unknown",
+            "source": context.source,
+        }
 
         if (
             self.include_payloads
@@ -85,57 +86,61 @@ class BaseLoggingMiddleware(Middleware):
 
         return message
 
-    def _create_after_message(
-        self, context: MiddlewareContext[Any], event: str
-    ) -> dict[str, str | int]:
-        return self._create_base_message(context, event)
-
-    def _create_base_message(
+    def _create_error_message(
         self,
         context: MiddlewareContext[Any],
-        event: str,
-    ) -> dict[str, str | int]:
-        """Format a message for logging."""
+        start_time: float,
+        error: Exception,
+    ) -> dict[str, str | int | float]:
+        duration_ms: float = _get_duration_ms(start_time)
+        message = {
+            "event": context.type + "_error",
+            "method": context.method or "unknown",
+            "source": context.source,
+            "duration_ms": duration_ms,
+            "error": str(object=error),
+        }
+        return message
 
-        parts: dict[str, str | int] = {
-            "event": event,
-            "timestamp": self._get_timestamp_from_context(context),
+    def _create_after_message(
+        self,
+        context: MiddlewareContext[Any],
+        start_time: float,
+    ) -> dict[str, str | int | float]:
+        duration_ms: float = _get_duration_ms(start_time)
+        message = {
+            "event": context.type + "_success",
             "method": context.method or "unknown",
-            "type": context.type,
             "source": context.source,
+            "duration_ms": duration_ms,
         }
+        return message
 
-        return parts
+    def _log_message(
+        self, message: dict[str, str | int | float], log_level: int | None = None
+    ):
+        self.logger.log(log_level or self.log_level, self._format_message(message))
 
     async def on_message(
         self, context: MiddlewareContext[Any], call_next: CallNext[Any, Any]
     ) -> Any:
-        """Log all messages."""
+        """Log messages for configured methods."""
 
         if self.methods and context.method not in self.methods:
             return await call_next(context)
 
-        request_start_log_message = self._create_before_message(
-            context, "request_start"
-        )
-
-        formatted_message = self._format_message(request_start_log_message)
-        self.logger.log(self.log_level, f"Processing message: {formatted_message}")
+        self._log_message(self._create_before_message(context))
 
+        start_time = time.perf_counter()
         try:
             result = await call_next(context)
 
-            request_success_log_message = self._create_after_message(
-                context, "request_success"
-            )
-
-            formatted_message = self._format_message(request_success_log_message)
-            self.logger.log(self.log_level, f"Completed message: {formatted_message}")
+            self._log_message(self._create_after_message(context, start_time))
 
             return result
         except Exception as e:
-            self.logger.log(
-                logging.ERROR, f"Failed message: {context.method or 'unknown'} - {e}"
+            self._log_message(
+                self._create_error_message(context, start_time, e), logging.ERROR
             )
             raise
 
@@ -184,7 +189,7 @@ class LoggingMiddleware(BaseLoggingMiddleware):
             payload_serializer: Callable that converts objects to a JSON string for the
                 payload. If not provided, uses FastMCP's default tool serializer.
         """
-        self.logger: Logger = logger or logging.getLogger("fastmcp.requests")
+        self.logger: Logger = logger or logging.getLogger("fastmcp.middleware.logging")
         self.log_level = log_level
         self.include_payloads: bool = include_payloads
         self.include_payload_length: bool = include_payload_length
@@ -234,7 +239,9 @@ class StructuredLoggingMiddleware(BaseLoggingMiddleware):
             payload_serializer: Callable that converts objects to a JSON string for the
                 payload. If not provided, uses FastMCP's default tool serializer.
         """
-        self.logger: Logger = logger or logging.getLogger("fastmcp.structured")
+        self.logger: Logger = logger or logging.getLogger(
+            "fastmcp.middleware.structured_logging"
+        )
         self.log_level: int = log_level
         self.include_payloads: bool = include_payloads
         self.include_payload_length: bool = include_payload_length
@@ -243,3 +250,7 @@ class StructuredLoggingMiddleware(BaseLoggingMiddleware):
         self.payload_serializer: Callable[[Any], str] | None = payload_serializer
         self.max_payload_length: int | None = None
         self.structured_logging: bool = True
+
+
+def _get_duration_ms(start_time: float, /) -> float:
+    return round(number=(time.perf_counter() - start_time) * 1000, ndigits=2)

fastmcp/server/middleware/middleware.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from collections.abc import Awaitable
+from collections.abc import Awaitable, Sequence
 from dataclasses import dataclass, field, replace
 from datetime import datetime, timezone
 from functools import partial
@@ -27,9 +27,9 @@ if TYPE_CHECKING:
     from fastmcp.server.context import Context
 
 __all__ = [
+    "CallNext",
     "Middleware",
     "MiddlewareContext",
-    "CallNext",
 ]
 
 logger = logging.getLogger(__name__)
@@ -99,6 +99,8 @@ class Middleware:
         handler = call_next
 
         match context.method:
+            case "initialize":
+                handler = partial(self.on_initialize, call_next=handler)
             case "tools/call":
                 handler = partial(self.on_call_tool, call_next=handler)
             case "resources/read":
@@ -133,18 +135,25 @@ class Middleware:
 
     async def on_request(
         self,
-        context: MiddlewareContext[mt.Request],
-        call_next: CallNext[mt.Request, Any],
+        context: MiddlewareContext[mt.Request[Any, Any]],
+        call_next: CallNext[mt.Request[Any, Any], Any],
     ) -> Any:
         return await call_next(context)
 
     async def on_notification(
         self,
-        context: MiddlewareContext[mt.Notification],
-        call_next: CallNext[mt.Notification, Any],
+        context: MiddlewareContext[mt.Notification[Any, Any]],
+        call_next: CallNext[mt.Notification[Any, Any], Any],
     ) -> Any:
         return await call_next(context)
 
+    async def on_initialize(
+        self,
+        context: MiddlewareContext[mt.InitializeRequest],
+        call_next: CallNext[mt.InitializeRequest, mt.InitializeResult | None],
+    ) -> mt.InitializeResult | None:
+        return await call_next(context)
+
     async def on_call_tool(
         self,
         context: MiddlewareContext[mt.CallToolRequestParams],
@@ -155,8 +164,10 @@ class Middleware:
     async def on_read_resource(
         self,
         context: MiddlewareContext[mt.ReadResourceRequestParams],
-        call_next: CallNext[mt.ReadResourceRequestParams, list[ReadResourceContents]],
-    ) -> list[ReadResourceContents]:
+        call_next: CallNext[
+            mt.ReadResourceRequestParams, Sequence[ReadResourceContents]
+        ],
+    ) -> Sequence[ReadResourceContents]:
         return await call_next(context)
 
     async def on_get_prompt(
@@ -169,27 +180,29 @@ class Middleware:
     async def on_list_tools(
         self,
         context: MiddlewareContext[mt.ListToolsRequest],
-        call_next: CallNext[mt.ListToolsRequest, list[Tool]],
-    ) -> list[Tool]:
+        call_next: CallNext[mt.ListToolsRequest, Sequence[Tool]],
+    ) -> Sequence[Tool]:
         return await call_next(context)
 
     async def on_list_resources(
         self,
         context: MiddlewareContext[mt.ListResourcesRequest],
-        call_next: CallNext[mt.ListResourcesRequest, list[Resource]],
-    ) -> list[Resource]:
+        call_next: CallNext[mt.ListResourcesRequest, Sequence[Resource]],
+    ) -> Sequence[Resource]:
         return await call_next(context)
 
     async def on_list_resource_templates(
         self,
         context: MiddlewareContext[mt.ListResourceTemplatesRequest],
-        call_next: CallNext[mt.ListResourceTemplatesRequest, list[ResourceTemplate]],
-    ) -> list[ResourceTemplate]:
+        call_next: CallNext[
+            mt.ListResourceTemplatesRequest, Sequence[ResourceTemplate]
+        ],
+    ) -> Sequence[ResourceTemplate]:
         return await call_next(context)
 
     async def on_list_prompts(
         self,
         context: MiddlewareContext[mt.ListPromptsRequest],
-        call_next: CallNext[mt.ListPromptsRequest, list[Prompt]],
-    ) -> list[Prompt]:
+        call_next: CallNext[mt.ListPromptsRequest, Sequence[Prompt]],
+    ) -> Sequence[Prompt]:
         return await call_next(context)

fastmcp/server/middleware/rate_limiting.py

@@ -1,11 +1,11 @@
 """Rate limiting middleware for protecting FastMCP servers from abuse."""
 
-import asyncio
 import time
 from collections import defaultdict, deque
 from collections.abc import Callable
 from typing import Any
 
+import anyio
 from mcp import McpError
 from mcp.types import ErrorData
 
@@ -33,7 +33,7 @@ class TokenBucketRateLimiter:
         self.refill_rate = refill_rate
         self.tokens = capacity
         self.last_refill = time.time()
-        self._lock = asyncio.Lock()
+        self._lock = anyio.Lock()
 
     async def consume(self, tokens: int = 1) -> bool:
         """Try to consume tokens from the bucket.
@@ -71,7 +71,7 @@ class SlidingWindowRateLimiter:
         self.max_requests = max_requests
         self.window_seconds = window_seconds
         self.requests = deque()
-        self._lock = asyncio.Lock()
+        self._lock = anyio.Lock()
 
     async def is_allowed(self) -> bool:
         """Check if a request is allowed."""

fastmcp/server/middleware/tool_injection.py

@@ -0,0 +1,116 @@
+"""A middleware for injecting tools into the MCP server context."""
+
+from collections.abc import Sequence
+from logging import Logger
+from typing import Annotated, Any
+
+import mcp.types
+from mcp.server.lowlevel.helper_types import ReadResourceContents
+from mcp.types import Prompt
+from pydantic import AnyUrl
+from typing_extensions import override
+
+from fastmcp.server.context import Context
+from fastmcp.server.middleware.middleware import CallNext, Middleware, MiddlewareContext
+from fastmcp.tools.tool import Tool, ToolResult
+from fastmcp.utilities.logging import get_logger
+
+logger: Logger = get_logger(name=__name__)
+
+
+class ToolInjectionMiddleware(Middleware):
+    """A middleware for injecting tools into the context."""
+
+    def __init__(self, tools: Sequence[Tool]):
+        """Initialize the tool injection middleware."""
+        self._tools_to_inject: Sequence[Tool] = tools
+        self._tools_to_inject_by_name: dict[str, Tool] = {
+            tool.name: tool for tool in tools
+        }
+
+    @override
+    async def on_list_tools(
+        self,
+        context: MiddlewareContext[mcp.types.ListToolsRequest],
+        call_next: CallNext[mcp.types.ListToolsRequest, Sequence[Tool]],
+    ) -> Sequence[Tool]:
+        """Inject tools into the response."""
+        return [*self._tools_to_inject, *await call_next(context)]
+
+    @override
+    async def on_call_tool(
+        self,
+        context: MiddlewareContext[mcp.types.CallToolRequestParams],
+        call_next: CallNext[mcp.types.CallToolRequestParams, ToolResult],
+    ) -> ToolResult:
+        """Intercept tool calls to injected tools."""
+        if context.message.name in self._tools_to_inject_by_name:
+            tool = self._tools_to_inject_by_name[context.message.name]
+            return await tool.run(arguments=context.message.arguments or {})
+
+        return await call_next(context)
+
+
+async def list_prompts(context: Context) -> list[Prompt]:
+    """List prompts available on the server."""
+    return await context.list_prompts()
+
+
+list_prompts_tool = Tool.from_function(
+    fn=list_prompts,
+)
+
+
+async def get_prompt(
+    context: Context,
+    name: Annotated[str, "The name of the prompt to render."],
+    arguments: Annotated[
+        dict[str, Any] | None, "The arguments to pass to the prompt."
+    ] = None,
+) -> mcp.types.GetPromptResult:
+    """Render a prompt available on the server."""
+    return await context.get_prompt(name=name, arguments=arguments)
+
+
+get_prompt_tool = Tool.from_function(
+    fn=get_prompt,
+)
+
+
+class PromptToolMiddleware(ToolInjectionMiddleware):
+    """A middleware for injecting prompts as tools into the context."""
+
+    def __init__(self) -> None:
+        tools: list[Tool] = [list_prompts_tool, get_prompt_tool]
+        super().__init__(tools=tools)
+
+
+async def list_resources(context: Context) -> list[mcp.types.Resource]:
+    """List resources available on the server."""
+    return await context.list_resources()
+
+
+list_resources_tool = Tool.from_function(
+    fn=list_resources,
+)
+
+
+async def read_resource(
+    context: Context,
+    uri: Annotated[AnyUrl | str, "The URI of the resource to read."],
+) -> list[ReadResourceContents]:
+    """Read a resource available on the server."""
+    return await context.read_resource(uri=uri)
+
+
+read_resource_tool = Tool.from_function(
+    fn=read_resource,
+)
+
+
+class ResourceToolMiddleware(ToolInjectionMiddleware):
+    """A middleware for injecting resources as tools into the context."""
+
+    def __init__(self) -> None:
+        tools: list[Tool] = [list_resources_tool, read_resource_tool]
+        super().__init__(tools=tools)

fastmcp/server/openapi/__init__.py

@@ -0,0 +1,35 @@
+"""OpenAPI server implementation for FastMCP - refactored for better maintainability."""
+
+# Import from server
+from .server import FastMCPOpenAPI
+
+# Import from routing
+from .routing import (
+    MCPType,
+    RouteMap,
+    RouteMapFn,
+    ComponentFn,
+    DEFAULT_ROUTE_MAPPINGS,
+    _determine_route_type,
+)
+
+# Import from components
+from .components import (
+    OpenAPITool,
+    OpenAPIResource,
+    OpenAPIResourceTemplate,
+)
+
+# Export public symbols - maintaining backward compatibility
+__all__ = [
+    "DEFAULT_ROUTE_MAPPINGS",
+    "ComponentFn",
+    "FastMCPOpenAPI",
+    "MCPType",
+    "OpenAPIResource",
+    "OpenAPIResourceTemplate",
+    "OpenAPITool",
+    "RouteMap",
+    "RouteMapFn",
+    "_determine_route_type",
+]

fastmcp/{experimental/server → server}/openapi/components.py

@@ -9,14 +9,15 @@ import httpx
 from mcp.types import ToolAnnotations
 from pydantic.networks import AnyUrl
 
-# Import from our new utilities
-from fastmcp.experimental.utilities.openapi import HTTPRoute
-from fastmcp.experimental.utilities.openapi.director import RequestDirector
 from fastmcp.resources import Resource, ResourceTemplate
 from fastmcp.server.dependencies import get_http_headers
 from fastmcp.tools.tool import Tool, ToolResult
 from fastmcp.utilities.logging import get_logger
 
+# Import from our new utilities
+from fastmcp.utilities.openapi import HTTPRoute
+from fastmcp.utilities.openapi.director import RequestDirector
+
 if TYPE_CHECKING:
     from fastmcp.server import Context
 
@@ -146,11 +147,11 @@ class OpenAPITool(Tool):
                 if e.response.text:
                     error_message += f" - {e.response.text}"
 
-            raise ValueError(error_message)
+            raise ValueError(error_message) from e
 
         except httpx.RequestError as e:
             # Handle request errors (connection, timeout, etc.)
-            raise ValueError(f"Request error: {str(e)}")
+            raise ValueError(f"Request error: {e!s}") from e
 
 
 class OpenAPIResource(Resource):
@@ -165,9 +166,11 @@ class OpenAPIResource(Resource):
         name: str,
         description: str,
         mime_type: str = "application/json",
-        tags: set[str] = set(),
+        tags: set[str] | None = None,
         timeout: float | None = None,
     ):
+        if tags is None:
+            tags = set()
         super().__init__(
             uri=AnyUrl(uri),  # Convert string to AnyUrl
             name=name,
@@ -276,11 +279,11 @@ class OpenAPIResource(Resource):
                 if e.response.text:
                     error_message += f" - {e.response.text}"
 
-            raise ValueError(error_message)
+            raise ValueError(error_message) from e
 
         except httpx.RequestError as e:
             # Handle request errors (connection, timeout, etc.)
-            raise ValueError(f"Request error: {str(e)}")
+            raise ValueError(f"Request error: {e!s}") from e
 
 
 class OpenAPIResourceTemplate(ResourceTemplate):
@@ -295,9 +298,11 @@ class OpenAPIResourceTemplate(ResourceTemplate):
         name: str,
         description: str,
         parameters: dict[str, Any],
-        tags: set[str] = set(),
+        tags: set[str] | None = None,
         timeout: float | None = None,
     ):
+        if tags is None:
+            tags = set()
         super().__init__(
             uri_template=uri_template,
             name=name,
@@ -342,7 +347,7 @@ class OpenAPIResourceTemplate(ResourceTemplate):
 
 # Export public symbols
 __all__ = [
-    "OpenAPITool",
     "OpenAPIResource",
     "OpenAPIResourceTemplate",
+    "OpenAPITool",
 ]

fastmcp/{experimental/server → server}/openapi/routing.py

@@ -14,8 +14,8 @@ if TYPE_CHECKING:
         OpenAPITool,
     )
 # Import from our new utilities
-from fastmcp.experimental.utilities.openapi import HttpMethod, HTTPRoute
 from fastmcp.utilities.logging import get_logger
+from fastmcp.utilities.openapi import HttpMethod, HTTPRoute
 
 logger = get_logger(__name__)
 
@@ -121,10 +121,10 @@ def _determine_route_type(
 
 # Export public symbols
 __all__ = [
+    "DEFAULT_ROUTE_MAPPINGS",
+    "ComponentFn",
     "MCPType",
     "RouteMap",
     "RouteMapFn",
-    "ComponentFn",
-    "DEFAULT_ROUTE_MAPPINGS",
     "_determine_route_type",
 ]

fastmcp/{experimental/server → server}/openapi/server.py

@@ -7,16 +7,17 @@ from typing import Any, Literal
 import httpx
 from jsonschema_path import SchemaPath
 
+from fastmcp.server.server import FastMCP
+from fastmcp.utilities.logging import get_logger
+
 # Import from our new utilities and components
-from fastmcp.experimental.utilities.openapi import (
+from fastmcp.utilities.openapi import (
     HTTPRoute,
     extract_output_schema_from_responses,
     format_simple_description,
     parse_openapi_to_http_routes,
 )
-from fastmcp.experimental.utilities.openapi.director import RequestDirector
-from fastmcp.server.server import FastMCP
-from fastmcp.utilities.logging import get_logger
+from fastmcp.utilities.openapi.director import RequestDirector
 
 from .components import (
     OpenAPIResource,
@@ -247,7 +248,7 @@ class FastMCPOpenAPI(FastMCP):
             # Create the new name
             new_name = f"{name}_{self._used_names[component_type][name]}"
             logger.debug(
-                f"Name collision detected: '{name}' already exists as a {component_type[:-1]}. "
+                f"Name collision detected: '{name}' already exists as a {component_type}. "
                 f"Using '{new_name}' instead."
             )