fix(core): resolve string annotations in _create_subset_model_v2

Subset models created by `_create_subset_model_v2` copied the source
model's raw `__annotations__` verbatim. When the source model lives in
a module using `from __future__ import annotations`, the copied values
are unresolved strings that cannot be evaluated in the subset model's
namespace, which breaks consumers that evaluate annotations, such as
model subclassing on pydantic 2.14 prereleases.

Resolve the annotations with `typing.get_type_hints(include_extras=True)`
instead, keeping `Annotated` extras intact, and fall back to the raw
copy for models whose annotations `get_type_hints` cannot resolve, for
example models defined inside function bodies that reference local
names.

The pydantic 2.14.0a1 crash in #37835 itself is a pydantic regression
with a pure-pydantic reduction and is being coordinated upstream; this
change removes the related latent hazard on the langchain side and adds
regression tests.

Author: qflen

libs/core/langchain_core/utils/pydantic.py

@@ -13,6 +13,7 @@
     Any,
     TypeVar,
     cast,
+    get_type_hints,
     overload,
 )
 
@@ -259,17 +260,24 @@ def _create_subset_model_v2(
         ),
     )
 
-    # TODO(0.3): Determine if there is a more "pydantic" way to preserve annotations.
-    # This is done to preserve __annotations__ when working with pydantic 2.x
-    # and using the Annotated type with TypedDict.
-    # Comment out the following line, to trigger the relevant test case.
-    selected_annotations = [
-        (name, annotation)
-        for name, annotation in model.__annotations__.items()
-        if name in field_names
-    ]
-
-    rtn.__annotations__ = dict(selected_annotations)
+    # Resolve the source model's annotations (including inherited ones) so the
+    # subset model preserves `Annotated` extras without carrying raw string
+    # annotations. Strings copied from a module using
+    # `from __future__ import annotations` cannot be resolved in the subset
+    # model's namespace and break consumers that evaluate annotations, such as
+    # model subclassing on pydantic 2.14 prereleases.
+    try:
+        type_hints = get_type_hints(model, include_extras=True)
+    except Exception:
+        # `get_type_hints` re-evaluates strings against the module namespace
+        # and can fail where pydantic's frame-aware resolution at class
+        # creation succeeded (e.g. function-local models). Fall back to the
+        # raw annotations, as before.
+        type_hints = model.__annotations__
+
+    rtn.__annotations__ = {
+        name: type_hints[name] for name in field_names if name in type_hints
+    }
     rtn.__doc__ = textwrap.dedent(fn_description or model.__doc__ or "")
     return rtn
 

libs/core/tests/unit_tests/utils/pydantic_future_annotations.py

@@ -0,0 +1,19 @@
+"""Models with lazy string annotations for `_create_subset_model_v2` tests.
+
+The `from __future__ import annotations` import is load-bearing: it makes every
+raw value in this module's `__annotations__` an unresolved string, which is the
+scenario the subset-model annotation tests exercise.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+from pydantic import BaseModel
+
+
+class FutureModel(BaseModel):
+    """Model whose raw `__annotations__` values are unresolved strings."""
+
+    metadata: dict[str, Any] | None = None
+    tagged: Annotated[dict, "extra"] | None = None

libs/core/tests/unit_tests/utils/test_pydantic.py

@@ -2,7 +2,7 @@
 
 import sys
 import warnings
-from typing import Any
+from typing import Annotated, Any, get_type_hints
 
 import pytest
 from pydantic import BaseModel, ConfigDict, Field
@@ -16,6 +16,7 @@
     is_basemodel_subclass,
     pre_init,
 )
+from tests.unit_tests.utils.pydantic_future_annotations import FutureModel
 
 
 def test_pre_init_decorator() -> None:
@@ -133,6 +134,64 @@ class Foo(BaseModel):
     }
 
 
+def test_create_subset_model_v2_resolves_string_annotations() -> None:
+    """Test that lazy string annotations are resolved on the subset model."""
+    subset_model = _create_subset_model_v2("Sub", FutureModel, ["metadata"])
+    assert subset_model.__annotations__ == {"metadata": dict[str, Any] | None}
+
+
+def test_create_subset_model_v2_preserves_annotated_extras() -> None:
+    """Test that `Annotated` metadata survives string annotation resolution."""
+    subset_model = _create_subset_model_v2("Sub", FutureModel, ["tagged"])
+    assert subset_model.__annotations__ == {"tagged": Annotated[dict, "extra"] | None}
+
+
+class LocalRegistry:
+    """Module-level shadow without `Inner` for the fallback test below."""
+
+
+def test_create_subset_model_v2_unresolvable_annotations_fall_back() -> None:
+    """Test the fallback for annotations `get_type_hints` cannot resolve.
+
+    Models defined inside function bodies can hold forward references to other
+    function-local names. Pydantic resolves those from the enclosing frame,
+    but `typing.get_type_hints` only sees the module namespace and raises,
+    for example `NameError` for an unknown name or `AttributeError` for an
+    attribute of a shadowed name. Subset model creation must not raise for
+    such models; the unresolvable annotation is copied as the raw string
+    instead.
+    """
+
+    class LocalModel(BaseModel):
+        x: "LocalDep | None" = None
+
+    class LocalDep(BaseModel):
+        y: int = 0
+
+    LocalModel.model_rebuild()
+
+    with pytest.raises(NameError):
+        get_type_hints(LocalModel)
+
+    subset_model = _create_subset_model_v2("Sub", LocalModel, ["x"])
+    assert subset_model.__annotations__ == {"x": "LocalDep | None"}
+
+    class LocalRegistry:
+        class Inner(BaseModel):
+            y: int = 0
+
+    class ShadowModel(BaseModel):
+        x: "LocalRegistry.Inner | None" = None
+
+    # `get_type_hints` resolves `LocalRegistry` to the module-level class of
+    # the same name above, which has no `Inner`.
+    with pytest.raises(AttributeError):
+        get_type_hints(ShadowModel)
+
+    subset_model = _create_subset_model_v2("Sub", ShadowModel, ["x"])
+    assert subset_model.__annotations__ == {"x": "LocalRegistry.Inner | None"}
+
+
 def test_fields_pydantic_v2_proper() -> None:
     class Foo(BaseModel):
         x: int