Backtestspydanticrun-20261009-110034#11922

Issue #11922 Merged fix PR # Run 9 Oct 2026 · run-20261009-110034 pydantic/pydantic

Some Field attributes lost in JSON schema when using RootModel

Better

Our patch was judged better than the merged fix.

In this judgment, Patch B = our agent, Patch A = the merged fix.

Both patches fix the core bug the same way: `GenerateJsonSchema` now copies `examples` and `deprecated` from the RootModel `root` field into the model-level schema, and also uses the root field's title. The difference is in how they handle edge cases.

**Title handling.**
- Patch A falls back to `cls.__pydantic_fields__['root'].title` whenever no title was set. That value can be filled in by a `field_title_generator` during schema generation. Patch A would then wrongly replace the class name with a generated field title such as 'ROOT'.
- Patch B only uses the root field's title when `'title' in root_field._attributes_set`, i.e. when the user set it explicitly. It tests this case directly (`FieldTitleGenerator`).
- Patch B also defines precedence: config title, then explicit field title, then `model_title_generator`, then class name. Patch A lets `model_title_generator` override an explicit field title, which is arguably less intuitive. Both keep the config title winning.

**Deprecated handling.**
- Patch B treats `deprecated=''` (an empty deprecation message) as deprecated. Patch A's truthiness check would silently drop it.
- Patch B tests `deprecated=None` as not deprecated, and tests a string message that becomes `True`.

**Tests.** Patch B covers the issue's exact `Annotated` example, title/description/examples/deprecated together, title precedence across config, `model_title_generator`, `field_title_generator` and `Annotated`, and the nested `$defs` case. Patch A's tests are reasonable but narrower, with no generator or nested coverage.

**Craft.** Patch B computes `root_field` once and reuses it in the existing description and `json_schema_extra` branches. This removes repeated `issubclass` checks and keeps the code consistent with the existing `__pydantic_root_model__` check.

Overall, Patch B is more correct at the edges and better tested.

The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.

Solve

5m 35s

Wall-clock time in the container

Full test suite

No new failures

1,247 passed · 15 skipped · 1,262 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

93vs 53 merged

Changed lines, ours vs merged

Initial Checks

  • I confirm that I'm using Pydantic V2

Description

When declaring a RootModel and adding a Field annotation to the root property that includes examples, those examples are not part of the generated JSON schema. This also applies to the deprecated attribute. The title attribute is also not applied or it is overwritten by the class name of the root model class.

Most other attributes, such as pattern or description are exposed as expected. Furthermore, placing examples in json_schema_extra also works as expected.

Example Code

from typing import Annotated
from pydantic import RootModel, Field

class Foo(RootModel):
    root: Annotated[str, Field(examples=["foo", "bar"], deprecated=True)]

print(Foo.model_json_schema())  # does not include examples or deprecated.

Python, Pydantic & OS Version

pydantic version: 2.11.4
        pydantic-core version: 2.33.2
          pydantic-core build: profile=release pgo=false
               python version: 3.13.3 (main, May 22 2025, 01:38:47) [Clang 20.1.4 ]
                     platform: macOS-15.5-arm64-arm-64bit-Mach-O
             related packages: pydantic-settings-2.9.1 mypy-1.15.0 typing_extensions-4.13.2 fastapi-0.115.12
                       commit: unknown

The two patches

