Skip to content

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

fix: keep generator iteration inside dependency lifetime (#5438)

mikae51b1f4613b1
diff --git a/fastmcp_slim/fastmcp/server/dependencies.py b/fastmcp_slim/fastmcp/server/dependencies.py
index 05b0943b3..0f4980cfd 100644
--- a/fastmcp_slim/fastmcp/server/dependencies.py
+++ b/fastmcp_slim/fastmcp/server/dependencies.py
@@ -773,20 +773,25 @@ def without_injected_parameters(
async def wrapper(**user_kwargs: Any) -> Any:
async with resolve_dependencies(fn, user_kwargs) as resolved_kwargs:
if fn_is_async:
- return await fn(**resolved_kwargs)
+ result = await fn(**resolved_kwargs)
elif run_in_thread:
# Run sync functions in threadpool to avoid blocking the event loop
result = await call_sync_fn_in_threadpool(fn, **resolved_kwargs)
# Handle sync wrappers that return awaitables (e.g., partial(async_fn))
if inspect.isawaitable(result):
result = await result
- return result
else:
# Call inline on the event loop thread (thread affinity opt-in).
result = fn(**resolved_kwargs)
if inspect.isawaitable(result):
result = await result
- return result
+ # Consume generators before dependencies are torn down so
+ # generator bodies still see open context-manager dependencies.
+ if inspect.isasyncgen(result):
+ return [item async for item in result]
+ if inspect.isgenerator(result):
+ return list(result)
+ return result
# Resolve string annotations (from `from __future__ import annotations`) using
# the original function's module context. The wrapper's __globals__ points to
diff --git a/tests/server/test_dependencies_advanced.py b/tests/server/test_dependencies_advanced.py
index 0657aaddc..b258d00bf 100644
--- a/tests/server/test_dependencies_advanced.py
+++ b/tests/server/test_dependencies_advanced.py
@@ -284,3 +284,57 @@ class TestTransformContextAnnotations:
result = await client.get_prompt("prompt_with_ctx", {"topic": "AI"})
assert "Write about AI" in result.messages[0].content.text
assert "session:" in result.messages[0].content.text
+
+
+class TestGeneratorDependencies:
+ """Generators must be consumed before injected dependencies close."""
+
+ async def test_async_generator_sees_open_dependency(self, mcp: FastMCP):
+ """Regression test for async-generator tools using Depends (#5399)."""
+ import io
+ from collections.abc import AsyncIterator
+ from contextlib import asynccontextmanager
+
+ from fastmcp.dependencies import Depends
+
+ @asynccontextmanager
+ async def open_stream():
+ stream = io.StringIO("payload")
+ try:
+ yield stream
+ finally:
+ stream.close()
+
+ @mcp.tool
+ async def read_stream(stream=Depends(open_stream)) -> AsyncIterator[str]:
+ yield stream.read()
+
+ async with Client(mcp) as client:
+ result = await client.call_tool("read_stream", {})
+ assert not result.is_error
+ assert result.content[0].text == '["payload"]'
+
+ async def test_sync_generator_sees_open_dependency(self, mcp: FastMCP):
+ """Sync generators share the same lifetime requirement."""
+ import io
+ from collections.abc import Iterator
+ from contextlib import contextmanager
+
+ from fastmcp.dependencies import Depends
+
+ @contextmanager
+ def open_stream():
+ stream = io.StringIO("payload")
+ try:
+ yield stream
+ finally:
+ stream.close()
+
+ @mcp.tool
+ def read_stream(stream=Depends(open_stream)) -> Iterator[str]:
+ yield stream.read()
+
+ async with Client(mcp) as client:
+ result = await client.call_tool("read_stream", {})
+ assert not result.is_error
+ assert result.content[0].text == '["payload"]'
diff --git a/tests/server/test_generator_dependency_lifetime.py b/tests/server/test_generator_dependency_lifetime.py
new file mode 100644
index 000000000..b4a6038de
--- /dev/null
+++ b/tests/server/test_generator_dependency_lifetime.py
@@ -0,0 +1,132 @@
+"""Generator results must finish before context-manager dependencies exit."""
+
+import asyncio
+import io
+from collections.abc import AsyncIterator, Iterator
+from contextlib import asynccontextmanager
+
+import pytest
+from pydantic import BaseModel
+from pydantic import ValidationError as PydanticValidationError
+
+from fastmcp import FastMCP
+from fastmcp.client import Client
+from fastmcp.dependencies import Depends
+from fastmcp.exceptions import ValidationError
+from fastmcp.tools.function_tool import FunctionTool
+
+
[email protected]("run_in_thread", [False, True])
+ "kind", ["async_generator", "sync_generator", "coroutine", "sync_wrapper"]
+)
+async def test_generator_result_keeps_dependency_open(kind: str, run_in_thread: bool):
+ stream = io.StringIO("payload")
+ events = []
+
+ @asynccontextmanager
+ async def open_stream():
+ events.append("enter")
+ try:
+ yield stream
+ finally:
+ events.append("exit")
+ stream.close()
+
+ async def produce(value) -> AsyncIterator[str]:
+ try:
+ events.append("body")
+ yield value.read()
+ finally:
+ events.append("generator-finally")
+
+ if kind == "async_generator":
+
+ async def read(value=Depends(open_stream)) -> AsyncIterator[str]:
+ async for item in produce(value):
+ yield item
+ elif kind == "sync_generator":
+
+ def read(value=Depends(open_stream)) -> Iterator[str]:
+ try:
+ events.append("body")
+ yield value.read()
+ finally:
+ events.append("generator-finally")
+ elif kind == "coroutine":
+
+ async def read(value=Depends(open_stream)) -> AsyncIterator[str]:
+ return produce(value)
+ else:
+
+ def read(value=Depends(open_stream)) -> AsyncIterator[str]:
+ return produce(value)
+
+ mcp = FastMCP("generator-dependency")
+ mcp.tool(read, run_in_thread=run_in_thread)
+ async with Client(mcp) as client:
+ result = await client.call_tool("read", {})
+ assert result.content[0].text == '["payload"]'
+ assert events == ["enter", "body", "generator-finally", "exit"]
+ assert stream.closed
+
+
[email protected]("failure", ["exception", "validation", "cancel"])
+async def test_generator_failure_closes_dependency_after_generator(failure: str):
+ events = []
+ started = asyncio.Event()
+
+ @asynccontextmanager
+ async def dependency():
+ events.append("enter")
+ try:
+ yield None
+ finally:
+ events.append("exit")
+
+ class Model(BaseModel):
+ value: int
+
+ async def read(value=Depends(dependency)) -> AsyncIterator[str]:
+ try:
+ events.append("body")
+ yield "first"
+ if failure == "exception":
+ raise RuntimeError("iteration failed")
+ if failure == "validation":
+ Model(value="invalid")
+ started.set()
+ await asyncio.Event().wait()
+ finally:
+ events.append("generator-finally")
+
+ tool = FunctionTool.from_function(read)
+ if failure == "cancel":
+ task = asyncio.create_task(tool.run({}))
+ await started.wait()
+ task.cancel()
+ with pytest.raises(asyncio.CancelledError):
+ await task
+ else:
+ error = RuntimeError if failure == "exception" else PydanticValidationError
+ with pytest.raises(error):
+ await tool.run({})
+ assert events == ["enter", "body", "generator-finally", "exit"]
+
+
+async def test_invalid_generator_arguments_do_not_enter_dependency():
+ events = []
+
+ @asynccontextmanager
+ async def dependency():
+ events.append("enter")
+ yield None
+ events.append("exit")
+
+ async def read(number: int, value=Depends(dependency)) -> AsyncIterator[str]:
+ yield str(number)
+
+ tool = FunctionTool.from_function(read)
+ with pytest.raises(ValidationError):
+ await tool.run({"number": "invalid"})
+ assert events == []