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

langchain_core/runnables/base.py

@@ -13,6 +13,7 @@ from collections.abc import (
     AsyncGenerator,
     AsyncIterator,
     Awaitable,
+    Callable,
     Coroutine,
     Iterator,
     Mapping,
@@ -26,13 +27,10 @@ from types import GenericAlias
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     Generic,
     Literal,
-    Optional,
     Protocol,
     TypeVar,
-    Union,
     cast,
     get_args,
     get_type_hints,
@@ -170,22 +168,22 @@ class Runnable(ABC, Generic[Input, Output]):
 
     For example,
 
-    .. code-block:: python
+    ```python
+    from langchain_core.runnables import RunnableLambda
 
-        from langchain_core.runnables import RunnableLambda
+    # A RunnableSequence constructed using the `|` operator
+    sequence = RunnableLambda(lambda x: x + 1) | RunnableLambda(lambda x: x * 2)
+    sequence.invoke(1)  # 4
+    sequence.batch([1, 2, 3])  # [4, 6, 8]
 
-        # A RunnableSequence constructed using the `|` operator
-        sequence = RunnableLambda(lambda x: x + 1) | RunnableLambda(lambda x: x * 2)
-        sequence.invoke(1)  # 4
-        sequence.batch([1, 2, 3])  # [4, 6, 8]
 
-
-        # A sequence that contains a RunnableParallel constructed using a dict literal
-        sequence = RunnableLambda(lambda x: x + 1) | {
-            "mul_2": RunnableLambda(lambda x: x * 2),
-            "mul_5": RunnableLambda(lambda x: x * 5),
-        }
-        sequence.invoke(1)  # {'mul_2': 4, 'mul_5': 10}
+    # A sequence that contains a RunnableParallel constructed using a dict literal
+    sequence = RunnableLambda(lambda x: x + 1) | {
+        "mul_2": RunnableLambda(lambda x: x * 2),
+        "mul_5": RunnableLambda(lambda x: x * 5),
+    }
+    sequence.invoke(1)  # {'mul_2': 4, 'mul_5': 10}
+    ```
 
     Standard Methods
     ================
@@ -200,34 +198,34 @@ class Runnable(ABC, Generic[Input, Output]):
 
     For example,
 
-    .. code-block:: python
+    ```python
+    from langchain_core.runnables import RunnableLambda
 
-        from langchain_core.runnables import RunnableLambda
-
-        import random
+    import random
 
-        def add_one(x: int) -> int:
-            return x + 1
+    def add_one(x: int) -> int:
+        return x + 1
 
 
-        def buggy_double(y: int) -> int:
-            \"\"\"Buggy code that will fail 70% of the time\"\"\"
-            if random.random() > 0.3:
-                print('This code failed, and will probably be retried!')  # noqa: T201
-                raise ValueError('Triggered buggy code')
-            return y * 2
+    def buggy_double(y: int) -> int:
+        \"\"\"Buggy code that will fail 70% of the time\"\"\"
+        if random.random() > 0.3:
+            print('This code failed, and will probably be retried!')  # noqa: T201
+            raise ValueError('Triggered buggy code')
+        return y * 2
 
-        sequence = (
-            RunnableLambda(add_one) |
-            RunnableLambda(buggy_double).with_retry( # Retry on failure
-                stop_after_attempt=10,
-                wait_exponential_jitter=False
-            )
+    sequence = (
+        RunnableLambda(add_one) |
+        RunnableLambda(buggy_double).with_retry( # Retry on failure
+            stop_after_attempt=10,
+            wait_exponential_jitter=False
         )
+    )
 
-        print(sequence.input_schema.model_json_schema()) # Show inferred input schema
-        print(sequence.output_schema.model_json_schema()) # Show inferred output schema
-        print(sequence.invoke(2)) # invoke the sequence (note the retry above!!)
+    print(sequence.input_schema.model_json_schema()) # Show inferred input schema
+    print(sequence.output_schema.model_json_schema()) # Show inferred output schema
+    print(sequence.invoke(2)) # invoke the sequence (note the retry above!!)
+    ```
 
     Debugging and tracing
     =====================
@@ -237,30 +235,28 @@ class Runnable(ABC, Generic[Input, Output]):
 
     You can set the global debug flag to True to enable debug output for all chains:
 
-        .. code-block:: python
-
-            from langchain_core.globals import set_debug
+        ```python
+        from langchain_core.globals import set_debug
 
-            set_debug(True)
+        set_debug(True)
+        ```
 
     Alternatively, you can pass existing or custom callbacks to any given chain:
 
-        .. code-block:: python
+        ```python
+        from langchain_core.tracers import ConsoleCallbackHandler
 
-            from langchain_core.tracers import ConsoleCallbackHandler
-
-            chain.invoke(..., config={"callbacks": [ConsoleCallbackHandler()]})
+        chain.invoke(..., config={"callbacks": [ConsoleCallbackHandler()]})
+        ```
 
     For a UI (and much more) checkout `LangSmith <https://docs.smith.langchain.com/>`__.
 
     """
 
-    name: Optional[str]
+    name: str | None
     """The name of the ``Runnable``. Used for debugging and tracing."""
 
-    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:
         """Get the name of the ``Runnable``.
 
         Args:
@@ -365,7 +361,7 @@ class Runnable(ABC, Generic[Input, Output]):
 
     def get_input_schema(
         self,
-        config: Optional[RunnableConfig] = None,  # noqa: ARG002
+        config: RunnableConfig | None = None,  # noqa: ARG002
     ) -> type[BaseModel]:
         """Get a pydantic model that can be used to validate input to the Runnable.
 
@@ -404,7 +400,7 @@ class Runnable(ABC, Generic[Input, Output]):
         )
 
     def get_input_jsonschema(
-        self, config: Optional[RunnableConfig] = None
+        self, config: RunnableConfig | None = None
     ) -> dict[str, Any]:
         """Get a JSON schema that represents the input to the ``Runnable``.
 
@@ -415,21 +411,20 @@ class Runnable(ABC, Generic[Input, Output]):
             A JSON schema that represents the input to the ``Runnable``.
 
         Example:
-
-            .. code-block:: python
-
-                from langchain_core.runnables import RunnableLambda
+            ```python
+            from langchain_core.runnables import RunnableLambda
 
 
-                def add_one(x: int) -> int:
-                    return x + 1
+            def add_one(x: int) -> int:
+                return x + 1
 
 
-                runnable = RunnableLambda(add_one)
+            runnable = RunnableLambda(add_one)
 
-                print(runnable.get_input_jsonschema())
+            print(runnable.get_input_jsonschema())
+            ```
 
-        .. versionadded:: 0.3.0
+        !!! version-added "Added in version 0.3.0"
 
         """
         return self.get_input_schema(config).model_json_schema()
@@ -444,7 +439,7 @@ class Runnable(ABC, Generic[Input, Output]):
 
     def get_output_schema(
         self,
-        config: Optional[RunnableConfig] = None,  # noqa: ARG002
+        config: RunnableConfig | None = None,  # noqa: ARG002
     ) -> type[BaseModel]:
         """Get a pydantic model that can be used to validate output to the ``Runnable``.
 
@@ -483,7 +478,7 @@ class Runnable(ABC, Generic[Input, Output]):
         )
 
     def get_output_jsonschema(
-        self, config: Optional[RunnableConfig] = None
+        self, config: RunnableConfig | None = None
     ) -> dict[str, Any]:
         """Get a JSON schema that represents the output of the ``Runnable``.
 
@@ -494,21 +489,20 @@ class Runnable(ABC, Generic[Input, Output]):
             A JSON schema that represents the output of the ``Runnable``.
 
         Example:
-
-            .. code-block:: python
-
-                from langchain_core.runnables import RunnableLambda
+            ```python
+            from langchain_core.runnables import RunnableLambda
 
 
-                def add_one(x: int) -> int:
-                    return x + 1
+            def add_one(x: int) -> int:
+                return x + 1
 
 
-                runnable = RunnableLambda(add_one)
+            runnable = RunnableLambda(add_one)
 
-                print(runnable.get_output_jsonschema())
+            print(runnable.get_output_jsonschema())
+            ```
 
-        .. versionadded:: 0.3.0
+        !!! version-added "Added in version 0.3.0"
 
         """
         return self.get_output_schema(config).model_json_schema()
@@ -518,9 +512,7 @@ class Runnable(ABC, Generic[Input, Output]):
         """List configurable fields for this ``Runnable``."""
         return []
 
-    def config_schema(
-        self, *, include: Optional[Sequence[str]] = None
-    ) -> type[BaseModel]:
+    def config_schema(self, *, include: Sequence[str] | None = None) -> type[BaseModel]:
         """The type of config this ``Runnable`` accepts specified as a pydantic model.
 
         To mark a field as configurable, see the ``configurable_fields``
@@ -564,7 +556,7 @@ class Runnable(ABC, Generic[Input, Output]):
         return create_model_v2(self.get_name("Config"), field_definitions=all_fields)
 
     def get_config_jsonschema(
-        self, *, include: Optional[Sequence[str]] = None
+        self, *, include: Sequence[str] | None = None
     ) -> dict[str, Any]:
         """Get a JSON schema that represents the config of the ``Runnable``.
 
@@ -574,12 +566,12 @@ class Runnable(ABC, Generic[Input, Output]):
         Returns:
             A JSON schema that represents the config of the ``Runnable``.
 
-        .. versionadded:: 0.3.0
+        !!! version-added "Added in version 0.3.0"
 
         """
         return self.config_schema(include=include).model_json_schema()
 
-    def get_graph(self, config: Optional[RunnableConfig] = None) -> Graph:
+    def get_graph(self, config: RunnableConfig | None = None) -> Graph:
         """Return a graph representation of this ``Runnable``."""
         # Import locally to prevent circular import
         from langchain_core.runnables.graph import Graph  # noqa: PLC0415
@@ -601,7 +593,7 @@ class Runnable(ABC, Generic[Input, Output]):
         return graph
 
     def get_prompts(
-        self, config: Optional[RunnableConfig] = None
+        self, config: RunnableConfig | None = None
     ) -> list[BasePromptTemplate]:
         """Return a list of prompts used by this ``Runnable``."""
         # Import locally to prevent circular import
@@ -615,13 +607,11 @@ class Runnable(ABC, Generic[Input, Output]):
 
     def __or__(
         self,
-        other: Union[
-            Runnable[Any, Other],
-            Callable[[Iterator[Any]], Iterator[Other]],
-            Callable[[AsyncIterator[Any]], AsyncIterator[Other]],
-            Callable[[Any], Other],
-            Mapping[str, Union[Runnable[Any, Other], Callable[[Any], Other], Any]],
-        ],
+        other: Runnable[Any, Other]
+        | Callable[[Iterator[Any]], Iterator[Other]]
+        | Callable[[AsyncIterator[Any]], AsyncIterator[Other]]
+        | Callable[[Any], Other]
+        | Mapping[str, Runnable[Any, Other] | Callable[[Any], Other] | Any],
     ) -> RunnableSerializable[Input, Other]:
         """Runnable "or" operator.
 
@@ -638,13 +628,11 @@ class Runnable(ABC, Generic[Input, Output]):
 
     def __ror__(
         self,
-        other: Union[
-            Runnable[Other, Any],
-            Callable[[Iterator[Other]], Iterator[Any]],
-            Callable[[AsyncIterator[Other]], AsyncIterator[Any]],
-            Callable[[Other], Any],
-            Mapping[str, Union[Runnable[Other, Any], Callable[[Other], Any], Any]],
-        ],
+        other: Runnable[Other, Any]
+        | Callable[[Iterator[Other]], Iterator[Any]]
+        | Callable[[AsyncIterator[Other]], AsyncIterator[Any]]
+        | Callable[[Other], Any]
+        | Mapping[str, Runnable[Other, Any] | Callable[[Other], Any] | Any],
     ) -> RunnableSerializable[Other, Output]:
         """Runnable "reverse-or" operator.
 
@@ -661,8 +649,8 @@ class Runnable(ABC, Generic[Input, Output]):
 
     def pipe(
         self,
-        *others: Union[Runnable[Any, Other], Callable[[Any], Other]],
-        name: Optional[str] = None,
+        *others: Runnable[Any, Other] | Callable[[Any], Other],
+        name: str | None = None,
     ) -> RunnableSerializable[Input, Other]:
         """Pipe runnables.
 
@@ -672,33 +660,32 @@ class Runnable(ABC, Generic[Input, Output]):
         Equivalent to ``RunnableSequence(self, *others)`` or ``self | others[0] | ...``
 
         Example:
-
-            .. code-block:: python
-
-                from langchain_core.runnables import RunnableLambda
+            ```python
+            from langchain_core.runnables import RunnableLambda
 
 
-                def add_one(x: int) -> int:
-                    return x + 1
+            def add_one(x: int) -> int:
+                return x + 1
 
 
-                def mul_two(x: int) -> int:
-                    return x * 2
+            def mul_two(x: int) -> int:
+                return x * 2
 
 
-                runnable_1 = RunnableLambda(add_one)
-                runnable_2 = RunnableLambda(mul_two)
-                sequence = runnable_1.pipe(runnable_2)
-                # Or equivalently:
-                # sequence = runnable_1 | runnable_2
-                # sequence = RunnableSequence(first=runnable_1, last=runnable_2)
-                sequence.invoke(1)
-                await sequence.ainvoke(1)
-                # -> 4
+            runnable_1 = RunnableLambda(add_one)
+            runnable_2 = RunnableLambda(mul_two)
+            sequence = runnable_1.pipe(runnable_2)
+            # Or equivalently:
+            # sequence = runnable_1 | runnable_2
+            # sequence = RunnableSequence(first=runnable_1, last=runnable_2)
+            sequence.invoke(1)
+            await sequence.ainvoke(1)
+            # -> 4
 
-                sequence.batch([1, 2, 3])
-                await sequence.abatch([1, 2, 3])
-                # -> [4, 6, 8]
+            sequence.batch([1, 2, 3])
+            await sequence.abatch([1, 2, 3])
+            # -> [4, 6, 8]
+            ```
 
         Args:
             *others: Other ``Runnable`` or ``Runnable``-like objects to compose
@@ -709,56 +696,56 @@ class Runnable(ABC, Generic[Input, Output]):
         """
         return RunnableSequence(self, *others, name=name)
 
-    def pick(self, keys: Union[str, list[str]]) -> RunnableSerializable[Any, Any]:
+    def pick(self, keys: str | list[str]) -> RunnableSerializable[Any, Any]:
         """Pick keys from the output dict of this ``Runnable``.
 
         Pick single key:
 
-            .. code-block:: python
+            ```python
+            import json
 
-                import json
+            from langchain_core.runnables import RunnableLambda, RunnableMap
 
-                from langchain_core.runnables import RunnableLambda, RunnableMap
+            as_str = RunnableLambda(str)
+            as_json = RunnableLambda(json.loads)
+            chain = RunnableMap(str=as_str, json=as_json)
 
-                as_str = RunnableLambda(str)
-                as_json = RunnableLambda(json.loads)
-                chain = RunnableMap(str=as_str, json=as_json)
+            chain.invoke("[1, 2, 3]")
+            # -> {"str": "[1, 2, 3]", "json": [1, 2, 3]}
 
-                chain.invoke("[1, 2, 3]")
-                # -> {"str": "[1, 2, 3]", "json": [1, 2, 3]}
-
-                json_only_chain = chain.pick("json")
-                json_only_chain.invoke("[1, 2, 3]")
-                # -> [1, 2, 3]
+            json_only_chain = chain.pick("json")
+            json_only_chain.invoke("[1, 2, 3]")
+            # -> [1, 2, 3]
+            ```
 
         Pick list of keys:
 
-            .. code-block:: python
-
-                from typing import Any
+            ```python
+            from typing import Any
 
-                import json
+            import json
 
-                from langchain_core.runnables import RunnableLambda, RunnableMap
+            from langchain_core.runnables import RunnableLambda, RunnableMap
 
-                as_str = RunnableLambda(str)
-                as_json = RunnableLambda(json.loads)
+            as_str = RunnableLambda(str)
+            as_json = RunnableLambda(json.loads)
 
 
-                def as_bytes(x: Any) -> bytes:
-                    return bytes(x, "utf-8")
+            def as_bytes(x: Any) -> bytes:
+                return bytes(x, "utf-8")
 
 
-                chain = RunnableMap(
-                    str=as_str, json=as_json, bytes=RunnableLambda(as_bytes)
-                )
+            chain = RunnableMap(
+                str=as_str, json=as_json, bytes=RunnableLambda(as_bytes)
+            )
 
-                chain.invoke("[1, 2, 3]")
-                # -> {"str": "[1, 2, 3]", "json": [1, 2, 3], "bytes": b"[1, 2, 3]"}
+            chain.invoke("[1, 2, 3]")
+            # -> {"str": "[1, 2, 3]", "json": [1, 2, 3], "bytes": b"[1, 2, 3]"}
 
-                json_and_bytes_chain = chain.pick(["json", "bytes"])
-                json_and_bytes_chain.invoke("[1, 2, 3]")
-                # -> {"json": [1, 2, 3], "bytes": b"[1, 2, 3]"}
+            json_and_bytes_chain = chain.pick(["json", "bytes"])
+            json_and_bytes_chain.invoke("[1, 2, 3]")
+            # -> {"json": [1, 2, 3], "bytes": b"[1, 2, 3]"}
+            ```
 
         Args:
             keys: A key or list of keys to pick from the output dict.
@@ -774,42 +761,37 @@ class Runnable(ABC, Generic[Input, Output]):
 
     def assign(
         self,
-        **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]],
     ) -> RunnableSerializable[Any, Any]:
         """Assigns new fields to the dict output of this ``Runnable``.
 
-        .. code-block:: python
-
-            from langchain_community.llms.fake import FakeStreamingListLLM
-            from langchain_core.output_parsers import StrOutputParser
-            from langchain_core.prompts import SystemMessagePromptTemplate
-            from langchain_core.runnables import Runnable
-            from operator import itemgetter
+        ```python
+        from langchain_community.llms.fake import FakeStreamingListLLM
+        from langchain_core.output_parsers import StrOutputParser
+        from langchain_core.prompts import SystemMessagePromptTemplate
+        from langchain_core.runnables import Runnable
+        from operator import itemgetter
 
-            prompt = (
-                SystemMessagePromptTemplate.from_template("You are a nice assistant.")
-                + "{question}"
-            )
-            llm = FakeStreamingListLLM(responses=["foo-lish"])
+        prompt = (
+            SystemMessagePromptTemplate.from_template("You are a nice assistant.")
+            + "{question}"
+        )
+        llm = FakeStreamingListLLM(responses=["foo-lish"])
 
-            chain: Runnable = prompt | llm | {"str": StrOutputParser()}
+        chain: Runnable = prompt | llm | {"str": StrOutputParser()}
 
-            chain_with_assign = chain.assign(hello=itemgetter("str") | llm)
+        chain_with_assign = chain.assign(hello=itemgetter("str") | llm)
 
-            print(chain_with_assign.input_schema.model_json_schema())
-            # {'title': 'PromptInput', 'type': 'object', 'properties':
-            {'question': {'title': 'Question', 'type': 'string'}}}
-            print(chain_with_assign.output_schema.model_json_schema())
-            # {'title': 'RunnableSequenceOutput', 'type': 'object', 'properties':
-            {'str': {'title': 'Str',
-            'type': 'string'}, 'hello': {'title': 'Hello', 'type': 'string'}}}
+        print(chain_with_assign.input_schema.model_json_schema())
+        # {'title': 'PromptInput', 'type': 'object', 'properties':
+        {'question': {'title': 'Question', 'type': 'string'}}}
+        print(chain_with_assign.output_schema.model_json_schema())
+        # {'title': 'RunnableSequenceOutput', 'type': 'object', 'properties':
+        {'str': {'title': 'Str',
+        'type': 'string'}, 'hello': {'title': 'Hello', 'type': 'string'}}}
+        ```
 
         Args:
             **kwargs: A mapping of keys to ``Runnable`` or ``Runnable``-like objects
@@ -830,7 +812,7 @@ class Runnable(ABC, Generic[Input, Output]):
     def invoke(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> Output:
         """Transform a single input into an output.
@@ -845,13 +827,12 @@ class Runnable(ABC, Generic[Input, Output]):
 
         Returns:
             The output of the ``Runnable``.
-
         """
 
     async def ainvoke(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> Output:
         """Transform a single input into an output.
@@ -866,17 +847,16 @@ class Runnable(ABC, Generic[Input, Output]):
 
         Returns:
             The output of the ``Runnable``.
-
         """
         return await run_in_executor(config, self.invoke, input, config, **kwargs)
 
     def batch(
         self,
         inputs: list[Input],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: RunnableConfig | list[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
-        **kwargs: Optional[Any],
+        **kwargs: Any | None,
     ) -> list[Output]:
         """Default implementation runs invoke in parallel using a thread pool executor.
 
@@ -898,14 +878,13 @@ class Runnable(ABC, Generic[Input, Output]):
 
         Returns:
             A list of outputs from the ``Runnable``.
-
         """
         if not inputs:
             return []
 
         configs = get_config_list(config, len(inputs))
 
-        def invoke(input_: Input, config: RunnableConfig) -> Union[Output, Exception]:
+        def invoke(input_: Input, config: RunnableConfig) -> Output | Exception:
             if return_exceptions:
                 try:
                     return self.invoke(input_, config, **kwargs)
@@ -925,7 +904,7 @@ class Runnable(ABC, Generic[Input, Output]):
     def batch_as_completed(
         self,
         inputs: Sequence[Input],
-        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        config: RunnableConfig | Sequence[RunnableConfig] | None = None,
         *,
         return_exceptions: Literal[False] = False,
         **kwargs: Any,
@@ -935,20 +914,20 @@ class Runnable(ABC, Generic[Input, Output]):
     def batch_as_completed(
         self,
         inputs: Sequence[Input],
-        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        config: RunnableConfig | Sequence[RunnableConfig] | None = None,
         *,
         return_exceptions: Literal[True],
         **kwargs: Any,
-    ) -> Iterator[tuple[int, Union[Output, Exception]]]: ...
+    ) -> Iterator[tuple[int, Output | Exception]]: ...
 
     def batch_as_completed(
         self,
         inputs: Sequence[Input],
-        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        config: RunnableConfig | Sequence[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
-        **kwargs: Optional[Any],
-    ) -> Iterator[tuple[int, Union[Output, Exception]]]:
+        **kwargs: Any | None,
+    ) -> Iterator[tuple[int, Output | Exception]]:
         """Run ``invoke`` in parallel on a list of inputs.
 
         Yields results as they complete.
@@ -975,12 +954,10 @@ class Runnable(ABC, Generic[Input, Output]):
 
         def invoke(
             i: int, input_: Input, config: RunnableConfig
-        ) -> tuple[int, Union[Output, Exception]]:
+        ) -> tuple[int, Output | Exception]:
             if return_exceptions:
                 try:
-                    out: Union[Output, Exception] = self.invoke(
-                        input_, config, **kwargs
-                    )
+                    out: Output | Exception = self.invoke(input_, config, **kwargs)
                 except Exception as e:
                     out = e
             else:
@@ -995,7 +972,7 @@ class Runnable(ABC, Generic[Input, Output]):
         with get_executor_for_config(configs[0]) as executor:
             futures = {
                 executor.submit(invoke, i, input_, config)
-                for i, (input_, config) in enumerate(zip(inputs, configs))
+                for i, (input_, config) in enumerate(zip(inputs, configs, strict=False))
             }
 
             try:
@@ -1010,10 +987,10 @@ class Runnable(ABC, Generic[Input, Output]):
     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: Optional[Any],
+        **kwargs: Any | None,
     ) -> list[Output]:
         """Default implementation runs ``ainvoke`` in parallel using ``asyncio.gather``.
 
@@ -1042,9 +1019,7 @@ class Runnable(ABC, Generic[Input, Output]):
 
         configs = get_config_list(config, len(inputs))
 
-        async def ainvoke(
-            value: Input, config: RunnableConfig
-        ) -> Union[Output, Exception]:
+        async def ainvoke(value: Input, config: RunnableConfig) -> Output | Exception:
             if return_exceptions:
                 try:
                     return await self.ainvoke(value, config, **kwargs)
@@ -1060,30 +1035,30 @@ class Runnable(ABC, Generic[Input, Output]):
     def abatch_as_completed(
         self,
         inputs: Sequence[Input],
-        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        config: RunnableConfig | Sequence[RunnableConfig] | None = None,
         *,
         return_exceptions: Literal[False] = False,
-        **kwargs: Optional[Any],
+        **kwargs: Any | None,
     ) -> AsyncIterator[tuple[int, Output]]: ...
 
     @overload
     def abatch_as_completed(
         self,
         inputs: Sequence[Input],
-        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        config: RunnableConfig | Sequence[RunnableConfig] | None = None,
         *,
         return_exceptions: Literal[True],
-        **kwargs: Optional[Any],
-    ) -> AsyncIterator[tuple[int, Union[Output, Exception]]]: ...
+        **kwargs: Any | None,
+    ) -> AsyncIterator[tuple[int, Output | Exception]]: ...
 
     async def abatch_as_completed(
         self,
         inputs: Sequence[Input],
-        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        config: RunnableConfig | Sequence[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
-        **kwargs: Optional[Any],
-    ) -> AsyncIterator[tuple[int, Union[Output, Exception]]]:
+        **kwargs: Any | None,
+    ) -> AsyncIterator[tuple[int, Output | Exception]]:
         """Run ``ainvoke`` in parallel on a list of inputs.
 
         Yields results as they complete.
@@ -1113,10 +1088,10 @@ class Runnable(ABC, Generic[Input, Output]):
 
         async def ainvoke_task(
             i: int, input_: Input, config: RunnableConfig
-        ) -> tuple[int, Union[Output, Exception]]:
+        ) -> tuple[int, Output | Exception]:
             if return_exceptions:
                 try:
-                    out: Union[Output, Exception] = await self.ainvoke(
+                    out: Output | Exception = await self.ainvoke(
                         input_, config, **kwargs
                     )
                 except Exception as e:
@@ -1129,7 +1104,7 @@ class Runnable(ABC, Generic[Input, Output]):
             gated_coro(semaphore, ainvoke_task(i, input_, config))
             if semaphore
             else ainvoke_task(i, input_, config)
-            for i, (input_, config) in enumerate(zip(inputs, configs))
+            for i, (input_, config) in enumerate(zip(inputs, configs, strict=False))
         ]
 
         for coro in asyncio.as_completed(coros):