Our patch+88 −5
pydantic/json_schema.pyindex 10d2f972..9d39fd4a 100644@@ -1639,10 +1639,16 @@ class GenerateJsonSchema:         """         from ._internal._dataclasses import is_stdlib_dataclass         from .main import BaseModel-        from .root_model import RootModel++        root_field = (+            cls.__pydantic_fields__['root'] if issubclass(cls, BaseModel) and cls.__pydantic_root_model__ else None+        )          if (config_title := config.get('title')) is not None:             json_schema.setdefault('title', config_title)+        elif root_field is not None and 'title' in root_field._attributes_set:+            # Only use an explicitly set title (not one created by a `field_title_generator`):+            json_schema.setdefault('title', root_field.title)         elif model_title_generator := config.get('model_title_generator'):             title = model_title_generator(cls)             if not isinstance(title, str):@@ -1667,8 +1673,14 @@ class GenerateJsonSchema:          if docstring:             json_schema.setdefault('description', inspect.cleandoc(docstring))-        elif issubclass(cls, RootModel) and (root_description := cls.__pydantic_fields__['root'].description):-            json_schema.setdefault('description', root_description)+        elif root_field is not None and root_field.description:+            json_schema.setdefault('description', root_field.description)++        if root_field is not None:+            if root_field.examples is not None:+                json_schema['examples'] = to_jsonable_python(root_field.examples)+            if bool(root_field.deprecated) or root_field.deprecated == '':+                json_schema['deprecated'] = True          extra = config.get('extra')         if 'additionalProperties' not in json_schema:  # This check is particularly important for `typed_dict_schema()`@@ -1678,8 +1690,8 @@ class GenerateJsonSchema:                 json_schema['additionalProperties'] = False          json_schema_extra = config.get('json_schema_extra')-        if issubclass(cls, BaseModel) and cls.__pydantic_root_model__:-            root_json_schema_extra = cls.model_fields['root'].json_schema_extra+        if root_field is not None:+            root_json_schema_extra = root_field.json_schema_extra             if json_schema_extra and root_json_schema_extra:                 raise ValueError(                     '"model_config[\'json_schema_extra\']" and "Field.json_schema_extra" on "RootModel.root"'tests/test_root_model.pyindex 687ee17c..064ceaa5 100644@@ -464,6 +464,77 @@ def test_root_model_json_schema_meta():     assert subclassed_json_schema.get('description') == 'Subclassed Model docstring'  +def test_root_model_json_schema_field_info_attributes() -> None:+    """https://github.com/pydantic/pydantic/issues/11872"""++    class Foo(RootModel):+        root: Annotated[str, Field(examples=['foo', 'bar'], deprecated=True)]++    assert Foo.model_json_schema() == {+        'title': 'Foo',+        'type': 'string',+        'examples': ['foo', 'bar'],+        'deprecated': True,+    }++    class Bar(RootModel[int]):+        root: int = Field(title='Bar title', description='Bar description', examples=[1], deprecated='msg')++    assert Bar.model_json_schema() == {+        'title': 'Bar title',+        'description': 'Bar description',+        'type': 'integer',+        'examples': [1],+        'deprecated': True,+    }++    class NotDeprecated(RootModel[int]):+        root: int = Field(deprecated=None)++    assert NotDeprecated.model_json_schema() == {'title': 'NotDeprecated', 'type': 'integer'}+++def test_root_model_json_schema_title_precedence() -> None:+    class ConfigTitle(RootModel[int]):+        model_config = ConfigDict(title='Config title')++        root: int = Field(title='Field title')++    assert ConfigTitle.model_json_schema()['title'] == 'Config title'++    class GeneratorTitle(RootModel[int]):+        model_config = ConfigDict(model_title_generator=lambda cls: 'Generated title')++        root: int = Field(title='Field title')++    assert GeneratorTitle.model_json_schema()['title'] == 'Field title'++    class FieldTitleGenerator(RootModel[int]):+        model_config = ConfigDict(field_title_generator=lambda name, field_info: name.upper())++    assert FieldTitleGenerator.model_json_schema()['title'] == 'FieldTitleGenerator'++    class AnnotatedTitle(RootModel[int]):+        root: Annotated[int, Field(title='Annotated title')]++    assert AnnotatedTitle.model_json_schema()['title'] == 'Annotated title'+++def test_root_model_json_schema_field_info_attributes_nested() -> None:+    class Inner(RootModel[str]):+        root: str = Field(title='Inner title', examples=['a'], deprecated=True)++    class Model(BaseModel):+        inner: Inner++    assert Model.model_json_schema()['$defs']['Inner'] == {+        'title': 'Inner title',+        'type': 'string',+        'examples': ['a'],+        'deprecated': True,+    }++ @pytest.mark.parametrize('order', ['BR', 'RB']) def test_root_model_dump_with_base_model(order):     class BModel(BaseModel): 
Merged fix · PR #+52 −1
pydantic/json_schema.pyindex 10d2f972e..1f76e861d 100644@@ -1649,7 +1649,10 @@ class GenerateJsonSchema:                 raise TypeError(f'model_title_generator {model_title_generator} must return str, not {title.__class__}')             json_schema.setdefault('title', title)         if 'title' not in json_schema:-            json_schema['title'] = cls.__name__+            if issubclass(cls, RootModel) and (root_title := cls.__pydantic_fields__['root'].title):+                json_schema['title'] = root_title+            else:+                json_schema['title'] = cls.__name__          # BaseModel and dataclasses; don't use cls.__doc__ as it will contain the verbose class signature by default         if cls is BaseModel:@@ -1670,6 +1673,13 @@ class GenerateJsonSchema:         elif issubclass(cls, RootModel) and (root_description := cls.__pydantic_fields__['root'].description):             json_schema.setdefault('description', root_description) +        if issubclass(cls, RootModel):+            root_field = cls.__pydantic_fields__['root']+            if root_field.examples is not None:+                json_schema.setdefault('examples', to_jsonable_python(root_field.examples))+            if root_field.deprecated:+                json_schema['deprecated'] = True+         extra = config.get('extra')         if 'additionalProperties' not in json_schema:  # This check is particularly important for `typed_dict_schema()`             if extra == 'allow':tests/test_root_model.pyindex 687ee17c8..60e36c338 100644@@ -721,3 +721,44 @@ def test_model_with_both_docstring_and_field_description() -> None:         'type': 'integer',         'description': 'More detailed description',     }+++def test_model_json_schema_field_examples() -> None:+    class AModel(RootModel):+        root: str = Field(examples=['foo', 'bar'])++    assert AModel.model_json_schema() == {'title': 'AModel', 'type': 'string', 'examples': ['foo', 'bar']}+++def test_model_json_schema_field_deprecated() -> None:+    class AModel(RootModel):+        root: str = Field(deprecated=True)++    assert AModel.model_json_schema() == {'title': 'AModel', 'type': 'string', 'deprecated': True}+++def test_model_json_schema_field_title() -> None:+    class AModel(RootModel):+        root: str = Field(title='My Title')++    assert AModel.model_json_schema() == {'title': 'My Title', 'type': 'string'}+++def test_model_json_schema_field_title_overridden_by_config() -> None:+    class AModel(RootModel):+        model_config = ConfigDict(title='Config Title')+        root: str = Field(title='Field Title')++    assert AModel.model_json_schema() == {'title': 'Config Title', 'type': 'string'}+++def test_model_json_schema_field_examples_and_deprecated_together() -> None:+    class AModel(RootModel):+        root: Annotated[str, Field(examples=['foo'], deprecated=True)]++    assert AModel.model_json_schema() == {+        'title': 'AModel',+        'type': 'string',+        'examples': ['foo'],+        'deprecated': True,+    }