Fix PydanticUserError when a generic BaseModel with Json[T] field is specialized with SerializeAsAny[SomeModel] - #15329

if lenient_issubclass(type_, (BaseModel, dict)) or is_dataclass(type_):
    model_config = None
else:
    model_config = model.model_config   # forwarded to TypeAdapter

def _needs_no_config(type_: Any) -> bool:
    if lenient_issubclass(type_, (BaseModel, dict)) or is_dataclass(type_):
        return True
    if get_origin(type_) is Annotated:
        return _needs_no_config(get_args(type_)[0])
    return False

# /// script
# requires-python = ">=3.11"
# dependencies = [
#   "fastapi==0.135.3",
#   "pydantic==2.12.5",
# ]
# ///
"""
PoC: FastAPI 0.135.3 + Pydantic 2.12 — OpenAPI schema generation crash

The guard in `get_model_fields()` (fastapi/_compat/v2.py) checks whether the
field annotation is directly a BaseModel / dict / dataclass to decide whether
to pass `config=` to TypeAdapter:

    type_ = field_info.annotation
    if lenient_issubclass(type_, (BaseModel, dict)) or is_dataclass(type_):
        model_config = None
    else:
        model_config = model.model_config   # ← forwarded to TypeAdapter

Pydantic 2.12 raises PydanticUserError when `config=` is passed to TypeAdapter
and the *resolved* inner type is a BaseModel / dataclass / TypedDict.

The guard correctly handles:
  - Source[Inner]               → type_ = Json[Inner]        → lenient_issubclass fails
                                  BUT TypeAdapter(Json[Inner], config=...) is also OK
                                  because Json[Inner] does not resolve to a bare BaseModel

The guard misses:
  - Source[SerializeAsAny[Inner]]
      type_ = Json[Annotated[Inner, SerializeAsAny]]
      lenient_issubclass fails (not a BaseModel)
      → TypeAdapter(Json[Annotated[Inner, SerializeAsAny]], config=ConfigDict())
      → Pydantic 2.12 rejects this: the inner Annotated[BaseModel, SerializeAsAny]
        is treated as a BaseModel-equivalent and config= is forbidden

Root cause: `Annotated[BaseModel subclass, SerializeAsAny]` is not caught by
`lenient_issubclass(..., BaseModel)`, so when it is further wrapped in Json[...]
the guard is bypassed and config= is passed through to TypeAdapter.

Run
---
    uv run poc.py
"""

from typing import Generic, TypeVar

import fastapi
from fastapi import FastAPI
from pydantic import BaseModel, Json, SerializeAsAny

T = TypeVar("T")

app = FastAPI()


class Inner(BaseModel):
    value: str


class Source(BaseModel, Generic[T]):
    payload: Json[T]


@app.get("/trigger")
def trigger() -> Source[SerializeAsAny[Inner]]: ...


if __name__ == "__main__":
    from typing import Generic as _Generic, TypeVar as _TypeVar

    from pydantic import BaseModel as _BaseModel, Json as _Json, SerializeAsAny as _SerializeAsAny

    _T = _TypeVar("_T")

    class _Inner(_BaseModel):
        value: str

    class _Source(_BaseModel, _Generic[_T]):
        payload: _Json[_T]

    def _try(label: str, fn):
        try:
            fn()
            print(f"OK : {label}")
        except Exception as e:
            print(f"NG : {label}")
            print(f"     {type(e).__name__}: {e}\n")

    ok_app = fastapi.FastAPI()

    @ok_app.get("/ok")
    def _ok() -> _Source[_Inner]: ...

    ng_app = fastapi.FastAPI()

    @ng_app.get("/ng")
    def _ng() -> _Source[_SerializeAsAny[_Inner]]: ...

    _try("Source[Inner]                  (no SerializeAsAny — should pass)", ok_app.openapi)
    _try("Source[SerializeAsAny[Inner]]  (SerializeAsAny wraps T — crashes)", ng_app.openapi)