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

langchain_core/runnables/passthrough.py

@@ -5,13 +5,10 @@ from __future__ import annotations
 import asyncio
 import inspect
 import threading
-from collections.abc import Awaitable
+from collections.abc import Awaitable, Callable
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Optional,
-    Union,
     cast,
 )
 
@@ -86,69 +83,66 @@ class RunnablePassthrough(RunnableSerializable[Other, Other]):
     and experiment with.
 
     Examples:
+        ```python
+        from langchain_core.runnables import (
+            RunnableLambda,
+            RunnableParallel,
+            RunnablePassthrough,
+        )
 
-        .. code-block:: python
-
-            from langchain_core.runnables import (
-                RunnableLambda,
-                RunnableParallel,
-                RunnablePassthrough,
-            )
-
-            runnable = RunnableParallel(
-                origin=RunnablePassthrough(), modified=lambda x: x + 1
-            )
+        runnable = RunnableParallel(
+            origin=RunnablePassthrough(), modified=lambda x: x + 1
+        )
 
-            runnable.invoke(1)  # {'origin': 1, 'modified': 2}
+        runnable.invoke(1)  # {'origin': 1, 'modified': 2}
 
 
-            def fake_llm(prompt: str) -> str:  # Fake LLM for the example
-                return "completion"
+        def fake_llm(prompt: str) -> str:  # Fake LLM for the example
+            return "completion"
 
 
-            chain = RunnableLambda(fake_llm) | {
-                "original": RunnablePassthrough(),  # Original LLM output
-                "parsed": lambda text: text[::-1],  # Parsing logic
-            }
+        chain = RunnableLambda(fake_llm) | {
+            "original": RunnablePassthrough(),  # Original LLM output
+            "parsed": lambda text: text[::-1],  # Parsing logic
+        }
 
-            chain.invoke("hello")  # {'original': 'completion', 'parsed': 'noitelpmoc'}
+        chain.invoke("hello")  # {'original': 'completion', 'parsed': 'noitelpmoc'}
+        ```
 
     In some cases, it may be useful to pass the input through while adding some
     keys to the output. In this case, you can use the `assign` method:
 
-        .. code-block:: python
-
-            from langchain_core.runnables import RunnablePassthrough
+        ```python
+        from langchain_core.runnables import RunnablePassthrough
 
 
-            def fake_llm(prompt: str) -> str:  # Fake LLM for the example
-                return "completion"
+        def fake_llm(prompt: str) -> str:  # Fake LLM for the example
+            return "completion"
 
 
-            runnable = {
-                "llm1": fake_llm,
-                "llm2": fake_llm,
-            } | RunnablePassthrough.assign(
-                total_chars=lambda inputs: len(inputs["llm1"] + inputs["llm2"])
-            )
-
-            runnable.invoke("hello")
-            # {'llm1': 'completion', 'llm2': 'completion', 'total_chars': 20}
+        runnable = {
+            "llm1": fake_llm,
+            "llm2": fake_llm,
+        } | RunnablePassthrough.assign(
+            total_chars=lambda inputs: len(inputs["llm1"] + inputs["llm2"])
+        )
 
+        runnable.invoke("hello")
+        # {'llm1': 'completion', 'llm2': 'completion', 'total_chars': 20}
+        ```
     """
 
-    input_type: Optional[type[Other]] = None
+    input_type: type[Other] | None = None
 
-    func: Optional[
-        Union[Callable[[Other], None], Callable[[Other, RunnableConfig], None]]
-    ] = None
+    func: Callable[[Other], None] | Callable[[Other, RunnableConfig], None] | None = (
+        None
+    )
 
-    afunc: Optional[
-        Union[
-            Callable[[Other], Awaitable[None]],
-            Callable[[Other, RunnableConfig], Awaitable[None]],
-        ]
-    ] = None
+    afunc: (
+        Callable[[Other], Awaitable[None]]
+        | Callable[[Other, RunnableConfig], Awaitable[None]]
+        | None
+    ) = None
 
     @override
     def __repr_args__(self) -> Any:
@@ -158,23 +152,16 @@ class RunnablePassthrough(RunnableSerializable[Other, Other]):
 
     def __init__(
         self,
-        func: Optional[
-            Union[
-                Union[Callable[[Other], None], Callable[[Other, RunnableConfig], None]],
-                Union[
-                    Callable[[Other], Awaitable[None]],
-                    Callable[[Other, RunnableConfig], Awaitable[None]],
-                ],
-            ]
-        ] = None,
-        afunc: Optional[
-            Union[
-                Callable[[Other], Awaitable[None]],
-                Callable[[Other, RunnableConfig], Awaitable[None]],
-            ]
-        ] = None,
+        func: Callable[[Other], None]
+        | Callable[[Other, RunnableConfig], None]
+        | Callable[[Other], Awaitable[None]]
+        | Callable[[Other, RunnableConfig], Awaitable[None]]
+        | None = None,
+        afunc: Callable[[Other], Awaitable[None]]
+        | Callable[[Other, RunnableConfig], Awaitable[None]]
+        | None = None,
         *,
-        input_type: Optional[type[Other]] = None,
+        input_type: type[Other] | None = None,
         **kwargs: Any,
     ) -> None:
         """Create e RunnablePassthrough.
