langchain-core 1.0.0a5__py3-none-any.whl → 1.0.3__py3-none-any.whl

langchain_core/tracers/core.py

@@ -10,8 +10,6 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Literal,
-    Optional,
-    Union,
     cast,
 )
 
@@ -81,7 +79,7 @@ class _TracerCore(ABC):
         """Map of run ID to (trace_id, dotted_order). Cleared when tracer GCed."""
 
     @abstractmethod
-    def _persist_run(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:
+    def _persist_run(self, run: Run) -> Coroutine[Any, Any, None] | None:
         """Persist a run."""
 
     @staticmethod
@@ -102,7 +100,7 @@ class _TracerCore(ABC):
         except:  # noqa: E722
             return msg
 
-    def _start_trace(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # type: ignore[return]
+    def _start_trace(self, run: Run) -> Coroutine[Any, Any, None] | None:  # type: ignore[return]
         current_dotted_order = run.start_time.strftime("%Y%m%dT%H%M%S%fZ") + str(run.id)
         if run.parent_run_id:
             if parent := self.order_map.get(run.parent_run_id):
@@ -126,9 +124,7 @@ class _TracerCore(ABC):
         self.order_map[run.id] = (run.trace_id, run.dotted_order)
         self.run_map[str(run.id)] = run
 
-    def _get_run(
-        self, run_id: UUID, run_type: Union[str, set[str], None] = None
-    ) -> Run:
+    def _get_run(self, run_id: UUID, run_type: str | set[str] | None = None) -> Run:
         try:
             run = self.run_map[str(run_id)]
         except KeyError as exc:
@@ -136,7 +132,7 @@ class _TracerCore(ABC):
             raise TracerException(msg) from exc
 
         if isinstance(run_type, str):
-            run_types: Union[set[str], None] = {run_type}
+            run_types: set[str] | None = {run_type}
         else:
             run_types = run_type
         if run_types is not None and run.run_type not in run_types:
@@ -152,10 +148,10 @@ class _TracerCore(ABC):
         serialized: dict[str, Any],
         messages: list[list[BaseMessage]],
         run_id: UUID,
-        tags: Optional[list[str]] = None,
-        parent_run_id: Optional[UUID] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        name: Optional[str] = None,
+        tags: list[str] | None = None,
+        parent_run_id: UUID | None = None,
+        metadata: dict[str, Any] | None = None,
+        name: str | None = None,
         **kwargs: Any,
     ) -> Run:
         """Create a chat model run."""
@@ -196,10 +192,10 @@ class _TracerCore(ABC):
         serialized: dict[str, Any],
         prompts: list[str],
         run_id: UUID,
-        tags: Optional[list[str]] = None,
-        parent_run_id: Optional[UUID] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        name: Optional[str] = None,
+        tags: list[str] | None = None,
+        parent_run_id: UUID | None = None,
+        metadata: dict[str, Any] | None = None,
+        name: str | None = None,
         **kwargs: Any,
     ) -> Run:
         """Create a llm run."""
@@ -224,8 +220,8 @@ class _TracerCore(ABC):
         self,
         token: str,
         run_id: UUID,
-        chunk: Optional[Union[GenerationChunk, ChatGenerationChunk]] = None,
-        parent_run_id: Optional[UUID] = None,  # noqa: ARG002
+        chunk: GenerationChunk | ChatGenerationChunk | None = None,
+        parent_run_id: UUID | None = None,  # noqa: ARG002
     ) -> Run:
         """Append token event to LLM run and return the run."""
         llm_run = self._get_run(run_id, run_type={"llm", "chat_model"})
@@ -291,7 +287,7 @@ class _TracerCore(ABC):
         return llm_run
 
     def _errored_llm_run(
-        self, error: BaseException, run_id: UUID, response: Optional[LLMResult] = None
+        self, error: BaseException, run_id: UUID, response: LLMResult | None = None
     ) -> Run:
         llm_run = self._get_run(run_id, run_type={"llm", "chat_model"})
         llm_run.error = self._get_stacktrace(error)
@@ -319,11 +315,11 @@ class _TracerCore(ABC):
         serialized: dict[str, Any],
         inputs: dict[str, Any],
         run_id: UUID,
