fastmcp 2.13.0rc2__py3-none-any.whl → 2.13.0.1__py3-none-any.whl

fastmcp/server/auth/providers/workos.py

@@ -46,6 +46,7 @@ class WorkOSProviderSettings(BaseSettings):
     required_scopes: list[str] | None = None
     timeout_seconds: int | None = None
     allowed_client_redirect_uris: list[str] | None = None
+    jwt_signing_key: str | None = None
 
     @field_validator("required_scopes", mode="before")
     @classmethod
@@ -168,10 +169,12 @@ class WorkOSProvider(OAuthProxy):
         base_url: AnyHttpUrl | str | NotSetT = NotSet,
         issuer_url: AnyHttpUrl | str | NotSetT = NotSet,
         redirect_path: str | NotSetT = NotSet,
-        required_scopes: list[str] | None | NotSetT = NotSet,
+        required_scopes: list[str] | NotSetT | None = NotSet,
         timeout_seconds: int | NotSetT = NotSet,
         allowed_client_redirect_uris: list[str] | NotSetT = NotSet,
         client_storage: AsyncKeyValue | None = None,
+        jwt_signing_key: str | bytes | NotSetT = NotSet,
+        require_authorization_consent: bool = True,
     ):
         """Initialize WorkOS OAuth provider.
 
@@ -187,7 +190,16 @@ class WorkOSProvider(OAuthProxy):
             timeout_seconds: HTTP request timeout for WorkOS API calls
             allowed_client_redirect_uris: List of allowed redirect URI patterns for MCP clients.
                 If None (default), all URIs are allowed. If empty list, no URIs are allowed.
-            client_storage: An AsyncKeyValue-compatible store for client registrations, registrations are stored in memory if not provided
+            client_storage: Storage backend for OAuth state (client registrations, encrypted tokens).
+                If None, a DiskStore will be created in the data directory (derived from `platformdirs`). The
+                disk store will be encrypted using a key derived from the JWT Signing Key.
+            jwt_signing_key: Secret for signing FastMCP JWT tokens (any string or bytes). If bytes are provided,
+                they will be used as is. If a string is provided, it will be derived into a 32-byte key. If not
+                provided, the upstream client secret will be used to derive a 32-byte key using PBKDF2.
+            require_authorization_consent: Whether to require user consent before authorizing clients (default True).
+                When True, users see a consent screen before being redirected to WorkOS.
+                When False, authorization proceeds directly without user confirmation.
+                SECURITY WARNING: Only disable for local development or testing environments.
         """
 
         settings = WorkOSProviderSettings.model_validate(
@@ -203,6 +215,7 @@ class WorkOSProvider(OAuthProxy):
                     "required_scopes": required_scopes,
                     "timeout_seconds": timeout_seconds,
                     "allowed_client_redirect_uris": allowed_client_redirect_uris,
+                    "jwt_signing_key": jwt_signing_key,
                 }.items()
                 if v is not NotSet
             }
@@ -256,6 +269,8 @@ class WorkOSProvider(OAuthProxy):
             or settings.base_url,  # Default to base_url if not specified
             allowed_client_redirect_uris=allowed_client_redirect_uris_final,
             client_storage=client_storage,
+            jwt_signing_key=settings.jwt_signing_key,
+            require_authorization_consent=require_authorization_consent,
         )
 
         logger.debug(
@@ -323,7 +338,7 @@ class AuthKitProvider(RemoteAuthProvider):
         *,
         authkit_domain: AnyHttpUrl | str | NotSetT = NotSet,
         base_url: AnyHttpUrl | str | NotSetT = NotSet,
-        required_scopes: list[str] | None | NotSetT = NotSet,
+        required_scopes: list[str] | NotSetT | None = NotSet,
         token_verifier: TokenVerifier | None = None,
     ):
         """Initialize AuthKit metadata provider.

fastmcp/server/context.py

@@ -22,6 +22,7 @@ from mcp.types import (
     AudioContent,
     ClientCapabilities,
     CreateMessageResult,
+    GetPromptResult,
     ImageContent,
     IncludeContext,
     ModelHint,
@@ -32,6 +33,8 @@ from mcp.types import (
     TextContent,
 )
 from mcp.types import CreateMessageRequestParams as SamplingParams
+from mcp.types import Prompt as MCPPrompt
+from mcp.types import Resource as MCPResource
 from pydantic.networks import AnyUrl
 from starlette.requests import Request
 from typing_extensions import TypeVar
@@ -185,8 +188,8 @@ class Context:
         """
         try:
             return request_ctx.get()
-        except LookupError:
-            raise ValueError("Context is not available outside of a request")
+        except LookupError as e:
+            raise ValueError("Context is not available outside of a request") from e
 
     async def report_progress(
         self, progress: float, total: float | None = None, message: str | None = None
@@ -215,6 +218,36 @@ class Context:
             related_request_id=self.request_id,
         )
 