@@ -219,14 +206,9 @@ class RunnablePassthrough(RunnableSerializable[Other, Other]):
     @override
     def assign(
         cls,
-        **kwargs: Union[
-            Runnable[dict[str, Any], Any],
-            Callable[[dict[str, Any]], Any],
-            Mapping[
-                str,
-                Union[Runnable[dict[str, Any], Any], Callable[[dict[str, Any]], Any]],
-            ],
-        ],
+        **kwargs: Runnable[dict[str, Any], Any]
+        | Callable[[dict[str, Any]], Any]
+        | Mapping[str, Runnable[dict[str, Any], Any] | Callable[[dict[str, Any]], Any]],
     ) -> RunnableAssign:
         """Merge the Dict input with the output produced by the mapping argument.
 
@@ -242,7 +224,7 @@ class RunnablePassthrough(RunnableSerializable[Other, Other]):
 
     @override
     def invoke(
-        self, input: Other, config: Optional[RunnableConfig] = None, **kwargs: Any
+        self, input: Other, config: RunnableConfig | None = None, **kwargs: Any
     ) -> Other:
         if self.func is not None:
             call_func_with_variable_args(
@@ -254,8 +236,8 @@ class RunnablePassthrough(RunnableSerializable[Other, Other]):
     async def ainvoke(
         self,
         input: Other,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Other:
         if self.afunc is not None:
             await acall_func_with_variable_args(
@@ -271,7 +253,7 @@ class RunnablePassthrough(RunnableSerializable[Other, Other]):
     def transform(
         self,
         input: Iterator[Other],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> Iterator[Other]:
         if self.func is None:
@@ -302,7 +284,7 @@ class RunnablePassthrough(RunnableSerializable[Other, Other]):
     async def atransform(
         self,
         input: AsyncIterator[Other],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[Other]:
         if self.afunc is None and self.func is None:
@@ -345,7 +327,7 @@ class RunnablePassthrough(RunnableSerializable[Other, Other]):
     def stream(
         self,
         input: Other,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> Iterator[Other]:
         return self.transform(iter([input]), config, **kwargs)
@@ -354,7 +336,7 @@ class RunnablePassthrough(RunnableSerializable[Other, Other]):
     async def astream(
         self,
         input: Other,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[Other]:
         async def input_aiter() -> AsyncIterator[Other]:
@@ -376,36 +358,35 @@ class RunnableAssign(RunnableSerializable[dict[str, Any], dict[str, Any]]):
     on the mapper's logic.
 
     Examples:
-        .. code-block:: python
-
-            # This is a RunnableAssign
-            from langchain_core.runnables.passthrough import (
-                RunnableAssign,
-                RunnableParallel,
-            )
-            from langchain_core.runnables.base import RunnableLambda
+        ```python
+        # This is a RunnableAssign
+        from langchain_core.runnables.passthrough import (
+            RunnableAssign,
+            RunnableParallel,
+        )
+        from langchain_core.runnables.base import RunnableLambda
 
 
-            def add_ten(x: dict[str, int]) -> dict[str, int]:
-                return {"added": x["input"] + 10}
+        def add_ten(x: dict[str, int]) -> dict[str, int]:
+            return {"added": x["input"] + 10}
 
 
-            mapper = RunnableParallel(
-                {
-                    "add_step": RunnableLambda(add_ten),
-                }
-            )
-
-            runnable_assign = RunnableAssign(mapper)
+        mapper = RunnableParallel(
+            {
+                "add_step": RunnableLambda(add_ten),
+            }
+        )
 
-            # Synchronous example
-            runnable_assign.invoke({"input": 5})
-            # returns {'input': 5, 'add_step': {'added': 15}}
+        runnable_assign = RunnableAssign(mapper)
 
-            # Asynchronous example
-            await runnable_assign.ainvoke({"input": 5})
-            # returns {'input': 5, 'add_step': {'added': 15}}
+        # Synchronous example
+        runnable_assign.invoke({"input": 5})
+        # returns {'input': 5, 'add_step': {'added': 15}}
 
+        # Asynchronous example
+        await runnable_assign.ainvoke({"input": 5})
+        # returns {'input': 5, 'add_step': {'added': 15}}
+        ```
     """
 
     mapper: RunnableParallel