-        tags: Optional[list[str]] = None,
-        parent_run_id: Optional[UUID] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        run_type: Optional[str] = None,
-        name: Optional[str] = None,
+        tags: list[str] | None = None,
+        parent_run_id: UUID | None = None,
+        metadata: dict[str, Any] | None = None,
+        run_type: str | None = None,
+        name: str | None = None,
         **kwargs: Any,
     ) -> Run:
         """Create a chain Run."""
@@ -370,7 +366,7 @@ class _TracerCore(ABC):
         self,
         outputs: dict[str, Any],
         run_id: UUID,
-        inputs: Optional[dict[str, Any]] = None,
+        inputs: dict[str, Any] | None = None,
     ) -> Run:
         """Update a chain run with outputs and end time."""
         chain_run = self._get_run(run_id)
@@ -389,7 +385,7 @@ class _TracerCore(ABC):
     def _errored_chain_run(
         self,
         error: BaseException,
-        inputs: Optional[dict[str, Any]],
+        inputs: dict[str, Any] | None,
         run_id: UUID,
     ) -> Run:
         chain_run = self._get_run(run_id)
@@ -405,11 +401,11 @@ class _TracerCore(ABC):
         serialized: dict[str, Any],
         input_str: str,
         run_id: UUID,
-        tags: Optional[list[str]] = None,
-        parent_run_id: Optional[UUID] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        name: Optional[str] = None,
-        inputs: Optional[dict[str, Any]] = None,
+        tags: list[str] | None = None,
+        parent_run_id: UUID | None = None,
+        metadata: dict[str, Any] | None = None,
+        name: str | None = None,
+        inputs: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> Run:
         """Create a tool run."""
@@ -472,10 +468,10 @@ class _TracerCore(ABC):
         serialized: dict[str, Any],
         query: str,
         run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        name: Optional[str] = None,
+        parent_run_id: UUID | None = None,
+        tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
+        name: str | None = None,
         **kwargs: Any,
     ) -> Run:
         """Create a retrieval run."""
@@ -532,7 +528,7 @@ class _TracerCore(ABC):
         """Return self copied."""
         return self
 
-    def _end_trace(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # noqa: ARG002
+    def _end_trace(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
         """End a trace for a run.
 
         Args:
@@ -540,7 +536,7 @@ class _TracerCore(ABC):
         """
         return None
 
-    def _on_run_create(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # noqa: ARG002
+    def _on_run_create(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
         """Process a run upon creation.
 
         Args:
@@ -548,7 +544,7 @@ class _TracerCore(ABC):
         """
         return None
 
-    def _on_run_update(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # noqa: ARG002
+    def _on_run_update(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
         """Process a run upon update.
 
         Args:
@@ -556,7 +552,7 @@ class _TracerCore(ABC):
         """
         return None
 
-    def _on_llm_start(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # noqa: ARG002
+    def _on_llm_start(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
         """Process the LLM Run upon start.
 
         Args:
@@ -568,8 +564,8 @@ class _TracerCore(ABC):
         self,
         run: Run,  # noqa: ARG002
         token: str,  # noqa: ARG002
-        chunk: Optional[Union[GenerationChunk, ChatGenerationChunk]],  # noqa: ARG002
-    ) -> Union[Coroutine[Any, Any, None], None]:
+        chunk: GenerationChunk | ChatGenerationChunk | None,  # noqa: ARG002
+    ) -> Coroutine[Any, Any, None] | None:
         """Process new LLM token.
 
         Args:
@@ -579,7 +575,7 @@ class _TracerCore(ABC):
         """
         return None
 
-    def _on_llm_end(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # noqa: ARG002
+    def _on_llm_end(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
         """Process the LLM Run.
 
         Args:
@@ -587,7 +583,7 @@ class _TracerCore(ABC):
         """
         return None
 
-    def _on_llm_error(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # noqa: ARG002
+    def _on_llm_error(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
         """Process the LLM Run upon error.
 
         Args:
@@ -595,7 +591,7 @@ class _TracerCore(ABC):
         """
         return None
 
-    def _on_chain_start(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # noqa: ARG002
+    def _on_chain_start(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
         """Process the Chain Run upon start.
 
         Args:
@@ -603,7 +599,7 @@ class _TracerCore(ABC):
         """
         return None
 
-    def _on_chain_end(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # noqa: ARG002
+    def _on_chain_end(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
         """Process the Chain Run.
 
         Args:
@@ -611,7 +607,7 @@ class _TracerCore(ABC):
         """
         return None
 
-    def _on_chain_error(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # noqa: ARG002
+    def _on_chain_error(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
         """Process the Chain Run upon error.
 
         Args:
@@ -619,7 +615,7 @@ class _TracerCore(ABC):
         """
         return None
 
-    def _on_tool_start(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # noqa: ARG002
+    def _on_tool_start(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
         """Process the Tool Run upon start.
 
         Args:
@@ -627,7 +623,7 @@ class _TracerCore(ABC):
         """
         return None
 
-    def _on_tool_end(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # noqa: ARG002
+    def _on_tool_end(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
         """Process the Tool Run.
 
         Args:
@@ -635,7 +631,7 @@ class _TracerCore(ABC):
         """
         return None
 
-    def _on_tool_error(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # noqa: ARG002
+    def _on_tool_error(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
         """Process the Tool Run upon error.
 
         Args:
@@ -643,7 +639,7 @@ class _TracerCore(ABC):
         """
         return None
 
-    def _on_chat_model_start(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # noqa: ARG002
+    def _on_chat_model_start(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
         """Process the Chat Model Run upon start.
 
         Args:
@@ -651,7 +647,7 @@ class _TracerCore(ABC):
         """
         return None
 
-    def _on_retriever_start(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # noqa: ARG002
+    def _on_retriever_start(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
         """Process the Retriever Run upon start.
 
         Args:
@@ -659,7 +655,7 @@ class _TracerCore(ABC):
         """
         return None
 
-    def _on_retriever_end(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # noqa: ARG002
+    def _on_retriever_end(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
         """Process the Retriever Run.
 
         Args:
@@ -667,7 +663,7 @@ class _TracerCore(ABC):
         """
         return None
 
-    def _on_retriever_error(self, run: Run) -> Union[Coroutine[Any, Any, None], None]:  # noqa: ARG002
+    def _on_retriever_error(self, run: Run) -> Coroutine[Any, Any, None] | None:  # noqa: ARG002
         """Process the Retriever Run upon error.
 
         Args:

langchain_core/tracers/evaluation.py

@@ -6,7 +6,7 @@ import logging
 import threading
 import weakref
 from concurrent.futures import Future, ThreadPoolExecutor, wait
-from typing import TYPE_CHECKING, Any, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, cast
 from uuid import UUID
 
 import langsmith
@@ -43,19 +43,19 @@ class EvaluatorCallbackHandler(BaseTracer):
     """
 
     name: str = "evaluator_callback_handler"
-    example_id: Optional[UUID] = None
+    example_id: UUID | None = None
     """The example ID associated with the runs."""
     client: langsmith.Client
     """The LangSmith client instance used for evaluating the runs."""
     evaluators: Sequence[langsmith.RunEvaluator] = ()
     """The sequence of run evaluators to be executed."""
-    executor: Optional[ThreadPoolExecutor] = None
+    executor: ThreadPoolExecutor | None = None
     """The thread pool executor used for running the evaluators."""
     futures: weakref.WeakSet[Future] = weakref.WeakSet()
     """The set of futures representing the running evaluators."""
     skip_unfinished: bool = True
     """Whether to skip runs that are not finished or raised an error."""
-    project_name: Optional[str] = None
+    project_name: str | None = None
     """The LangSmith project name to be organize eval chain runs under."""
     logged_eval_results: dict[tuple[str, str], list[EvaluationResult]]
     lock: threading.Lock
@@ -63,11 +63,11 @@ class EvaluatorCallbackHandler(BaseTracer):
     def __init__(
         self,
         evaluators: Sequence[langsmith.RunEvaluator],
-        client: Optional[langsmith.Client] = None,
-        example_id: Optional[Union[UUID, str]] = None,
+        client: langsmith.Client | None = None,
+        example_id: UUID | str | None = None,
         skip_unfinished: bool = True,  # noqa: FBT001,FBT002
-        project_name: Optional[str] = "evaluators",
-        max_concurrency: Optional[int] = None,
+        project_name: str | None = "evaluators",
+        max_concurrency: int | None = None,
         **kwargs: Any,
     ) -> None:
         """Create an EvaluatorCallbackHandler.
@@ -156,7 +156,7 @@ class EvaluatorCallbackHandler(BaseTracer):
 
     def _select_eval_results(
         self,
-        results: Union[EvaluationResult, EvaluationResults],
+        results: EvaluationResult | EvaluationResults,
     ) -> list[EvaluationResult]:
         if isinstance(results, EvaluationResult):
             results_ = [results]
@@ -172,9 +172,9 @@ class EvaluatorCallbackHandler(BaseTracer):
 
     def _log_evaluation_feedback(
         self,
-        evaluator_response: Union[EvaluationResult, EvaluationResults],
+        evaluator_response: EvaluationResult | EvaluationResults,
         run: Run,
-        source_run_id: Optional[UUID] = None,
+        source_run_id: UUID | None = None,
     ) -> list[EvaluationResult]:
         results = self._select_eval_results(evaluator_response)
         for res in results:

langchain_core/tracers/event_stream.py

@@ -8,10 +8,8 @@ import logging
 from typing import (
     TYPE_CHECKING,
     Any,
-    Optional,
     TypedDict,
     TypeVar,
-    Union,
     cast,
 )
 from uuid import UUID, uuid4
@@ -72,11 +70,11 @@ class RunInfo(TypedDict):
     """The type of the run."""
     inputs: NotRequired[Any]
     """The inputs to the run."""
-    parent_run_id: Optional[UUID]
+    parent_run_id: UUID | None
     """The ID of the parent run."""
 
 
-def _assign_name(name: Optional[str], serialized: Optional[dict[str, Any]]) -> str:
+def _assign_name(name: str | None, serialized: dict[str, Any] | None) -> str:
     """Assign a name to a run."""
     if name is not None:
         return name
@@ -97,12 +95,12 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
     def __init__(
         self,
         *args: Any,
-        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,
     ) -> None:
         """Initialize the tracer."""
@@ -116,7 +114,7 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
         # of a child run, which results in clean up of run_map.
         # So we keep track of the mapping between children and parent run IDs
         # in a separate container. This container is GCed when the tracer is GCed.
-        self.parent_map: dict[UUID, Optional[UUID]] = {}
+        self.parent_map: dict[UUID, UUID | None] = {}
 
         self.is_tapped: dict[UUID, Any] = {}
 
@@ -130,7 +128,10 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
             exclude_tags=exclude_tags,
         )
 
-        loop = asyncio.get_event_loop()
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
         memory_stream = _MemoryStream[StreamEvent](loop)
         self.send_stream = memory_stream.get_send_stream()
         self.receive_stream = memory_stream.get_receive_stream()
@@ -181,7 +182,7 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
             output: The output of the Runnable.
 
         Yields:
-            T: The output of the Runnable.
+            The output of the Runnable.
         """
         sentinel = object()
         # atomic check and set
@@ -231,7 +232,7 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
             output: The output of the Runnable.
 
         Yields:
-            T: The output of the Runnable.
+            The output of the Runnable.
         """
         sentinel = object()
         # atomic check and set
@@ -277,9 +278,9 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
         self,
         run_id: UUID,
         *,
-        tags: Optional[list[str]],
-        metadata: Optional[dict[str, Any]],
-        parent_run_id: Optional[UUID],
+        tags: list[str] | None,
+        metadata: dict[str, Any] | None,
+        parent_run_id: UUID | None,
         name_: str,
         run_type: str,
         **kwargs: Any,
@@ -309,10 +310,10 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
         messages: list[list[BaseMessage]],
         *,
         run_id: UUID,
-        tags: Optional[list[str]] = None,
-        parent_run_id: Optional[UUID] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        name: Optional[str] = None,
+        tags: list[str] | None = None,
+        parent_run_id: UUID | None = None,
+        metadata: dict[str, Any] | None = None,
+        name: str | None = None,
         **kwargs: Any,
     ) -> None:
         """Start a trace for a chat model run."""
@@ -351,10 +352,10 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
         prompts: list[str],
         *,
         run_id: UUID,
-        tags: Optional[list[str]] = None,
-        parent_run_id: Optional[UUID] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        name: Optional[str] = None,
+        tags: list[str] | None = None,
+        parent_run_id: UUID | None = None,
+        metadata: dict[str, Any] | None = None,
+        name: str | None = None,
         **kwargs: Any,
     ) -> None:
         """Start a trace for a (non-chat model) LLM run."""
@@ -395,8 +396,8 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
         data: Any,
         *,
         run_id: UUID,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
+        tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> None:
         """Generate a custom astream event."""
@@ -416,9 +417,9 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
         self,
         token: str,
         *,
-        chunk: Optional[Union[GenerationChunk, ChatGenerationChunk]] = None,
+        chunk: GenerationChunk | ChatGenerationChunk | None = None,
         run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
+        parent_run_id: UUID | None = None,
         **kwargs: Any,
     ) -> None:
         """Run on new output token. Only available when streaming is enabled.
@@ -426,7 +427,7 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
         For both chat models and non-chat models (legacy LLMs).
         """
         run_info = self.run_map.get(run_id)
-        chunk_: Union[GenerationChunk, BaseMessageChunk]
+        chunk_: GenerationChunk | BaseMessageChunk
 
         if run_info is None:
             msg = f"Run ID {run_id} not found in run map."
@@ -475,13 +476,13 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
         For both chat models and non-chat models (legacy LLMs).
 
         Raises:
-            ValueError: If the run type is not ``'llm'`` or ``'chat_model'``.
+            ValueError: If the run type is not `'llm'` or `'chat_model'`.
         """
         run_info = self.run_map.pop(run_id)
         inputs_ = run_info.get("inputs")
 
-        generations: Union[list[list[GenerationChunk]], list[list[ChatGenerationChunk]]]
-        output: Union[dict, BaseMessage] = {}
+        generations: list[list[GenerationChunk]] | list[list[ChatGenerationChunk]]
+        output: dict | BaseMessage = {}
 
         if run_info["run_type"] == "chat_model":
             generations = cast("list[list[ChatGenerationChunk]]", response.generations)
@@ -533,11 +534,11 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
         inputs: dict[str, Any],
         *,
         run_id: UUID,
-        tags: Optional[list[str]] = None,
-        parent_run_id: Optional[UUID] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        run_type: Optional[str] = None,
-        name: Optional[str] = None,
+        tags: list[str] | None = None,
+        parent_run_id: UUID | None = None,
+        metadata: dict[str, Any] | None = None,
+        run_type: str | None = None,
+        name: str | None = None,
         **kwargs: Any,
     ) -> None:
         """Start a trace for a chain run."""
@@ -581,7 +582,7 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
         outputs: dict[str, Any],
         *,
         run_id: UUID,
-        inputs: Optional[dict[str, Any]] = None,
+        inputs: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> None:
         """End a trace for a chain run."""
@@ -639,11 +640,11 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
         input_str: str,
         *,
         run_id: UUID,
-        tags: Optional[list[str]] = None,
-        parent_run_id: Optional[UUID] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        name: Optional[str] = None,
-        inputs: Optional[dict[str, Any]] = None,
+        tags: list[str] | None = None,
+        parent_run_id: UUID | None = None,
+        metadata: dict[str, Any] | None = None,
+        name: str | None = None,
+        inputs: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> None:
         """Start a trace for a tool run."""
@@ -680,8 +681,8 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
         error: BaseException,
         *,
         run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        tags: Optional[list[str]] = None,
+        parent_run_id: UUID | None = None,
+        tags: list[str] | None = None,
         **kwargs: Any,
     ) -> None:
         """Run when tool errors."""
@@ -735,10 +736,10 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
         query: str,
         *,
         run_id: UUID,
-        parent_run_id: Optional[UUID] = None,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        name: Optional[str] = None,
+        parent_run_id: UUID | None = None,
+        tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
+        name: str | None = None,
         **kwargs: Any,
     ) -> None:
         """Run when Retriever starts running."""
@@ -807,14 +808,14 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
 async def _astream_events_implementation_v1(
     runnable: Runnable[Input, Output],
     value: Any,
-    config: Optional[RunnableConfig] = None,
+    config: RunnableConfig | None = None,
     *,
-    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[StandardStreamEvent]:
     stream = LogStreamCallbackHandler(
@@ -983,14 +984,14 @@ async def _astream_events_implementation_v1(
 async def _astream_events_implementation_v2(
     runnable: Runnable[Input, Output],
     value: Any,
-    config: Optional[RunnableConfig] = None,
+    config: RunnableConfig | None = None,
     *,
-    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[StandardStreamEvent]:
     """Implementation of the astream events API for V2 runnables."""