+    async def list_resources(self) -> list[MCPResource]:
+        """List all available resources from the server.
+
+        Returns:
+            List of Resource objects available on the server
+        """
+        return await self.fastmcp._list_resources_mcp()
+
+    async def list_prompts(self) -> list[MCPPrompt]:
+        """List all available prompts from the server.
+
+        Returns:
+            List of Prompt objects available on the server
+        """
+        return await self.fastmcp._list_prompts_mcp()
+
+    async def get_prompt(
+        self, name: str, arguments: dict[str, Any] | None = None
+    ) -> GetPromptResult:
+        """Get a prompt by name with optional arguments.
+
+        Args:
+            name: The name of the prompt to get
+            arguments: Optional arguments to pass to the prompt
+
+        Returns:
+            The prompt result
+        """
+        return await self.fastmcp._get_prompt_mcp(name, arguments)
+
     async def read_resource(self, uri: str | AnyUrl) -> list[ReadResourceContents]:
         """Read a resource by URI.
 
@@ -224,8 +257,6 @@ class Context:
         Returns:
             The resource content as either text or bytes
         """
-        if self.fastmcp is None:
-            raise ValueError("Context is not available outside of a request")
         return await self.fastmcp._read_resource_mcp(uri)
 
     async def log(
@@ -311,7 +342,7 @@ class Context:
             session_id = str(uuid4())
 
         # Save the session id to the session attributes
-        setattr(session, "_fastmcp_id", session_id)
+        session._fastmcp_id = session_id
         return session_id
 
     @property
@@ -564,13 +595,11 @@ class Context:
                 choice_literal = Literal[tuple(response_type)]  # type: ignore
                 response_type = ScalarElicitationType[choice_literal]  # type: ignore
             # if the user provided a primitive scalar, wrap it in an object schema
-            elif response_type in {bool, int, float, str}:
-                response_type = ScalarElicitationType[response_type]  # type: ignore
-            # if the user provided a Literal type, wrap it in an object schema
-            elif get_origin(response_type) is Literal:
-                response_type = ScalarElicitationType[response_type]  # type: ignore
-            # if the user provided an Enum type, wrap it in an object schema
-            elif isinstance(response_type, type) and issubclass(response_type, Enum):
+            elif (
+                response_type in {bool, int, float, str}
+                or get_origin(response_type) is Literal
+                or (isinstance(response_type, type) and issubclass(response_type, Enum))
+            ):
                 response_type = ScalarElicitationType[response_type]  # type: ignore
 
             response_type = cast(type[T], response_type)

fastmcp/server/dependencies.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import contextlib
 from typing import TYPE_CHECKING
 
 from mcp.server.auth.middleware.auth_context import (
@@ -16,11 +17,11 @@ if TYPE_CHECKING:
     from fastmcp.server.context import Context
 
 __all__ = [
+    "AccessToken",
+    "get_access_token",
     "get_context",
-    "get_http_request",
     "get_http_headers",
-    "get_access_token",
-    "AccessToken",
+    "get_http_request",
 ]
 
 
@@ -43,10 +44,8 @@ def get_http_request() -> Request:
     from mcp.server.lowlevel.server import request_ctx
 
     request = None
-    try:
+    with contextlib.suppress(LookupError):
         request = request_ctx.get().request
-    except LookupError:
-        pass
 
     if request is None:
         raise RuntimeError("No active HTTP request found.")

fastmcp/server/elicitation.py

@@ -20,8 +20,8 @@ __all__ = [
     "AcceptedElicitation",
     "CancelledElicitation",
     "DeclinedElicitation",
-    "get_elicitation_schema",
     "ScalarElicitationType",
+    "get_elicitation_schema",
 ]
 
 logger = get_logger(__name__)

fastmcp/server/http.py

@@ -5,7 +5,6 @@ from contextlib import asynccontextmanager, contextmanager
 from contextvars import ContextVar
 from typing import TYPE_CHECKING
 
-from mcp.server.auth.middleware.bearer_auth import RequireAuthMiddleware
 from mcp.server.auth.routes import build_resource_metadata_url
 from mcp.server.lowlevel.server import LifespanResultT
 from mcp.server.sse import SseServerTransport
@@ -21,6 +20,7 @@ from starlette.routing import BaseRoute, Mount, Route
 from starlette.types import Lifespan, Receive, Scope, Send
 
 from fastmcp.server.auth import AuthProvider
+from fastmcp.server.auth.middleware import RequireAuthMiddleware
 from fastmcp.utilities.logging import get_logger
 
 if TYPE_CHECKING:
@@ -342,9 +342,8 @@ def create_streamable_http_app(
     # Create a lifespan manager to start and stop the session manager
     @asynccontextmanager
     async def lifespan(app: Starlette) -> AsyncGenerator[None, None]:
-        async with server._lifespan_manager():
-            async with session_manager.run():
-                yield
+        async with server._lifespan_manager(), session_manager.run():
+            yield
 
     # Create and return the app with lifespan
     app = create_base_app(

fastmcp/server/middleware/__init__.py

@@ -5,7 +5,7 @@ from .middleware import (
 )
 
 __all__ = [
+    "CallNext",
     "Middleware",
     "MiddlewareContext",
-    "CallNext",
 ]

fastmcp/server/middleware/caching.py

@@ -46,7 +46,7 @@ class CachableReadResourceContents(BaseModel):
 
     @classmethod
     def get_sizes(cls, values: Sequence[Self]) -> int:
-        return sum([item.get_size() for item in values])
+        return sum(item.get_size() for item in values)
 
     @classmethod
     def wrap(cls, values: Sequence[ReadResourceContents]) -> list[Self]:

fastmcp/server/middleware/error_handling.py

@@ -64,7 +64,7 @@ class ErrorHandlingMiddleware(Middleware):
         error_key = f"{error_type}:{method}"
         self.error_counts[error_key] = self.error_counts.get(error_key, 0) + 1
 
-        base_message = f"Error in {method}: {error_type}: {str(error)}"
+        base_message = f"Error in {method}: {error_type}: {error!s}"
 
         if self.include_traceback:
             self.logger.error(f"{base_message}\n{traceback.format_exc()}")
@@ -91,24 +91,24 @@ class ErrorHandlingMiddleware(Middleware):
 
         if error_type in (ValueError, TypeError):
             return McpError(
-                ErrorData(code=-32602, message=f"Invalid params: {str(error)}")
+                ErrorData(code=-32602, message=f"Invalid params: {error!s}")
             )
         elif error_type in (FileNotFoundError, KeyError, NotFoundError):
             return McpError(
-                ErrorData(code=-32001, message=f"Resource not found: {str(error)}")
+                ErrorData(code=-32001, message=f"Resource not found: {error!s}")
             )
         elif error_type is PermissionError:
             return McpError(
-                ErrorData(code=-32000, message=f"Permission denied: {str(error)}")
+                ErrorData(code=-32000, message=f"Permission denied: {error!s}")
             )
         # asyncio.TimeoutError is a subclass of TimeoutError in Python 3.10, alias in 3.11+
         elif error_type in (TimeoutError, asyncio.TimeoutError):
             return McpError(
-                ErrorData(code=-32000, message=f"Request timeout: {str(error)}")
+                ErrorData(code=-32000, message=f"Request timeout: {error!s}")
             )
         else:
             return McpError(
-                ErrorData(code=-32603, message=f"Internal error: {str(error)}")
+                ErrorData(code=-32603, message=f"Internal error: {error!s}")
             )
 
     async def on_message(self, context: MiddlewareContext, call_next: CallNext) -> Any:
@@ -120,7 +120,7 @@ class ErrorHandlingMiddleware(Middleware):
 
             # Transform and re-raise
             transformed_error = self._transform_error(error)
-            raise transformed_error
+            raise transformed_error from error
 
     def get_error_stats(self) -> dict[str, int]:
         """Get error statistics for monitoring."""
@@ -200,7 +200,7 @@ class RetryMiddleware(Middleware):
                 delay = self._calculate_delay(attempt)
                 self.logger.warning(
                     f"Request {context.method} failed (attempt {attempt + 1}/{self.max_retries + 1}): "
-                    f"{type(error).__name__}: {str(error)}. Retrying in {delay:.1f}s..."
+                    f"{type(error).__name__}: {error!s}. Retrying in {delay:.1f}s..."
                 )
 
                 await anyio.sleep(delay)

fastmcp/server/middleware/middleware.py

@@ -27,9 +27,9 @@ if TYPE_CHECKING:
     from fastmcp.server.context import Context
 
 __all__ = [
+    "CallNext",
     "Middleware",
     "MiddlewareContext",
-    "CallNext",
 ]
 
 logger = logging.getLogger(__name__)

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.py

@@ -513,11 +513,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):
@@ -531,9 +531,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,
@@ -632,11 +634,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):
@@ -650,9 +652,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,

fastmcp/server/proxy.py

@@ -198,7 +198,9 @@ class ProxyResourceManager(ResourceManager, ProxyManagerMixin):
                 elif isinstance(result[0], BlobResourceContents):
                     return result[0].blob
                 else:
-                    raise ResourceError(f"Unsupported content type: {type(result[0])}")
+                    raise ResourceError(
+                        f"Unsupported content type: {type(result[0])}"
+                    ) from None
 
 
 class ProxyPromptManager(PromptManager, ProxyManagerMixin):
@@ -558,7 +560,7 @@ class ProxyClient(Client[ClientTransportT]):
             kwargs["log_handler"] = ProxyClient.default_log_handler
         if "progress_handler" not in kwargs:
             kwargs["progress_handler"] = ProxyClient.default_progress_handler
-        super().__init__(**kwargs | dict(transport=transport))
+        super().__init__(**kwargs | {"transport": transport})
 
     @classmethod
     async def default_sampling_handler(
@@ -572,7 +574,7 @@ class ProxyClient(Client[ClientTransportT]):
         """
         ctx = get_context()
         content = await ctx.sample(
-            [msg for msg in messages],
+            list(messages),
             system_prompt=params.systemPrompt,
             temperature=params.temperature,
             max_tokens=params.maxTokens,
@@ -649,7 +651,6 @@ class StatefulProxyClient(ProxyClient[ClientTransportT]):
         The stateful proxy client will be forced disconnected when the session is exited.
         So we do nothing here.
         """
-        pass
 
     async def clear(self):
         """