Skip to content

πŸš€ The fast, Pythonic way to build MCP servers and clients.

fix: preserve input requests in resource and prompt tools (#5476)

HootRockaa6aac869d3a
diff --git a/fastmcp_slim/fastmcp/server/transforms/prompts_as_tools.py b/fastmcp_slim/fastmcp/server/transforms/prompts_as_tools.py
index 1d01d1a78..096f132b3 100644
--- a/fastmcp_slim/fastmcp/server/transforms/prompts_as_tools.py
+++ b/fastmcp_slim/fastmcp/server/transforms/prompts_as_tools.py
@@ -24,8 +24,9 @@ import json
from collections.abc import Sequence
from typing import TYPE_CHECKING, Annotated, Any
-from mcp_types import TextContent
+from mcp_types import InputRequiredResult, TextContent
+from fastmcp.prompts.base import InputRequiredPromptResult
from fastmcp.server.dependencies import get_context
from fastmcp.server.transforms import GetToolNext, Transform
from fastmcp.tools.base import Tool
@@ -134,7 +135,7 @@ class PromptsAsTools(Transform):
dict[str, Any] | None,
"Optional arguments for the prompt",
] = None,
- ) -> str:
+ ) -> str | InputRequiredResult:
"""Get a prompt by name with optional arguments.
Returns the rendered prompt as JSON with a messages array.
@@ -143,6 +144,8 @@ class PromptsAsTools(Transform):
"""
ctx = get_context()
result = await ctx.fastmcp.render_prompt(name, arguments=arguments or {})
+ if isinstance(result, InputRequiredPromptResult):
+ return result.input_required
return _format_prompt_result(result)
return Tool.from_function(fn=get_prompt)
diff --git a/fastmcp_slim/fastmcp/server/transforms/resources_as_tools.py b/fastmcp_slim/fastmcp/server/transforms/resources_as_tools.py
index 416c5724d..0d618a178 100644
--- a/fastmcp_slim/fastmcp/server/transforms/resources_as_tools.py
+++ b/fastmcp_slim/fastmcp/server/transforms/resources_as_tools.py
@@ -25,8 +25,9 @@ import json
from collections.abc import Sequence
from typing import TYPE_CHECKING, Annotated, Any
-from mcp_types import ToolAnnotations
+from mcp_types import InputRequiredResult, ToolAnnotations
+from fastmcp.resources.base import InputRequiredResourceResult
from fastmcp.server.dependencies import get_context
from fastmcp.server.transforms import GetToolNext, Transform
from fastmcp.tools.base import Tool
@@ -141,7 +142,7 @@ class ResourcesAsTools(Transform):
async def read_resource(
uri: Annotated[str, "The URI of the resource to read"],
- ) -> str:
+ ) -> str | InputRequiredResult:
"""Read a resource by its URI.
For static resources, provide the exact URI. For templated
@@ -152,6 +153,8 @@ class ResourcesAsTools(Transform):
"""
ctx = get_context()
result = await ctx.fastmcp.read_resource(uri)
+ if isinstance(result, InputRequiredResourceResult):
+ return result.input_required
return _format_result(result)
return Tool.from_function(fn=read_resource, annotations=_DEFAULT_ANNOTATIONS)
diff --git a/tests/server/transforms/test_input_required.py b/tests/server/transforms/test_input_required.py
new file mode 100644
index 000000000..2e394c8f3
--- /dev/null
+++ b/tests/server/transforms/test_input_required.py
@@ -0,0 +1,181 @@
+"""Generated resource and prompt tools preserve input-required control flow."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from typing import Any, Literal
+
+import pytest
+from mcp.shared.exceptions import MCPError
+from mcp_types import ElicitRequest, ElicitRequestFormParams, InputRequiredResult
+from mcp_types import ElicitResult as ElicitResponse
+
+from fastmcp import Client, Context, FastMCP
+from fastmcp.client.elicitation import ElicitResult
+from fastmcp.server.transforms import PromptsAsTools, ResourcesAsTools
+from fastmcp.utilities.tests import asgi_server
+
+_CALLS = [
+ pytest.param("read_resource", {"uri": "greeting://name"}, id="resource"),
+ pytest.param("read_resource", {"uri": "greeting://Hello"}, id="template"),
+ pytest.param(
+ "get_prompt",
+ {"name": "greeting", "arguments": {"prefix": "Hello"}},
+ id="prompt",
+ ),
+]
+
+
+def _ask(field: str, message: str, state: str) -> InputRequiredResult:
+ return InputRequiredResult(
+ result_type="input_required",
+ input_requests={
+ field: ElicitRequest(
+ method="elicitation/create",
+ params=ElicitRequestFormParams(
+ message=message,
+ requested_schema={
+ "type": "object",
+ "properties": {field: {"type": "string"}},
+ "required": [field],
+ },
+ ),
+ )
+ },
+ request_state=state,
+ )
+
+
+def _server(rounds: int = 1) -> FastMCP:
+ mcp = FastMCP("input-required-transforms")
+
+ def render(ctx: Context, prefix: str) -> str | InputRequiredResult:
+ responses = ctx.input_responses
+ if responses is None:
+ return _ask("name", "Name?", prefix)
+ field = "name" if "name" in responses else "suffix"
+ answer = responses[field]
+ assert isinstance(answer, ElicitResponse)
+ if answer.action != "accept":
+ return f"Input {answer.action}"
+ assert answer.content is not None
+ assert ctx.request_state is not None
+ if field == "name":
+ greeting = f"{ctx.request_state} {answer.content['name']}"
+ if rounds == 2:
+ return _ask("suffix", "Suffix?", greeting)
+ return greeting
+ return f"{ctx.request_state}{answer.content['suffix']}"
+
+ @mcp.resource("greeting://name")
+ def resource(ctx: Context) -> str | InputRequiredResult:
+ return render(ctx, "Hello")
+
+ @mcp.resource("greeting://{prefix}")
+ def template(prefix: str, ctx: Context) -> str | InputRequiredResult:
+ return render(ctx, prefix)
+
+ @mcp.prompt
+ def greeting(prefix: str, ctx: Context) -> str | InputRequiredResult:
+ return render(ctx, prefix)
+
+ mcp.add_transform(ResourcesAsTools(mcp))
+ mcp.add_transform(PromptsAsTools(mcp))
+ return mcp
+
+
+def _expected(tool: str, text: str) -> str | dict[str, Any]:
+ if tool == "get_prompt":
+ return {"messages": [{"role": "user", "content": text}]}
+ return text
+
+
+@asynccontextmanager
+async def _client(
+ server: FastMCP, stateless: bool | None, **kwargs: Any
+) -> AsyncIterator[Client]:
+ if stateless is None:
+ async with Client(server, **kwargs) as client:
+ yield client
+ else:
+ async with asgi_server(
+ server, stateless_http=stateless, json_response=True
+ ) as running:
+ async with running.client(**kwargs) as client:
+ yield client
+
+
+ "stateless", [None, False, True], ids=["memory", "stateful-http", "stateless-http"]
+)
[email protected]("tool,arguments", _CALLS)
[email protected]("rounds", [1, 2])
+async def test_generated_tool_drives_input_rounds(
+ tool: str, arguments: dict[str, Any], rounds: int, stateless: bool | None
+):
+ """Formatting the empty control result must not swallow the question."""
+ asked: list[str] = []
+
+ async def answer(message, response_type, params, ctx):
+ asked.append(message)
+ content = (
+ response_type(name="Ada")
+ if message == "Name?"
+ else response_type(suffix="!")
+ )
+ return ElicitResult(action="accept", content=content)
+
+ async with _client(
+ _server(rounds), stateless, elicitation_handler=answer
+ ) as client:
+ result = await client.call_tool(tool, arguments)
+
+ data = json.loads(result.data) if tool == "get_prompt" else result.data
+ assert data == _expected(tool, "Hello Ada" if rounds == 1 else "Hello Ada!")
+ assert result.structured_content == {"result": result.data}
+ assert not result.is_error
+ assert asked == (["Name?"] if rounds == 1 else ["Name?", "Suffix?"])
+
+
+ "stateless", [None, False, True], ids=["memory", "stateful-http", "stateless-http"]
+)
[email protected]("tool,arguments", _CALLS)
[email protected]("action", ["decline", "cancel"])
+async def test_generated_tool_delivers_non_accepting_answer(
+ tool: str,
+ arguments: dict[str, Any],
+ action: Literal["decline", "cancel"],
+ stateless: bool | None,
+):
+ """The component receives refusal instead of empty success or a retry."""
+
+ asked: list[str] = []
+
+ async def answer(message, response_type, params, ctx):
+ asked.append(message)
+ return ElicitResult(action=action)
+
+ async with _client(_server(), stateless, elicitation_handler=answer) as client:
+ result = await client.call_tool(tool, arguments)
+
+ data = json.loads(result.data) if tool == "get_prompt" else result.data
+ assert data == _expected(tool, f"Input {action}")
+ assert result.structured_content == {"result": result.data}
+ assert not result.is_error
+ assert asked == ["Name?"]
+
+
+ "stateless", [None, False, True], ids=["memory", "stateful-http", "stateless-http"]
+)
[email protected]("tool,arguments", _CALLS)
+async def test_generated_tool_rejects_input_required_on_legacy_connection(
+ tool: str, arguments: dict[str, Any], stateless: bool | None
+):
+ """An unsupported era must raise its usual error, not empty success."""
+ async with _client(_server(), stateless, mode="legacy") as client:
+ with pytest.raises(MCPError, match="2026-07-28"):
+ await client.call_tool(tool, arguments)