@@ -436,9 +417,7 @@ class RunnableAssign(RunnableSerializable[dict[str, Any], dict[str, Any]]):
         return ["langchain", "schema", "runnable"]
 
     @override
-    def get_name(
-        self, suffix: Optional[str] = None, *, name: Optional[str] = None
-    ) -> str:
+    def get_name(self, suffix: str | None = None, *, name: str | None = None) -> str:
         name = (
             name
             or self.name
@@ -447,9 +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: Optional[RunnableConfig] = None
-    ) -> type[BaseModel]:
+    def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
         map_input_schema = self.mapper.get_input_schema(config)
         if not issubclass(map_input_schema, RootModel):
             # ie. it's a dict
@@ -459,7 +436,7 @@ class RunnableAssign(RunnableSerializable[dict[str, Any], dict[str, Any]]):
 
     @override
     def get_output_schema(
-        self, config: Optional[RunnableConfig] = None
+        self, config: RunnableConfig | None = None
     ) -> type[BaseModel]:
         map_input_schema = self.mapper.get_input_schema(config)
         map_output_schema = self.mapper.get_output_schema(config)
@@ -524,7 +501,7 @@ class RunnableAssign(RunnableSerializable[dict[str, Any], dict[str, Any]]):
     def invoke(
         self,
         input: dict[str, Any],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> dict[str, Any]:
         return self._call_with_config(self._invoke, input, config, **kwargs)
@@ -553,7 +530,7 @@ class RunnableAssign(RunnableSerializable[dict[str, Any], dict[str, Any]]):
     async def ainvoke(
         self,
         input: dict[str, Any],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> dict[str, Any]:
         return await self._acall_with_config(self._ainvoke, input, config, **kwargs)
@@ -608,7 +585,7 @@ class RunnableAssign(RunnableSerializable[dict[str, Any], dict[str, Any]]):
     def transform(
         self,
         input: Iterator[dict[str, Any]],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any | None,
     ) -> Iterator[dict[str, Any]]:
         yield from self._transform_stream_with_config(
@@ -660,7 +637,7 @@ class RunnableAssign(RunnableSerializable[dict[str, Any], dict[str, Any]]):
     async def atransform(
         self,
         input: AsyncIterator[dict[str, Any]],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[dict[str, Any]]:
         async for chunk in self._atransform_stream_with_config(
@@ -672,7 +649,7 @@ class RunnableAssign(RunnableSerializable[dict[str, Any], dict[str, Any]]):
     def stream(
         self,
         input: dict[str, Any],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> Iterator[dict[str, Any]]:
         return self.transform(iter([input]), config, **kwargs)
@@ -681,7 +658,7 @@ class RunnableAssign(RunnableSerializable[dict[str, Any], dict[str, Any]]):
     async def astream(
         self,
         input: dict[str, Any],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[dict[str, Any]]:
         async def input_aiter() -> AsyncIterator[dict[str, Any]]:
@@ -700,28 +677,27 @@ class RunnablePick(RunnableSerializable[dict[str, Any], dict[str, Any]]):
     the selected keys.
 
     Example:
-        .. code-block:: python
-
-            from langchain_core.runnables.passthrough import RunnablePick
-
-            input_data = {
-                "name": "John",
-                "age": 30,
-                "city": "New York",
-                "country": "USA",
-            }
-
-            runnable = RunnablePick(keys=["name", "age"])
+        ```python
+        from langchain_core.runnables.passthrough import RunnablePick
+
+        input_data = {
+            "name": "John",
+            "age": 30,
+            "city": "New York",
+            "country": "USA",
+        }
 
-            output_data = runnable.invoke(input_data)
+        runnable = RunnablePick(keys=["name", "age"])
 
-            print(output_data)  # Output: {'name': 'John', 'age': 30}
+        output_data = runnable.invoke(input_data)
 
+        print(output_data)  # Output: {'name': 'John', 'age': 30}
+        ```
     """
 
-    keys: Union[str, list[str]]
+    keys: str | list[str]
 
-    def __init__(self, keys: Union[str, list[str]], **kwargs: Any) -> None:
+    def __init__(self, keys: str | list[str], **kwargs: Any) -> None:
         """Create a RunnablePick.
 
         Args:
@@ -746,9 +722,7 @@ class RunnablePick(RunnableSerializable[dict[str, Any], dict[str, Any]]):
         return ["langchain", "schema", "runnable"]
 
     @override
-    def get_name(
-        self, suffix: Optional[str] = None, *, name: Optional[str] = None
-    ) -> str:
+    def get_name(self, suffix: str | None = None, *, name: str | None = None) -> str:
         name = (
             name
             or self.name
@@ -779,7 +753,7 @@ class RunnablePick(RunnableSerializable[dict[str, Any], dict[str, Any]]):
     def invoke(
         self,
         input: dict[str, Any],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> dict[str, Any]:
         return self._call_with_config(self._invoke, input, config, **kwargs)
@@ -794,7 +768,7 @@ class RunnablePick(RunnableSerializable[dict[str, Any], dict[str, Any]]):
     async def ainvoke(
         self,
         input: dict[str, Any],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> dict[str, Any]:
         return await self._acall_with_config(self._ainvoke, input, config, **kwargs)
@@ -812,7 +786,7 @@ class RunnablePick(RunnableSerializable[dict[str, Any], dict[str, Any]]):
     def transform(
         self,
         input: Iterator[dict[str, Any]],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> Iterator[dict[str, Any]]:
         yield from self._transform_stream_with_config(
@@ -832,7 +806,7 @@ class RunnablePick(RunnableSerializable[dict[str, Any], dict[str, Any]]):
     async def atransform(
         self,
         input: AsyncIterator[dict[str, Any]],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[dict[str, Any]]:
         async for chunk in self._atransform_stream_with_config(
@@ -844,7 +818,7 @@ class RunnablePick(RunnableSerializable[dict[str, Any], dict[str, Any]]):
     def stream(
         self,
         input: dict[str, Any],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> Iterator[dict[str, Any]]:
         return self.transform(iter([input]), config, **kwargs)
@@ -853,7 +827,7 @@ class RunnablePick(RunnableSerializable[dict[str, Any], dict[str, Any]]):
     async def astream(
         self,
         input: dict[str, Any],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[dict[str, Any]]:
         async def input_aiter() -> AsyncIterator[dict[str, Any]]:

langchain_core/runnables/retry.py

@@ -3,9 +3,7 @@
 from typing import (
     TYPE_CHECKING,
     Any,
-    Optional,
     TypeVar,
-    Union,
     cast,
 )
 
@@ -62,36 +60,34 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
     Example:
     Here's an example that uses a RunnableLambda to raise an exception
 
-        .. code-block:: python
+        ```python
+        import time
 
-            import time
 
+        def foo(input) -> None:
+            '''Fake function that raises an exception.'''
+            raise ValueError(f"Invoking foo failed. At time {time.time()}")
 
-            def foo(input) -> None:
-                '''Fake function that raises an exception.'''
-                raise ValueError(f"Invoking foo failed. At time {time.time()}")
 
+        runnable = RunnableLambda(foo)
 
-            runnable = RunnableLambda(foo)
-
-            runnable_with_retries = runnable.with_retry(
-                retry_if_exception_type=(ValueError,),  # Retry only on ValueError
-                wait_exponential_jitter=True,  # Add jitter to the exponential backoff
-                stop_after_attempt=2,  # Try twice
-                exponential_jitter_params={
-                    "initial": 2
-                },  # if desired, customize backoff
-            )
+        runnable_with_retries = runnable.with_retry(
+            retry_if_exception_type=(ValueError,),  # Retry only on ValueError
+            wait_exponential_jitter=True,  # Add jitter to the exponential backoff
+            stop_after_attempt=2,  # Try twice
+            exponential_jitter_params={"initial": 2},  # if desired, customize backoff
+        )
 
-            # The method invocation above is equivalent to the longer form below:
+        # The method invocation above is equivalent to the longer form below:
 
-            runnable_with_retries = RunnableRetry(
-                bound=runnable,
-                retry_exception_types=(ValueError,),
-                max_attempt_number=2,
-                wait_exponential_jitter=True,
-                exponential_jitter_params={"initial": 2},
-            )
+        runnable_with_retries = RunnableRetry(
+            bound=runnable,
+            retry_exception_types=(ValueError,),
+            max_attempt_number=2,
+            wait_exponential_jitter=True,
+            exponential_jitter_params={"initial": 2},
+        )
+        ```
 
     This logic can be used to retry any Runnable, including a chain of Runnables,
     but in general it's best practice to keep the scope of the retry as small as
@@ -99,22 +95,20 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
     the Runnable that is likely to fail, not the entire chain.
 
     Example:
+        ```python
+        from langchain_core.chat_models import ChatOpenAI
+        from langchain_core.prompts import PromptTemplate
 
-        .. code-block:: python
-
-            from langchain_core.chat_models import ChatOpenAI
-            from langchain_core.prompts import PromptTemplate
-
-            template = PromptTemplate.from_template("tell me a joke about {topic}.")
-            model = ChatOpenAI(temperature=0.5)
-
-            # Good
-            chain = template | model.with_retry()
+        template = PromptTemplate.from_template("tell me a joke about {topic}.")
+        model = ChatOpenAI(temperature=0.5)
 
-            # Bad
-            chain = template | model
-            retryable_chain = chain.with_retry()
+        # Good
+        chain = template | model.with_retry()
 
+        # Bad
+        chain = template | model
+        retryable_chain = chain.with_retry()
+        ```
     """
 
     retry_exception_types: tuple[type[BaseException], ...] = (Exception,)
@@ -130,7 +124,7 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
     wait_exponential_jitter: bool = True
     """Whether to add jitter to the exponential backoff."""
 
-    exponential_jitter_params: Optional[ExponentialJitterParams] = None
+    exponential_jitter_params: ExponentialJitterParams | None = None
     """Parameters for ``tenacity.wait_exponential_jitter``. Namely: ``initial``,
     ``max``, ``exp_base``, and ``jitter`` (all float values).
     """
@@ -178,7 +172,8 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
         retry_state: RetryCallState,
     ) -> list[RunnableConfig]:
         return [
-            self._patch_config(c, rm, retry_state) for c, rm in zip(config, run_manager)
+            self._patch_config(c, rm, retry_state)
+            for c, rm in zip(config, run_manager, strict=False)
         ]
 
     def _invoke(
@@ -201,7 +196,7 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
 
     @override
     def invoke(
-        self, input: Input, config: Optional[RunnableConfig] = None, **kwargs: Any
+        self, input: Input, config: RunnableConfig | None = None, **kwargs: Any
     ) -> Output:
         return self._call_with_config(self._invoke, input, config, **kwargs)
 
@@ -225,7 +220,7 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
 
     @override
     async def ainvoke(
-        self, input: Input, config: Optional[RunnableConfig] = None, **kwargs: Any
+        self, input: Input, config: RunnableConfig | None = None, **kwargs: Any
     ) -> Output:
         return await self._acall_with_config(self._ainvoke, input, config, **kwargs)
 
@@ -235,7 +230,7 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
         run_manager: list["CallbackManagerForChainRun"],
         config: list[RunnableConfig],
         **kwargs: Any,
-    ) -> list[Union[Output, Exception]]:
+    ) -> list[Output | Exception]:
         results_map: dict[int, Output] = {}
 
         not_set: list[Output] = []
@@ -284,7 +279,7 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
             if result is not_set:
                 result = cast("list[Output]", [e] * len(inputs))
 
-        outputs: list[Union[Output, Exception]] = []
+        outputs: list[Output | Exception] = []
         for idx in range(len(inputs)):
             if idx in results_map:
                 outputs.append(results_map[idx])
@@ -296,7 +291,7 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
     def batch(
         self,
         inputs: list[Input],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: RunnableConfig | list[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
         **kwargs: Any,
@@ -311,7 +306,7 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
         run_manager: list["AsyncCallbackManagerForChainRun"],
         config: list[RunnableConfig],
         **kwargs: Any,
-    ) -> list[Union[Output, Exception]]:
+    ) -> list[Output | Exception]:
         results_map: dict[int, Output] = {}
 
         not_set: list[Output] = []
@@ -359,7 +354,7 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
             if result is not_set:
                 result = cast("list[Output]", [e] * len(inputs))
 
-        outputs: list[Union[Output, Exception]] = []
+        outputs: list[Output | Exception] = []
         for idx in range(len(inputs)):
             if idx in results_map:
                 outputs.append(results_map[idx])
@@ -371,7 +366,7 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
     async def abatch(
         self,
         inputs: list[Input],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: RunnableConfig | list[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
         **kwargs: Any,