π The fast, Pythonic way to build MCP servers and clients.
Keep multi-round-trip asks out of the response cache
Jeremiah Lowin4ef7d16419bc
diff --git a/fastmcp_slim/fastmcp/server/middleware/caching.py b/fastmcp_slim/fastmcp/server/middleware/caching.pyindex cbf48b849..d470f1b90 100644--- a/fastmcp_slim/fastmcp/server/middleware/caching.py+++ b/fastmcp_slim/fastmcp/server/middleware/caching.py@@ -18,8 +18,18 @@ from key_value.aio.wrappers.statistics.wrapper import (from pydantic import Fieldfrom typing_extensions import NotRequired, Self, TypeVar, override-from fastmcp.prompts.base import Message, Prompt, PromptResult-from fastmcp.resources.base import Resource, ResourceContent, ResourceResult+from fastmcp.prompts.base import (+ InputRequiredPromptResult,+ Message,+ Prompt,+ PromptResult,+)+from fastmcp.resources.base import (+ InputRequiredResourceResult,+ Resource,+ ResourceContent,+ ResourceResult,+)from fastmcp.server.dependencies import get_access_tokenfrom fastmcp.server.middleware.middleware import CallNext, Middleware, MiddlewareContextfrom fastmcp.tools.base import InputRequiredToolResult, Tool, ToolResult@@ -28,6 +38,28 @@ from fastmcp.utilities.types import FastMCPBaseModellogger: Logger = get_logger(name=__name__)++def _is_continuation_leg(context: MiddlewareContext[Any]) -> bool:+ """Whether this request is answering a previous round's ask (SEP-2322).++ A continuation must bypass the cache entirely. Cache keys are built from the+ component's identity and arguments alone, so a continuation shares its key+ with a fresh call: reading could serve a prior flow's final answer to this+ leg, and writing would serve THIS flow's final answer to a later fresh call,+ which would then never be asked the questions at all.++ Either signal marks a continuation. A state-only round (one that carried+ `request_state` without asking anything) retries with `input_responses`+ still `None`.+ """+ fastmcp_ctx = context.fastmcp_context+ if fastmcp_ctx is None:+ return False+ return (+ fastmcp_ctx.input_responses is not None or fastmcp_ctx.request_state is not None+ )++# ConstantsONE_HOUR_IN_SECONDS = 3600FIVE_MINUTES_IN_SECONDS = 300@@ -413,19 +445,7 @@ class ResponseCachingMiddleware(Middleware):) is False or not self._matches_tool_cache_settings(tool_name=tool_name):return await call_next(context)- # A multi-round continuation leg (SEP-2322) must bypass the cache- # entirely: the cache key is built from the tool name and arguments- # only, so a continuation shares its key with a fresh call. Reading- # could serve a prior flow's final answer to this leg; writing would- # serve THIS flow's final answer to a later fresh call β which would- # then never be asked the tool's questions. Either signal marks a- # continuation: a state-only round (request_state with no questions)- # retries with input_responses=None but still carries request_state.- fastmcp_ctx = context.fastmcp_context- if fastmcp_ctx is not None and (- fastmcp_ctx.input_responses is not None- or fastmcp_ctx.request_state is not None- ):+ if _is_continuation_leg(context):return await call_next(context)cache_key: str = _make_call_tool_cache_key(@@ -477,6 +497,9 @@ class ResponseCachingMiddleware(Middleware):if self._read_resource_settings.get("enabled") is False:return await call_next(context)+ if _is_continuation_leg(context):+ return await call_next(context)+cache_key: str = _make_read_resource_cache_key(msg=context.message, auth_key=_get_auth_partition_key())@@ -486,6 +509,14 @@ class ResponseCachingMiddleware(Middleware):return cached_value.unwrap()value: ResourceResult = await call_next(context)++ # Never cache a multi-round-trip ask (SEP-2322). An+ # InputRequiredResourceResult is a request for client input on this leg,+ # not a stable answer, and it carries no contents β wrapping it would+ # cache an empty read and the client would never see the question.+ if isinstance(value, InputRequiredResourceResult):+ return value+cached_value = CacheableResourceResult.wrap(value)await self._read_resource_cache.put(@@ -507,6 +538,9 @@ class ResponseCachingMiddleware(Middleware):if self._get_prompt_settings.get("enabled") is False:return await call_next(context)+ if _is_continuation_leg(context):+ return await call_next(context)+cache_key: str = _make_get_prompt_cache_key(msg=context.message, auth_key=_get_auth_partition_key())@@ -515,6 +549,14 @@ class ResponseCachingMiddleware(Middleware):return cached_value.unwrap()value: PromptResult = await call_next(context)++ # Never cache a multi-round-trip ask (SEP-2322). An+ # InputRequiredPromptResult is a request for client input on this leg,+ # not a stable answer, and it carries no messages β wrapping it would+ # cache an empty prompt and the client would never see the question.+ if isinstance(value, InputRequiredPromptResult):+ return value+cached_value = CacheablePromptResult.wrap(value)await self._get_prompt_cache.put(diff --git a/tests/server/middleware/test_caching.py b/tests/server/middleware/test_caching.pyindex b45961bcf..dd1782a7e 100644--- a/tests/server/middleware/test_caching.py+++ b/tests/server/middleware/test_caching.py@@ -902,3 +902,110 @@ class TestAuthAwareCaching:assert {p.name for p in prompts} == {"public_prompt"}finally:auth_context_var.reset(tok)+++class TestCachingWithInputRequiredResults:+ """A multi-round-trip ask must survive `ResponseCachingMiddleware`.++ An ask carries no content of its own, so caching one would store an empty+ result and the client would never see the question. Continuation legs must+ also bypass the cache, since they share a cache key with a fresh call.+ """++ @staticmethod+ def _answer(responses: mcp_types.InputResponses) -> str:+ """The accepted value for the single question these guards ask."""+ result = responses["q"]+ assert isinstance(result, mcp_types.ElicitResult)+ assert result.content is not None+ return str(result.content["q"])++ @staticmethod+ def _ask() -> mcp_types.InputRequiredResult:+ return mcp_types.InputRequiredResult(+ result_type="input_required",+ input_requests={+ "q": mcp_types.ElicitRequest(+ method="elicitation/create",+ params=mcp_types.ElicitRequestFormParams(+ message="Which quarter?",+ requested_schema={+ "type": "object",+ "properties": {"q": {"type": "string"}},+ "required": ["q"],+ },+ ),+ )+ },+ )++ @classmethod+ def _server(cls) -> FastMCP:+ mcp = FastMCP("cached-guards")+ mcp.add_middleware(ResponseCachingMiddleware())++ @mcp.tool+ async def summarize_tool(ctx: Context) -> str | mcp_types.InputRequiredResult:+ if ctx.input_responses is None:+ return cls._ask()+ return f"Summary for {cls._answer(ctx.input_responses)}"++ @mcp.prompt+ async def summarize(ctx: Context) -> str | mcp_types.InputRequiredResult:+ if ctx.input_responses is None:+ return cls._ask()+ return f"Summary for {cls._answer(ctx.input_responses)}"++ @mcp.resource("report://x")+ async def report(ctx: Context) -> str | mcp_types.InputRequiredResult:+ if ctx.input_responses is None:+ return cls._ask()+ return f"Report for {cls._answer(ctx.input_responses)}"++ return mcp++ @staticmethod+ async def _handler(message, response_type, params, ctx):+ from fastmcp.client.elicitation import ElicitResult++ return ElicitResult(action="accept", content=response_type(q="Q3"))++ async def test_tool_guard_completes_under_caching(self):+ async with Client(+ self._server(), mode="auto", elicitation_handler=self._handler+ ) as client:+ result = await client.call_tool("summarize_tool", {})++ assert result.data == "Summary for Q3"++ async def test_prompt_guard_completes_under_caching(self):+ async with Client(+ self._server(), mode="auto", elicitation_handler=self._handler+ ) as client:+ result = await client.get_prompt("summarize")++ assert result.messages[0].content.text == "Summary for Q3"++ async def test_resource_guard_completes_under_caching(self):+ async with Client(+ self._server(), mode="auto", elicitation_handler=self._handler+ ) as client:+ result = await client.read_resource("report://x")++ assert result[0].text == "Report for Q3"++ async def test_guard_still_asks_on_a_second_fresh_call(self):+ """The ask must not be cached away for the next caller.++ A second fresh flow has to be asked the same question; serving it a+ cached final answer would skip the component's own per-round logic.+ """+ mcp = self._server()+ async with Client(+ mcp, mode="auto", elicitation_handler=self._handler+ ) as client:+ first = await client.get_prompt("summarize")+ second = await client.get_prompt("summarize")++ assert first.messages[0].content.text == "Summary for Q3"+ assert second.messages[0].content.text == "Summary for Q3"