@@ -1138,8 +1113,8 @@ class Runnable(ABC, Generic[Input, Output]):
     def stream(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Iterator[Output]:
         """Default implementation of ``stream``, which calls ``invoke``.
 
@@ -1159,8 +1134,8 @@ class Runnable(ABC, Generic[Input, Output]):
     async def astream(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> AsyncIterator[Output]:
         """Default implementation of ``astream``, which calls ``ainvoke``.
 
@@ -1181,16 +1156,16 @@ class Runnable(ABC, Generic[Input, Output]):
     def astream_log(
         self,
         input: Any,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         *,
         diff: Literal[True] = True,
         with_streamed_output_list: bool = True,
-        include_names: Optional[Sequence[str]] = None,
-        include_types: Optional[Sequence[str]] = None,
-        include_tags: Optional[Sequence[str]] = None,
-        exclude_names: Optional[Sequence[str]] = None,
-        exclude_types: Optional[Sequence[str]] = None,
-        exclude_tags: Optional[Sequence[str]] = None,
+        include_names: Sequence[str] | None = None,
+        include_types: Sequence[str] | None = None,
+        include_tags: Sequence[str] | None = None,
+        exclude_names: Sequence[str] | None = None,
+        exclude_types: Sequence[str] | None = None,
+        exclude_tags: Sequence[str] | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[RunLogPatch]: ...
 
@@ -1198,34 +1173,34 @@ class Runnable(ABC, Generic[Input, Output]):
     def astream_log(
         self,
         input: Any,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         *,
         diff: Literal[False],
         with_streamed_output_list: bool = True,
-        include_names: Optional[Sequence[str]] = None,
-        include_types: Optional[Sequence[str]] = None,
-        include_tags: Optional[Sequence[str]] = None,
-        exclude_names: Optional[Sequence[str]] = None,
-        exclude_types: Optional[Sequence[str]] = None,
-        exclude_tags: Optional[Sequence[str]] = None,
+        include_names: Sequence[str] | None = None,
+        include_types: Sequence[str] | None = None,
+        include_tags: Sequence[str] | None = None,
+        exclude_names: Sequence[str] | None = None,
+        exclude_types: Sequence[str] | None = None,
+        exclude_tags: Sequence[str] | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[RunLog]: ...
 
     async def astream_log(
         self,
         input: Any,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         *,
         diff: bool = True,
         with_streamed_output_list: bool = True,
-        include_names: Optional[Sequence[str]] = None,
-        include_types: Optional[Sequence[str]] = None,
-        include_tags: Optional[Sequence[str]] = None,
-        exclude_names: Optional[Sequence[str]] = None,
-        exclude_types: Optional[Sequence[str]] = None,
-        exclude_tags: Optional[Sequence[str]] = None,
+        include_names: Sequence[str] | None = None,
+        include_types: Sequence[str] | None = None,
+        include_tags: Sequence[str] | None = None,
+        exclude_names: Sequence[str] | None = None,
+        exclude_types: Sequence[str] | None = None,
+        exclude_tags: Sequence[str] | None = None,
         **kwargs: Any,
-    ) -> Union[AsyncIterator[RunLogPatch], AsyncIterator[RunLog]]:
+    ) -> AsyncIterator[RunLogPatch] | AsyncIterator[RunLog]:
         """Stream all output from a ``Runnable``, as reported to the callback system.
 
         This includes all inner runs of LLMs, Retrievers, Tools, etc.
@@ -1281,15 +1256,15 @@ class Runnable(ABC, Generic[Input, Output]):
     async def astream_events(
         self,
         input: Any,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         *,
         version: Literal["v1", "v2"] = "v2",
-        include_names: Optional[Sequence[str]] = None,
-        include_types: Optional[Sequence[str]] = None,
-        include_tags: Optional[Sequence[str]] = None,
-        exclude_names: Optional[Sequence[str]] = None,
-        exclude_types: Optional[Sequence[str]] = None,
-        exclude_tags: Optional[Sequence[str]] = None,
+        include_names: Sequence[str] | None = None,
+        include_types: Sequence[str] | None = None,
+        include_tags: Sequence[str] | None = None,
+        exclude_names: Sequence[str] | None = None,
+        exclude_types: Sequence[str] | None = None,
+        exclude_tags: Sequence[str] | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[StreamEvent]:
         """Generate a stream of events.
@@ -1321,7 +1296,7 @@ class Runnable(ABC, Generic[Input, Output]):
         chains. Metadata fields have been omitted from the table for brevity.
         Chain definitions have been included after the table.
 
-        .. note::
+        !!! note
             This reference table is for the v2 version of the schema.
 
         +--------------------------+------------------+-------------------------------------+---------------------------------------------------+-----------------------------------------------------+
@@ -1376,112 +1351,107 @@ class Runnable(ABC, Generic[Input, Output]):
 
         ``format_docs``:
 
-        .. code-block:: python
-
-            def format_docs(docs: list[Document]) -> str:
-                '''Format the docs.'''
-                return ", ".join([doc.page_content for doc in docs])
+        ```python
+        def format_docs(docs: list[Document]) -> str:
+            '''Format the docs.'''
+            return ", ".join([doc.page_content for doc in docs])
 
 
-            format_docs = RunnableLambda(format_docs)
+        format_docs = RunnableLambda(format_docs)
+        ```
 
         ``some_tool``:
 
-        .. code-block:: python
-
-            @tool
-            def some_tool(x: int, y: str) -> dict:
-                '''Some_tool.'''
-                return {"x": x, "y": y}
+        ```python
+        @tool
+        def some_tool(x: int, y: str) -> dict:
+            '''Some_tool.'''
+            return {"x": x, "y": y}
+        ```
 
         ``prompt``:
 
-        .. code-block:: python
-
-            template = ChatPromptTemplate.from_messages(
-                [
-                    ("system", "You are Cat Agent 007"),
-                    ("human", "{question}"),
-                ]
-            ).with_config({"run_name": "my_template", "tags": ["my_template"]})
-
-
+        ```python
+        template = ChatPromptTemplate.from_messages(
+            [
+                ("system", "You are Cat Agent 007"),
+                ("human", "{question}"),
+            ]
+        ).with_config({"run_name": "my_template", "tags": ["my_template"]})
+        ```
         Example:
 
-        .. code-block:: python
-
-            from langchain_core.runnables import RunnableLambda
+        ```python
+        from langchain_core.runnables import RunnableLambda
 
 
-            async def reverse(s: str) -> str:
-                return s[::-1]
+        async def reverse(s: str) -> str:
+            return s[::-1]
 
 
-            chain = RunnableLambda(func=reverse)
+        chain = RunnableLambda(func=reverse)
 
-            events = [
-                event async for event in chain.astream_events("hello", version="v2")
-            ]
-
-            # will produce the following events (run_id, and parent_ids
-            # has been omitted for brevity):
-            [
-                {
-                    "data": {"input": "hello"},
-                    "event": "on_chain_start",
-                    "metadata": {},
-                    "name": "reverse",
-                    "tags": [],
-                },
-                {
-                    "data": {"chunk": "olleh"},
-                    "event": "on_chain_stream",
-                    "metadata": {},
-                    "name": "reverse",
-                    "tags": [],
-                },
-                {
-                    "data": {"output": "olleh"},
-                    "event": "on_chain_end",
-                    "metadata": {},
-                    "name": "reverse",
-                    "tags": [],
-                },
-            ]
+        events = [event async for event in chain.astream_events("hello", version="v2")]
 
+        # will produce the following events (run_id, and parent_ids
+        # has been omitted for brevity):
+        [
+            {
+                "data": {"input": "hello"},
+                "event": "on_chain_start",
+                "metadata": {},
+                "name": "reverse",
+                "tags": [],
+            },
+            {
+                "data": {"chunk": "olleh"},
+                "event": "on_chain_stream",
+                "metadata": {},
+                "name": "reverse",
+                "tags": [],
+            },
+            {
+                "data": {"output": "olleh"},
+                "event": "on_chain_end",
+                "metadata": {},
+                "name": "reverse",
+                "tags": [],
+            },
+        ]
+        ```
 
         Example: Dispatch Custom Event
 
-        .. code-block:: python
-
-            from langchain_core.callbacks.manager import (
-                adispatch_custom_event,
-            )
-            from langchain_core.runnables import RunnableLambda, RunnableConfig
-            import asyncio
+        ```python
+        from langchain_core.callbacks.manager import (
+            adispatch_custom_event,
+        )
+        from langchain_core.runnables import RunnableLambda, RunnableConfig
+        import asyncio
 
 
-            async def slow_thing(some_input: str, config: RunnableConfig) -> str:
-                \"\"\"Do something that takes a long time.\"\"\"
-                await asyncio.sleep(1) # Placeholder for some slow operation
-                await adispatch_custom_event(
-                    "progress_event",
-                    {"message": "Finished step 1 of 3"},
-                    config=config # Must be included for python < 3.10
-                )
-                await asyncio.sleep(1) # Placeholder for some slow operation
-                await adispatch_custom_event(
-                    "progress_event",
-                    {"message": "Finished step 2 of 3"},
-                    config=config # Must be included for python < 3.10
-                )
-                await asyncio.sleep(1) # Placeholder for some slow operation
-                return "Done"
+        async def slow_thing(some_input: str, config: RunnableConfig) -> str:
+            \"\"\"Do something that takes a long time.\"\"\"
+            await asyncio.sleep(1) # Placeholder for some slow operation
+            await adispatch_custom_event(
+                "progress_event",
+                {"message": "Finished step 1 of 3"},
+                config=config # Must be included for python < 3.10
+            )
+            await asyncio.sleep(1) # Placeholder for some slow operation
+            await adispatch_custom_event(
+                "progress_event",
+                {"message": "Finished step 2 of 3"},
+                config=config # Must be included for python < 3.10
+            )
+            await asyncio.sleep(1) # Placeholder for some slow operation
+            return "Done"
 
-            slow_thing = RunnableLambda(slow_thing)
+        slow_thing = RunnableLambda(slow_thing)
 
-            async for event in slow_thing.astream_events("some_input", version="v2"):
-                print(event)
+        async for event in slow_thing.astream_events("some_input", version="v2"):
+            print(event)
+        ```
 
         Args:
             input: The input to the ``Runnable``.
@@ -1548,8 +1518,8 @@ class Runnable(ABC, Generic[Input, Output]):
     def transform(
         self,
         input: Iterator[Input],
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Iterator[Output]:
         """Transform inputs to outputs.
 
@@ -1593,8 +1563,8 @@ class Runnable(ABC, Generic[Input, Output]):
     async def atransform(
         self,
         input: AsyncIterator[Input],
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> AsyncIterator[Output]:
         """Transform inputs to outputs.
 
@@ -1649,13 +1619,11 @@ class Runnable(ABC, Generic[Input, Output]):
             A new ``Runnable`` with the arguments bound.
 
         Example:
-
-        .. code-block:: python
-
+            ```python
             from langchain_ollama import ChatOllama
             from langchain_core.output_parsers import StrOutputParser
 
-            llm = ChatOllama(model="llama2")
+            llm = ChatOllama(model="llama3.1")
 
             # Without bind.
             chain = llm | StrOutputParser()
@@ -1668,13 +1636,13 @@ class Runnable(ABC, Generic[Input, Output]):
 
             chain.invoke("Repeat quoted words exactly: 'One two three four five.'")
             # Output is 'One two'
-
+            ```
         """
         return RunnableBinding(bound=self, kwargs=kwargs, config={})
 
     def with_config(
         self,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         # Sadly Unpack is not well-supported by mypy so this will have to be untyped
         **kwargs: Any,
     ) -> Runnable[Input, Output]:
@@ -1700,15 +1668,15 @@ class Runnable(ABC, Generic[Input, Output]):
     def with_listeners(
         self,
         *,
-        on_start: Optional[
-            Union[Callable[[Run], None], Callable[[Run, RunnableConfig], None]]
-        ] = None,
-        on_end: Optional[
-            Union[Callable[[Run], None], Callable[[Run, RunnableConfig], None]]
-        ] = None,
-        on_error: Optional[
-            Union[Callable[[Run], None], Callable[[Run, RunnableConfig], None]]
-        ] = None,
+        on_start: Callable[[Run], None]
+        | Callable[[Run, RunnableConfig], None]
+        | None = None,
+        on_end: Callable[[Run], None]
+        | Callable[[Run, RunnableConfig], None]
+        | None = None,
+        on_error: Callable[[Run], None]
+        | Callable[[Run, RunnableConfig], None]
+        | None = None,
     ) -> Runnable[Input, Output]:
         """Bind lifecycle listeners to a ``Runnable``, returning a new ``Runnable``.
 
@@ -1728,9 +1696,7 @@ class Runnable(ABC, Generic[Input, Output]):
             A new ``Runnable`` with the listeners bound.
 
         Example:
-
-        .. code-block:: python
-
+            ```python
             from langchain_core.runnables import RunnableLambda
             from langchain_core.tracers.schemas import Run
 
@@ -1753,7 +1719,7 @@ class Runnable(ABC, Generic[Input, Output]):
                 on_start=fn_start, on_end=fn_end
             )
             chain.invoke(2)
-
+            ```
         """
         return RunnableBinding(
             bound=self,
@@ -1774,9 +1740,9 @@ class Runnable(ABC, Generic[Input, Output]):
     def with_alisteners(
         self,
         *,
-        on_start: Optional[AsyncListener] = None,
-        on_end: Optional[AsyncListener] = None,
-        on_error: Optional[AsyncListener] = None,
+        on_start: AsyncListener | None = None,
+        on_end: AsyncListener | None = None,
+        on_error: AsyncListener | None = None,
     ) -> Runnable[Input, Output]:
         """Bind async lifecycle listeners to a ``Runnable``.
 
@@ -1798,9 +1764,7 @@ class Runnable(ABC, Generic[Input, Output]):
             A new ``Runnable`` with the listeners bound.
 
         Example:
-
-        .. code-block:: python
-
+            ```python
             from langchain_core.runnables import RunnableLambda, Runnable
             from datetime import datetime, timezone
             import time
@@ -1809,17 +1773,17 @@ class Runnable(ABC, Generic[Input, Output]):
             def format_t(timestamp: float) -> str:
                 return datetime.fromtimestamp(timestamp, tz=timezone.utc).isoformat()
 
-            async def test_runnable(time_to_sleep : int):
+            async def test_runnable(time_to_sleep: int):
                 print(f"Runnable[{time_to_sleep}s]: starts at {format_t(time.time())}")
                 await asyncio.sleep(time_to_sleep)
                 print(f"Runnable[{time_to_sleep}s]: ends at {format_t(time.time())}")
 
-            async def fn_start(run_obj : Runnable):
+            async def fn_start(run_obj: Runnable):
                 print(f"on start callback starts at {format_t(time.time())}")
                 await asyncio.sleep(3)
                 print(f"on start callback ends at {format_t(time.time())}")
 
-            async def fn_end(run_obj : Runnable):
+            async def fn_end(run_obj: Runnable):
                 print(f"on end callback starts at {format_t(time.time())}")
                 await asyncio.sleep(2)
                 print(f"on end callback ends at {format_t(time.time())}")
@@ -1846,6 +1810,7 @@ class Runnable(ABC, Generic[Input, Output]):
             on end callback ends at 2025-03-01T07:05:29.883893+00:00
             on end callback ends at 2025-03-01T07:05:30.884831+00:00
 
+            ```
         """
         return RunnableBinding(
             bound=self,
@@ -1866,8 +1831,8 @@ class Runnable(ABC, Generic[Input, Output]):
     def with_types(
         self,
         *,
-        input_type: Optional[type[Input]] = None,
-        output_type: Optional[type[Output]] = None,
+        input_type: type[Input] | None = None,
+        output_type: type[Output] | None = None,
     ) -> Runnable[Input, Output]:
         """Bind input and output types to a ``Runnable``, returning a new ``Runnable``.
 
@@ -1890,7 +1855,7 @@ class Runnable(ABC, Generic[Input, Output]):
         *,
         retry_if_exception_type: tuple[type[BaseException], ...] = (Exception,),
         wait_exponential_jitter: bool = True,
-        exponential_jitter_params: Optional[ExponentialJitterParams] = None,
+        exponential_jitter_params: ExponentialJitterParams | None = None,
         stop_after_attempt: int = 3,
     ) -> Runnable[Input, Output]:
         """Create a new Runnable that retries the original Runnable on exceptions.
@@ -1910,9 +1875,7 @@ class Runnable(ABC, Generic[Input, Output]):
             A new Runnable that retries the original Runnable on exceptions.
 
         Example:
-
-        .. code-block:: python
-
+            ```python
             from langchain_core.runnables import RunnableLambda
 
             count = 0
@@ -1937,7 +1900,7 @@ class Runnable(ABC, Generic[Input, Output]):
                 pass
 
             assert count == 2
-
+            ```
         """
         # Import locally to prevent circular import
         from langchain_core.runnables.retry import RunnableRetry  # noqa: PLC0415
@@ -1961,19 +1924,17 @@ class Runnable(ABC, Generic[Input, Output]):
             A new ``Runnable`` that maps a list of inputs to a list of outputs.
 
         Example:
+            ```python
+            from langchain_core.runnables import RunnableLambda
 
-            .. code-block:: python
-
-                    from langchain_core.runnables import RunnableLambda
-
-
-                    def _lambda(x: int) -> int:
-                        return x + 1
 
+            def _lambda(x: int) -> int:
+                return x + 1
 
-                    runnable = RunnableLambda(_lambda)
-                    print(runnable.map().invoke([1, 2, 3]))  # [2, 3, 4]
 
+            runnable = RunnableLambda(_lambda)
+            print(runnable.map().invoke([1, 2, 3]))  # [2, 3, 4]
+            ```
         """
         return RunnableEach(bound=self)
 
@@ -1982,7 +1943,7 @@ class Runnable(ABC, Generic[Input, Output]):
         fallbacks: Sequence[Runnable[Input, Output]],
         *,
         exceptions_to_handle: tuple[type[BaseException], ...] = (Exception,),
-        exception_key: Optional[str] = None,
+        exception_key: str | None = None,
     ) -> RunnableWithFallbacksT[Input, Output]:
         """Add fallbacks to a ``Runnable``, returning a new ``Runnable``.
 
@@ -2005,27 +1966,26 @@ class Runnable(ABC, Generic[Input, Output]):
             fallback in order, upon failures.
 
         Example:
+            ```python
+            from typing import Iterator
 
-            .. code-block:: python
-
-                from typing import Iterator
-
-                from langchain_core.runnables import RunnableGenerator
+            from langchain_core.runnables import RunnableGenerator
 
 
-                def _generate_immediate_error(input: Iterator) -> Iterator[str]:
-                    raise ValueError()
-                    yield ""
+            def _generate_immediate_error(input: Iterator) -> Iterator[str]:
+                raise ValueError()
+                yield ""
 
 
-                def _generate(input: Iterator) -> Iterator[str]:
-                    yield from "foo bar"
+            def _generate(input: Iterator) -> Iterator[str]:
+                yield from "foo bar"
 
 
-                runnable = RunnableGenerator(_generate_immediate_error).with_fallbacks(
-                    [RunnableGenerator(_generate)]
-                )
-                print("".join(runnable.stream({})))  # foo bar
+            runnable = RunnableGenerator(_generate_immediate_error).with_fallbacks(
+                [RunnableGenerator(_generate)]
+            )
+            print("".join(runnable.stream({})))  # foo bar
+            ```
 
         Args:
             fallbacks: A sequence of runnables to try if the original ``Runnable``
@@ -2058,16 +2018,14 @@ class Runnable(ABC, Generic[Input, Output]):
 
     def _call_with_config(
         self,
-        func: Union[
-            Callable[[Input], Output],
-            Callable[[Input, CallbackManagerForChainRun], Output],
-            Callable[[Input, CallbackManagerForChainRun, RunnableConfig], Output],
-        ],
+        func: Callable[[Input], Output]
+        | Callable[[Input, CallbackManagerForChainRun], Output]
+        | Callable[[Input, CallbackManagerForChainRun, RunnableConfig], Output],
         input_: Input,
-        config: Optional[RunnableConfig],
-        run_type: Optional[str] = None,
-        serialized: Optional[dict[str, Any]] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None,
+        run_type: str | None = None,
+        serialized: dict[str, Any] | None = None,
+        **kwargs: Any | None,
     ) -> Output:
         """Call with config.
 
@@ -2109,19 +2067,16 @@ class Runnable(ABC, Generic[Input, Output]):
 
     async def _acall_with_config(
         self,
-        func: Union[
-            Callable[[Input], Awaitable[Output]],
-            Callable[[Input, AsyncCallbackManagerForChainRun], Awaitable[Output]],
-            Callable[
-                [Input, AsyncCallbackManagerForChainRun, RunnableConfig],
-                Awaitable[Output],
-            ],
+        func: Callable[[Input], Awaitable[Output]]
+        | Callable[[Input, AsyncCallbackManagerForChainRun], Awaitable[Output]]
+        | Callable[
+            [Input, AsyncCallbackManagerForChainRun, RunnableConfig], Awaitable[Output]
         ],
         input_: Input,
-        config: Optional[RunnableConfig],
-        run_type: Optional[str] = None,
-        serialized: Optional[dict[str, Any]] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None,
+        run_type: str | None = None,
+        serialized: dict[str, Any] | None = None,
+        **kwargs: Any | None,
     ) -> Output:
         """Async call with config.
 
@@ -2155,23 +2110,20 @@ class Runnable(ABC, Generic[Input, Output]):
 
     def _batch_with_config(
         self,
-        func: Union[
-            Callable[[list[Input]], list[Union[Exception, Output]]],
-            Callable[
-                [list[Input], list[CallbackManagerForChainRun]],
-                list[Union[Exception, Output]],
-            ],
-            Callable[
-                [list[Input], list[CallbackManagerForChainRun], list[RunnableConfig]],
-                list[Union[Exception, Output]],
-            ],
+        func: Callable[[list[Input]], list[Exception | Output]]
+        | Callable[
+            [list[Input], list[CallbackManagerForChainRun]], list[Exception | Output]
+        ]
+        | Callable[
+            [list[Input], list[CallbackManagerForChainRun], list[RunnableConfig]],
+            list[Exception | Output],
         ],
         inputs: list[Input],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: RunnableConfig | list[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
-        run_type: Optional[str] = None,
-        **kwargs: Optional[Any],
+        run_type: str | None = None,
+        **kwargs: Any | None,
     ) -> list[Output]:
         """Transform a list of inputs to a list of outputs, with callbacks.
 
@@ -2193,14 +2145,14 @@ class Runnable(ABC, Generic[Input, Output]):
                 run_id=config.pop("run_id", None),
             )
             for callback_manager, input_, config in zip(
-                callback_managers, inputs, configs
+                callback_managers, inputs, configs, strict=False
             )
         ]
         try:
             if accepts_config(func):
                 kwargs["config"] = [
                     patch_config(c, callbacks=rm.get_child())
-                    for c, rm in zip(configs, run_managers)
+                    for c, rm in zip(configs, run_managers, strict=False)
                 ]
             if accepts_run_manager(func):
                 kwargs["run_manager"] = run_managers
@@ -2212,8 +2164,8 @@ class Runnable(ABC, Generic[Input, Output]):
                 return cast("list[Output]", [e for _ in inputs])
             raise
         else:
-            first_exception: Optional[Exception] = None
-            for run_manager, out in zip(run_managers, output):
+            first_exception: Exception | None = None
+            for run_manager, out in zip(run_managers, output, strict=False):
                 if isinstance(out, Exception):
                     first_exception = first_exception or out
                     run_manager.on_chain_error(out)
@@ -2225,27 +2177,21 @@ class Runnable(ABC, Generic[Input, Output]):
 
     async def _abatch_with_config(
         self,
-        func: Union[
-            Callable[[list[Input]], Awaitable[list[Union[Exception, Output]]]],
-            Callable[
-                [list[Input], list[AsyncCallbackManagerForChainRun]],
-                Awaitable[list[Union[Exception, Output]]],
-            ],
-            Callable[
-                [
-                    list[Input],
-                    list[AsyncCallbackManagerForChainRun],
-                    list[RunnableConfig],
-                ],
-                Awaitable[list[Union[Exception, Output]]],
-            ],
+        func: Callable[[list[Input]], Awaitable[list[Exception | Output]]]
+        | Callable[
+            [list[Input], list[AsyncCallbackManagerForChainRun]],
+            Awaitable[list[Exception | Output]],
+        ]
+        | Callable[
+            [list[Input], list[AsyncCallbackManagerForChainRun], list[RunnableConfig]],
+            Awaitable[list[Exception | Output]],
         ],
         inputs: list[Input],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: RunnableConfig | list[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
-        run_type: Optional[str] = None,
-        **kwargs: Optional[Any],
+        run_type: str | None = None,
+        **kwargs: Any | None,
     ) -> list[Output]:
         """Transform a list of inputs to a list of outputs, with callbacks.
 
@@ -2270,7 +2216,7 @@ class Runnable(ABC, Generic[Input, Output]):
                     run_id=config.pop("run_id", None),
                 )
                 for callback_manager, input_, config in zip(
-                    callback_managers, inputs, configs
+                    callback_managers, inputs, configs, strict=False
                 )
             )
         )
@@ -2278,7 +2224,7 @@ class Runnable(ABC, Generic[Input, Output]):
             if accepts_config(func):
                 kwargs["config"] = [
                     patch_config(c, callbacks=rm.get_child())
-                    for c, rm in zip(configs, run_managers)
+                    for c, rm in zip(configs, run_managers, strict=False)
                 ]
             if accepts_run_manager(func):
                 kwargs["run_manager"] = run_managers
@@ -2291,9 +2237,9 @@ class Runnable(ABC, Generic[Input, Output]):
                 return cast("list[Output]", [e for _ in inputs])
             raise
         else:
-            first_exception: Optional[Exception] = None
+            first_exception: Exception | None = None
             coros: list[Awaitable[None]] = []
-            for run_manager, out in zip(run_managers, output):
+            for run_manager, out in zip(run_managers, output, strict=False):
                 if isinstance(out, Exception):
                     first_exception = first_exception or out
                     coros.append(run_manager.on_chain_error(out))
@@ -2307,21 +2253,15 @@ class Runnable(ABC, Generic[Input, Output]):
     def _transform_stream_with_config(
         self,
         inputs: Iterator[Input],
-        transformer: Union[
-            Callable[[Iterator[Input]], Iterator[Output]],
-            Callable[[Iterator[Input], CallbackManagerForChainRun], Iterator[Output]],
-            Callable[
-                [
-                    Iterator[Input],
-                    CallbackManagerForChainRun,
-                    RunnableConfig,
-                ],
-                Iterator[Output],
-            ],
+        transformer: Callable[[Iterator[Input]], Iterator[Output]]
+        | Callable[[Iterator[Input], CallbackManagerForChainRun], Iterator[Output]]
+        | Callable[
+            [Iterator[Input], CallbackManagerForChainRun, RunnableConfig],
+            Iterator[Output],
         ],
-        config: Optional[RunnableConfig],
-        run_type: Optional[str] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None,
+        run_type: str | None = None,
+        **kwargs: Any | None,
     ) -> Iterator[Output]:
         """Transform a stream with config.
 
@@ -2334,9 +2274,9 @@ class Runnable(ABC, Generic[Input, Output]):
         # tee the input so we can iterate over it twice
         input_for_tracing, input_for_transform = tee(inputs, 2)
         # Start the input iterator to ensure the input Runnable starts before this one
-        final_input: Optional[Input] = next(input_for_tracing, None)
+        final_input: Input | None = next(input_for_tracing, None)
         final_input_supported = True
-        final_output: Optional[Output] = None
+        final_output: Output | None = None
         final_output_supported = True
 
         config = ensure_config(config)
@@ -2407,24 +2347,18 @@ class Runnable(ABC, Generic[Input, Output]):
     async def _atransform_stream_with_config(
         self,
         inputs: AsyncIterator[Input],
-        transformer: Union[
-            Callable[[AsyncIterator[Input]], AsyncIterator[Output]],
-            Callable[
-                [AsyncIterator[Input], AsyncCallbackManagerForChainRun],
-                AsyncIterator[Output],
-            ],
-            Callable[
-                [
-                    AsyncIterator[Input],
-                    AsyncCallbackManagerForChainRun,
-                    RunnableConfig,
-                ],
-                AsyncIterator[Output],
-            ],
+        transformer: Callable[[AsyncIterator[Input]], AsyncIterator[Output]]
+        | Callable[
+            [AsyncIterator[Input], AsyncCallbackManagerForChainRun],
+            AsyncIterator[Output],
+        ]
+        | Callable[
+            [AsyncIterator[Input], AsyncCallbackManagerForChainRun, RunnableConfig],
+            AsyncIterator[Output],
         ],
-        config: Optional[RunnableConfig],
-        run_type: Optional[str] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None,
+        run_type: str | None = None,
+        **kwargs: Any | None,
     ) -> AsyncIterator[Output]:
         """Transform a stream with config.
 
@@ -2437,9 +2371,9 @@ class Runnable(ABC, Generic[Input, Output]):
         # tee the input so we can iterate over it twice
         input_for_tracing, input_for_transform = atee(inputs, 2)
         # Start the input iterator to ensure the input Runnable starts before this one
-        final_input: Optional[Input] = await py_anext(input_for_tracing, None)
+        final_input: Input | None = await py_anext(input_for_tracing, None)
         final_input_supported = True
-        final_output: Optional[Output] = None
+        final_output: Output | None = None
         final_output_supported = True
 
         config = ensure_config(config)
@@ -2516,11 +2450,11 @@ class Runnable(ABC, Generic[Input, Output]):
     @beta_decorator.beta(message="This API is in beta and may change in the future.")
     def as_tool(
         self,
-        args_schema: Optional[type[BaseModel]] = None,
+        args_schema: type[BaseModel] | None = None,
         *,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        arg_types: Optional[dict[str, type]] = None,
+        name: str | None = None,
+        description: str | None = None,
+        arg_types: dict[str, type] | None = None,
     ) -> BaseTool:
         """Create a ``BaseTool`` from a ``Runnable``.
 
@@ -2542,82 +2476,82 @@ class Runnable(ABC, Generic[Input, Output]):
 
         Typed dict input:
 
-        .. code-block:: python
-
-            from typing_extensions import TypedDict
-            from langchain_core.runnables import RunnableLambda
+        ```python
+        from typing_extensions import TypedDict
+        from langchain_core.runnables import RunnableLambda
 
 
-            class Args(TypedDict):
-                a: int
-                b: list[int]
+        class Args(TypedDict):
+            a: int
+            b: list[int]
 
 
-            def f(x: Args) -> str:
-                return str(x["a"] * max(x["b"]))
+        def f(x: Args) -> str:
+            return str(x["a"] * max(x["b"]))
 
 
-            runnable = RunnableLambda(f)
-            as_tool = runnable.as_tool()
-            as_tool.invoke({"a": 3, "b": [1, 2]})
+        runnable = RunnableLambda(f)
+        as_tool = runnable.as_tool()
+        as_tool.invoke({"a": 3, "b": [1, 2]})
+        ```
 
         ``dict`` input, specifying schema via ``args_schema``:
 
-        .. code-block:: python
-
-            from typing import Any
-            from pydantic import BaseModel, Field
-            from langchain_core.runnables import RunnableLambda
+        ```python
+        from typing import Any
+        from pydantic import BaseModel, Field
+        from langchain_core.runnables import RunnableLambda
 
-            def f(x: dict[str, Any]) -> str:
-                return str(x["a"] * max(x["b"]))
+        def f(x: dict[str, Any]) -> str:
+            return str(x["a"] * max(x["b"]))
 
-            class FSchema(BaseModel):
-                \"\"\"Apply a function to an integer and list of integers.\"\"\"
+        class FSchema(BaseModel):
+            \"\"\"Apply a function to an integer and list of integers.\"\"\"
 
-                a: int = Field(..., description="Integer")
-                b: list[int] = Field(..., description="List of ints")
+            a: int = Field(..., description="Integer")
+            b: list[int] = Field(..., description="List of ints")
 
-            runnable = RunnableLambda(f)
-            as_tool = runnable.as_tool(FSchema)
-            as_tool.invoke({"a": 3, "b": [1, 2]})
+        runnable = RunnableLambda(f)
+        as_tool = runnable.as_tool(FSchema)
+        as_tool.invoke({"a": 3, "b": [1, 2]})
+        ```
 
         ``dict`` input, specifying schema via ``arg_types``:
 
-        .. code-block:: python
-
-            from typing import Any
-            from langchain_core.runnables import RunnableLambda
+        ```python
+        from typing import Any
+        from langchain_core.runnables import RunnableLambda
 
 
-            def f(x: dict[str, Any]) -> str:
-                return str(x["a"] * max(x["b"]))
+        def f(x: dict[str, Any]) -> str:
+            return str(x["a"] * max(x["b"]))
 
 
-            runnable = RunnableLambda(f)
-            as_tool = runnable.as_tool(arg_types={"a": int, "b": list[int]})
-            as_tool.invoke({"a": 3, "b": [1, 2]})
+        runnable = RunnableLambda(f)
+        as_tool = runnable.as_tool(arg_types={"a": int, "b": list[int]})
+        as_tool.invoke({"a": 3, "b": [1, 2]})
+        ```
 
         String input:
 
-        .. code-block:: python
-
-            from langchain_core.runnables import RunnableLambda
+        ```python
+        from langchain_core.runnables import RunnableLambda
 
 
-            def f(x: str) -> str:
-                return x + "a"
+        def f(x: str) -> str:
+            return x + "a"
 
 
-            def g(x: str) -> str:
-                return x + "z"
+        def g(x: str) -> str:
+            return x + "z"
 
 
-            runnable = RunnableLambda(f) | g
-            as_tool = runnable.as_tool()
-            as_tool.invoke("b")
+        runnable = RunnableLambda(f) | g
+        as_tool = runnable.as_tool()
+        as_tool.invoke("b")
+        ```
 
-        .. versionadded:: 0.2.14
+        !!! version-added "Added in version 0.2.14"
 
         """
         # Avoid circular import
@@ -2635,7 +2569,7 @@ class Runnable(ABC, Generic[Input, Output]):
 class RunnableSerializable(Serializable, Runnable[Input, Output]):
     """Runnable that can be serialized to JSON."""
 
-    name: Optional[str] = None
+    name: str | None = None
 
     model_config = ConfigDict(
         # Suppress warnings from pydantic protected namespaces
@@ -2644,7 +2578,7 @@ class RunnableSerializable(Serializable, Runnable[Input, Output]):
     )
 
     @override
-    def to_json(self) -> Union[SerializedConstructor, SerializedNotImplemented]:
+    def to_json(self) -> SerializedConstructor | SerializedNotImplemented:
         """Serialize the ``Runnable`` to JSON.
 
         Returns:
@@ -2670,32 +2604,29 @@ class RunnableSerializable(Serializable, Runnable[Input, Output]):
         Returns:
             A new ``Runnable`` with the fields configured.
 
-        .. code-block:: python
+        ```python
+        from langchain_core.runnables import ConfigurableField
+        from langchain_openai import ChatOpenAI
 
-            from langchain_core.runnables import ConfigurableField
-            from langchain_openai import ChatOpenAI
-
-            model = ChatOpenAI(max_tokens=20).configurable_fields(
-                max_tokens=ConfigurableField(
-                    id="output_token_number",
-                    name="Max tokens in the output",
-                    description="The maximum number of tokens in the output",
-                )
-            )
-
-            # max_tokens = 20
-            print(
-                "max_tokens_20: ", model.invoke("tell me something about chess").content
+        model = ChatOpenAI(max_tokens=20).configurable_fields(
+            max_tokens=ConfigurableField(
+                id="output_token_number",
+                name="Max tokens in the output",
+                description="The maximum number of tokens in the output",
             )
+        )
 
-            # max_tokens = 200
-            print(
-                "max_tokens_200: ",
-                model.with_config(configurable={"output_token_number": 200})
-                .invoke("tell me something about chess")
-                .content,
-            )
+        # max_tokens = 20
+        print("max_tokens_20: ", model.invoke("tell me something about chess").content)
 
+        # max_tokens = 200
+        print(
+            "max_tokens_200: ",
+            model.with_config(configurable={"output_token_number": 200})
+            .invoke("tell me something about chess")
+            .content,
+        )
+        ```
         """
         # Import locally to prevent circular import
         from langchain_core.runnables.configurable import (  # noqa: PLC0415
@@ -2719,7 +2650,7 @@ class RunnableSerializable(Serializable, Runnable[Input, Output]):
         *,
         default_key: str = "default",
         prefix_keys: bool = False,
-        **kwargs: Union[Runnable[Input, Output], Callable[[], Runnable[Input, Output]]],
+        **kwargs: Runnable[Input, Output] | Callable[[], Runnable[Input, Output]],
     ) -> RunnableSerializable[Input, Output]:
         """Configure alternatives for ``Runnables`` that can be set at runtime.
 
@@ -2736,30 +2667,29 @@ class RunnableSerializable(Serializable, Runnable[Input, Output]):
         Returns:
             A new ``Runnable`` with the alternatives configured.
 
-        .. code-block:: python
-
-            from langchain_anthropic import ChatAnthropic
-            from langchain_core.runnables.utils import ConfigurableField
-            from langchain_openai import ChatOpenAI
-
-            model = ChatAnthropic(
-                model_name="claude-3-7-sonnet-20250219"
-            ).configurable_alternatives(
-                ConfigurableField(id="llm"),
-                default_key="anthropic",
-                openai=ChatOpenAI(),
-            )
-
-            # uses the default model ChatAnthropic
-            print(model.invoke("which organization created you?").content)
+        ```python
+        from langchain_anthropic import ChatAnthropic
+        from langchain_core.runnables.utils import ConfigurableField
+        from langchain_openai import ChatOpenAI
+
+        model = ChatAnthropic(
+            model_name="claude-3-7-sonnet-20250219"
+        ).configurable_alternatives(
+            ConfigurableField(id="llm"),
+            default_key="anthropic",
+            openai=ChatOpenAI(),
+        )
 
-            # uses ChatOpenAI
-            print(
-                model.with_config(configurable={"llm": "openai"})
-                .invoke("which organization created you?")
-                .content
-            )
+        # uses the default model ChatAnthropic
+        print(model.invoke("which organization created you?").content)
 
+        # uses ChatOpenAI
+        print(
+            model.with_config(configurable={"llm": "openai"})
+            .invoke("which organization created you?")
+            .content
+        )
+        ```
         """
         # Import locally to prevent circular import
         from langchain_core.runnables.configurable import (  # noqa: PLC0415
@@ -2776,7 +2706,7 @@ class RunnableSerializable(Serializable, Runnable[Input, Output]):
 
 
 def _seq_input_schema(
-    steps: list[Runnable[Any, Any]], config: Optional[RunnableConfig]
+    steps: list[Runnable[Any, Any]], config: RunnableConfig | None
 ) -> type[BaseModel]:
     # Import locally to prevent circular import
     from langchain_core.runnables.passthrough import (  # noqa: PLC0415
@@ -2806,7 +2736,7 @@ def _seq_input_schema(
 
 
 def _seq_output_schema(
-    steps: list[Runnable[Any, Any]], config: Optional[RunnableConfig]
+    steps: list[Runnable[Any, Any]], config: RunnableConfig | None
 ) -> type[BaseModel]:
     # Import locally to prevent circular import
     from langchain_core.runnables.passthrough import (  # noqa: PLC0415
@@ -2884,7 +2814,7 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
     streaming will only begin after this component is run. If there are
     multiple blocking components, streaming begins after the last one.
 
-    .. note::
+    !!! note
         ``RunnableLambdas`` do not support ``transform`` by default! So if you need to
         use a ``RunnableLambdas`` be careful about where you place them in a
         ``RunnableSequence`` (if you need to use the ``stream``/``astream`` methods).
@@ -2895,50 +2825,49 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
     Here is a simple example that uses simple functions to illustrate the use of
     ``RunnableSequence``:
 
-        .. code-block:: python
-
-            from langchain_core.runnables import RunnableLambda
+        ```python
+        from langchain_core.runnables import RunnableLambda
 
 
-            def add_one(x: int) -> int:
-                return x + 1
+        def add_one(x: int) -> int:
+            return x + 1
 
 
-            def mul_two(x: int) -> int:
-                return x * 2
+        def mul_two(x: int) -> int:
+            return x * 2
 
 
-            runnable_1 = RunnableLambda(add_one)
-            runnable_2 = RunnableLambda(mul_two)
-            sequence = runnable_1 | runnable_2
-            # Or equivalently:
-            # sequence = RunnableSequence(first=runnable_1, last=runnable_2)
-            sequence.invoke(1)
-            await sequence.ainvoke(1)
+        runnable_1 = RunnableLambda(add_one)
+        runnable_2 = RunnableLambda(mul_two)
+        sequence = runnable_1 | runnable_2
+        # Or equivalently:
+        # sequence = RunnableSequence(first=runnable_1, last=runnable_2)
+        sequence.invoke(1)
+        await sequence.ainvoke(1)
 
-            sequence.batch([1, 2, 3])
-            await sequence.abatch([1, 2, 3])
+        sequence.batch([1, 2, 3])
+        await sequence.abatch([1, 2, 3])
+        ```
 
     Here's an example that uses streams JSON output generated by an LLM:
 
-        .. code-block:: python
-
-            from langchain_core.output_parsers.json import SimpleJsonOutputParser
-            from langchain_openai import ChatOpenAI
+        ```python
+        from langchain_core.output_parsers.json import SimpleJsonOutputParser
+        from langchain_openai import ChatOpenAI
 
-            prompt = PromptTemplate.from_template(
-                "In JSON format, give me a list of {topic} and their "
-                "corresponding names in French, Spanish and in a "
-                "Cat Language."
-            )
-
-            model = ChatOpenAI()
-            chain = prompt | model | SimpleJsonOutputParser()
+        prompt = PromptTemplate.from_template(
+            "In JSON format, give me a list of {topic} and their "
+            "corresponding names in French, Spanish and in a "
+            "Cat Language."
+        )
 
-            async for chunk in chain.astream({"topic": "colors"}):
-                print("-")  # noqa: T201
-                print(chunk, sep="", flush=True)  # noqa: T201
+        model = ChatOpenAI()
+        chain = prompt | model | SimpleJsonOutputParser()
 
+        async for chunk in chain.astream({"topic": "colors"}):
+            print("-")  # noqa: T201
+            print(chunk, sep="", flush=True)  # noqa: T201
+        ```
     """
 
     # The steps are broken into first, middle and last, solely for type checking
@@ -2954,10 +2883,10 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
     def __init__(
         self,
         *steps: RunnableLike,
-        name: Optional[str] = None,
-        first: Optional[Runnable[Any, Any]] = None,
-        middle: Optional[list[Runnable[Any, Any]]] = None,
-        last: Optional[Runnable[Any, Any]] = None,
+        name: str | None = None,
+        first: Runnable[Any, Any] | None = None,
+        middle: list[Runnable[Any, Any]] | None = None,
+        last: Runnable[Any, Any] | None = None,
     ) -> None:
         """Create a new ``RunnableSequence``.
 
@@ -3031,9 +2960,7 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
         return self.last.OutputType
 
     @override
-    def get_input_schema(
-        self, config: Optional[RunnableConfig] = None
-    ) -> type[BaseModel]:
+    def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
         """Get the input schema of the ``Runnable``.
 
         Args:
@@ -3047,7 +2974,7 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
 
     @override
     def get_output_schema(
-        self, config: Optional[RunnableConfig] = None
+        self, config: RunnableConfig | None = None
     ) -> type[BaseModel]:
         """Get the output schema of the ``Runnable``.
 
@@ -3075,7 +3002,7 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
         )
 
     @override
-    def get_graph(self, config: Optional[RunnableConfig] = None) -> Graph:
+    def get_graph(self, config: RunnableConfig | None = None) -> Graph:
         """Get the graph representation of the ``Runnable``.
 
         Args:
@@ -3118,13 +3045,11 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
     @override
     def __or__(
         self,
-        other: Union[
-            Runnable[Any, Other],
-            Callable[[Iterator[Any]], Iterator[Other]],
-            Callable[[AsyncIterator[Any]], AsyncIterator[Other]],
-            Callable[[Any], Other],
-            Mapping[str, Union[Runnable[Any, Other], Callable[[Any], Other], Any]],
-        ],
+        other: Runnable[Any, Other]
+        | Callable[[Iterator[Any]], Iterator[Other]]
+        | Callable[[AsyncIterator[Any]], AsyncIterator[Other]]
+        | Callable[[Any], Other]
+        | Mapping[str, Runnable[Any, Other] | Callable[[Any], Other] | Any],
     ) -> RunnableSerializable[Input, Other]:
         if isinstance(other, RunnableSequence):
             return RunnableSequence(
@@ -3147,13 +3072,11 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
     @override
     def __ror__(
         self,
-        other: Union[
-            Runnable[Other, Any],
-            Callable[[Iterator[Other]], Iterator[Any]],
-            Callable[[AsyncIterator[Other]], AsyncIterator[Any]],
-            Callable[[Other], Any],
-            Mapping[str, Union[Runnable[Other, Any], Callable[[Other], Any], Any]],
-        ],
+        other: Runnable[Other, Any]
+        | Callable[[Iterator[Other]], Iterator[Any]]
+        | Callable[[AsyncIterator[Other]], AsyncIterator[Any]]
+        | Callable[[Other], Any]
+        | Mapping[str, Runnable[Other, Any] | Callable[[Other], Any] | Any],
     ) -> RunnableSerializable[Other, Output]:
         if isinstance(other, RunnableSequence):
             return RunnableSequence(
@@ -3175,7 +3098,7 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
 
     @override
     def invoke(
-        self, input: Input, config: Optional[RunnableConfig] = None, **kwargs: Any
+        self, input: Input, config: RunnableConfig | None = None, **kwargs: Any
     ) -> Output:
         # setup callbacks and context
         config = ensure_config(config)
@@ -3213,8 +3136,8 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
     async def ainvoke(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Output:
         # setup callbacks and context
         config = ensure_config(config)
@@ -3253,10 +3176,10 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
     def batch(
         self,
         inputs: list[Input],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: RunnableConfig | list[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
-        **kwargs: Optional[Any],
+        **kwargs: Any | None,
     ) -> list[Output]:
         if not inputs:
             return []
@@ -3283,7 +3206,9 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
                 name=config.get("run_name") or self.get_name(),
                 run_id=config.pop("run_id", None),
             )
-            for cm, input_, config in zip(callback_managers, inputs, configs)
+            for cm, input_, config in zip(
+                callback_managers, inputs, configs, strict=False
+            )
         ]
 
         # invoke
@@ -3303,7 +3228,7 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
                     inputs = step.batch(
                         [
                             inp
-                            for i, inp in zip(remaining_idxs, inputs)
+                            for i, inp in zip(remaining_idxs, inputs, strict=False)
                             if i not in failed_inputs_map
                         ],
                         [
@@ -3312,7 +3237,9 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
                                 config,
                                 callbacks=rm.get_child(f"seq:step:{stepidx + 1}"),
                             )
-                            for i, (rm, config) in enumerate(zip(run_managers, configs))
+                            for i, (rm, config) in enumerate(
+                                zip(run_managers, configs, strict=False)
+                            )
                             if i not in failed_inputs_map
                         ],
                         return_exceptions=return_exceptions,
@@ -3322,7 +3249,7 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
                     failed_inputs_map.update(
                         {
                             i: inp
-                            for i, inp in zip(remaining_idxs, inputs)
+                            for i, inp in zip(remaining_idxs, inputs, strict=False)
                             if isinstance(inp, Exception)
                         }
                     )
@@ -3348,7 +3275,7 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
                             patch_config(
                                 config, callbacks=rm.get_child(f"seq:step:{i + 1}")
                             )
-                            for rm, config in zip(run_managers, configs)
+                            for rm, config in zip(run_managers, configs, strict=False)
                         ],
                         return_exceptions=return_exceptions,
                         **(kwargs if i == 0 else {}),
@@ -3362,8 +3289,8 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
                 return cast("list[Output]", [e for _ in inputs])
             raise
         else:
-            first_exception: Optional[Exception] = None
-            for run_manager, out in zip(run_managers, inputs):
+            first_exception: Exception | None = None
+            for run_manager, out in zip(run_managers, inputs, strict=False):
                 if isinstance(out, Exception):
                     first_exception = first_exception or out
                     run_manager.on_chain_error(out)
@@ -3377,10 +3304,10 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
     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: Optional[Any],
+        **kwargs: Any | None,
     ) -> list[Output]:
         if not inputs:
             return []
@@ -3408,7 +3335,9 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
                     name=config.get("run_name") or self.get_name(),
                     run_id=config.pop("run_id", None),
                 )
-                for cm, input_, config in zip(callback_managers, inputs, configs)
+                for cm, input_, config in zip(
+                    callback_managers, inputs, configs, strict=False
+                )
             )
         )
 
@@ -3430,7 +3359,7 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
                     inputs = await step.abatch(
                         [
                             inp
-                            for i, inp in zip(remaining_idxs, inputs)
+                            for i, inp in zip(remaining_idxs, inputs, strict=False)
                             if i not in failed_inputs_map
                         ],
                         [
@@ -3439,7 +3368,9 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
                                 config,
                                 callbacks=rm.get_child(f"seq:step:{stepidx + 1}"),
                             )
-                            for i, (rm, config) in enumerate(zip(run_managers, configs))
+                            for i, (rm, config) in enumerate(
+                                zip(run_managers, configs, strict=False)
+                            )
                             if i not in failed_inputs_map
                         ],
                         return_exceptions=return_exceptions,
@@ -3449,7 +3380,7 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
                     failed_inputs_map.update(
                         {
                             i: inp
-                            for i, inp in zip(remaining_idxs, inputs)
+                            for i, inp in zip(remaining_idxs, inputs, strict=False)
                             if isinstance(inp, Exception)
                         }
                     )
@@ -3475,7 +3406,7 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
                             patch_config(
                                 config, callbacks=rm.get_child(f"seq:step:{i + 1}")
                             )
-                            for rm, config in zip(run_managers, configs)
+                            for rm, config in zip(run_managers, configs, strict=False)
                         ],
                         return_exceptions=return_exceptions,
                         **(kwargs if i == 0 else {}),
@@ -3487,9 +3418,9 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
                 return cast("list[Output]", [e for _ in inputs])
             raise
         else:
-            first_exception: Optional[Exception] = None
+            first_exception: Exception | None = None
             coros: list[Awaitable[None]] = []
-            for run_manager, out in zip(run_managers, inputs):
+            for run_manager, out in zip(run_managers, inputs, strict=False):
                 if isinstance(out, Exception):
                     first_exception = first_exception or out
                     coros.append(run_manager.on_chain_error(out))
@@ -3552,8 +3483,8 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
     def transform(
         self,
         input: Iterator[Input],
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Iterator[Output]:
         yield from self._transform_stream_with_config(
             input,
@@ -3566,8 +3497,8 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
     def stream(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Iterator[Output]:
         yield from self.transform(iter([input]), config, **kwargs)
 
@@ -3575,8 +3506,8 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
     async def atransform(
         self,
         input: AsyncIterator[Input],
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> AsyncIterator[Output]:
         async for chunk in self._atransform_stream_with_config(
             input,
@@ -3590,8 +3521,8 @@ class RunnableSequence(RunnableSerializable[Input, Output]):
     async def astream(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> AsyncIterator[Output]:
         async def input_aiter() -> AsyncIterator[Input]:
             yield input
@@ -3615,95 +3546,89 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
     Here is a simple example that uses functions to illustrate the use of
     ``RunnableParallel``:
 
-        .. code-block:: python
-
-            from langchain_core.runnables import RunnableLambda
-
-
-            def add_one(x: int) -> int:
-                return x + 1
+        ```python
+        from langchain_core.runnables import RunnableLambda
 
 
-            def mul_two(x: int) -> int:
-                return x * 2
+        def add_one(x: int) -> int:
+            return x + 1
 
 
-            def mul_three(x: int) -> int:
-                return x * 3
+        def mul_two(x: int) -> int:
+            return x * 2
 
 
-            runnable_1 = RunnableLambda(add_one)
-            runnable_2 = RunnableLambda(mul_two)
-            runnable_3 = RunnableLambda(mul_three)
+        def mul_three(x: int) -> int:
+            return x * 3
 
-            sequence = runnable_1 | {  # this dict is coerced to a RunnableParallel
-                "mul_two": runnable_2,
-                "mul_three": runnable_3,
-            }
-            # Or equivalently:
-            # sequence = runnable_1 | RunnableParallel(
-            #     {"mul_two": runnable_2, "mul_three": runnable_3}
-            # )
-            # Also equivalently:
-            # sequence = runnable_1 | RunnableParallel(
-            #     mul_two=runnable_2,
-            #     mul_three=runnable_3,
-            # )
 
-            sequence.invoke(1)
-            await sequence.ainvoke(1)
+        runnable_1 = RunnableLambda(add_one)
+        runnable_2 = RunnableLambda(mul_two)
+        runnable_3 = RunnableLambda(mul_three)
 
-            sequence.batch([1, 2, 3])
-            await sequence.abatch([1, 2, 3])
+        sequence = runnable_1 | {  # this dict is coerced to a RunnableParallel
+            "mul_two": runnable_2,
+            "mul_three": runnable_3,
+        }
+        # Or equivalently:
+        # sequence = runnable_1 | RunnableParallel(
+        #     {"mul_two": runnable_2, "mul_three": runnable_3}
+        # )
+        # Also equivalently:
+        # sequence = runnable_1 | RunnableParallel(
+        #     mul_two=runnable_2,
+        #     mul_three=runnable_3,
+        # )
+
+        sequence.invoke(1)
+        await sequence.ainvoke(1)
+
+        sequence.batch([1, 2, 3])
+        await sequence.abatch([1, 2, 3])
+        ```
 
     ``RunnableParallel`` makes it easy to run ``Runnable``s in parallel. In the below
     example, we simultaneously stream output from two different ``Runnables``:
 
-        .. code-block:: python
-
-            from langchain_core.prompts import ChatPromptTemplate
-            from langchain_core.runnables import RunnableParallel
-            from langchain_openai import ChatOpenAI
-
-            model = ChatOpenAI()
-            joke_chain = (
-                ChatPromptTemplate.from_template("tell me a joke about {topic}") | model
-            )
-            poem_chain = (
-                ChatPromptTemplate.from_template("write a 2-line poem about {topic}")
-                | model
-            )
+        ```python
+        from langchain_core.prompts import ChatPromptTemplate
+        from langchain_core.runnables import RunnableParallel
+        from langchain_openai import ChatOpenAI
 
-            runnable = RunnableParallel(joke=joke_chain, poem=poem_chain)
+        model = ChatOpenAI()
+        joke_chain = (
+            ChatPromptTemplate.from_template("tell me a joke about {topic}") | model
+        )
+        poem_chain = (
+            ChatPromptTemplate.from_template("write a 2-line poem about {topic}")
+            | model
+        )
 
-            # Display stream
-            output = {key: "" for key, _ in runnable.output_schema()}
-            for chunk in runnable.stream({"topic": "bear"}):
-                for key in chunk:
-                    output[key] = output[key] + chunk[key].content
-                print(output)  # noqa: T201
+        runnable = RunnableParallel(joke=joke_chain, poem=poem_chain)
 
+        # Display stream
+        output = {key: "" for key, _ in runnable.output_schema()}
+        for chunk in runnable.stream({"topic": "bear"}):
+            for key in chunk:
+                output[key] = output[key] + chunk[key].content
+            print(output)  # noqa: T201
+        ```
     """
 
     steps__: Mapping[str, Runnable[Input, Any]]
 
     def __init__(
         self,
-        steps__: Optional[
-            Mapping[
-                str,
-                Union[
-                    Runnable[Input, Any],
-                    Callable[[Input], Any],
-                    Mapping[str, Union[Runnable[Input, Any], Callable[[Input], Any]]],
-                ],
-            ]
-        ] = None,
-        **kwargs: Union[
-            Runnable[Input, Any],
-            Callable[[Input], Any],
-            Mapping[str, Union[Runnable[Input, Any], Callable[[Input], Any]]],
-        ],
+        steps__: Mapping[
+            str,
+            Runnable[Input, Any]
+            | Callable[[Input], Any]
+            | Mapping[str, Runnable[Input, Any] | Callable[[Input], Any]],
+        ]
+        | None = None,
+        **kwargs: Runnable[Input, Any]
+        | Callable[[Input], Any]
+        | Mapping[str, Runnable[Input, Any] | Callable[[Input], Any]],
     ) -> None:
         """Create a ``RunnableParallel``.
 
@@ -3739,9 +3664,7 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
     )
 
     @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:
         """Get the name of the ``Runnable``.
 
         Args:
@@ -3766,9 +3689,7 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
         return Any
 
     @override
-    def get_input_schema(
-        self, config: Optional[RunnableConfig] = None
-    ) -> type[BaseModel]:
+    def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
         """Get the input schema of the ``Runnable``.
 
         Args:
@@ -3798,7 +3719,7 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
 
     @override
     def get_output_schema(
-        self, config: Optional[RunnableConfig] = None
+        self, config: RunnableConfig | None = None
     ) -> type[BaseModel]:
         """Get the output schema of the ``Runnable``.
 
@@ -3826,7 +3747,7 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
         )
 
     @override
-    def get_graph(self, config: Optional[RunnableConfig] = None) -> Graph:
+    def get_graph(self, config: RunnableConfig | None = None) -> Graph:
         """Get the graph representation of the ``Runnable``.
 
         Args:
@@ -3874,7 +3795,7 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
 
     @override
     def invoke(
-        self, input: Input, config: Optional[RunnableConfig] = None, **kwargs: Any
+        self, input: Input, config: RunnableConfig | None = None, **kwargs: Any
     ) -> dict[str, Any]:
         # setup callbacks
         config = ensure_config(config)
@@ -3920,7 +3841,10 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
                     executor.submit(_invoke_step, step, input, config, key)
                     for key, step in steps.items()
                 ]
-                output = {key: future.result() for key, future in zip(steps, futures)}
+                output = {
+                    key: future.result()
+                    for key, future in zip(steps, futures, strict=False)
+                }
         # finish the root run
         except BaseException as e:
             run_manager.on_chain_error(e)
@@ -3933,8 +3857,8 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
     async def ainvoke(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> dict[str, Any]:
         # setup callbacks
         config = ensure_config(config)
@@ -3975,7 +3899,7 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
                     for key, step in steps.items()
                 )
             )
-            output = dict(zip(steps, results))
+            output = dict(zip(steps, results, strict=False))
         # finish the root run
         except BaseException as e:
             await run_manager.on_chain_error(e)
@@ -4035,7 +3959,7 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
     def transform(
         self,
         input: Iterator[Input],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> Iterator[dict[str, Any]]:
         yield from self._transform_stream_with_config(
@@ -4046,8 +3970,8 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
     def stream(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Iterator[dict[str, Any]]:
         yield from self.transform(iter([input]), config)
 
@@ -4077,7 +4001,7 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
         ]
 
         # Wrap in a coroutine to satisfy linter
-        async def get_next_chunk(generator: AsyncIterator) -> Optional[Output]:
+        async def get_next_chunk(generator: AsyncIterator) -> Output | None:
             return await py_anext(generator)
 
         # Start the first iteration of each generator
@@ -4106,7 +4030,7 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
     async def atransform(
         self,
         input: AsyncIterator[Input],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[dict[str, Any]]:
         async for chunk in self._atransform_stream_with_config(
@@ -4118,8 +4042,8 @@ class RunnableParallel(RunnableSerializable[Input, dict[str, Any]]):
     async def astream(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> AsyncIterator[dict[str, Any]]:
         async def input_aiter() -> AsyncIterator[Input]:
             yield input
@@ -4144,7 +4068,7 @@ class RunnableGenerator(Runnable[Input, Output]):
     ``RunnableGenerator`` allows it to emit output chunks as soon as they are streamed
     in from the previous step.
 
-    .. note::
+    !!! note
         If a generator function has a ``signature A -> Iterator[B]``, such that it
         requires its input from the previous step to be completed before emitting chunks
         (e.g., most LLMs need the entire prompt available to start generating), it can
@@ -4152,92 +4076,86 @@ class RunnableGenerator(Runnable[Input, Output]):
 
     Here is an example to show the basic mechanics of a ``RunnableGenerator``:
 
-        .. code-block:: python
+        ```python
+        from typing import Any, AsyncIterator, Iterator
 
-            from typing import Any, AsyncIterator, Iterator
+        from langchain_core.runnables import RunnableGenerator
 
-            from langchain_core.runnables import RunnableGenerator
 
-
-            def gen(input: Iterator[Any]) -> Iterator[str]:
-                for token in ["Have", " a", " nice", " day"]:
-                    yield token
+        def gen(input: Iterator[Any]) -> Iterator[str]:
+            for token in ["Have", " a", " nice", " day"]:
+                yield token
 
 
-            runnable = RunnableGenerator(gen)
-            runnable.invoke(None)  # "Have a nice day"
-            list(runnable.stream(None))  # ["Have", " a", " nice", " day"]
-            runnable.batch([None, None])  # ["Have a nice day", "Have a nice day"]
+        runnable = RunnableGenerator(gen)
+        runnable.invoke(None)  # "Have a nice day"
+        list(runnable.stream(None))  # ["Have", " a", " nice", " day"]
+        runnable.batch([None, None])  # ["Have a nice day", "Have a nice day"]
 
 
-            # Async version:
-            async def agen(input: AsyncIterator[Any]) -> AsyncIterator[str]:
-                for token in ["Have", " a", " nice", " day"]:
-                    yield token
+        # Async version:
+        async def agen(input: AsyncIterator[Any]) -> AsyncIterator[str]:
+            for token in ["Have", " a", " nice", " day"]:
+                yield token
 
 
-            runnable = RunnableGenerator(agen)
-            await runnable.ainvoke(None)  # "Have a nice day"
-            [p async for p in runnable.astream(None)]  # ["Have", " a", " nice", " day"]
+        runnable = RunnableGenerator(agen)
+        await runnable.ainvoke(None)  # "Have a nice day"
+        [p async for p in runnable.astream(None)]  # ["Have", " a", " nice", " day"]
+        ```
 
     ``RunnableGenerator`` makes it easy to implement custom behavior within a streaming
     context. Below we show an example:
 
-        .. code-block:: python
+        ```python
+        from langchain_core.prompts import ChatPromptTemplate
+        from langchain_core.runnables import RunnableGenerator, RunnableLambda
+        from langchain_openai import ChatOpenAI
+        from langchain_core.output_parsers import StrOutputParser
 
-            from langchain_core.prompts import ChatPromptTemplate
-            from langchain_core.runnables import RunnableGenerator, RunnableLambda
-            from langchain_openai import ChatOpenAI
-            from langchain_core.output_parsers import StrOutputParser
-
-
-            model = ChatOpenAI()
-            chant_chain = (
-                ChatPromptTemplate.from_template("Give me a 3 word chant about {topic}")
-                | model
-                | StrOutputParser()
-            )
 
+        model = ChatOpenAI()
+        chant_chain = (
+            ChatPromptTemplate.from_template("Give me a 3 word chant about {topic}")
+            | model
+            | StrOutputParser()
+        )
 
-            def character_generator(input: Iterator[str]) -> Iterator[str]:
-                for token in input:
-                    if "," in token or "." in token:
-                        yield "👏" + token
-                    else:
-                        yield token
 
+        def character_generator(input: Iterator[str]) -> Iterator[str]:
+            for token in input:
+                if "," in token or "." in token:
+                    yield "👏" + token
+                else:
+                    yield token
 
-            runnable = chant_chain | character_generator
-            assert type(runnable.last) is RunnableGenerator
-            "".join(
-                runnable.stream({"topic": "waste"})
-            )  # Reduce👏, Reuse👏, Recycle👏.
 
+        runnable = chant_chain | character_generator
+        assert type(runnable.last) is RunnableGenerator
+        "".join(runnable.stream({"topic": "waste"}))  # Reduce👏, Reuse👏, Recycle👏.
 
-            # Note that RunnableLambda can be used to delay streaming of one step in a
-            # sequence until the previous step is finished:
-            def reverse_generator(input: str) -> Iterator[str]:
-                # Yield characters of input in reverse order.
-                for character in input[::-1]:
-                    yield character
 
+        # Note that RunnableLambda can be used to delay streaming of one step in a
+        # sequence until the previous step is finished:
+        def reverse_generator(input: str) -> Iterator[str]:
+            # Yield characters of input in reverse order.
+            for character in input[::-1]:
+                yield character
 
-            runnable = chant_chain | RunnableLambda(reverse_generator)
-            "".join(runnable.stream({"topic": "waste"}))  # ".elcycer ,esuer ,ecudeR"
 
+        runnable = chant_chain | RunnableLambda(reverse_generator)
+        "".join(runnable.stream({"topic": "waste"}))  # ".elcycer ,esuer ,ecudeR"
+        ```
     """
 
     def __init__(
         self,
-        transform: Union[
-            Callable[[Iterator[Input]], Iterator[Output]],
-            Callable[[AsyncIterator[Input]], AsyncIterator[Output]],
-        ],
-        atransform: Optional[
-            Callable[[AsyncIterator[Input]], AsyncIterator[Output]]
-        ] = None,
+        transform: Callable[[Iterator[Input]], Iterator[Output]]
+        | Callable[[AsyncIterator[Input]], AsyncIterator[Output]],
+        atransform: Callable[[AsyncIterator[Input]], AsyncIterator[Output]]
+        | None = None,
         *,
-        name: Optional[str] = None,
+        name: str | None = None,
     ) -> None:
         """Initialize a ``RunnableGenerator``.
 
@@ -4286,9 +4204,7 @@ class RunnableGenerator(Runnable[Input, Output]):
         return Any
 
     @override
-    def get_input_schema(
-        self, config: Optional[RunnableConfig] = None
-    ) -> type[BaseModel]:
+    def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
         # Override the default implementation.
         # For a runnable generator, we need to bring to provide the
         # module of the underlying function when creating the model.
@@ -4329,7 +4245,7 @@ class RunnableGenerator(Runnable[Input, Output]):
 
     @override
     def get_output_schema(
-        self, config: Optional[RunnableConfig] = None
+        self, config: RunnableConfig | None = None
     ) -> type[BaseModel]:
         # Override the default implementation.
         # For a runnable generator, we need to bring to provide the
@@ -4374,7 +4290,7 @@ class RunnableGenerator(Runnable[Input, Output]):
     def transform(
         self,
         input: Iterator[Input],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> Iterator[Output]:
         if not hasattr(self, "_transform"):
@@ -4391,16 +4307,16 @@ class RunnableGenerator(Runnable[Input, Output]):
     def stream(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> Iterator[Output]:
         return self.transform(iter([input]), config, **kwargs)
 
     @override
     def invoke(
-        self, input: Input, config: Optional[RunnableConfig] = None, **kwargs: Any
+        self, input: Input, config: RunnableConfig | None = None, **kwargs: Any
     ) -> Output:
-        final: Optional[Output] = None
+        final: Output | None = None
         for output in self.stream(input, config, **kwargs):
             final = output if final is None else final + output  # type: ignore[operator]
         return cast("Output", final)
@@ -4409,7 +4325,7 @@ class RunnableGenerator(Runnable[Input, Output]):
     def atransform(
         self,
         input: AsyncIterator[Input],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[Output]:
         if not hasattr(self, "_atransform"):
@@ -4424,7 +4340,7 @@ class RunnableGenerator(Runnable[Input, Output]):
     def astream(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[Output]:
         async def input_aiter() -> AsyncIterator[Input]:
@@ -4434,9 +4350,9 @@ class RunnableGenerator(Runnable[Input, Output]):
 
     @override
     async def ainvoke(
-        self, input: Input, config: Optional[RunnableConfig] = None, **kwargs: Any
+        self, input: Input, config: RunnableConfig | None = None, **kwargs: Any
     ) -> Output:
-        final: Optional[Output] = None
+        final: Output | None = None
         async for output in self.astream(input, config, **kwargs):
             final = output if final is None else final + output  # type: ignore[operator]
         return cast("Output", final)
@@ -4460,73 +4376,60 @@ class RunnableLambda(Runnable[Input, Output]):
     instance is invoked (or streamed) during execution.
 
     Examples:
+        ```python
+        # This is a RunnableLambda
+        from langchain_core.runnables import RunnableLambda
 
-        .. code-block:: python
-
-            # This is a RunnableLambda
-            from langchain_core.runnables import RunnableLambda
-
-
-            def add_one(x: int) -> int:
-                return x + 1
 
+        def add_one(x: int) -> int:
+            return x + 1
 
-            runnable = RunnableLambda(add_one)
 
-            runnable.invoke(1)  # returns 2
-            runnable.batch([1, 2, 3])  # returns [2, 3, 4]
+        runnable = RunnableLambda(add_one)
 
-            # Async is supported by default by delegating to the sync implementation
-            await runnable.ainvoke(1)  # returns 2
-            await runnable.abatch([1, 2, 3])  # returns [2, 3, 4]
+        runnable.invoke(1)  # returns 2
+        runnable.batch([1, 2, 3])  # returns [2, 3, 4]
 
+        # Async is supported by default by delegating to the sync implementation
+        await runnable.ainvoke(1)  # returns 2
+        await runnable.abatch([1, 2, 3])  # returns [2, 3, 4]
 
-            # Alternatively, can provide both synd and sync implementations
-            async def add_one_async(x: int) -> int:
-                return x + 1
 
+        # Alternatively, can provide both synd and sync implementations
+        async def add_one_async(x: int) -> int:
+            return x + 1
 
-            runnable = RunnableLambda(add_one, afunc=add_one_async)
-            runnable.invoke(1)  # Uses add_one
-            await runnable.ainvoke(1)  # Uses add_one_async
 
+        runnable = RunnableLambda(add_one, afunc=add_one_async)
+        runnable.invoke(1)  # Uses add_one
+        await runnable.ainvoke(1)  # Uses add_one_async
+        ```
     """
 
     def __init__(
         self,
-        func: Union[
-            Union[
-                Callable[[Input], Iterator[Output]],
-                Callable[[Input], Runnable[Input, Output]],
-                Callable[[Input], Output],
-                Callable[[Input, RunnableConfig], Output],
-                Callable[[Input, CallbackManagerForChainRun], Output],
-                Callable[[Input, CallbackManagerForChainRun, RunnableConfig], Output],
-            ],
-            Union[
-                Callable[[Input], Awaitable[Output]],
-                Callable[[Input], AsyncIterator[Output]],
-                Callable[[Input, RunnableConfig], Awaitable[Output]],
-                Callable[[Input, AsyncCallbackManagerForChainRun], Awaitable[Output]],
-                Callable[
-                    [Input, AsyncCallbackManagerForChainRun, RunnableConfig],
-                    Awaitable[Output],
-                ],
-            ],
+        func: Callable[[Input], Iterator[Output]]
+        | Callable[[Input], Runnable[Input, Output]]
+        | Callable[[Input], Output]
+        | Callable[[Input, RunnableConfig], Output]
+        | Callable[[Input, CallbackManagerForChainRun], Output]
+        | Callable[[Input, CallbackManagerForChainRun, RunnableConfig], Output]
+        | Callable[[Input], Awaitable[Output]]
+        | Callable[[Input], AsyncIterator[Output]]
+        | Callable[[Input, RunnableConfig], Awaitable[Output]]
+        | Callable[[Input, AsyncCallbackManagerForChainRun], Awaitable[Output]]
+        | Callable[
+            [Input, AsyncCallbackManagerForChainRun, RunnableConfig], Awaitable[Output]
         ],
-        afunc: Optional[
-            Union[
-                Callable[[Input], Awaitable[Output]],
-                Callable[[Input], AsyncIterator[Output]],
-                Callable[[Input, RunnableConfig], Awaitable[Output]],
-                Callable[[Input, AsyncCallbackManagerForChainRun], Awaitable[Output]],
-                Callable[
-                    [Input, AsyncCallbackManagerForChainRun, RunnableConfig],
-                    Awaitable[Output],
-                ],
-            ]
-        ] = None,
-        name: Optional[str] = None,
+        afunc: Callable[[Input], Awaitable[Output]]
+        | Callable[[Input], AsyncIterator[Output]]
+        | Callable[[Input, RunnableConfig], Awaitable[Output]]
+        | Callable[[Input, AsyncCallbackManagerForChainRun], Awaitable[Output]]
+        | Callable[
+            [Input, AsyncCallbackManagerForChainRun, RunnableConfig], Awaitable[Output]
+        ]
+        | None = None,
+        name: str | None = None,
     ) -> None:
         """Create a ``RunnableLambda`` from a callable, and async callable or both.
 
@@ -4576,7 +4479,7 @@ class RunnableLambda(Runnable[Input, Output]):
         except AttributeError:
             pass
 
-        self._repr: Optional[str] = None
+        self._repr: str | None = None
 
     @property
     @override
@@ -4593,9 +4496,7 @@ class RunnableLambda(Runnable[Input, Output]):
         return Any
 
     @override
-    def get_input_schema(
-        self, config: Optional[RunnableConfig] = None
-    ) -> type[BaseModel]:
+    def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
         """The pydantic schema for the input to this ``Runnable``.
 
         Args:
@@ -4664,7 +4565,7 @@ class RunnableLambda(Runnable[Input, Output]):
 
     @override
     def get_output_schema(
-        self, config: Optional[RunnableConfig] = None
+        self, config: RunnableConfig | None = None
     ) -> type[BaseModel]:
         # Override the default implementation.
         # For a runnable lambda, we need to bring to provide the
@@ -4785,7 +4686,7 @@ class RunnableLambda(Runnable[Input, Output]):
         **kwargs: Any,
     ) -> Output:
         if inspect.isgeneratorfunction(self.func):
-            output: Optional[Output] = None
+            output: Output | None = None
             for chunk in call_func_with_variable_args(
                 cast("Callable[[Input], Iterator[Output]]", self.func),
                 input_,
@@ -4840,7 +4741,7 @@ class RunnableLambda(Runnable[Input, Output]):
                     config: RunnableConfig,
                     **kwargs: Any,
                 ) -> Output:
-                    output: Optional[Output] = None
+                    output: Output | None = None
                     for chunk in call_func_with_variable_args(
                         cast("Callable[[Input], Iterator[Output]]", self.func),
                         value,
@@ -4876,7 +4777,7 @@ class RunnableLambda(Runnable[Input, Output]):
             afunc = f
 
         if is_async_generator(afunc):
-            output: Optional[Output] = None
+            output: Output | None = None
             async with aclosing(
                 cast(
                     "AsyncGenerator[Any, Any]",
@@ -4926,8 +4827,8 @@ class RunnableLambda(Runnable[Input, Output]):
     def invoke(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Output:
         """Invoke this ``Runnable`` synchronously.
 
@@ -4957,8 +4858,8 @@ class RunnableLambda(Runnable[Input, Output]):
     async def ainvoke(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Output:
         """Invoke this ``Runnable`` asynchronously.
 
@@ -5002,7 +4903,7 @@ class RunnableLambda(Runnable[Input, Output]):
                     final = ichunk
 
         if inspect.isgeneratorfunction(self.func):
-            output: Optional[Output] = None
+            output: Output | None = None
             for chunk in call_func_with_variable_args(
                 self.func, final, config, run_manager, **kwargs
             ):
@@ -5044,8 +4945,8 @@ class RunnableLambda(Runnable[Input, Output]):
     def transform(
         self,
         input: Iterator[Input],
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Iterator[Output]:
         if hasattr(self, "func"):
             yield from self._transform_stream_with_config(
@@ -5065,8 +4966,8 @@ class RunnableLambda(Runnable[Input, Output]):
     def stream(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Iterator[Output]:
         return self.transform(iter([input]), config, **kwargs)
 
@@ -5120,7 +5021,7 @@ class RunnableLambda(Runnable[Input, Output]):
             afunc = f
 
         if is_async_generator(afunc):
-            output: Optional[Output] = None
+            output: Output | None = None
             async for chunk in cast(
                 "AsyncIterator[Output]",
                 acall_func_with_variable_args(
@@ -5173,8 +5074,8 @@ class RunnableLambda(Runnable[Input, Output]):
     async def atransform(
         self,
         input: AsyncIterator[Input],
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> AsyncIterator[Output]:
         async for output in self._atransform_stream_with_config(
             input,
@@ -5188,8 +5089,8 @@ class RunnableLambda(Runnable[Input, Output]):
     async def astream(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> AsyncIterator[Output]:
         async def input_aiter() -> AsyncIterator[Input]:
             yield input
@@ -5222,9 +5123,7 @@ class RunnableEachBase(RunnableSerializable[list[Input], list[Output]]):
         return list[self.bound.InputType]  # type: ignore[name-defined]
 
     @override
-    def get_input_schema(
-        self, config: Optional[RunnableConfig] = None
-    ) -> type[BaseModel]:
+    def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
         return create_model_v2(
             self.get_name("Input"),
             root=(
@@ -5248,7 +5147,7 @@ class RunnableEachBase(RunnableSerializable[list[Input], list[Output]]):
 
     @override
     def get_output_schema(
-        self, config: Optional[RunnableConfig] = None
+        self, config: RunnableConfig | None = None
     ) -> type[BaseModel]:
         schema = self.bound.get_output_schema(config)
         return create_model_v2(
@@ -5270,7 +5169,7 @@ class RunnableEachBase(RunnableSerializable[list[Input], list[Output]]):
         return self.bound.config_specs
 
     @override
-    def get_graph(self, config: Optional[RunnableConfig] = None) -> Graph:
+    def get_graph(self, config: RunnableConfig | None = None) -> Graph:
         return self.bound.get_graph(config)
 
     @classmethod
@@ -5303,7 +5202,7 @@ class RunnableEachBase(RunnableSerializable[list[Input], list[Output]]):
 
     @override
     def invoke(
-        self, input: list[Input], config: Optional[RunnableConfig] = None, **kwargs: Any
+        self, input: list[Input], config: RunnableConfig | None = None, **kwargs: Any
     ) -> list[Output]:
         return self._call_with_config(self._invoke, input, config, **kwargs)
 
@@ -5321,7 +5220,7 @@ class RunnableEachBase(RunnableSerializable[list[Input], list[Output]]):
 
     @override
     async def ainvoke(
-        self, input: list[Input], config: Optional[RunnableConfig] = None, **kwargs: Any
+        self, input: list[Input], config: RunnableConfig | None = None, **kwargs: Any
     ) -> list[Output]:
         return await self._acall_with_config(self._ainvoke, input, config, **kwargs)
 
@@ -5329,8 +5228,8 @@ class RunnableEachBase(RunnableSerializable[list[Input], list[Output]]):
     async def astream_events(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> AsyncIterator[StreamEvent]:
         def _error_stream_event(message: str) -> StreamEvent:
             raise NotImplementedError(message)
@@ -5352,29 +5251,27 @@ class RunnableEach(RunnableEachBase[Input, Output]):
     In the below example, we associate and run three inputs
     with a ``Runnable``:
 
-        .. code-block:: python
-
-            from langchain_core.runnables.base import RunnableEach
-            from langchain_openai import ChatOpenAI
-            from langchain_core.prompts import ChatPromptTemplate
-            from langchain_core.output_parsers import StrOutputParser
-            prompt = ChatPromptTemplate.from_template("Tell me a short joke about
-            {topic}")
-            model = ChatOpenAI()
-            output_parser = StrOutputParser()
-            runnable = prompt | model | output_parser
-            runnable_each = RunnableEach(bound=runnable)
-            output = runnable_each.invoke([{'topic':'Computer Science'},
-                                        {'topic':'Art'},
-                                        {'topic':'Biology'}])
-            print(output)  # noqa: T201
-
+        ```python
+        from langchain_core.runnables.base import RunnableEach
+        from langchain_openai import ChatOpenAI
+        from langchain_core.prompts import ChatPromptTemplate
+        from langchain_core.output_parsers import StrOutputParser
+        prompt = ChatPromptTemplate.from_template("Tell me a short joke about
+        {topic}")
+        model = ChatOpenAI()
+        output_parser = StrOutputParser()
+        runnable = prompt | model | output_parser
+        runnable_each = RunnableEach(bound=runnable)
+        output = runnable_each.invoke([{'topic':'Computer Science'},
+                                    {'topic':'Art'},
+                                    {'topic':'Biology'}])
+        print(output)  # noqa: T201
+
+        ```
     """
 
     @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 or f"RunnableEach<{self.bound.get_name()}>"
         return super().get_name(suffix, name=name)
 
@@ -5384,7 +5281,7 @@ class RunnableEach(RunnableEachBase[Input, Output]):
 
     @override
     def with_config(
-        self, config: Optional[RunnableConfig] = None, **kwargs: Any
+        self, config: RunnableConfig | None = None, **kwargs: Any
     ) -> RunnableEach[Input, Output]:
         return RunnableEach(bound=self.bound.with_config(config, **kwargs))
 
@@ -5392,15 +5289,15 @@ class RunnableEach(RunnableEachBase[Input, Output]):
     def with_listeners(
         self,
         *,
-        on_start: Optional[
-            Union[Callable[[Run], None], Callable[[Run, RunnableConfig], None]]
-        ] = None,
-        on_end: Optional[
-            Union[Callable[[Run], None], Callable[[Run, RunnableConfig], None]]
-        ] = None,
-        on_error: Optional[
-            Union[Callable[[Run], None], Callable[[Run, RunnableConfig], None]]
-        ] = None,
+        on_start: Callable[[Run], None]
+        | Callable[[Run, RunnableConfig], None]
+        | None = None,
+        on_end: Callable[[Run], None]
+        | Callable[[Run, RunnableConfig], None]
+        | None = None,
+        on_error: Callable[[Run], None]
+        | Callable[[Run, RunnableConfig], None]
+        | None = None,
     ) -> RunnableEach[Input, Output]:
         """Bind lifecycle listeners to a ``Runnable``, returning a new ``Runnable``.
 
@@ -5429,9 +5326,9 @@ class RunnableEach(RunnableEachBase[Input, Output]):
     def with_alisteners(
         self,
         *,
-        on_start: Optional[AsyncListener] = None,
-        on_end: Optional[AsyncListener] = None,
-        on_error: Optional[AsyncListener] = None,
+        on_start: AsyncListener | None = None,
+        on_end: AsyncListener | None = None,
+        on_error: AsyncListener | None = None,
     ) -> RunnableEach[Input, Output]:
         """Bind async lifecycle listeners to a ``Runnable``.
 
@@ -5491,13 +5388,13 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
     """The config factories to bind to the underlying ``Runnable``."""
 
     # Union[Type[Input], BaseModel] + things like list[str]
-    custom_input_type: Optional[Any] = None
+    custom_input_type: Any | None = None
     """Override the input type of the underlying ``Runnable`` with a custom type.
 
     The type can be a pydantic model, or a type annotation (e.g., ``list[str]``).
     """
     # Union[Type[Output], BaseModel] + things like list[str]
-    custom_output_type: Optional[Any] = None
+    custom_output_type: Any | None = None
     """Override the output type of the underlying ``Runnable`` with a custom type.
 
     The type can be a pydantic model, or a type annotation (e.g., ``list[str]``).
@@ -5511,13 +5408,12 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
         self,
         *,
         bound: Runnable[Input, Output],
-        kwargs: Optional[Mapping[str, Any]] = None,
-        config: Optional[RunnableConfig] = None,
-        config_factories: Optional[
-            list[Callable[[RunnableConfig], RunnableConfig]]
-        ] = None,
-        custom_input_type: Optional[Union[type[Input], BaseModel]] = None,
-        custom_output_type: Optional[Union[type[Output], BaseModel]] = None,
+        kwargs: Mapping[str, Any] | None = None,
+        config: RunnableConfig | None = None,
+        config_factories: list[Callable[[RunnableConfig], RunnableConfig]]
+        | None = None,
+        custom_input_type: type[Input] | BaseModel | None = None,
+        custom_output_type: type[Output] | BaseModel | None = None,
         **other_kwargs: Any,
     ) -> None:
         """Create a ``RunnableBinding`` from a ``Runnable`` and kwargs.
@@ -5555,9 +5451,7 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
         self.config = config or {}
 
     @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:
         return self.bound.get_name(suffix, name=name)
 
     @property
@@ -5579,16 +5473,14 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
         )
 
     @override
-    def get_input_schema(
-        self, config: Optional[RunnableConfig] = None
-    ) -> type[BaseModel]:
+    def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
         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: Optional[RunnableConfig] = None
+        self, config: RunnableConfig | None = None
     ) -> type[BaseModel]:
         if self.custom_output_type is not None:
             return super().get_output_schema(config)
@@ -5600,7 +5492,7 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
         return self.bound.config_specs
 
     @override
-    def get_graph(self, config: Optional[RunnableConfig] = None) -> Graph:
+    def get_graph(self, config: RunnableConfig | None = None) -> Graph:
         return self.bound.get_graph(self._merge_configs(config))
 
     @classmethod
@@ -5619,7 +5511,7 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
         """
         return ["langchain", "schema", "runnable"]
 
-    def _merge_configs(self, *configs: Optional[RunnableConfig]) -> RunnableConfig:
+    def _merge_configs(self, *configs: RunnableConfig | None) -> RunnableConfig:
         config = merge_configs(self.config, *configs)
         return merge_configs(config, *(f(config) for f in self.config_factories))
 
@@ -5627,8 +5519,8 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
     def invoke(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Output:
         return self.bound.invoke(
             input,
@@ -5640,8 +5532,8 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
     async def ainvoke(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Output:
         return await self.bound.ainvoke(
             input,
@@ -5653,10 +5545,10 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
     def batch(
         self,
         inputs: list[Input],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: RunnableConfig | list[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
-        **kwargs: Optional[Any],
+        **kwargs: Any | None,
     ) -> list[Output]:
         if isinstance(config, list):
             configs = cast(
@@ -5676,10 +5568,10 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
     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: Optional[Any],
+        **kwargs: Any | None,
     ) -> list[Output]:
         if isinstance(config, list):
             configs = cast(
@@ -5699,7 +5591,7 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
     def batch_as_completed(
         self,
         inputs: Sequence[Input],
-        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        config: RunnableConfig | Sequence[RunnableConfig] | None = None,
         *,
         return_exceptions: Literal[False] = False,
         **kwargs: Any,
@@ -5709,21 +5601,21 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
     def batch_as_completed(
         self,
         inputs: Sequence[Input],
-        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        config: RunnableConfig | Sequence[RunnableConfig] | None = None,
         *,
         return_exceptions: Literal[True],
         **kwargs: Any,
-    ) -> Iterator[tuple[int, Union[Output, Exception]]]: ...
+    ) -> Iterator[tuple[int, Output | Exception]]: ...
 
     @override
     def batch_as_completed(
         self,
         inputs: Sequence[Input],
-        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        config: RunnableConfig | Sequence[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
-        **kwargs: Optional[Any],
-    ) -> Iterator[tuple[int, Union[Output, Exception]]]:
+        **kwargs: Any | None,
+    ) -> Iterator[tuple[int, Output | Exception]]:
         if isinstance(config, Sequence):
             configs = cast(
                 "list[RunnableConfig]",
@@ -5751,31 +5643,31 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
     def abatch_as_completed(
         self,
         inputs: Sequence[Input],
-        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        config: RunnableConfig | Sequence[RunnableConfig] | None = None,
         *,
         return_exceptions: Literal[False] = False,
-        **kwargs: Optional[Any],
+        **kwargs: Any | None,
     ) -> AsyncIterator[tuple[int, Output]]: ...
 
     @overload
     def abatch_as_completed(
         self,
         inputs: Sequence[Input],
-        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        config: RunnableConfig | Sequence[RunnableConfig] | None = None,
         *,
         return_exceptions: Literal[True],
-        **kwargs: Optional[Any],
-    ) -> AsyncIterator[tuple[int, Union[Output, Exception]]]: ...
+        **kwargs: Any | None,
+    ) -> AsyncIterator[tuple[int, Output | Exception]]: ...
 
     @override
     async def abatch_as_completed(
         self,
         inputs: Sequence[Input],
-        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        config: RunnableConfig | Sequence[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
-        **kwargs: Optional[Any],
-    ) -> AsyncIterator[tuple[int, Union[Output, Exception]]]:
+        **kwargs: Any | None,
+    ) -> AsyncIterator[tuple[int, Output | Exception]]:
         if isinstance(config, Sequence):
             configs = cast(
                 "list[RunnableConfig]",
@@ -5804,8 +5696,8 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
     def stream(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Iterator[Output]:
         yield from self.bound.stream(
             input,
@@ -5817,8 +5709,8 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
     async def astream(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> AsyncIterator[Output]:
         async for item in self.bound.astream(
             input,
@@ -5831,8 +5723,8 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
     async def astream_events(
         self,
         input: Input,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> AsyncIterator[StreamEvent]:
         async for item in self.bound.astream_events(
             input, self._merge_configs(config), **{**self.kwargs, **kwargs}
@@ -5843,7 +5735,7 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
     def transform(
         self,
         input: Iterator[Input],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> Iterator[Output]:
         yield from self.bound.transform(
@@ -5856,7 +5748,7 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]):  # type: ignore[
     async def atransform(
         self,
         input: AsyncIterator[Input],
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[Output]:
         async for item in self.bound.atransform(
@@ -5893,32 +5785,30 @@ class RunnableBinding(RunnableBindingBase[Input, Output]):  # type: ignore[no-re
     Example:
     `bind`: Bind kwargs to pass to the underlying ``Runnable`` when running it.
 
-        .. code-block:: python
-
-            # Create a Runnable binding that invokes the ChatModel with the
-            # additional kwarg `stop=['-']` when running it.
-            from langchain_community.chat_models import ChatOpenAI
-
-            model = ChatOpenAI()
-            model.invoke('Say "Parrot-MAGIC"', stop=["-"])  # Should return `Parrot`
-            # Using it the easy way via `bind` method which returns a new
-            # RunnableBinding
-            runnable_binding = model.bind(stop=["-"])
-            runnable_binding.invoke('Say "Parrot-MAGIC"')  # Should return `Parrot`
-
+        ```python
+        # Create a Runnable binding that invokes the ChatModel with the
+        # additional kwarg `stop=['-']` when running it.
+        from langchain_community.chat_models import ChatOpenAI
+
+        model = ChatOpenAI()
+        model.invoke('Say "Parrot-MAGIC"', stop=["-"])  # Should return `Parrot`
+        # Using it the easy way via `bind` method which returns a new
+        # RunnableBinding
+        runnable_binding = model.bind(stop=["-"])
+        runnable_binding.invoke('Say "Parrot-MAGIC"')  # Should return `Parrot`
+        ```
         Can also be done by instantiating a ``RunnableBinding`` directly (not
         recommended):
 
-        .. code-block:: python
-
-            from langchain_core.runnables import RunnableBinding
-
-            runnable_binding = RunnableBinding(
-                bound=model,
-                kwargs={"stop": ["-"]},  # <-- Note the additional kwargs
-            )
-            runnable_binding.invoke('Say "Parrot-MAGIC"')  # Should return `Parrot`
+        ```python
+        from langchain_core.runnables import RunnableBinding
 
+        runnable_binding = RunnableBinding(
+            bound=model,
+            kwargs={"stop": ["-"]},  # <-- Note the additional kwargs
+        )
+        runnable_binding.invoke('Say "Parrot-MAGIC"')  # Should return `Parrot`
+        ```
     """
 
     @override
@@ -5945,7 +5835,7 @@ class RunnableBinding(RunnableBindingBase[Input, Output]):  # type: ignore[no-re
     @override
     def with_config(
         self,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         # Sadly Unpack is not well supported by mypy so this will have to be untyped
         **kwargs: Any,
     ) -> Runnable[Input, Output]:
@@ -5962,15 +5852,15 @@ class RunnableBinding(RunnableBindingBase[Input, Output]):  # type: ignore[no-re
     def with_listeners(
         self,
         *,
-        on_start: Optional[
-            Union[Callable[[Run], None], Callable[[Run, RunnableConfig], None]]
-        ] = None,
-        on_end: Optional[
-            Union[Callable[[Run], None], Callable[[Run, RunnableConfig], None]]
-        ] = None,
-        on_error: Optional[
-            Union[Callable[[Run], None], Callable[[Run, RunnableConfig], None]]
-        ] = None,
+        on_start: Callable[[Run], None]
+        | Callable[[Run, RunnableConfig], None]
+        | None = None,
+        on_end: Callable[[Run], None]
+        | Callable[[Run, RunnableConfig], None]
+        | None = None,
+        on_error: Callable[[Run], None]
+        | Callable[[Run, RunnableConfig], None]
+        | None = None,
     ) -> Runnable[Input, Output]:
         """Bind lifecycle listeners to a ``Runnable``, returning a new ``Runnable``.
 
@@ -6014,8 +5904,8 @@ class RunnableBinding(RunnableBindingBase[Input, Output]):  # type: ignore[no-re
     @override
     def with_types(
         self,
-        input_type: Optional[Union[type[Input], BaseModel]] = None,
-        output_type: Optional[Union[type[Output], BaseModel]] = None,
+        input_type: type[Input] | BaseModel | None = None,
+        output_type: type[Output] | BaseModel | None = None,
     ) -> Runnable[Input, Output]:
         return self.__class__(
             bound=self.bound,
@@ -6099,18 +5989,18 @@ class _RunnableCallableAsyncIterator(Protocol[Input, Output]):
     ) -> AsyncIterator[Output]: ...
 
 
-RunnableLike = Union[
-    Runnable[Input, Output],
-    Callable[[Input], Output],
-    Callable[[Input], Awaitable[Output]],
-    Callable[[Iterator[Input]], Iterator[Output]],
-    Callable[[AsyncIterator[Input]], AsyncIterator[Output]],
-    _RunnableCallableSync[Input, Output],
-    _RunnableCallableAsync[Input, Output],
-    _RunnableCallableIterator[Input, Output],
-    _RunnableCallableAsyncIterator[Input, Output],
-    Mapping[str, Any],
-]
+RunnableLike = (
+    Runnable[Input, Output]
+    | Callable[[Input], Output]
+    | Callable[[Input], Awaitable[Output]]
+    | Callable[[Iterator[Input]], Iterator[Output]]
+    | Callable[[AsyncIterator[Input]], AsyncIterator[Output]]
+    | _RunnableCallableSync[Input, Output]
+    | _RunnableCallableAsync[Input, Output]
+    | _RunnableCallableIterator[Input, Output]
+    | _RunnableCallableAsyncIterator[Input, Output]
+    | Mapping[str, Any]
+)
 
 
 def coerce_to_runnable(thing: RunnableLike) -> Runnable[Input, Output]:
@@ -6165,12 +6055,10 @@ def chain(
 
 
 def chain(
-    func: Union[
-        Callable[[Input], Output],
-        Callable[[Input], Iterator[Output]],
-        Callable[[Input], Coroutine[Any, Any, Output]],
-        Callable[[Input], AsyncIterator[Output]],
-    ],
+    func: Callable[[Input], Output]
+    | Callable[[Input], Iterator[Output]]
+    | Callable[[Input], Coroutine[Any, Any, Output]]
+    | Callable[[Input], AsyncIterator[Output]],
 ) -> Runnable[Input, Output]:
     """Decorate a function to make it a ``Runnable``.
 
@@ -6184,9 +6072,7 @@ def chain(
         A ``Runnable``.
 
     Example:
-
-    .. code-block:: python
-
+        ```python
         from langchain_core.runnables import chain
         from langchain_core.prompts import PromptTemplate
         from langchain_openai import OpenAI
@@ -6200,6 +6086,6 @@ def chain(
 
             for chunk in llm.stream(formatted):
                 yield chunk
-
+        ```
     """
     return RunnableLambda(func)