Skip to content

The agent engineering platform.

fix(core): fix Pydantic v1 support in tools/runnable (#33698)

Christophe Bornet0392b6bae4bd
diff --git a/libs/core/langchain_core/language_models/chat_models.py b/libs/core/langchain_core/language_models/chat_models.py
index 7c21d12110..a0e8f42bef 100644
--- a/libs/core/langchain_core/language_models/chat_models.py
+++ b/libs/core/langchain_core/language_models/chat_models.py
@@ -91,7 +91,7 @@ from langchain_core.utils.function_calling import (
convert_to_json_schema,
convert_to_openai_tool,
)
-from langchain_core.utils.pydantic import TypeBaseModel, is_basemodel_subclass
+from langchain_core.utils.pydantic import is_basemodel_subclass
from langchain_core.utils.utils import LC_ID_PREFIX, from_env
if TYPE_CHECKING:
@@ -2519,9 +2519,7 @@ class BaseChatModel(BaseLanguageModel[AIMessage], ABC):
)
output_parser: JsonOutputToolsParser
if isinstance(schema, type) and is_basemodel_subclass(schema):
- output_parser = PydanticToolsParser(
- tools=[cast("TypeBaseModel", schema)], first_tool_only=True
- )
+ output_parser = PydanticToolsParser(tools=[schema], first_tool_only=True)
else:
key_name = convert_to_openai_tool(schema)["function"]["name"]
output_parser = JsonOutputKeyToolsParser(
diff --git a/libs/core/langchain_core/output_parsers/openai_tools.py b/libs/core/langchain_core/output_parsers/openai_tools.py
index 78be65ecef..c4b404b97a 100644
--- a/libs/core/langchain_core/output_parsers/openai_tools.py
+++ b/libs/core/langchain_core/output_parsers/openai_tools.py
@@ -6,7 +6,8 @@ import logging
from json import JSONDecodeError
from typing import Annotated, Any
-from pydantic import SkipValidation, ValidationError
+from pydantic import BaseModel, SkipValidation, ValidationError
+from pydantic.v1 import BaseModel as BaseModelV1
from langchain_core.exceptions import OutputParserException
from langchain_core.messages import AIMessage, InvalidToolCall
@@ -17,8 +18,6 @@ from langchain_core.outputs import ChatGeneration, Generation
from langchain_core.utils.json import parse_partial_json
from langchain_core.utils.pydantic import (
TypeBaseModel,
- is_pydantic_v1_subclass,
- is_pydantic_v2_subclass,
)
logger = logging.getLogger(__name__)
@@ -339,10 +338,10 @@ class PydanticToolsParser(JsonOutputToolsParser):
name_dict_v2: dict[str, TypeBaseModel] = {
tool.model_config.get("title") or tool.__name__: tool
for tool in self.tools
- if is_pydantic_v2_subclass(tool)
+ if issubclass(tool, BaseModel)
}
name_dict_v1: dict[str, TypeBaseModel] = {
- tool.__name__: tool for tool in self.tools if is_pydantic_v1_subclass(tool)
+ tool.__name__: tool for tool in self.tools if issubclass(tool, BaseModelV1)
}
name_dict: dict[str, TypeBaseModel] = {**name_dict_v2, **name_dict_v1}
pydantic_objects = []
diff --git a/libs/core/langchain_core/runnables/base.py b/libs/core/langchain_core/runnables/base.py
index f6b47558af..231553dc81 100644
--- a/libs/core/langchain_core/runnables/base.py
+++ b/libs/core/langchain_core/runnables/base.py
@@ -38,6 +38,7 @@ from typing import (
)
from pydantic import BaseModel, ConfigDict, Field, RootModel
+from pydantic.fields import FieldInfo
from typing_extensions import override
from langchain_core._api import beta_decorator
@@ -97,9 +98,16 @@ from langchain_core.tracers.root_listeners import (
)
from langchain_core.utils.aiter import aclosing, atee
from langchain_core.utils.iter import safetee
-from langchain_core.utils.pydantic import create_model_v2
+from langchain_core.utils.pydantic import (
+ TypeBaseModel,
+ create_model_v2,
+ get_fields,
+ model_json_schema,
+)
if TYPE_CHECKING:
+ from pydantic.v1.fields import ModelField
+
from langchain_core.callbacks.manager import (
AsyncCallbackManagerForChainRun,
CallbackManagerForChainRun,
@@ -364,14 +372,14 @@ class Runnable(ABC, Generic[Input, Output]):
raise TypeError(msg)
@property
- def input_schema(self) -> type[BaseModel]:
+ def input_schema(self) -> TypeBaseModel:
"""The type of input this `Runnable` accepts specified as a Pydantic model."""
return self.get_input_schema()
def get_input_schema(
self,
config: RunnableConfig | None = None,
- ) -> type[BaseModel]:
+ ) -> TypeBaseModel:
"""Get a Pydantic model that can be used to validate input to the `Runnable`.
`Runnable` objects that leverage the `configurable_fields` and
@@ -437,10 +445,10 @@ class Runnable(ABC, Generic[Input, Output]):
!!! version-added "Added in `langchain-core` 0.3.0"
"""
- return self.get_input_schema(config).model_json_schema()
+ return model_json_schema(self.get_input_schema(config))
@property
- def output_schema(self) -> type[BaseModel]:
+ def output_schema(self) -> TypeBaseModel:
"""Output schema.
The type of output this `Runnable` produces specified as a Pydantic model.
@@ -450,7 +458,7 @@ class Runnable(ABC, Generic[Input, Output]):
def get_output_schema(
self,
config: RunnableConfig | None = None,
- ) -> type[BaseModel]:
+ ) -> TypeBaseModel:
"""Get a Pydantic model that can be used to validate output to the `Runnable`.
`Runnable` objects that leverage the `configurable_fields` and
@@ -516,7 +524,7 @@ class Runnable(ABC, Generic[Input, Output]):
!!! version-added "Added in `langchain-core` 0.3.0"
"""
- return self.get_output_schema(config).model_json_schema()
+ return model_json_schema(self.get_output_schema(config))
@property
def config_specs(self) -> list[ConfigurableFieldSpec]:
@@ -2953,7 +2961,7 @@ class RunnableSerializable(Serializable, Runnable[Input, Output]):
def _seq_input_schema(
steps: list[Runnable[Any, Any]], config: RunnableConfig | None
-) -> type[BaseModel]:
+) -> TypeBaseModel:
# Import locally to prevent circular import
from langchain_core.runnables.passthrough import ( # noqa: PLC0415
RunnableAssign,
@@ -2971,7 +2979,7 @@ def _seq_input_schema(
"RunnableSequenceInput",
field_definitions={
k: (v.annotation, v.default)
- for k, v in next_input_schema.model_fields.items()
+ for k, v in get_fields(next_input_schema).items()
if k not in first.mapper.steps__
},
)
@@ -2983,7 +2991,7 @@ def _seq_input_schema(
def _seq_output_schema(
steps: list[Runnable[Any, Any]], config: RunnableConfig | None
-) -> type[BaseModel]:
+) -> TypeBaseModel:
# Import locally to prevent circular import
from langchain_core.runnables.passthrough import ( # noqa: PLC0415
RunnableAssign,
@@ -3002,12 +3010,12 @@ def _seq_output_schema(
"RunnableSequenceOutput",
field_definitions={
**{
- k: (v.annotation, v.default)
- for k, v in prev_output_schema.model_fields.items()
+ k: _get_schema_field_definition(v)
+ for k, v in get_fields(prev_output_schema).items()
},
**{
- k: (v.annotation, v.default)
- for k, v in mapper_output_schema.model_fields.items()
+ k: _get_schema_field_definition(v)
+ for k, v in get_fields(mapper_output_schema).items()
},
},
)
@@ -3019,19 +3027,36 @@ def _seq_output_schema(
return create_model_v2(
"RunnableSequenceOutput",
field_definitions={
- k: (v.annotation, v.default)
- for k, v in prev_output_schema.model_fields.items()
+ k: _get_schema_field_definition(v)
+ for k, v in get_fields(prev_output_schema).items()
if k in last.keys
},
)
- field = prev_output_schema.model_fields[last.keys]
+ field = get_fields(prev_output_schema)[last.keys]
return create_model_v2(
- "RunnableSequenceOutput", root=(field.annotation, field.default)
+ "RunnableSequenceOutput", root=_get_schema_field_definition(field)
)
return last.get_output_schema(config)
+def _get_schema_field_definition(field: FieldInfo | ModelField) -> tuple[Any, Any]:
+ """Convert a Pydantic field to a field definition for `create_model_v2`.
+
+ Handles both Pydantic v2 (`FieldInfo`) and v1 (`ModelField`) fields. v1
+ required fields carry a `None` default with `required=True`, so they must be
+ translated to the `...` sentinel rather than passed through as optional.
+ """
+ if isinstance(field, FieldInfo):
+ return (field.annotation, field.default)
+
+ if field.required:
+ return (field.annotation, ...)
+ if field.default_factory is not None:
+ return (field.annotation, Field(default_factory=field.default_factory))
+ return (field.annotation, field.default)
+
+
_RUNNABLE_SEQUENCE_MIN_STEPS = 2
@@ -3212,7 +3237,7 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
return self.last.OutputType
@override
- def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
+ def get_input_schema(self, config: RunnableConfig | None = None) -> TypeBaseModel:
"""Get the input schema of the `Runnable`.
Args:
@@ -3225,9 +3250,7 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
return _seq_input_schema(self.steps, config)
@override
- def get_output_schema(
- self, config: RunnableConfig | None = None
- ) -> type[BaseModel]:
+ def get_output_schema(self, config: RunnableConfig | None = None) -> TypeBaseModel:
"""Get the output schema of the `Runnable`.
Args:
@@ -3984,7 +4007,7 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
return Any
@override
- def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
+ def get_input_schema(self, config: RunnableConfig | None = None) -> TypeBaseModel:
"""Get the input schema of the `Runnable`.
Args:
@@ -3995,23 +4018,26 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
"""
if all(
- s.get_input_schema(config).model_json_schema().get("type", "object")
- == "object"
+ s.get_input_jsonschema(config).get("type", "object") == "object"
for s in self.steps__.values()
):
for step in self.steps__.values():
- fields = step.get_input_schema(config).model_fields
+ step_input_schema = step.get_input_schema(config)
+ fields = get_fields(step_input_schema)
root_field = fields.get("root")
if root_field is not None and root_field.annotation != Any:
return super().get_input_schema(config)
+ root_field = fields.get("__root__")
+ if root_field is not None and root_field.annotation != Any:
+ return step_input_schema
# This is correct, but pydantic typings/mypy don't think so.
return create_model_v2(
self.get_name("Input"),
field_definitions={
- k: (v.annotation, v.default)
+ k: _get_schema_field_definition(v)
for step in self.steps__.values()
- for k, v in step.get_input_schema(config).model_fields.items()
+ for k, v in get_fields(step.get_input_schema(config)).items()
if k != "__root__"
},
)
@@ -4032,6 +4058,9 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
"""
fields = {k: (v.OutputType, ...) for k, v in self.steps__.items()}
+ # The return type is narrowed to `type[BaseModel]` (rather than the base
+ # class's `TypeBaseModel`) because this override always builds the schema
+ # with `create_model_v2`, so it is guaranteed to be a Pydantic v2 model.
return create_model_v2(self.get_name("Output"), field_definitions=fields)
@property
@@ -4932,7 +4961,7 @@ class RunnableLambda(Runnable[Input, Output]):
return Any
@override
- def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
+ def get_input_schema(self, config: RunnableConfig | None = None) -> TypeBaseModel:
"""The Pydantic schema for the input to this `Runnable`.
Args:
@@ -5925,15 +5954,13 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]): # type: ignore[
)
@override
- def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
+ def get_input_schema(self, config: RunnableConfig | None = None) -> TypeBaseModel:
if self.custom_input_type is not None:
return super().get_input_schema(config)
return self.bound.get_input_schema(merge_configs(self.config, config))
@override
- def get_output_schema(
- self, config: RunnableConfig | None = None
- ) -> type[BaseModel]:
+ def get_output_schema(self, config: RunnableConfig | None = None) -> TypeBaseModel:
if self.custom_output_type is not None:
return super().get_output_schema(config)
return self.bound.get_output_schema(merge_configs(self.config, config))
diff --git a/libs/core/langchain_core/runnables/branch.py b/libs/core/langchain_core/runnables/branch.py
index 277a4a3607..1c14476912 100644
--- a/libs/core/langchain_core/runnables/branch.py
+++ b/libs/core/langchain_core/runnables/branch.py
@@ -13,7 +13,7 @@ from typing import (
cast,
)
-from pydantic import BaseModel, ConfigDict
+from pydantic import ConfigDict
from typing_extensions import override
from langchain_core.runnables.base import (
@@ -35,6 +35,7 @@ from langchain_core.runnables.utils import (
Output,
get_unique_config_specs,
)
+from langchain_core.utils.pydantic import TypeBaseModel
_MIN_BRANCHES = 2
@@ -154,7 +155,7 @@ class RunnableBranch(RunnableSerializable[Input, Output]):
return ["langchain", "schema", "runnable"]
@override
- def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
+ def get_input_schema(self, config: RunnableConfig | None = None) -> TypeBaseModel:
runnables = (
[self.default]
+ [r for _, r in self.branches]
@@ -162,10 +163,7 @@ class RunnableBranch(RunnableSerializable[Input, Output]):
)
for runnable in runnables:
- if (
- runnable.get_input_schema(config).model_json_schema().get("type")
- is not None
- ):
+ if runnable.get_input_jsonschema(config).get("type") is not None:
return runnable.get_input_schema(config)
return super().get_input_schema(config)
diff --git a/libs/core/langchain_core/runnables/configurable.py b/libs/core/langchain_core/runnables/configurable.py
index a03108850f..415c30d4d2 100644
--- a/libs/core/langchain_core/runnables/configurable.py
+++ b/libs/core/langchain_core/runnables/configurable.py
@@ -19,7 +19,7 @@ from typing import (
)
from weakref import WeakValueDictionary
-from pydantic import BaseModel, ConfigDict
+from pydantic import ConfigDict
from typing_extensions import override
from langchain_core.runnables.base import Runnable, RunnableSerializable
@@ -44,6 +44,7 @@ from langchain_core.runnables.utils import (
if TYPE_CHECKING:
from langchain_core.runnables.graph import Graph
+ from langchain_core.utils.pydantic import TypeBaseModel
class DynamicRunnable(RunnableSerializable[Input, Output]):
@@ -90,14 +91,12 @@ class DynamicRunnable(RunnableSerializable[Input, Output]):
return self.default.OutputType
@override
- def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
+ def get_input_schema(self, config: RunnableConfig | None = None) -> TypeBaseModel:
runnable, config = self.prepare(config)
return runnable.get_input_schema(config)
@override
- def get_output_schema(
- self, config: RunnableConfig | None = None
- ) -> type[BaseModel]:
+ def get_output_schema(self, config: RunnableConfig | None = None) -> TypeBaseModel:
runnable, config = self.prepare(config)
return runnable.get_output_schema(config)
diff --git a/libs/core/langchain_core/runnables/fallbacks.py b/libs/core/langchain_core/runnables/fallbacks.py
index 16963722b2..7e8235a4d4 100644
--- a/libs/core/langchain_core/runnables/fallbacks.py
+++ b/libs/core/langchain_core/runnables/fallbacks.py
@@ -7,7 +7,7 @@ from collections.abc import AsyncIterator, Iterator, Sequence
from functools import wraps
from typing import TYPE_CHECKING, Any, cast
-from pydantic import BaseModel, ConfigDict
+from pydantic import ConfigDict
from typing_extensions import override
from langchain_core.callbacks.manager import AsyncCallbackManager, CallbackManager
@@ -28,6 +28,7 @@ from langchain_core.runnables.utils import (
coro_with_context,
get_unique_config_specs,
)
+from langchain_core.utils.pydantic import TypeBaseModel
if TYPE_CHECKING:
from langchain_core.callbacks.manager import AsyncCallbackManagerForChainRun
@@ -118,13 +119,11 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
return self.runnable.OutputType
@override
- def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
+ def get_input_schema(self, config: RunnableConfig | None = None) -> TypeBaseModel:
return self.runnable.get_input_schema(config)
@override
- def get_output_schema(
- self, config: RunnableConfig | None = None
- ) -> type[BaseModel]:
+ def get_output_schema(self, config: RunnableConfig | None = None) -> TypeBaseModel:
return self.runnable.get_output_schema(config)
@property
diff --git a/libs/core/langchain_core/runnables/graph.py b/libs/core/langchain_core/runnables/graph.py
index 4b5bfdfb83..6886d7b661 100644
--- a/libs/core/langchain_core/runnables/graph.py
+++ b/libs/core/langchain_core/runnables/graph.py
@@ -18,13 +18,15 @@ from uuid import UUID, uuid4
from langchain_core.load.serializable import to_json_not_implemented
from langchain_core.runnables.base import Runnable, RunnableSerializable
-from langchain_core.utils.pydantic import _IgnoreUnserializable, is_basemodel_subclass
+from langchain_core.utils.pydantic import (
+ TypeBaseModel,
+ _IgnoreUnserializable,
+ is_basemodel_subclass,
+)
if TYPE_CHECKING:
from collections.abc import Callable, Sequence
- from pydantic import BaseModel
-
from langchain_core.runnables.base import Runnable as RunnableType
@@ -97,7 +99,7 @@ class Node(NamedTuple):
"""The unique identifier of the node."""
name: str
"""The name of the node."""
- data: type[BaseModel] | RunnableType[Any, Any] | None
+ data: TypeBaseModel | RunnableType[Any, Any] | None
"""The data of the node."""
metadata: dict[str, Any] | None
"""Optional metadata for the node. """
@@ -177,7 +179,7 @@ class MermaidDrawMethod(Enum):
def node_data_str(
id: str,
- data: type[BaseModel] | RunnableType[Any, Any] | None,
+ data: TypeBaseModel | RunnableType[Any, Any] | None,
) -> str:
"""Convert the data of a node to a string.
@@ -311,7 +313,7 @@ class Graph:
def add_node(
self,
- data: type[BaseModel] | RunnableType[Any, Any] | None,
+ data: TypeBaseModel | RunnableType[Any, Any] | None,
id: str | None = None,
*,
metadata: dict[str, Any] | None = None,
diff --git a/libs/core/langchain_core/runnables/passthrough.py b/libs/core/langchain_core/runnables/passthrough.py
index 0df584d252..f6dc04ab12 100644
--- a/libs/core/langchain_core/runnables/passthrough.py
+++ b/libs/core/langchain_core/runnables/passthrough.py
@@ -11,7 +11,7 @@ from typing import (
Any,
)
-from pydantic import BaseModel, RootModel
+from pydantic import RootModel
from typing_extensions import override
from langchain_core.runnables.base import (
@@ -19,6 +19,7 @@ from langchain_core.runnables.base import (
Runnable,
RunnableParallel,
RunnableSerializable,
+ _get_schema_field_definition,
)
from langchain_core.runnables.config import (
RunnableConfig,
@@ -34,7 +35,7 @@ from langchain_core.runnables.utils import (
)
from langchain_core.utils.aiter import atee
from langchain_core.utils.iter import safetee
-from langchain_core.utils.pydantic import create_model_v2
+from langchain_core.utils.pydantic import TypeBaseModel, create_model_v2, get_fields
if TYPE_CHECKING:
from collections.abc import AsyncIterator, Iterator, Mapping
@@ -425,7 +426,7 @@ class RunnableAssign(RunnableSerializable[dict[str, Any], dict[str, Any]]):
return super().get_name(suffix, name=name)
@override
- def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
+ def get_input_schema(self, config: RunnableConfig | None = None) -> TypeBaseModel:
map_input_schema = self.mapper.get_input_schema(config)
if not issubclass(map_input_schema, RootModel):
# ie. it's a dict
@@ -434,9 +435,11 @@ class RunnableAssign(RunnableSerializable[dict[str, Any], dict[str, Any]]):
return super().get_input_schema(config)
@override
- def get_output_schema(
- self, config: RunnableConfig | None = None
- ) -> type[BaseModel]:
+ def get_output_schema(self, config: RunnableConfig | None = None) -> TypeBaseModel:
+ # The return type stays `TypeBaseModel` (rather than narrowing to
+ # `type[BaseModel]` as `RunnableParallel.get_output_schema` does) because
+ # the fallback branches return the mapper's output schema or delegate to
+ # `super().get_output_schema()`, either of which may be a Pydantic v1 model.
map_input_schema = self.mapper.get_input_schema(config)
map_output_schema = self.mapper.get_output_schema(config)
if not issubclass(map_input_schema, RootModel) and not issubclass(
@@ -444,11 +447,11 @@ class RunnableAssign(RunnableSerializable[dict[str, Any], dict[str, Any]]):
):
fields = {}
- for name, field_info in map_input_schema.model_fields.items():
- fields[name] = (field_info.annotation, field_info.default)
+ for name, field_info in get_fields(map_input_schema).items():
+ fields[name] = _get_schema_field_definition(field_info)
- for name, field_info in map_output_schema.model_fields.items():
- fields[name] = (field_info.annotation, field_info.default)
+ for name, field_info in get_fields(map_output_schema).items():
+ fields[name] = _get_schema_field_definition(field_info)
return create_model_v2("RunnableAssignOutput", field_definitions=fields)
if not issubclass(map_output_schema, RootModel):
diff --git a/libs/core/langchain_core/tools/base.py b/libs/core/langchain_core/tools/base.py
index a04f0abef4..66744e1ffe 100644
--- a/libs/core/langchain_core/tools/base.py
+++ b/libs/core/langchain_core/tools/base.py
@@ -65,6 +65,7 @@ from langchain_core.utils.pydantic import (
is_basemodel_subclass,
is_pydantic_v1_subclass,
is_pydantic_v2_subclass,
+ model_json_schema,
)
if TYPE_CHECKING:
@@ -267,7 +268,7 @@ def create_schema_from_function(
parse_docstring: bool = False,
error_on_invalid_docstring: bool = False,
include_injected: bool = True,
-) -> type[BaseModel]:
+) -> TypeBaseModel:
"""Create a Pydantic schema from a function's signature.
Args:
@@ -572,14 +573,12 @@ class ChildTool(BaseTool):
"""
if isinstance(self.args_schema, dict):
json_schema = self.args_schema
- elif self.args_schema and issubclass(self.args_schema, BaseModelV1):
- json_schema = self.args_schema.schema()
else:
input_schema = self.tool_call_schema
if isinstance(input_schema, dict):
json_schema = input_schema
else:
- json_schema = input_schema.model_json_schema()
+ json_schema = model_json_schema(input_schema)
return cast("dict[str, Any]", json_schema["properties"])
@property
@@ -615,7 +614,7 @@ class ChildTool(BaseTool):
# --- Runnable ---
@override
- def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
+ def get_input_schema(self, config: RunnableConfig | None = None) -> TypeBaseModel:
"""The tool's input schema.
Args:
@@ -693,6 +692,7 @@ class ChildTool(BaseTool):
if input_args is not None:
if isinstance(input_args, dict):
return tool_input
+ result: BaseModel | BaseModelV1
if issubclass(input_args, BaseModel):
# Check args_schema for InjectedToolCallId
for k, v in get_all_basemodel_annotations(input_args).items():
@@ -707,8 +707,9 @@ class ChildTool(BaseTool):
)
raise ValueError(msg)
tool_input[k] = tool_call_id
- result = input_args.model_validate(tool_input)
- result_dict = result.model_dump()
+ result_v2 = input_args.model_validate(tool_input)
+ result_dict = result_v2.model_dump()
+ result = result_v2
elif issubclass(input_args, BaseModelV1):
# Check args_schema for InjectedToolCallId
for k, v in get_all_basemodel_annotations(input_args).items():
@@ -723,8 +724,9 @@ class ChildTool(BaseTool):
)
raise ValueError(msg)
tool_input[k] = tool_call_id
- result = input_args.parse_obj(tool_input)
- result_dict = result.dict()
+ result_v1 = input_args.parse_obj(tool_input)
+ result_dict = result_v1.dict()
+ result = result_v1
else:
msg = (
f"args_schema must be a Pydantic BaseModel, got {self.args_schema}"
diff --git a/libs/core/langchain_core/tools/convert.py b/libs/core/langchain_core/tools/convert.py
index 5781afc473..3a6311cdbb 100644
--- a/libs/core/langchain_core/tools/convert.py
+++ b/libs/core/langchain_core/tools/convert.py
@@ -11,6 +11,7 @@ from langchain_core.runnables import Runnable
from langchain_core.tools.base import ArgsSchema, BaseTool
from langchain_core.tools.simple import Tool
from langchain_core.tools.structured import StructuredTool
+from langchain_core.utils.pydantic import TypeBaseModel
@overload
@@ -275,7 +276,7 @@ def tool(
if isinstance(dec_func, Runnable):
runnable = dec_func
- if runnable.input_schema.model_json_schema().get("type") != "object":
+ if runnable.get_input_jsonschema().get("type") != "object":
msg = "Runnable must have an object schema."
raise ValueError(msg)
@@ -394,7 +395,7 @@ def tool(
def _get_description_from_runnable(runnable: Runnable[Any, Any]) -> str:
"""Generate a placeholder description of a `Runnable`."""
- input_schema = runnable.input_schema.model_json_schema()
+ input_schema = runnable.get_input_jsonschema()
return f"Takes {input_schema}."
@@ -420,7 +421,7 @@ def _get_schema_from_runnable_and_arg_types(
def convert_runnable_to_tool(
runnable: Runnable[Any, Any],
- args_schema: type[BaseModel] | None = None,
+ args_schema: TypeBaseModel | None = None,
*,
name: str | None = None,
description: str | None = None,
@@ -443,7 +444,7 @@ def convert_runnable_to_tool(
description = description or _get_description_from_runnable(runnable)
name = name or runnable.get_name()
- schema = runnable.input_schema.model_json_schema()
+ schema = runnable.get_input_jsonschema()
if schema.get("type") == "string":
return Tool(
name=name,
diff --git a/libs/core/langchain_core/utils/pydantic.py b/libs/core/langchain_core/utils/pydantic.py
index 7fed428145..9d78932263 100644
--- a/libs/core/langchain_core/utils/pydantic.py
+++ b/libs/core/langchain_core/utils/pydantic.py
@@ -69,8 +69,8 @@ PYDANTIC_MINOR_VERSION = PYDANTIC_VERSION.minor
IS_PYDANTIC_V1 = False
IS_PYDANTIC_V2 = True
-PydanticBaseModel = BaseModel
-TypeBaseModel = type[BaseModel]
+PydanticBaseModel = BaseModel | BaseModelV1
+TypeBaseModel = type[BaseModel] | type[BaseModelV1]
TBaseModel = TypeVar("TBaseModel", bound=PydanticBaseModel)
@@ -287,7 +287,7 @@ def _create_subset_model(
*,
descriptions: dict[str, str] | None = None,
fn_description: str | None = None,
-) -> type[BaseModel]:
+) -> TypeBaseModel:
"""Create subset model using the same pydantic version as the input model.
Returns:
@@ -347,6 +347,49 @@ def get_fields(
raise TypeError(msg)
+def model_json_schema(model: TypeBaseModel) -> dict[str, Any]:
+ """Return the JSON schema of a Pydantic model class of either major version.
+
+ Dispatches to the correct method for Pydantic v1 (`schema`) or v2
+ (`model_json_schema`), so callers holding a `TypeBaseModel` don't have to
+ branch on the model's version themselves.
+
+ Args:
+ model: The Pydantic model class.
+
+ Raises:
+ TypeError: If the model is not a Pydantic model class.
+ """
+ if issubclass(model, BaseModel):
+ return model.model_json_schema()
+ if issubclass(model, BaseModelV1):
+ return model.schema()
+ msg = f"Expected a Pydantic model. Got {model}"
+ raise TypeError(msg)
+
+
+def model_validate(model: TypeBaseModel, obj: Any) -> PydanticBaseModel:
+ """Validate `obj` against a Pydantic model class of either major version.
+
+ Dispatches to the correct method for Pydantic v1 (`parse_obj`) or v2
+ (`model_validate`), so callers holding a `TypeBaseModel` don't have to
+ branch on the model's version themselves.
+
+ Args:
+ model: The Pydantic model class to validate against.
+ obj: The object to validate.
+
+ Raises:
+ TypeError: If the model is not a Pydantic model class.
+ """
+ if issubclass(model, BaseModel):
+ return model.model_validate(obj)
+ if issubclass(model, BaseModelV1):
+ return model.parse_obj(obj)
+ msg = f"Expected a Pydantic model. Got {model}"
+ raise TypeError(msg)
+
+
_SchemaConfig = ConfigDict(
arbitrary_types_allowed=True, frozen=True, protected_namespaces=()
)
diff --git a/libs/core/tests/unit_tests/output_parsers/test_pydantic_parser.py b/libs/core/tests/unit_tests/output_parsers/test_pydantic_parser.py
index 2726261aff..0451b26ce4 100644
--- a/libs/core/tests/unit_tests/output_parsers/test_pydantic_parser.py
+++ b/libs/core/tests/unit_tests/output_parsers/test_pydantic_parser.py
@@ -175,7 +175,7 @@ def test_pydantic_output_parser_type_inference() -> None:
# Ignoring mypy error that appears in python 3.8, but not 3.11.
# This seems to be functionally correct, so we'll ignore the error.
pydantic_parser = PydanticOutputParser[SampleModel](pydantic_object=SampleModel)
- schema = pydantic_parser.get_output_schema().model_json_schema()
+ schema = pydantic_parser.get_output_jsonschema()
assert schema == {
"properties": {
diff --git a/libs/core/tests/unit_tests/pydantic_utils.py b/libs/core/tests/unit_tests/pydantic_utils.py
index 1379c53d52..0499d9a321 100644
--- a/libs/core/tests/unit_tests/pydantic_utils.py
+++ b/libs/core/tests/unit_tests/pydantic_utils.py
@@ -1,9 +1,18 @@
+import sys
from inspect import isclass
from typing import Any
+import pytest
from pydantic import BaseModel
from pydantic.v1 import BaseModel as BaseModelV1
+# pydantic.v1 models cannot be exercised under the compatibility shim on
+# Python 3.14+, so v1-specific tests are skipped there.
+skip_if_no_pydantic_v1 = pytest.mark.skipif(
+ sys.version_info >= (3, 14),
+ reason="pydantic.v1 namespace not supported with Python 3.14+",
+)
+
# Function to replace allOf with $ref
def replace_all_of_with_ref(schema: Any) -> None:
diff --git a/libs/core/tests/unit_tests/runnables/test_runnable.py b/libs/core/tests/unit_tests/runnables/test_runnable.py
index f07a3aa3d5..550198f2f0 100644
--- a/libs/core/tests/unit_tests/runnables/test_runnable.py
+++ b/libs/core/tests/unit_tests/runnables/test_runnable.py
@@ -19,7 +19,10 @@ from uuid import UUID
import pytest
from freezegun import freeze_time
from packaging import version
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, ValidationError
+from pydantic.v1 import BaseModel as BaseModelV1
+from pydantic.v1 import Field as FieldV1
+from pydantic.v1 import ValidationError as ValidationErrorV1
from pytest_mock import MockerFixture
from syrupy.assertion import SnapshotAssertion
from typing_extensions import TypedDict, override
@@ -90,9 +93,17 @@ from langchain_core.tracers import (
)
from langchain_core.tracers._compat import pydantic_copy
from langchain_core.tracers.context import collect_runs
-from langchain_core.utils.pydantic import PYDANTIC_VERSION
+from langchain_core.utils.pydantic import (
+ PYDANTIC_VERSION,
+ TypeBaseModel,
+ model_validate,
+)
from langchain_core.version import VERSION
-from tests.unit_tests.pydantic_utils import _normalize_schema, _schema
+from tests.unit_tests.pydantic_utils import (
+ _normalize_schema,
+ _schema,
+ skip_if_no_pydantic_v1,
+)
from tests.unit_tests.stubs import AnyStr, _any_id_ai_message, _any_id_ai_message_chunk
PYDANTIC_VERSION_AT_LEAST_29 = version.parse("2.9") <= PYDANTIC_VERSION
@@ -499,7 +510,7 @@ def test_schemas(snapshot: SnapshotAssertion) -> None:
foo_ = RunnableLambda(foo)
- assert foo_.assign(bar=lambda _: "foo").get_output_schema().model_json_schema() == {
+ assert foo_.assign(bar=lambda _: "foo").get_output_jsonschema() == {
"properties": {"bar": {"title": "Bar"}, "root": {"title": "Root"}},
"required": ["root", "bar"],
"title": "RunnableAssignOutput",
@@ -5820,6 +5831,167 @@ def test_runnable_typed_dict_schema() -> None:
other=other_runnable,
)
assert (
- repr(parallel.input_schema.model_validate({"foo": "Y", "bar": "Z"}))
+ repr(model_validate(parallel.input_schema, {"foo": "Y", "bar": "Z"}))
== "RunnableParallel<foo,other>Input(root={'foo': 'Y', 'bar': 'Z'})"
)
+
+
+class _RunnableWithInputSchema(Runnable[Any, Any]):
+ def __init__(self, input_schema: TypeBaseModel) -> None:
+ self._input_schema = input_schema
+
+ @property
+ @override
+ def InputType(self) -> Any:
+ return self._input_schema
+
+ @override
+ def get_input_schema(self, config: RunnableConfig | None = None) -> TypeBaseModel:
+ _ = config
+ return self._input_schema
+
+ @override
+ def invoke(
+ self,
+ input: Any,
+ config: RunnableConfig | None = None,
+ **kwargs: Any,
+ ) -> Any:
+ return input
+
+
+@skip_if_no_pydantic_v1
+def test_runnable_parallel_preserves_required_v1_input_fields() -> None:
+ class InputModel(BaseModelV1):
+ a: int
+ b: int = 2
+
+ parallel = RunnableParallel(foo=_RunnableWithInputSchema(InputModel))
+
+ schema = cast("type[BaseModel]", parallel.input_schema)
+ assert schema.model_json_schema()["required"] == ["a"]
+ with pytest.raises(ValidationError):
+ schema.model_validate({})
+
+ model = schema.model_validate({"a": 1})
+ assert model.model_dump() == {"a": 1, "b": 2}
+
+
+@skip_if_no_pydantic_v1
+def test_runnable_parallel_uses_base_schema_for_v1_root_model() -> None:
+ class InputModel(BaseModelV1):
+ __root__: dict[str, int]
+
+ parallel = RunnableParallel(foo=_RunnableWithInputSchema(InputModel))
+
+ schema = parallel.input_schema
+ assert schema is InputModel
+ assert schema.schema() == {
+ "additionalProperties": {"type": "integer"},
+ "title": "InputModel",
+ "type": "object",
+ }
+ assert schema.parse_obj({"a": 1}).__root__ == {"a": 1}
+ with pytest.raises(ValidationErrorV1):
+ schema.parse_obj({"a": "not an int"})
+
+
+@skip_if_no_pydantic_v1
+def test_runnable_sequence_v1_input_schema() -> None:
+ """A `RunnableSequence` exposes a Pydantic v1 first-step input schema.
+
+ Regression test: deriving the sequence schema previously assumed Pydantic v2.
+ """
+
+ class InputModel(BaseModelV1):
+ a: int
+
+ sequence = _RunnableWithInputSchema(InputModel) | RunnableLambda(lambda x: x)
+
+ assert sequence.get_input_jsonschema()["properties"] == {
+ "a": {"title": "A", "type": "integer"}
+ }
+
+
+@skip_if_no_pydantic_v1
+def test_runnable_branch_v1_input_schema() -> None:
+ """A `RunnableBranch` exposes a Pydantic v1 input schema.
+
+ Regression test: `get_input_schema` previously assumed Pydantic v2 when
+ inspecting each branch's schema.
+ """
+
+ class InputModel(BaseModelV1):
+ a: int
+
+ branch = RunnableBranch(
+ (lambda _: True, _RunnableWithInputSchema(InputModel)),
+ _RunnableWithInputSchema(InputModel),
+ )
+
+ assert branch.get_input_jsonschema()["properties"] == {
+ "a": {"title": "A", "type": "integer"}
+ }
+
+
+@skip_if_no_pydantic_v1
+def test_runnable_parallel_preserves_v1_default_factory() -> None:
+ """A v1 `default_factory` field keeps its factory in the derived schema.
+
+ Regression test for `_get_schema_field_definition`: without the dedicated
+ `default_factory` branch the factory is dropped and the field defaults to
+ `None` instead of producing the factory's value.
+ """
+
+ class InputModel(BaseModelV1):
+ a: int
+ items: list[int] = FieldV1(default_factory=list)
+
+ parallel = RunnableParallel(foo=_RunnableWithInputSchema(InputModel))
+
+ schema = cast("type[BaseModel]", parallel.input_schema)
+ # The factory field is optional, so only `a` is required.
+ assert schema.model_json_schema()["required"] == ["a"]
+
+ # The factory runs when omitted, yielding `[]` rather than `None`.
+ assert schema.model_validate({"a": 1}).model_dump() == {"a": 1, "items": []}
+
+
+@skip_if_no_pydantic_v1
+def test_runnable_sequence_v1_output_schema_with_assign() -> None:
+ """A sequence ending in `RunnableAssign` derives a v1 upstream output schema.
+
+ Regression test: `_seq_output_schema` previously read `.model_fields` on the
+ upstream schema (v2-only) and translated required v1 fields as optional.
+ """
+
+ class InputModel(BaseModelV1):
+ a: int
+
+ sequence = _RunnableWithInputSchema(InputModel) | RunnableAssign(
+ RunnableParallel(bar=RunnableLambda(lambda _: "bar"))
+ )
+
+ schema = sequence.get_output_jsonschema()
+ assert set(schema["properties"]) == {"a", "bar"}
+ # The required v1 field survives as required rather than becoming optional.
+ assert "a" in schema["required"]
+
+
+@skip_if_no_pydantic_v1
+def test_runnable_sequence_v1_output_schema_with_pick() -> None:
+ """A sequence ending in `RunnablePick` derives a v1 upstream output schema.
+
+ Regression test: `_seq_output_schema` previously read `.model_fields` on the
+ upstream schema (v2-only) for the `RunnablePick` branch.
+ """
+
+ class InputModel(BaseModelV1):
+ a: int
+ b: int
+
+ sequence = _RunnableWithInputSchema(InputModel) | RunnablePick(["a"])
+
+ schema = sequence.get_output_jsonschema()
+ assert set(schema["properties"]) == {"a"}
+ assert "a" in schema["required"]
diff --git a/libs/core/tests/unit_tests/test_tools.py b/libs/core/tests/unit_tests/test_tools.py
index 43c23a109b..76c72d2770 100644
--- a/libs/core/tests/unit_tests/test_tools.py
+++ b/libs/core/tests/unit_tests/test_tools.py
@@ -40,6 +40,7 @@ from langchain_core.messages import ToolCall, ToolMessage
from langchain_core.messages.tool import ToolOutputMixin
from langchain_core.retrievers import BaseRetriever
from langchain_core.runnables import (
+ Runnable,
RunnableConfig,
RunnableLambda,
ensure_config,
@@ -49,6 +50,7 @@ from langchain_core.tools import (
StructuredTool,
Tool,
ToolException,
+ convert_runnable_to_tool,
tool,
)
from langchain_core.tools.base import (
@@ -68,11 +70,16 @@ from langchain_core.utils.function_calling import (
convert_to_openai_tool,
)
from langchain_core.utils.pydantic import (
+ TypeBaseModel,
_create_subset_model,
create_model_v2,
)
from tests.unit_tests.fake.callbacks import FakeCallbackHandler
-from tests.unit_tests.pydantic_utils import _normalize_schema, _schema
+from tests.unit_tests.pydantic_utils import (
+ _normalize_schema,
+ _schema,
+ skip_if_no_pydantic_v1,
+)
try:
from langgraph.prebuilt import ToolRuntime # type: ignore[import-not-found]
@@ -1964,7 +1971,7 @@ def test_tool_inherited_injected_arg() -> None:
return y
tool_ = InheritedInjectedArgTool()
- assert tool_.get_input_schema().model_json_schema() == {
+ assert tool_.get_input_jsonschema() == {
"title": "FooSchema", # Matches the title from the provided schema
"description": "foo.",
"type": "object",
@@ -2138,7 +2145,7 @@ def test_args_schema_explicitly_typed() -> None:
tool = SomeTool(name="some_tool", description="some description")
- assert tool.get_input_schema().model_json_schema() == {
+ assert tool.get_input_jsonschema() == {
"properties": {
"a": {"title": "A", "type": "integer"},
"b": {"title": "B", "type": "string"},
@@ -2160,6 +2167,92 @@ def test_args_schema_explicitly_typed() -> None:
}
+@skip_if_no_pydantic_v1
+def test_get_input_jsonschema_v1_args_schema() -> None:
+ """`get_input_jsonschema()` works for a tool with a Pydantic v1 `args_schema`.
+
+ Regression test: previously this raised `AttributeError` because a Pydantic
+ v1 model does not implement `model_json_schema`.
+ """
+
+ class FooV1(BaseModelV1):
+ a: int
+ b: str
+
+ class SomeTool(BaseTool):
+ args_schema: type[BaseModelV1] = FooV1
+
+ @override
+ def _run(self, *args: Any, **kwargs: Any) -> str:
+ return "foo"
+
+ tool = SomeTool(name="some_tool", description="some description", args_schema=FooV1)
+
+ assert tool.get_input_jsonschema()["properties"] == {
+ "a": {"title": "A", "type": "integer"},
+ "b": {"title": "B", "type": "string"},
+ }
+
+
+@skip_if_no_pydantic_v1
+def test_v1_args_schema_excludes_injected_args() -> None:
+ """A Pydantic v1 `args_schema` must not expose injected args via `.args`.
+
+ Injected arguments are supplied by the framework rather than the model, so
+ they must be hidden from the tool-call schema regardless of the `args_schema`
+ Pydantic version. Previously a v1 `args_schema` bypassed `tool_call_schema`
+ and leaked injected arguments into `.args`.
+ """
+
+ class FooV1(BaseModelV1):
+ a: int
+ injected: Annotated[str, InjectedToolArg()] = "default"
+
+ class SomeTool(BaseTool):
+ args_schema: type[BaseModelV1] = FooV1
+
+ @override
+ def _run(self, *args: Any, **kwargs: Any) -> str:
+ return "foo"
+
+ tool = SomeTool(name="some_tool", description="some description", args_schema=FooV1)
+
+ assert set(tool.args) == {"a"}
+ assert "injected" not in tool.args
+
+
+@skip_if_no_pydantic_v1
+def test_convert_runnable_to_tool_v1_input_schema() -> None:
+ """`convert_runnable_to_tool` works for a runnable with a v1 input schema.
+
+ Regression test: deriving the tool schema from the runnable previously
+ assumed a Pydantic v2 input schema and raised on v1.
+ """
+
+ class FooV1(BaseModelV1):
+ a: int
+
+ class V1InputRunnable(Runnable[Any, Any]):
+ @override
+ def get_input_schema(
+ self, config: RunnableConfig | None = None
+ ) -> TypeBaseModel:
+ return FooV1
+
+ @override
+ def invoke(
+ self,
+ input: Any,
+ config: RunnableConfig | None = None,
+ **kwargs: Any,
+ ) -> Any:
+ return input
+
+ tool = convert_runnable_to_tool(V1InputRunnable())
+
+ assert set(tool.args) == {"a"}
+
+
@pytest.mark.parametrize("pydantic_model", TEST_MODELS)
def test_structured_tool_with_different_pydantic_versions(pydantic_model: Any) -> None:
"""This should test that one can type the args schema as a Pydantic model."""
@@ -2784,7 +2877,7 @@ def test_structured_tool_args_schema_dict(caplog: pytest.LogCaptureFixture) -> N
assert _get_tool_call_json_schema(tool) == args_schema
# test that the input schema is the same as the parent (Runnable) input schema
assert (
- tool.get_input_schema().model_json_schema()
+ tool.get_input_jsonschema()
== create_model_v2(
tool.get_name("Input"),
root=tool.InputType,
@@ -2822,7 +2915,7 @@ def test_simple_tool_args_schema_dict() -> None:
assert _get_tool_call_json_schema(tool) == args_schema
# test that the input schema is the same as the parent (Runnable) input schema
assert (
- tool.get_input_schema().model_json_schema()
+ tool.get_input_jsonschema()
== create_model_v2(
tool.get_name("Input"),
root=tool.InputType,
diff --git a/libs/core/tests/unit_tests/utils/test_pydantic.py b/libs/core/tests/unit_tests/utils/test_pydantic.py
index a329e19d19..3830c26923 100644
--- a/libs/core/tests/unit_tests/utils/test_pydantic.py
+++ b/libs/core/tests/unit_tests/utils/test_pydantic.py
@@ -14,6 +14,8 @@ from langchain_core.utils.pydantic import (
get_fields,
is_basemodel_instance,
is_basemodel_subclass,
+ model_json_schema,
+ model_validate,
pre_init,
)
@@ -153,6 +155,56 @@ def test_fields_pydantic_v1_from_2() -> None:
assert fields == {"x": Foo.__fields__["x"]}
+def test_model_json_schema_v2() -> None:
+ class Foo(BaseModel):
+ x: int
+
+ assert model_json_schema(Foo) == Foo.model_json_schema()
+
+
+ sys.version_info >= (3, 14),
+ reason="pydantic.v1 namespace not supported with Python 3.14+",
+)
+def test_model_json_schema_v1() -> None:
+ class Foo(BaseModelV1):
+ x: int
+
+ assert model_json_schema(Foo) == Foo.schema()
+
+
+def test_model_json_schema_non_model() -> None:
+ with pytest.raises(TypeError, match="Expected a Pydantic model"):
+ model_json_schema(dict) # type: ignore[arg-type]
+
+
+def test_model_validate_v2() -> None:
+ class Foo(BaseModel):
+ x: int
+
+ result = model_validate(Foo, {"x": 1})
+ assert isinstance(result, Foo)
+ assert result.x == 1
+
+
+ sys.version_info >= (3, 14),
+ reason="pydantic.v1 namespace not supported with Python 3.14+",
+)
+def test_model_validate_v1() -> None:
+ class Foo(BaseModelV1):
+ x: int
+
+ result = model_validate(Foo, {"x": 1})
+ assert isinstance(result, Foo)
+ assert result.x == 1
+
+
+def test_model_validate_non_model() -> None:
+ with pytest.raises(TypeError, match="Expected a Pydantic model"):
+ model_validate(dict, {"x": 1}) # type: ignore[arg-type]
+
+
def test_create_model_v2() -> None:
"""Test that create model v2 works as expected."""
with warnings.catch_warnings(record=True) as record:
diff --git a/libs/langchain/langchain_classic/chains/hyde/base.py b/libs/langchain/langchain_classic/chains/hyde/base.py
index 7ee9780b4a..e4b4a43ef7 100644
--- a/libs/langchain/langchain_classic/chains/hyde/base.py
+++ b/libs/langchain/langchain_classic/chains/hyde/base.py
@@ -40,7 +40,7 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
@property
def input_keys(self) -> list[str]:
"""Input keys for Hyde's LLM chain."""
- return self.llm_chain.input_schema.model_json_schema()["required"]
+ return self.llm_chain.get_input_jsonschema()["required"]
@property
def output_keys(self) -> list[str]: