langchain-core 1.0.0a6__py3-none-any.whl → 1.0.0a7__py3-none-any.whl

langchain_core/messages/system.py

@@ -1,6 +1,6 @@
 """System message."""
 
-from typing import Any, Literal, Optional, Union, cast, overload
+from typing import Any, Literal, cast, overload
 
 from langchain_core.messages import content as types
 from langchain_core.messages.base import BaseMessage, BaseMessageChunk
@@ -38,28 +38,28 @@ class SystemMessage(BaseMessage):
     @overload
     def __init__(
         self,
-        content: Union[str, list[Union[str, dict]]],
+        content: str | list[str | dict],
         **kwargs: Any,
     ) -> None: ...
 
     @overload
     def __init__(
         self,
-        content: Optional[Union[str, list[Union[str, dict]]]] = None,
-        content_blocks: Optional[list[types.ContentBlock]] = None,
+        content: str | list[str | dict] | None = None,
+        content_blocks: list[types.ContentBlock] | None = None,
         **kwargs: Any,
     ) -> None: ...
 
     def __init__(
         self,
-        content: Optional[Union[str, list[Union[str, dict]]]] = None,
-        content_blocks: Optional[list[types.ContentBlock]] = None,
+        content: str | list[str | dict] | None = None,
+        content_blocks: list[types.ContentBlock] | None = None,
         **kwargs: Any,
     ) -> None:
         """Specify ``content`` as positional arg or ``content_blocks`` for typing."""
         if content_blocks is not None:
             super().__init__(
-                content=cast("Union[str, list[Union[str, dict]]]", content_blocks),
+                content=cast("str | list[str | dict]", content_blocks),
                 **kwargs,
             )
         else:

langchain_core/messages/tool.py

@@ -1,7 +1,7 @@
 """Messages for tools."""
 
 import json
-from typing import Any, Literal, Optional, Union, cast, overload
+from typing import Any, Literal, cast, overload
 from uuid import UUID
 
 from pydantic import Field, model_validator
@@ -41,7 +41,7 @@ class ToolMessage(BaseMessage, ToolOutputMixin):
     Example: A ``ToolMessage`` where only part of the tool output is sent to the model
         and the full output is passed in to artifact.
 
-        .. versionadded:: 0.2.17
+        !!! version-added "Added in version 0.2.17"
 
         .. code-block:: python
 
@@ -83,14 +83,14 @@ class ToolMessage(BaseMessage, ToolOutputMixin):
     a subset of the full tool output is being passed as message content but the full
     output is needed in other parts of the code.
 
-    .. versionadded:: 0.2.17
+    !!! version-added "Added in version 0.2.17"
 
     """
 
     status: Literal["success", "error"] = "success"
     """Status of the tool invocation.
 
-    .. versionadded:: 0.2.24
+    !!! version-added "Added in version 0.2.24"
 
     """
 
@@ -147,22 +147,22 @@ class ToolMessage(BaseMessage, ToolOutputMixin):
     @overload
     def __init__(
         self,
-        content: Union[str, list[Union[str, dict]]],
+        content: str | list[str | dict],
         **kwargs: Any,
     ) -> None: ...
 
     @overload
     def __init__(
         self,
-        content: Optional[Union[str, list[Union[str, dict]]]] = None,
-        content_blocks: Optional[list[types.ContentBlock]] = None,
+        content: str | list[str | dict] | None = None,
+        content_blocks: list[types.ContentBlock] | None = None,
         **kwargs: Any,
     ) -> None: ...
 
     def __init__(
         self,
-        content: Optional[Union[str, list[Union[str, dict]]]] = None,
-        content_blocks: Optional[list[types.ContentBlock]] = None,
+        content: str | list[str | dict] | None = None,
+        content_blocks: list[types.ContentBlock] | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize ``ToolMessage``.
@@ -176,7 +176,7 @@ class ToolMessage(BaseMessage, ToolOutputMixin):
         """
         if content_blocks is not None:
             super().__init__(
-                content=cast("Union[str, list[Union[str, dict]]]", content_blocks),
+                content=cast("str | list[str | dict]", content_blocks),
                 **kwargs,
             )
         else:
@@ -233,7 +233,7 @@ class ToolCall(TypedDict):
     """The name of the tool to be called."""
     args: dict[str, Any]
     """The arguments to the tool call."""
-    id: Optional[str]
+    id: str | None
     """An identifier associated with the tool call.
 
     An identifier is needed to associate a tool call request with a tool
@@ -247,7 +247,7 @@ def tool_call(
     *,
     name: str,
     args: dict[str, Any],
-    id: Optional[str],
+    id: str | None,
 ) -> ToolCall:
     """Create a tool call.
 
@@ -283,23 +283,23 @@ class ToolCallChunk(TypedDict):
 
     """
 
-    name: Optional[str]
+    name: str | None
     """The name of the tool to be called."""
-    args: Optional[str]
+    args: str | None
     """The arguments to the tool call."""
-    id: Optional[str]
+    id: str | None
     """An identifier associated with the tool call."""
-    index: Optional[int]
+    index: int | None
     """The index of the tool call in a sequence."""
     type: NotRequired[Literal["tool_call_chunk"]]
 
 
 def tool_call_chunk(
     *,
-    name: Optional[str] = None,
-    args: Optional[str] = None,
-    id: Optional[str] = None,
-    index: Optional[int] = None,
+    name: str | None = None,
+    args: str | None = None,
+    id: str | None = None,
+    index: int | None = None,
 ) -> ToolCallChunk:
     """Create a tool call chunk.
 
@@ -319,10 +319,10 @@ def tool_call_chunk(
 
 def invalid_tool_call(
     *,
-    name: Optional[str] = None,
-    args: Optional[str] = None,
-    id: Optional[str] = None,
-    error: Optional[str] = None,
+    name: str | None = None,
+    args: str | None = None,
+    id: str | None = None,
+    error: str | None = None,
 ) -> InvalidToolCall:
     """Create an invalid tool call.
 

langchain_core/messages/utils.py

@@ -15,16 +15,13 @@ import inspect
 import json
 import logging
 import math
-from collections.abc import Iterable, Sequence
+from collections.abc import Callable, Iterable, Sequence
 from functools import partial
 from typing import (
     TYPE_CHECKING,
     Annotated,
     Any,
-    Callable,
     Literal,
-    Optional,
-    Union,
     cast,
     overload,
 )
@@ -76,20 +73,18 @@ def _get_type(v: Any) -> str:
 
 
 AnyMessage = Annotated[
-    Union[
-        Annotated[AIMessage, Tag(tag="ai")],
-        Annotated[HumanMessage, Tag(tag="human")],
-        Annotated[ChatMessage, Tag(tag="chat")],
-        Annotated[SystemMessage, Tag(tag="system")],
-        Annotated[FunctionMessage, Tag(tag="function")],
-        Annotated[ToolMessage, Tag(tag="tool")],
-        Annotated[AIMessageChunk, Tag(tag="AIMessageChunk")],
-        Annotated[HumanMessageChunk, Tag(tag="HumanMessageChunk")],
-        Annotated[ChatMessageChunk, Tag(tag="ChatMessageChunk")],
-        Annotated[SystemMessageChunk, Tag(tag="SystemMessageChunk")],
-        Annotated[FunctionMessageChunk, Tag(tag="FunctionMessageChunk")],
-        Annotated[ToolMessageChunk, Tag(tag="ToolMessageChunk")],
-    ],
+    Annotated[AIMessage, Tag(tag="ai")]
+    | Annotated[HumanMessage, Tag(tag="human")]
+    | Annotated[ChatMessage, Tag(tag="chat")]
+    | Annotated[SystemMessage, Tag(tag="system")]
+    | Annotated[FunctionMessage, Tag(tag="function")]
+    | Annotated[ToolMessage, Tag(tag="tool")]
+    | Annotated[AIMessageChunk, Tag(tag="AIMessageChunk")]
+    | Annotated[HumanMessageChunk, Tag(tag="HumanMessageChunk")]
+    | Annotated[ChatMessageChunk, Tag(tag="ChatMessageChunk")]
+    | Annotated[SystemMessageChunk, Tag(tag="SystemMessageChunk")]
+    | Annotated[FunctionMessageChunk, Tag(tag="FunctionMessageChunk")]
+    | Annotated[ToolMessageChunk, Tag(tag="ToolMessageChunk")],
     Field(discriminator=Discriminator(_get_type)),
 ]
 
@@ -215,18 +210,18 @@ def message_chunk_to_message(chunk: BaseMessage) -> BaseMessage:
     )
 
 
-MessageLikeRepresentation = Union[
-    BaseMessage, list[str], tuple[str, str], str, dict[str, Any]
-]
+MessageLikeRepresentation = (
+    BaseMessage | list[str] | tuple[str, str] | str | dict[str, Any]
+)
 
 
 def _create_message_from_message_type(
     message_type: str,
     content: str,
-    name: Optional[str] = None,
-    tool_call_id: Optional[str] = None,
-    tool_calls: Optional[list[dict[str, Any]]] = None,
-    id: Optional[str] = None,
+    name: str | None = None,
+    tool_call_id: str | None = None,
+    tool_calls: list[dict[str, Any]] | None = None,
+    id: str | None = None,
     **additional_kwargs: Any,
 ) -> BaseMessage:
     """Create a message from a ``Message`` type and content string.
@@ -368,7 +363,7 @@ def _convert_to_message(message: MessageLikeRepresentation) -> BaseMessage:
 
 
 def convert_to_messages(
-    messages: Union[Iterable[MessageLikeRepresentation], PromptValue],
+    messages: Iterable[MessageLikeRepresentation] | PromptValue,
 ) -> list[BaseMessage]:
     """Convert a sequence of messages to a list of messages.
 
@@ -399,12 +394,12 @@ def _runnable_support(func: Callable) -> Callable:
     ) -> list[BaseMessage]: ...
 
     def wrapped(
-        messages: Union[Sequence[MessageLikeRepresentation], None] = None,
+        messages: Sequence[MessageLikeRepresentation] | None = None,
         **kwargs: Any,
-    ) -> Union[
-        list[BaseMessage],
-        Runnable[Sequence[MessageLikeRepresentation], list[BaseMessage]],
-    ]:
+    ) -> (
+        list[BaseMessage]
+        | Runnable[Sequence[MessageLikeRepresentation], list[BaseMessage]]
+    ):
         # Import locally to prevent circular import.
         from langchain_core.runnables.base import RunnableLambda  # noqa: PLC0415
 
@@ -418,15 +413,15 @@ def _runnable_support(func: Callable) -> Callable:
 
 @_runnable_support
 def filter_messages(
-    messages: Union[Iterable[MessageLikeRepresentation], PromptValue],
+    messages: Iterable[MessageLikeRepresentation] | PromptValue,
     *,
-    include_names: Optional[Sequence[str]] = None,
-    exclude_names: Optional[Sequence[str]] = None,
-    include_types: Optional[Sequence[Union[str, type[BaseMessage]]]] = None,
-    exclude_types: Optional[Sequence[Union[str, type[BaseMessage]]]] = None,
-    include_ids: Optional[Sequence[str]] = None,
-    exclude_ids: Optional[Sequence[str]] = None,
-    exclude_tool_calls: Optional[Sequence[str] | bool] = None,
+    include_names: Sequence[str] | None = None,
+    exclude_names: Sequence[str] | None = None,
+    include_types: Sequence[str | type[BaseMessage]] | None = None,
+    exclude_types: Sequence[str | type[BaseMessage]] | None = None,
+    include_ids: Sequence[str] | None = None,
+    exclude_ids: Sequence[str] | None = None,
+    exclude_tool_calls: Sequence[str] | bool | None = None,
 ) -> list[BaseMessage]:
     """Filter messages based on ``name``, ``type`` or ``id``.
 
@@ -461,7 +456,7 @@ def filter_messages(
         anything that is not explicitly excluded will be included.
 
     Raises:
-        ValueError if two incompatible arguments are provided.
+        ValueError: If two incompatible arguments are provided.
 
     Example:
         .. code-block:: python
@@ -563,20 +558,20 @@ def filter_messages(
 
 @_runnable_support
 def merge_message_runs(
-    messages: Union[Iterable[MessageLikeRepresentation], PromptValue],
+    messages: Iterable[MessageLikeRepresentation] | PromptValue,
     *,
     chunk_separator: str = "\n",
 ) -> list[BaseMessage]:
     r"""Merge consecutive Messages of the same type.
 
-    .. note::
+    !!! note
         ToolMessages are not merged, as each has a distinct tool call id that can't be
         merged.
 
     Args:
         messages: Sequence Message-like objects to merge.
         chunk_separator: Specify the string to be inserted between message chunks.
-        Default is ``'\n'``.
+            Defaults to ``'\n'``.
 
     Returns:
         list of BaseMessages with consecutive runs of message types merged into single
@@ -696,24 +691,18 @@ def merge_message_runs(
 # init not at runtime.
 @_runnable_support
 def trim_messages(
-    messages: Union[Iterable[MessageLikeRepresentation], PromptValue],
+    messages: Iterable[MessageLikeRepresentation] | PromptValue,
     *,
     max_tokens: int,
-    token_counter: Union[
-        Callable[[list[BaseMessage]], int],
-        Callable[[BaseMessage], int],
-        BaseLanguageModel,
-    ],
+    token_counter: Callable[[list[BaseMessage]], int]
+    | Callable[[BaseMessage], int]
+    | BaseLanguageModel,
     strategy: Literal["first", "last"] = "last",
     allow_partial: bool = False,
-    end_on: Optional[
-        Union[str, type[BaseMessage], Sequence[Union[str, type[BaseMessage]]]]
-    ] = None,
-    start_on: Optional[
-        Union[str, type[BaseMessage], Sequence[Union[str, type[BaseMessage]]]]
-    ] = None,
+    end_on: str | type[BaseMessage] | Sequence[str | type[BaseMessage]] | None = None,
+    start_on: str | type[BaseMessage] | Sequence[str | type[BaseMessage]] | None = None,
     include_system: bool = False,
-    text_splitter: Optional[Union[Callable[[str], list[str]], TextSplitter]] = None,
+    text_splitter: Callable[[str], list[str]] | TextSplitter | None = None,
 ) -> list[BaseMessage]:
     r"""Trim messages to be below a token count.
 
@@ -739,7 +728,7 @@ def trim_messages(
        the first message in the history if present. To achieve this set the
        ``include_system=True``.
 
-    .. note::
+    !!! note
         The examples below show how to configure ``trim_messages`` to achieve a behavior
         consistent with the above properties.
 
@@ -751,7 +740,7 @@ def trim_messages(
             ``BaseLanguageModel.get_num_tokens_from_messages()`` will be used.
             Set to ``len`` to count the number of **messages** in the chat history.
 
-            .. note::
+            !!! note
                 Use ``count_tokens_approximately`` to get fast, approximate token
                 counts.
                 This is recommended for using ``trim_messages`` on the hot path, where
@@ -1042,10 +1031,11 @@ def trim_messages(
 
 
 def convert_to_openai_messages(
-    messages: Union[MessageLikeRepresentation, Sequence[MessageLikeRepresentation]],
+    messages: MessageLikeRepresentation | Sequence[MessageLikeRepresentation],
     *,
     text_format: Literal["string", "block"] = "string",
-) -> Union[dict, list[dict]]:
+    include_id: bool = False,
+) -> dict | list[dict]:
     """Convert LangChain messages into OpenAI message dicts.
 
     Args:
@@ -1062,6 +1052,8 @@ def convert_to_openai_messages(
                     If a message has a string content, this is turned into a list
                     with a single content block of type ``'text'``. If a message has
                     content blocks these are left as is.
+        include_id: Whether to include message ids in the openai messages, if they
+                    are present in the source messages.
 
     Raises:
         ValueError: if an unrecognized ``text_format`` is specified, or if a message
@@ -1071,11 +1063,11 @@ def convert_to_openai_messages(
         The return type depends on the input type:
 
         - dict:
-          If a single message-like object is passed in, a single OpenAI message
-          dict is returned.
+            If a single message-like object is passed in, a single OpenAI message
+            dict is returned.
         - list[dict]:
-          If a sequence of message-like objects are passed in, a list of OpenAI
-          message dicts is returned.
+            If a sequence of message-like objects are passed in, a list of OpenAI
+            message dicts is returned.
 
     Example:
 
@@ -1123,7 +1115,7 @@ def convert_to_openai_messages(
             #   {'role': 'assistant', 'content': 'thats nice'}
             # ]
 
-    .. versionadded:: 0.3.11
+    !!! version-added "Added in version 0.3.11"
 
     """  # noqa: E501
     if text_format not in {"string", "block"}:
@@ -1140,7 +1132,7 @@ def convert_to_openai_messages(
     for i, message in enumerate(messages):
         oai_msg: dict = {"role": _get_message_openai_role(message)}
         tool_messages: list = []
-        content: Union[str, list[dict]]
+        content: str | list[dict]
 
         if message.name:
             oai_msg["name"] = message.name
@@ -1150,6 +1142,8 @@ def convert_to_openai_messages(
             oai_msg["refusal"] = message.additional_kwargs["refusal"]
         if isinstance(message, ToolMessage):
             oai_msg["tool_call_id"] = message.tool_call_id
+        if include_id and message.id:
+            oai_msg["id"] = message.id
 
         if not message.content:
             content = "" if text_format == "string" else []
@@ -1421,10 +1415,8 @@ def _first_max_tokens(
     max_tokens: int,
     token_counter: Callable[[list[BaseMessage]], int],
     text_splitter: Callable[[str], list[str]],
-    partial_strategy: Optional[Literal["first", "last"]] = None,
-    end_on: Optional[
-        Union[str, type[BaseMessage], Sequence[Union[str, type[BaseMessage]]]]
-    ] = None,
+    partial_strategy: Literal["first", "last"] | None = None,
+    end_on: str | type[BaseMessage] | Sequence[str | type[BaseMessage]] | None = None,
 ) -> list[BaseMessage]:
     messages = list(messages)
     if not messages:
@@ -1541,12 +1533,8 @@ def _last_max_tokens(
     text_splitter: Callable[[str], list[str]],
     allow_partial: bool = False,
     include_system: bool = False,
-    start_on: Optional[
-        Union[str, type[BaseMessage], Sequence[Union[str, type[BaseMessage]]]]
-    ] = None,
-    end_on: Optional[
-        Union[str, type[BaseMessage], Sequence[Union[str, type[BaseMessage]]]]
-    ] = None,
+    start_on: str | type[BaseMessage] | Sequence[str | type[BaseMessage]] | None = None,
+    end_on: str | type[BaseMessage] | Sequence[str | type[BaseMessage]] | None = None,
 ) -> list[BaseMessage]:
     messages = list(messages)
     if len(messages) == 0:
@@ -1647,7 +1635,7 @@ def _default_text_splitter(text: str) -> list[str]:
 
 def _is_message_type(
     message: BaseMessage,
-    type_: Union[str, type[BaseMessage], Sequence[Union[str, type[BaseMessage]]]],
+    type_: str | type[BaseMessage] | Sequence[str | type[BaseMessage]],
 ) -> bool:
     types = [type_] if isinstance(type_, (str, type)) else type_
     types_str = [t for t in types if isinstance(t, str)]
@@ -1720,14 +1708,14 @@ def count_tokens_approximately(
     Returns:
         Approximate number of tokens in the messages.
 
-    .. note::
+    !!! note
         This is a simple approximation that may not match the exact token count used by
         specific models. For accurate counts, use model-specific tokenizers.
 
     Warning:
         This function does not currently support counting image tokens.
 
-    .. versionadded:: 0.3.46
+    !!! version-added "Added in version 0.3.46"
 
     """
     token_count = 0.0

langchain_core/output_parsers/base.py

@@ -8,9 +8,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Generic,
-    Optional,
     TypeVar,
-    Union,
 )
 
 from typing_extensions import override
@@ -71,7 +69,7 @@ class BaseGenerationOutputParser(
     @override
     def InputType(self) -> Any:
         """Return the input type for the parser."""
-        return Union[str, AnyMessage]
+        return str | AnyMessage
 
     @property
     @override
@@ -84,8 +82,8 @@ class BaseGenerationOutputParser(
     @override
     def invoke(
         self,
-        input: Union[str, BaseMessage],
-        config: Optional[RunnableConfig] = None,
+        input: str | BaseMessage,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> T:
         if isinstance(input, BaseMessage):
@@ -107,9 +105,9 @@ class BaseGenerationOutputParser(
     @override
     async def ainvoke(
         self,
-        input: Union[str, BaseMessage],
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        input: str | BaseMessage,
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> T:
         if isinstance(input, BaseMessage):
             return await self._acall_with_config(
@@ -165,7 +163,7 @@ class BaseOutputParser(
     @override
     def InputType(self) -> Any:
         """Return the input type for the parser."""
-        return Union[str, AnyMessage]
+        return str | AnyMessage
 
     @property
     @override
@@ -192,8 +190,8 @@ class BaseOutputParser(
     @override
     def invoke(
         self,
-        input: Union[str, BaseMessage],
-        config: Optional[RunnableConfig] = None,
+        input: str | BaseMessage,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> T:
         if isinstance(input, BaseMessage):
@@ -215,9 +213,9 @@ class BaseOutputParser(
     @override
     async def ainvoke(
         self,
-        input: Union[str, BaseMessage],
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        input: str | BaseMessage,
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> T:
         if isinstance(input, BaseMessage):
             return await self._acall_with_config(

langchain_core/output_parsers/json.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import json
 from json import JSONDecodeError
-from typing import Annotated, Any, Optional, TypeVar, Union
+from typing import Annotated, Any, TypeVar
 
 import jsonpatch  # type: ignore[import-untyped]
 import pydantic
@@ -23,7 +23,7 @@ from langchain_core.utils.json import (
 )
 
 # Union type needs to be last assignment to PydanticBaseModel to make mypy happy.
-PydanticBaseModel = Union[BaseModel, pydantic.BaseModel]
+PydanticBaseModel = BaseModel | pydantic.BaseModel
 
 TBaseModel = TypeVar("TBaseModel", bound=PydanticBaseModel)
 
@@ -38,12 +38,12 @@ class JsonOutputParser(BaseCumulativeTransformOutputParser[Any]):
     describing the difference between the previous and the current object.
     """
 
-    pydantic_object: Annotated[Optional[type[TBaseModel]], SkipValidation()] = None  # type: ignore[valid-type]
+    pydantic_object: Annotated[type[TBaseModel] | None, SkipValidation()] = None  # type: ignore[valid-type]
     """The Pydantic object to use for validation.
     If None, no validation is performed."""
 
     @override
-    def _diff(self, prev: Optional[Any], next: Any) -> Any:
+    def _diff(self, prev: Any | None, next: Any) -> Any:
         return jsonpatch.make_patch(prev, next).patch
 
     @staticmethod

langchain_core/output_parsers/list.py

@@ -7,7 +7,7 @@ import re
 from abc import abstractmethod
 from collections import deque
 from io import StringIO
-from typing import TYPE_CHECKING, TypeVar, Union
+from typing import TYPE_CHECKING, TypeVar
 
 from typing_extensions import override
 
@@ -70,9 +70,7 @@ class ListOutputParser(BaseTransformOutputParser[list[str]]):
         raise NotImplementedError
 
     @override
-    def _transform(
-        self, input: Iterator[Union[str, BaseMessage]]
-    ) -> Iterator[list[str]]:
+    def _transform(self, input: Iterator[str | BaseMessage]) -> Iterator[list[str]]:
         buffer = ""
         for chunk in input:
             if isinstance(chunk, BaseMessage):
@@ -105,7 +103,7 @@ class ListOutputParser(BaseTransformOutputParser[list[str]]):
 
     @override
     async def _atransform(
-        self, input: AsyncIterator[Union[str, BaseMessage]]
+        self, input: AsyncIterator[str | BaseMessage]
     ) -> AsyncIterator[list[str]]:
         buffer = ""
         async for chunk in input:

langchain_core/output_parsers/openai_functions.py

@@ -3,7 +3,7 @@
 import copy
 import json
 from types import GenericAlias
-from typing import Any, Optional, Union
+from typing import Any
 
 import jsonpatch  # type: ignore[import-untyped]
 from pydantic import BaseModel, model_validator
@@ -74,7 +74,7 @@ class JsonOutputFunctionsParser(BaseCumulativeTransformOutputParser[Any]):
         return "json_functions"
 
     @override
-    def _diff(self, prev: Optional[Any], next: Any) -> Any:
+    def _diff(self, prev: Any | None, next: Any) -> Any:
         return jsonpatch.make_patch(prev, next).patch
 
     def parse_result(self, result: list[Generation], *, partial: bool = False) -> Any:
@@ -217,7 +217,7 @@ class PydanticOutputFunctionsParser(OutputFunctionsParser):
 
     """
 
-    pydantic_schema: Union[type[BaseModel], dict[str, type[BaseModel]]]
+    pydantic_schema: type[BaseModel] | dict[str, type[BaseModel]]
     """The pydantic schema to parse the output with.
 
     If multiple schemas are provided, then the function name will be used to