π 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.pyindex 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 loopresult = 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 resultelse:# 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 todiff --git a/tests/server/test_dependencies_advanced.py b/tests/server/test_dependencies_advanced.pyindex 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.textassert "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.pynew file mode 100644index 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 == []