langchain-core 0.4.0.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

langchain_core/callbacks/manager.py

@@ -8,18 +8,11 @@ import functools
 import logging
 import uuid
 from abc import ABC, abstractmethod
+from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import asynccontextmanager, contextmanager
 from contextvars import copy_context
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Optional,
-    TypeVar,
-    Union,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, TypeVar, cast
 from uuid import UUID
 
 from langsmith.run_helpers import get_tracing_context
@@ -36,17 +29,19 @@ from langchain_core.callbacks.base import (
     ToolManagerMixin,
 )
 from langchain_core.callbacks.stdout import StdOutCallbackHandler
+from langchain_core.globals import get_debug
 from langchain_core.messages import BaseMessage, get_buffer_string
-from langchain_core.messages.utils import convert_from_v1_message
-from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, LLMResult
+from langchain_core.tracers.context import (
+    _configure_hooks,
+    _get_trace_callbacks,
+    _get_tracer_project,
+    _tracing_v2_is_enabled,
+    tracing_v2_callback_var,
+)
+from langchain_core.tracers.langchain import LangChainTracer
 from langchain_core.tracers.schemas import Run
+from langchain_core.tracers.stdout import ConsoleCallbackHandler
 from langchain_core.utils.env import env_var_is_set
-from langchain_core.v1.messages import (
-    AIMessage,
-    AIMessageChunk,
-    MessageV1,
-    MessageV1Types,
-)
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator, Coroutine, Generator, Sequence
@@ -55,29 +50,27 @@ if TYPE_CHECKING:
 
     from langchain_core.agents import AgentAction, AgentFinish
     from langchain_core.documents import Document
-    from langchain_core.outputs import GenerationChunk
+    from langchain_core.outputs import ChatGenerationChunk, GenerationChunk, LLMResult
     from langchain_core.runnables.config import RunnableConfig
 
 logger = logging.getLogger(__name__)
 
 
 def _get_debug() -> bool:
-    from langchain_core.globals import get_debug
-
     return get_debug()
 
 
 @contextmanager
 def trace_as_chain_group(
     group_name: str,
-    callback_manager: Optional[CallbackManager] = None,
+    callback_manager: CallbackManager | None = None,
     *,
-    inputs: Optional[dict[str, Any]] = None,
-    project_name: Optional[str] = None,
-    example_id: Optional[Union[str, UUID]] = None,
-    run_id: Optional[UUID] = None,
-    tags: Optional[list[str]] = None,
-    metadata: Optional[dict[str, Any]] = None,
+    inputs: dict[str, Any] | None = None,
+    project_name: str | None = None,
+    example_id: str | UUID | None = None,
+    run_id: UUID | None = None,
+    tags: list[str] | None = None,
+    metadata: dict[str, Any] | None = None,
 ) -> Generator[CallbackManagerForChainGroup, None, None]:
     """Get a callback manager for a chain group in a context manager.
 
@@ -85,38 +78,31 @@ def trace_as_chain_group(
     they aren't composed in a single chain.
 
     Args:
-        group_name (str): The name of the chain group.
-        callback_manager (CallbackManager, optional): The callback manager to use.
-            Defaults to None.
-        inputs (dict[str, Any], optional): The inputs to the chain group.
-            Defaults to None.
-        project_name (str, optional): The name of the project.
-            Defaults to None.
-        example_id (str or UUID, optional): The ID of the example.
-            Defaults to None.
-        run_id (UUID, optional): The ID of the run.
-        tags (list[str], optional): The inheritable tags to apply to all runs.
-            Defaults to None.
-        metadata (dict[str, Any], optional): The metadata to apply to all runs.
-            Defaults to None.
-
-    Note: must have LANGCHAIN_TRACING_V2 env var set to true to see the trace in LangSmith.
-
-    Returns:
-        CallbackManagerForChainGroup: The callback manager for the chain group.
+        group_name: The name of the chain group.
+        callback_manager: The callback manager to use.
+        inputs: The inputs to the chain group.
+        project_name: The name of the project.
+        example_id: The ID of the example.
+        run_id: The ID of the run.
+        tags: The inheritable tags to apply to all runs.
+        metadata: The metadata to apply to all runs.
+
+    !!! note
+        Must have `LANGCHAIN_TRACING_V2` env var set to true to see the trace in
+        LangSmith.
+
+    Yields:
+        The callback manager for the chain group.
 
     Example:
-        .. code-block:: python
-
-            llm_input = "Foo"
-            with trace_as_chain_group("group_name", inputs={"input": llm_input}) as manager:
-                # Use the callback manager for the chain group
-                res = llm.invoke(llm_input, {"callbacks": manager})
-                manager.on_chain_end({"output": res})
-
-    """  # noqa: E501
-    from langchain_core.tracers.context import _get_trace_callbacks
-
+        ```python
+        llm_input = "Foo"
+        with trace_as_chain_group("group_name", inputs={"input": llm_input}) as manager:
+            # Use the callback manager for the chain group
+            res = llm.invoke(llm_input, {"callbacks": manager})
+            manager.on_chain_end({"output": res})
+        ```
+    """
     cb = _get_trace_callbacks(
         project_name, example_id, callback_manager=callback_manager
     )
@@ -152,14 +138,14 @@ def trace_as_chain_group(
 @asynccontextmanager
 async def atrace_as_chain_group(
     group_name: str,
-    callback_manager: Optional[AsyncCallbackManager] = None,
+    callback_manager: AsyncCallbackManager | None = None,
     *,
-    inputs: Optional[dict[str, Any]] = None,
-    project_name: Optional[str] = None,
-    example_id: Optional[Union[str, UUID]] = None,
-    run_id: Optional[UUID] = None,
-    tags: Optional[list[str]] = None,
-    metadata: Optional[dict[str, Any]] = None,
+    inputs: dict[str, Any] | None = None,
+    project_name: str | None = None,
+    example_id: str | UUID | None = None,
+    run_id: UUID | None = None,
+    tags: list[str] | None = None,
+    metadata: dict[str, Any] | None = None,
 ) -> AsyncGenerator[AsyncCallbackManagerForChainGroup, None]:
     """Get an async callback manager for a chain group in a context manager.
 
@@ -167,38 +153,34 @@ async def atrace_as_chain_group(
     they aren't composed in a single chain.
 
     Args:
-        group_name (str): The name of the chain group.
-        callback_manager (AsyncCallbackManager, optional): The async callback manager to use,
-            which manages tracing and other callback behavior. Defaults to None.
-        inputs (dict[str, Any], optional): The inputs to the chain group.
-            Defaults to None.
-        project_name (str, optional): The name of the project.
-            Defaults to None.
-        example_id (str or UUID, optional): The ID of the example.
-            Defaults to None.
-        run_id (UUID, optional): The ID of the run.
-        tags (list[str], optional): The inheritable tags to apply to all runs.
-            Defaults to None.
-        metadata (dict[str, Any], optional): The metadata to apply to all runs.
-            Defaults to None.
-
-    Returns:
-        AsyncCallbackManager: The async callback manager for the chain group.
-
-    Note: must have LANGCHAIN_TRACING_V2 env var set to true to see the trace in LangSmith.
+        group_name: The name of the chain group.
+        callback_manager: The async callback manager to use,
+            which manages tracing and other callback behavior.
+        inputs: The inputs to the chain group.
+        project_name: The name of the project.
+        example_id: The ID of the example.
+        run_id: The ID of the run.
+        tags: The inheritable tags to apply to all runs.
+        metadata: The metadata to apply to all runs.
+
+    Yields:
+        The async callback manager for the chain group.
+
+    !!! note
+        Must have `LANGCHAIN_TRACING_V2` env var set to true to see the trace in
+        LangSmith.
 
     Example:
-        .. code-block:: python
-
-            llm_input = "Foo"
-            async with atrace_as_chain_group("group_name", inputs={"input": llm_input}) as manager:
-                # Use the async callback manager for the chain group
-                res = await llm.ainvoke(llm_input, {"callbacks": manager})
-                await manager.on_chain_end({"output": res})
-
-    """  # noqa: E501
-    from langchain_core.tracers.context import _get_trace_callbacks
-
+        ```python
+        llm_input = "Foo"
+        async with atrace_as_chain_group(
+            "group_name", inputs={"input": llm_input}
+        ) as manager:
+            # Use the async callback manager for the chain group
+            res = await llm.ainvoke(llm_input, {"callbacks": manager})
+            await manager.on_chain_end({"output": res})
+        ```
+    """
     cb = _get_trace_callbacks(
         project_name, example_id, callback_manager=callback_manager
     )
@@ -238,10 +220,11 @@ def shielded(func: Func) -> Func:
     """Makes so an awaitable method is always shielded from cancellation.
 
     Args:
-        func (Callable): The function to shield.
+        func: The function to shield.
 
     Returns:
-        Callable: The shielded function
+        The shielded function
+
     """
 
     @functools.wraps(func)
@@ -251,76 +234,36 @@ def shielded(func: Func) -> Func:
     return cast("Func", wrapped)
 
 
-def _convert_llm_events(
-    event_name: str, args: tuple[Any, ...], kwargs: dict[str, Any]
-) -> tuple[tuple[Any, ...], dict[str, Any]]:
-    args_list = list(args)
-    if (
-        event_name == "on_chat_model_start"
-        and isinstance(args_list[1], list)
-        and args_list[1]
-        and isinstance(args_list[1][0], MessageV1Types)
-    ):
-        batch = [
-            convert_from_v1_message(item)
-            for item in args_list[1]
-            if isinstance(item, MessageV1Types)
-        ]
-        args_list[1] = [batch]
-    elif (
-        event_name == "on_llm_new_token"
-        and "chunk" in kwargs
-        and isinstance(kwargs["chunk"], MessageV1Types)
-    ):
-        chunk = kwargs["chunk"]
-        kwargs["chunk"] = ChatGenerationChunk(text=chunk.text, message=chunk)
-    elif event_name == "on_llm_end" and isinstance(args_list[0], MessageV1Types):
-        args_list[0] = LLMResult(
-            generations=[
-                [
-                    ChatGeneration(
-                        text=args_list[0].text,
-                        message=convert_from_v1_message(args_list[0]),
-                    )
-                ]
-            ]
-        )
-    else:
-        pass
-
-    return tuple(args_list), kwargs
-
-
 def handle_event(
     handlers: list[BaseCallbackHandler],
     event_name: str,
-    ignore_condition_name: Optional[str],
+    ignore_condition_name: str | None,
     *args: Any,
     **kwargs: Any,
 ) -> None:
     """Generic event handler for CallbackManager.
 
-    Note: This function is used by LangServe to handle events.
+    !!! note
+        This function is used by `LangServe` to handle events.
 
     Args:
         handlers: The list of handlers that will handle the event.
-        event_name: The name of the event (e.g., "on_llm_start").
+        event_name: The name of the event (e.g., `'on_llm_start'`).
         ignore_condition_name: Name of the attribute defined on handler
             that if True will cause the handler to be skipped for the given event.
         *args: The arguments to pass to the event handler.
         **kwargs: The keyword arguments to pass to the event handler
+
     """
     coros: list[Coroutine[Any, Any, Any]] = []
 
     try:
-        message_strings: Optional[list[str]] = None
+        message_strings: list[str] | None = None
         for handler in handlers:
             try:
                 if ignore_condition_name is None or not getattr(
                     handler, ignore_condition_name
                 ):
-                    if not handler.accepts_new_messages:
-                        args, kwargs = _convert_llm_events(event_name, args, kwargs)
                     event = getattr(handler, event_name)(*args, **kwargs)
                     if asyncio.iscoroutine(event):
                         coros.append(event)
@@ -409,14 +352,12 @@ def _run_coros(coros: list[Coroutine[Any, Any, Any]]) -> None:
 async def _ahandle_event_for_handler(
     handler: BaseCallbackHandler,
     event_name: str,
-    ignore_condition_name: Optional[str],
+    ignore_condition_name: str | None,
     *args: Any,
     **kwargs: Any,
 ) -> None:
     try:
         if ignore_condition_name is None or not getattr(handler, ignore_condition_name):
-            if not handler.accepts_new_messages:
-                args, kwargs = _convert_llm_events(event_name, args, kwargs)
             event = getattr(handler, event_name)
             if asyncio.iscoroutinefunction(event):
                 await event(*args, **kwargs)
@@ -463,21 +404,23 @@ async def _ahandle_event_for_handler(
 async def ahandle_event(
     handlers: list[BaseCallbackHandler],
     event_name: str,
-    ignore_condition_name: Optional[str],
+    ignore_condition_name: str | None,
     *args: Any,
     **kwargs: Any,
 ) -> None:
-    """Async generic event handler for AsyncCallbackManager.
+    """Async generic event handler for `AsyncCallbackManager`.
 
-    Note: This function is used by LangServe to handle events.
+    !!! note
+        This function is used by `LangServe` to handle events.
 
     Args:
         handlers: The list of handlers that will handle the event.
-        event_name: The name of the event (e.g., "on_llm_start").
+        event_name: The name of the event (e.g., `'on_llm_start'`).
         ignore_condition_name: Name of the attribute defined on handler
             that if True will cause the handler to be skipped for the given event.
         *args: The arguments to pass to the event handler.
         **kwargs: The keyword arguments to pass to the event handler.
+
     """
     for handler in [h for h in handlers if h.run_inline]:
         await _ahandle_event_for_handler(
@@ -507,28 +450,24 @@ class BaseRunManager(RunManagerMixin):
         run_id: UUID,
         handlers: list[BaseCallbackHandler],
         inheritable_handlers: list[BaseCallbackHandler],
-        parent_run_id: Optional[UUID] = None,
-        tags: Optional[list[str]] = None,
-        inheritable_tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        inheritable_metadata: Optional[dict[str, Any]] = None,
+        parent_run_id: UUID | None = None,
+        tags: list[str] | None = None,
+        inheritable_tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
+        inheritable_metadata: dict[str, Any] | None = None,
     ) -> None:
         """Initialize the run manager.
 
         Args:
-            run_id (UUID): The ID of the run.
-            handlers (list[BaseCallbackHandler]): The list of handlers.
-            inheritable_handlers (list[BaseCallbackHandler]):
-                The list of inheritable handlers.
-            parent_run_id (UUID, optional): The ID of the parent run.
-                Defaults to None.
-            tags (Optional[list[str]]): The list of tags. Defaults to None.
-            inheritable_tags (Optional[list[str]]): The list of inheritable tags.
-                Defaults to None.
-            metadata (Optional[dict[str, Any]]): The metadata.
-                Defaults to None.
-            inheritable_metadata (Optional[dict[str, Any]]): The inheritable metadata.
-                Defaults to None.
+            run_id: The ID of the run.
+            handlers: The list of handlers.
+            inheritable_handlers: The list of inheritable handlers.
+            parent_run_id: The ID of the parent run.
+            tags: The list of tags.
+            inheritable_tags: The list of inheritable tags.
+            metadata: The metadata.
+            inheritable_metadata: The inheritable metadata.
+
         """
         self.run_id = run_id
         self.handlers = handlers
@@ -544,7 +483,8 @@ class BaseRunManager(RunManagerMixin):
         """Return a manager that doesn't perform any operations.
 
         Returns:
-            BaseRunManager: The noop manager.
+            The noop manager.
+
         """
         return cls(
             run_id=uuid.uuid4(),
@@ -564,15 +504,12 @@ class RunManager(BaseRunManager):
         self,
         text: str,
         **kwargs: Any,
-    ) -> Any:
+    ) -> None:
         """Run when a text is received.
 
         Args:
-            text (str): The received text.
-            **kwargs (Any): Additional keyword arguments.
-
-        Returns:
-            Any: The result of the callback.
+            text: The received text.
+            **kwargs: Additional keyword arguments.
         """
         if not self.handlers:
             return
@@ -595,8 +532,9 @@ class RunManager(BaseRunManager):
         """Run when a retry is received.
 
         Args:
-            retry_state (RetryCallState): The retry state.
-            **kwargs (Any): Additional keyword arguments.
+            retry_state: The retry state.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -615,15 +553,15 @@ class RunManager(BaseRunManager):
 class ParentRunManager(RunManager):
     """Sync Parent Run Manager."""
 
-    def get_child(self, tag: Optional[str] = None) -> CallbackManager:
+    def get_child(self, tag: str | None = None) -> CallbackManager:
         """Get a child callback manager.
 
         Args:
-            tag (str, optional): The tag for the child callback manager.
-                Defaults to None.
+            tag: The tag for the child callback manager.
 
         Returns:
-            CallbackManager: The child callback manager.
+            The child callback manager.
+
         """
         manager = CallbackManager(handlers=[], parent_run_id=self.run_id)
         manager.set_handlers(self.inheritable_handlers)
@@ -642,22 +580,20 @@ class AsyncRunManager(BaseRunManager, ABC):
         """Get the equivalent sync RunManager.
 
         Returns:
-            RunManager: The sync RunManager.
+            The sync RunManager.
+
         """
 
     async def on_text(
         self,
         text: str,
         **kwargs: Any,
-    ) -> Any:
+    ) -> None:
         """Run when a text is received.
 
         Args:
-            text (str): The received text.
-            **kwargs (Any): Additional keyword arguments.
-
-        Returns:
-            Any: The result of the callback.
+            text: The received text.
+            **kwargs: Additional keyword arguments.
         """
         if not self.handlers:
             return
@@ -680,8 +616,9 @@ class AsyncRunManager(BaseRunManager, ABC):
         """Async run when a retry is received.
 
         Args:
-            retry_state (RetryCallState): The retry state.
-            **kwargs (Any): Additional keyword arguments.
+            retry_state: The retry state.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -700,15 +637,15 @@ class AsyncRunManager(BaseRunManager, ABC):
 class AsyncParentRunManager(AsyncRunManager):
     """Async Parent Run Manager."""
 
-    def get_child(self, tag: Optional[str] = None) -> AsyncCallbackManager:
+    def get_child(self, tag: str | None = None) -> AsyncCallbackManager:
         """Get a child callback manager.
 
         Args:
-            tag (str, optional): The tag for the child callback manager.
-                Defaults to None.
+            tag: The tag for the child callback manager.
 
         Returns:
-            AsyncCallbackManager: The child callback manager.
+            The child callback manager.
+
         """
         manager = AsyncCallbackManager(handlers=[], parent_run_id=self.run_id)
         manager.set_handlers(self.inheritable_handlers)
@@ -726,18 +663,16 @@ class CallbackManagerForLLMRun(RunManager, LLMManagerMixin):
         self,
         token: str,
         *,
-        chunk: Optional[
-            Union[GenerationChunk, ChatGenerationChunk, AIMessageChunk]
-        ] = None,
+        chunk: GenerationChunk | ChatGenerationChunk | None = None,
         **kwargs: Any,
     ) -> None:
         """Run when LLM generates a new token.
 
         Args:
-            token (str): The new token.
-            chunk (Optional[Union[GenerationChunk, ChatGenerationChunk]], optional):
-                The chunk. Defaults to None.
-            **kwargs (Any): Additional keyword arguments.
+            token: The new token.
+            chunk: The chunk.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -753,12 +688,13 @@ class CallbackManagerForLLMRun(RunManager, LLMManagerMixin):
             **kwargs,
         )
 
-    def on_llm_end(self, response: Union[LLMResult, AIMessage], **kwargs: Any) -> None:
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
         """Run when LLM ends running.
 
         Args:
-            response (LLMResult | AIMessage): The LLM result.
-            **kwargs (Any): Additional keyword arguments.
+            response: The LLM result.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -781,10 +717,10 @@ class CallbackManagerForLLMRun(RunManager, LLMManagerMixin):
         """Run when LLM errors.
 
         Args:
-            error (Exception or KeyboardInterrupt): The error.
-            kwargs (Any): Additional keyword arguments.
-                - response (LLMResult | AIMessage): The response which was generated
-                  before the error occurred.
+            error: The error.
+            **kwargs: Additional keyword arguments.
+                - response (LLMResult): The response which was generated before
+                    the error occurred.
         """
         if not self.handlers:
             return
@@ -807,7 +743,8 @@ class AsyncCallbackManagerForLLMRun(AsyncRunManager, LLMManagerMixin):
         """Get the equivalent sync RunManager.
 
         Returns:
-            CallbackManagerForLLMRun: The sync RunManager.
+            The sync RunManager.
+
         """
         return CallbackManagerForLLMRun(
             run_id=self.run_id,
@@ -824,18 +761,16 @@ class AsyncCallbackManagerForLLMRun(AsyncRunManager, LLMManagerMixin):
         self,
         token: str,
         *,
-        chunk: Optional[
-            Union[GenerationChunk, ChatGenerationChunk, AIMessageChunk]
-        ] = None,
+        chunk: GenerationChunk | ChatGenerationChunk | None = None,
         **kwargs: Any,
     ) -> None:
         """Run when LLM generates a new token.
 
         Args:
-            token (str): The new token.
-            chunk (Optional[Union[GenerationChunk, ChatGenerationChunk]], optional):
-                The chunk. Defaults to None.
-            **kwargs (Any): Additional keyword arguments.
+            token: The new token.
+            chunk: The chunk.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -852,14 +787,13 @@ class AsyncCallbackManagerForLLMRun(AsyncRunManager, LLMManagerMixin):
         )
 
     @shielded
-    async def on_llm_end(
-        self, response: Union[LLMResult, AIMessage], **kwargs: Any
-    ) -> None:
+    async def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
         """Run when LLM ends running.
 
         Args:
-            response (LLMResult | AIMessage): The LLM result.
-            **kwargs (Any): Additional keyword arguments.
+            response: The LLM result.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -883,10 +817,13 @@ class AsyncCallbackManagerForLLMRun(AsyncRunManager, LLMManagerMixin):
         """Run when LLM errors.
 
         Args:
-            error (Exception or KeyboardInterrupt): The error.
-            kwargs (Any): Additional keyword arguments.
-                - response (LLMResult | AIMessage): The response which was generated
-                  before the error occurred.
+            error: The error.
+            **kwargs: Additional keyword arguments.
+                - response (LLMResult): The response which was generated before
+                    the error occurred.
+
+
+
         """
         if not self.handlers:
             return
@@ -905,12 +842,13 @@ class AsyncCallbackManagerForLLMRun(AsyncRunManager, LLMManagerMixin):
 class CallbackManagerForChainRun(ParentRunManager, ChainManagerMixin):
     """Callback manager for chain run."""
 
-    def on_chain_end(self, outputs: Union[dict[str, Any], Any], **kwargs: Any) -> None:
+    def on_chain_end(self, outputs: dict[str, Any] | Any, **kwargs: Any) -> None:
         """Run when chain ends running.
 
         Args:
-            outputs (Union[dict[str, Any], Any]): The outputs of the chain.
-            **kwargs (Any): Additional keyword arguments.
+            outputs: The outputs of the chain.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -933,8 +871,9 @@ class CallbackManagerForChainRun(ParentRunManager, ChainManagerMixin):
         """Run when chain errors.
 
         Args:
-            error (Exception or KeyboardInterrupt): The error.
-            **kwargs (Any): Additional keyword arguments.
+            error: The error.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -949,15 +888,12 @@ class CallbackManagerForChainRun(ParentRunManager, ChainManagerMixin):
             **kwargs,
         )
 
-    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> None:
         """Run when agent action is received.
 
         Args:
-            action (AgentAction): The agent action.
-            **kwargs (Any): Additional keyword arguments.
-
-        Returns:
-            Any: The result of the callback.
+            action: The agent action.
+            **kwargs: Additional keyword arguments.
         """
         if not self.handlers:
             return
@@ -972,15 +908,12 @@ class CallbackManagerForChainRun(ParentRunManager, ChainManagerMixin):
             **kwargs,
         )
 
-    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> Any:
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
         """Run when agent finish is received.
 
         Args:
-            finish (AgentFinish): The agent finish.
-            **kwargs (Any): Additional keyword arguments.
-
-        Returns:
-            Any: The result of the callback.
+            finish: The agent finish.
+            **kwargs: Additional keyword arguments.
         """
         if not self.handlers:
             return
@@ -1003,7 +936,7 @@ class AsyncCallbackManagerForChainRun(AsyncParentRunManager, ChainManagerMixin):
         """Get the equivalent sync RunManager.
 
         Returns:
-            CallbackManagerForChainRun: The sync RunManager.
+            The sync RunManager.
         """
         return CallbackManagerForChainRun(
             run_id=self.run_id,
@@ -1017,14 +950,13 @@ class AsyncCallbackManagerForChainRun(AsyncParentRunManager, ChainManagerMixin):
         )
 
     @shielded
-    async def on_chain_end(
-        self, outputs: Union[dict[str, Any], Any], **kwargs: Any
-    ) -> None:
+    async def on_chain_end(self, outputs: dict[str, Any] | Any, **kwargs: Any) -> None:
         """Run when a chain ends running.
 
         Args:
-            outputs (Union[dict[str, Any], Any]): The outputs of the chain.
-            **kwargs (Any): Additional keyword arguments.
+            outputs: The outputs of the chain.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -1048,8 +980,9 @@ class AsyncCallbackManagerForChainRun(AsyncParentRunManager, ChainManagerMixin):
         """Run when chain errors.
 
         Args:
-            error (Exception or KeyboardInterrupt): The error.
-            **kwargs (Any): Additional keyword arguments.
+            error: The error.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -1064,15 +997,12 @@ class AsyncCallbackManagerForChainRun(AsyncParentRunManager, ChainManagerMixin):
             **kwargs,
         )
 
-    async def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+    async def on_agent_action(self, action: AgentAction, **kwargs: Any) -> None:
         """Run when agent action is received.
 
         Args:
-            action (AgentAction): The agent action.
-            **kwargs (Any): Additional keyword arguments.
-
-        Returns:
-            Any: The result of the callback.
+            action: The agent action.
+            **kwargs: Additional keyword arguments.
         """
         if not self.handlers:
             return
@@ -1087,15 +1017,12 @@ class AsyncCallbackManagerForChainRun(AsyncParentRunManager, ChainManagerMixin):
             **kwargs,
         )
 
-    async def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> Any:
+    async def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
         """Run when agent finish is received.
 
         Args:
-            finish (AgentFinish): The agent finish.
-            **kwargs (Any): Additional keyword arguments.
-
-        Returns:
-            Any: The result of the callback.
+            finish: The agent finish.
+            **kwargs: Additional keyword arguments.
         """
         if not self.handlers:
             return
@@ -1122,8 +1049,9 @@ class CallbackManagerForToolRun(ParentRunManager, ToolManagerMixin):
         """Run when the tool ends running.
 
         Args:
-            output (Any): The output of the tool.
-            **kwargs (Any): The keyword arguments to pass to the event handler
+            output: The output of the tool.
+            **kwargs: The keyword arguments to pass to the event handler
+
         """
         if not self.handlers:
             return
@@ -1146,8 +1074,9 @@ class CallbackManagerForToolRun(ParentRunManager, ToolManagerMixin):
         """Run when tool errors.
 
         Args:
-            error (Exception or KeyboardInterrupt): The error.
-            **kwargs (Any): Additional keyword arguments.
+            error: The error.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -1170,7 +1099,7 @@ class AsyncCallbackManagerForToolRun(AsyncParentRunManager, ToolManagerMixin):
         """Get the equivalent sync RunManager.
 
         Returns:
-            CallbackManagerForToolRun: The sync RunManager.
+            The sync RunManager.
         """
         return CallbackManagerForToolRun(
             run_id=self.run_id,
@@ -1187,8 +1116,9 @@ class AsyncCallbackManagerForToolRun(AsyncParentRunManager, ToolManagerMixin):
         """Async run when the tool ends running.
 
         Args:
-            output (Any): The output of the tool.
-            **kwargs (Any): Additional keyword arguments.
+            output: The output of the tool.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -1211,8 +1141,9 @@ class AsyncCallbackManagerForToolRun(AsyncParentRunManager, ToolManagerMixin):
         """Run when tool errors.
 
         Args:
-            error (Exception or KeyboardInterrupt): The error.
-            **kwargs (Any): Additional keyword arguments.
+            error: The error.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -1239,8 +1170,9 @@ class CallbackManagerForRetrieverRun(ParentRunManager, RetrieverManagerMixin):
         """Run when retriever ends running.
 
         Args:
-            documents (Sequence[Document]): The retrieved documents.
-            **kwargs (Any): Additional keyword arguments.
+            documents: The retrieved documents.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -1263,8 +1195,9 @@ class CallbackManagerForRetrieverRun(ParentRunManager, RetrieverManagerMixin):
         """Run when retriever errors.
 
         Args:
-            error (BaseException): The error.
-            **kwargs (Any): Additional keyword arguments.
+            error: The error.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -1290,7 +1223,8 @@ class AsyncCallbackManagerForRetrieverRun(
         """Get the equivalent sync RunManager.
 
         Returns:
-            CallbackManagerForRetrieverRun: The sync RunManager.
+            The sync RunManager.
+
         """
         return CallbackManagerForRetrieverRun(
             run_id=self.run_id,
@@ -1310,8 +1244,9 @@ class AsyncCallbackManagerForRetrieverRun(
         """Run when the retriever ends running.
 
         Args:
-            documents (Sequence[Document]): The retrieved documents.
-            **kwargs (Any): Additional keyword arguments.
+            documents: The retrieved documents.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -1335,8 +1270,9 @@ class AsyncCallbackManagerForRetrieverRun(
         """Run when retriever errors.
 
         Args:
-            error (BaseException): The error.
-            **kwargs (Any): Additional keyword arguments.
+            error: The error.
+            **kwargs: Additional keyword arguments.
+
         """
         if not self.handlers:
             return
@@ -1359,20 +1295,20 @@ class CallbackManager(BaseCallbackManager):
         self,
         serialized: dict[str, Any],
         prompts: list[str],
-        run_id: Optional[UUID] = None,
+        run_id: UUID | None = None,
         **kwargs: Any,
     ) -> list[CallbackManagerForLLMRun]:
         """Run when LLM starts running.
 
         Args:
-            serialized (dict[str, Any]): The serialized LLM.
-            prompts (list[str]): The list of prompts.
-            run_id (UUID, optional): The ID of the run. Defaults to None.
-            **kwargs (Any): Additional keyword arguments.
+            serialized: The serialized LLM.
+            prompts: The list of prompts.
+            run_id: The ID of the run.
+            **kwargs: Additional keyword arguments.
 
         Returns:
-            list[CallbackManagerForLLMRun]: A callback manager for each
-                prompt as an LLM run.
+            A callback manager for each prompt as an LLM run.
+
         """
         managers = []
         for i, prompt in enumerate(prompts):
@@ -1409,48 +1345,22 @@ class CallbackManager(BaseCallbackManager):
     def on_chat_model_start(
         self,
         serialized: dict[str, Any],
-        messages: Union[list[list[BaseMessage]], list[MessageV1]],
-        run_id: Optional[UUID] = None,
+        messages: list[list[BaseMessage]],
+        run_id: UUID | None = None,
         **kwargs: Any,
     ) -> list[CallbackManagerForLLMRun]:
         """Run when chat model starts running.
 
         Args:
-            serialized (dict[str, Any]): The serialized LLM.
-            messages (list[list[BaseMessage | MessageV1]]): The list of messages.
-            run_id (UUID, optional): The ID of the run. Defaults to None.
-            **kwargs (Any): Additional keyword arguments.
+            serialized: The serialized LLM.
+            messages: The list of messages.
+            run_id: The ID of the run.
+            **kwargs: Additional keyword arguments.
 
         Returns:
-            list[CallbackManagerForLLMRun]: A callback manager for each
-                list of messages as an LLM run.
+            A callback manager for each list of messages as an LLM run.
+
         """
-        if messages and isinstance(messages[0], MessageV1Types):
-            run_id_ = run_id if run_id is not None else uuid.uuid4()
-            handle_event(
-                self.handlers,
-                "on_chat_model_start",
-                "ignore_chat_model",
-                serialized,
-                messages,
-                run_id=run_id_,
-                parent_run_id=self.parent_run_id,
-                tags=self.tags,
-                metadata=self.metadata,
-                **kwargs,
-            )
-            return [
-                CallbackManagerForLLMRun(
-                    run_id=run_id_,
-                    handlers=self.handlers,
-                    inheritable_handlers=self.inheritable_handlers,
-                    parent_run_id=self.parent_run_id,
-                    tags=self.tags,
-                    inheritable_tags=self.inheritable_tags,
-                    metadata=self.metadata,
-                    inheritable_metadata=self.inheritable_metadata,
-                )
-            ]
         managers = []
         for message_list in messages:
             if run_id is not None:
@@ -1488,21 +1398,22 @@ class CallbackManager(BaseCallbackManager):
 
     def on_chain_start(
         self,
-        serialized: Optional[dict[str, Any]],
-        inputs: Union[dict[str, Any], Any],
-        run_id: Optional[UUID] = None,
+        serialized: dict[str, Any] | None,
+        inputs: dict[str, Any] | Any,
+        run_id: UUID | None = None,
         **kwargs: Any,
     ) -> CallbackManagerForChainRun:
         """Run when chain starts running.
 
         Args:
-            serialized (Optional[dict[str, Any]]): The serialized chain.
-            inputs (Union[dict[str, Any], Any]): The inputs to the chain.
-            run_id (UUID, optional): The ID of the run. Defaults to None.
-            **kwargs (Any): Additional keyword arguments.
+            serialized: The serialized chain.
+            inputs: The inputs to the chain.
+            run_id: The ID of the run.
+            **kwargs: Additional keyword arguments.
 
         Returns:
-            CallbackManagerForChainRun: The callback manager for the chain run.
+            The callback manager for the chain run.
+
         """
         if run_id is None:
             run_id = uuid.uuid4()
@@ -1533,11 +1444,11 @@ class CallbackManager(BaseCallbackManager):
     @override
     def on_tool_start(
         self,
-        serialized: Optional[dict[str, Any]],
+        serialized: dict[str, Any] | None,
         input_str: str,
-        run_id: Optional[UUID] = None,
-        parent_run_id: Optional[UUID] = None,
-        inputs: Optional[dict[str, Any]] = None,
+        run_id: UUID | None = None,
+        parent_run_id: UUID | None = None,
+        inputs: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> CallbackManagerForToolRun:
         """Run when tool starts running.
@@ -1546,17 +1457,18 @@ class CallbackManager(BaseCallbackManager):
             serialized: Serialized representation of the tool.
             input_str: The  input to the tool as a string.
                 Non-string inputs are cast to strings.
-            run_id: ID for the run. Defaults to None.
-            parent_run_id: The ID of the parent run. Defaults to None.
+            run_id: ID for the run.
+            parent_run_id: The ID of the parent run.
             inputs: The original input to the tool if provided.
                 Recommended for usage instead of input_str when the original
                 input is needed.
                 If provided, the inputs are expected to be formatted as a dict.
                 The keys will correspond to the named-arguments in the tool.
-            **kwargs (Any): The keyword arguments to pass to the event handler
+            **kwargs: The keyword arguments to pass to the event handler
 
         Returns:
-            CallbackManagerForToolRun: The callback manager for the tool run.
+            The callback manager for the tool run.
+
         """
         if run_id is None:
             run_id = uuid.uuid4()
@@ -1589,20 +1501,23 @@ class CallbackManager(BaseCallbackManager):
     @override
     def on_retriever_start(
         self,
-        serialized: Optional[dict[str, Any]],
+        serialized: dict[str, Any] | None,
         query: str,
-        run_id: Optional[UUID] = None,
-        parent_run_id: Optional[UUID] = None,
+        run_id: UUID | None = None,
+        parent_run_id: UUID | None = None,
         **kwargs: Any,
     ) -> CallbackManagerForRetrieverRun:
         """Run when the retriever starts running.
 
         Args:
-            serialized (Optional[dict[str, Any]]): The serialized retriever.
-            query (str): The query.
-            run_id (UUID, optional): The ID of the run. Defaults to None.
-            parent_run_id (UUID, optional): The ID of the parent run. Defaults to None.
-            **kwargs (Any): Additional keyword arguments.
+            serialized: The serialized retriever.
+            query: The query.
+            run_id: The ID of the run.
+            parent_run_id: The ID of the parent run.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            The callback manager for the retriever run.
         """
         if run_id is None:
             run_id = uuid.uuid4()
@@ -1635,7 +1550,7 @@ class CallbackManager(BaseCallbackManager):
         self,
         name: str,
         data: Any,
-        run_id: Optional[UUID] = None,
+        run_id: UUID | None = None,
         **kwargs: Any,
     ) -> None:
         """Dispatch an adhoc event to the handlers (async version).
@@ -1647,9 +1562,13 @@ class CallbackManager(BaseCallbackManager):
         Args:
             name: The name of the adhoc event.
             data: The data for the adhoc event.
-            run_id: The ID of the run. Defaults to None.
+            run_id: The ID of the run.
+
+        Raises:
+            ValueError: If additional keyword arguments are passed.
+
+        !!! version-added "Added in version 0.2.14"
 
-        .. versionadded:: 0.2.14
         """
         if not self.handlers:
             return
@@ -1680,30 +1599,24 @@ class CallbackManager(BaseCallbackManager):
         inheritable_callbacks: Callbacks = None,
         local_callbacks: Callbacks = None,
         verbose: bool = False,  # noqa: FBT001,FBT002
-        inheritable_tags: Optional[list[str]] = None,
-        local_tags: Optional[list[str]] = None,
-        inheritable_metadata: Optional[dict[str, Any]] = None,
-        local_metadata: Optional[dict[str, Any]] = None,
+        inheritable_tags: list[str] | None = None,
+        local_tags: list[str] | None = None,
+        inheritable_metadata: dict[str, Any] | None = None,
+        local_metadata: dict[str, Any] | None = None,
     ) -> CallbackManager:
         """Configure the callback manager.
 
         Args:
-            inheritable_callbacks (Optional[Callbacks], optional): The inheritable
-                callbacks. Defaults to None.
-            local_callbacks (Optional[Callbacks], optional): The local callbacks.
-                Defaults to None.
-            verbose (bool, optional): Whether to enable verbose mode. Defaults to False.
-            inheritable_tags (Optional[list[str]], optional): The inheritable tags.
-                Defaults to None.
-            local_tags (Optional[list[str]], optional): The local tags.
-                Defaults to None.
-            inheritable_metadata (Optional[dict[str, Any]], optional): The inheritable
-                metadata. Defaults to None.
-            local_metadata (Optional[dict[str, Any]], optional): The local metadata.
-                Defaults to None.
+            inheritable_callbacks: The inheritable callbacks.
+            local_callbacks: The local callbacks.
+            verbose: Whether to enable verbose mode.
+            inheritable_tags: The inheritable tags.
+            local_tags: The local tags.
+            inheritable_metadata: The inheritable metadata.
+            local_metadata: The local metadata.
 
         Returns:
-            CallbackManager: The configured callback manager.
+            The configured callback manager.
         """
         return _configure(
             cls,
@@ -1723,8 +1636,8 @@ class CallbackManagerForChainGroup(CallbackManager):
     def __init__(
         self,
         handlers: list[BaseCallbackHandler],
-        inheritable_handlers: Optional[list[BaseCallbackHandler]] = None,
-        parent_run_id: Optional[UUID] = None,
+        inheritable_handlers: list[BaseCallbackHandler] | None = None,
+        parent_run_id: UUID | None = None,
         *,
         parent_run_manager: CallbackManagerForChainRun,
         **kwargs: Any,
@@ -1732,12 +1645,12 @@ class CallbackManagerForChainGroup(CallbackManager):
         """Initialize the callback manager.
 
         Args:
-            handlers (list[BaseCallbackHandler]): The list of handlers.
-            inheritable_handlers (Optional[list[BaseCallbackHandler]]): The list of
-                inheritable handlers. Defaults to None.
-            parent_run_id (Optional[UUID]): The ID of the parent run. Defaults to None.
-            parent_run_manager (CallbackManagerForChainRun): The parent run manager.
-            **kwargs (Any): Additional keyword arguments.
+            handlers: The list of handlers.
+            inheritable_handlers: The list of inheritable handlers.
+            parent_run_id: The ID of the parent run.
+            parent_run_manager: The parent run manager.
+            **kwargs: Additional keyword arguments.
+
         """
         super().__init__(
             handlers,
@@ -1748,8 +1661,8 @@ class CallbackManagerForChainGroup(CallbackManager):
         self.parent_run_manager = parent_run_manager
         self.ended = False
 
+    @override
     def copy(self) -> CallbackManagerForChainGroup:
-        """Copy the callback manager."""
         return self.__class__(
             handlers=self.handlers.copy(),
             inheritable_handlers=self.inheritable_handlers.copy(),
@@ -1771,31 +1684,33 @@ class CallbackManagerForChainGroup(CallbackManager):
         from the current object.
 
         Returns:
-            CallbackManagerForChainGroup: A copy of the current object with the
-                handlers, tags, and other attributes merged from the other object.
+            A copy of the current object with the handlers, tags, and other attributes
+            merged from the other object.
 
         Example: Merging two callback managers.
 
-            .. code-block:: python
-
-                from langchain_core.callbacks.manager import CallbackManager, trace_as_chain_group
-                from langchain_core.callbacks.stdout import StdOutCallbackHandler
-
-                manager = CallbackManager(handlers=[StdOutCallbackHandler()], tags=["tag2"])
-                with trace_as_chain_group("My Group Name", tags=["tag1"]) as group_manager:
-                    merged_manager = group_manager.merge(manager)
-                    print(type(merged_manager))
-                    # <class 'langchain_core.callbacks.manager.CallbackManagerForChainGroup'>
-
-                    print(merged_manager.handlers)
-                    # [
-                    #    <langchain_core.callbacks.stdout.LangChainTracer object at ...>,
-                    #    <langchain_core.callbacks.streaming_stdout.StdOutCallbackHandler object at ...>,
-                    # ]
-
-                    print(merged_manager.tags)
-                    #    ['tag2', 'tag1']
-
+            ```python
+            from langchain_core.callbacks.manager import (
+                CallbackManager,
+                trace_as_chain_group,
+            )
+            from langchain_core.callbacks.stdout import StdOutCallbackHandler
+
+            manager = CallbackManager(handlers=[StdOutCallbackHandler()], tags=["tag2"])
+            with trace_as_chain_group("My Group Name", tags=["tag1"]) as group_manager:
+                merged_manager = group_manager.merge(manager)
+                print(type(merged_manager))
+                # <class 'langchain_core.callbacks.manager.CallbackManagerForChainGroup'>
+
+                print(merged_manager.handlers)
+                # [
+                #    <langchain_core.callbacks.stdout.LangChainTracer object at ...>,
+                #    <langchain_core.callbacks.streaming_stdout.StdOutCallbackHandler object at ...>,
+                # ]
+
+                print(merged_manager.tags)
+                #    ['tag2', 'tag1']
+            ```
         """  # noqa: E501
         manager = self.__class__(
             parent_run_id=self.parent_run_id or other.parent_run_id,
@@ -1820,12 +1735,13 @@ class CallbackManagerForChainGroup(CallbackManager):
             manager.add_handler(handler, inherit=True)
         return manager
 
-    def on_chain_end(self, outputs: Union[dict[str, Any], Any], **kwargs: Any) -> None:
+    def on_chain_end(self, outputs: dict[str, Any] | Any, **kwargs: Any) -> None:
         """Run when traced chain group ends.
 
         Args:
-            outputs (Union[dict[str, Any], Any]): The outputs of the chain.
-            **kwargs (Any): Additional keyword arguments.
+            outputs: The outputs of the chain.
+            **kwargs: Additional keyword arguments.
+
         """
         self.ended = True
         return self.parent_run_manager.on_chain_end(outputs, **kwargs)
@@ -1838,8 +1754,9 @@ class CallbackManagerForChainGroup(CallbackManager):
         """Run when chain errors.
 
         Args:
-            error (Exception or KeyboardInterrupt): The error.
-            **kwargs (Any): Additional keyword arguments.
+            error: The error.
+            **kwargs: Additional keyword arguments.
+
         """
         self.ended = True
         return self.parent_run_manager.on_chain_error(error, **kwargs)
@@ -1857,21 +1774,20 @@ class AsyncCallbackManager(BaseCallbackManager):
         self,
         serialized: dict[str, Any],
         prompts: list[str],
-        run_id: Optional[UUID] = None,
+        run_id: UUID | None = None,
         **kwargs: Any,
     ) -> list[AsyncCallbackManagerForLLMRun]:
         """Run when LLM starts running.
 
         Args:
-            serialized (dict[str, Any]): The serialized LLM.
-            prompts (list[str]): The list of prompts.
-            run_id (UUID, optional): The ID of the run. Defaults to None.
-            **kwargs (Any): Additional keyword arguments.
+            serialized: The serialized LLM.
+            prompts: The list of prompts.
+            run_id: The ID of the run.
+            **kwargs: Additional keyword arguments.
 
         Returns:
-            list[AsyncCallbackManagerForLLMRun]: The list of async
-                callback managers, one for each LLM Run corresponding
-                to each prompt.
+            The list of async callback managers, one for each LLM Run corresponding to
+            each prompt.
         """
         inline_tasks = []
         non_inline_tasks = []
@@ -1945,68 +1861,26 @@ class AsyncCallbackManager(BaseCallbackManager):
     async def on_chat_model_start(
         self,
         serialized: dict[str, Any],
-        messages: Union[list[list[BaseMessage]], list[MessageV1]],
-        run_id: Optional[UUID] = None,
+        messages: list[list[BaseMessage]],
+        run_id: UUID | None = None,
         **kwargs: Any,
     ) -> list[AsyncCallbackManagerForLLMRun]:
         """Async run when LLM starts running.
 
         Args:
-            serialized (dict[str, Any]): The serialized LLM.
-            messages (list[list[BaseMessage | MessageV1]]): The list of messages.
-            run_id (UUID, optional): The ID of the run. Defaults to None.
-            **kwargs (Any): Additional keyword arguments.
+            serialized: The serialized LLM.
+            messages: The list of messages.
+            run_id: The ID of the run.
+            **kwargs: Additional keyword arguments.
 
         Returns:
-            list[AsyncCallbackManagerForLLMRun]: The list of
-                async callback managers, one for each LLM Run
-                corresponding to each inner  message list.
+            The list of async callback managers, one for each LLM Run corresponding to
+            each inner  message list.
         """
-        if messages and isinstance(messages[0], MessageV1Types):
-            run_id_ = run_id if run_id is not None else uuid.uuid4()
-            inline_tasks = []
-            non_inline_tasks = []
-            for handler in self.handlers:
-                task = ahandle_event(
-                    [handler],
-                    "on_chat_model_start",
-                    "ignore_chat_model",
-                    serialized,
-                    messages,
-                    run_id=run_id_,
-                    parent_run_id=self.parent_run_id,
-                    tags=self.tags,
-                    metadata=self.metadata,
-                    **kwargs,
-                )
-                if handler.run_inline:
-                    inline_tasks.append(task)
-                else:
-                    non_inline_tasks.append(task)
-            managers = [
-                AsyncCallbackManagerForLLMRun(
-                    run_id=run_id_,
-                    handlers=self.handlers,
-                    inheritable_handlers=self.inheritable_handlers,
-                    parent_run_id=self.parent_run_id,
-                    tags=self.tags,
-                    inheritable_tags=self.inheritable_tags,
-                    metadata=self.metadata,
-                    inheritable_metadata=self.inheritable_metadata,
-                )
-            ]
-            # Run inline tasks sequentially
-            for task in inline_tasks:
-                await task
-
-            # Run non-inline tasks concurrently
-            if non_inline_tasks:
-                await asyncio.gather(*non_inline_tasks)
-
-            return managers
         inline_tasks = []
         non_inline_tasks = []
         managers = []
+
         for message_list in messages:
             if run_id is not None:
                 run_id_ = run_id
@@ -2057,22 +1931,21 @@ class AsyncCallbackManager(BaseCallbackManager):
 
     async def on_chain_start(
         self,
-        serialized: Optional[dict[str, Any]],
-        inputs: Union[dict[str, Any], Any],
-        run_id: Optional[UUID] = None,
+        serialized: dict[str, Any] | None,
+        inputs: dict[str, Any] | Any,
+        run_id: UUID | None = None,
         **kwargs: Any,
     ) -> AsyncCallbackManagerForChainRun:
         """Async run when chain starts running.
 
         Args:
-            serialized (Optional[dict[str, Any]]): The serialized chain.
-            inputs (Union[dict[str, Any], Any]): The inputs to the chain.
-            run_id (UUID, optional): The ID of the run. Defaults to None.
-            **kwargs (Any): Additional keyword arguments.
+            serialized: The serialized chain.
+            inputs: The inputs to the chain.
+            run_id: The ID of the run.
+            **kwargs: Additional keyword arguments.
 
         Returns:
-            AsyncCallbackManagerForChainRun: The async callback manager
-                for the chain run.
+            The async callback manager for the chain run.
         """
         if run_id is None:
             run_id = uuid.uuid4()
@@ -2104,25 +1977,23 @@ class AsyncCallbackManager(BaseCallbackManager):
     @override
     async def on_tool_start(
         self,
-        serialized: Optional[dict[str, Any]],
+        serialized: dict[str, Any] | None,
         input_str: str,
-        run_id: Optional[UUID] = None,
-        parent_run_id: Optional[UUID] = None,
+        run_id: UUID | None = None,
+        parent_run_id: UUID | None = None,
         **kwargs: Any,
     ) -> AsyncCallbackManagerForToolRun:
         """Run when the tool starts running.
 
         Args:
-            serialized (Optional[dict[str, Any]]): The serialized tool.
-            input_str (str): The input to the tool.
-            run_id (UUID, optional): The ID of the run. Defaults to None.
-            parent_run_id (UUID, optional): The ID of the parent run.
-                Defaults to None.
-            **kwargs (Any): Additional keyword arguments.
+            serialized: The serialized tool.
+            input_str: The input to the tool.
+            run_id: The ID of the run.
+            parent_run_id: The ID of the parent run.
+            **kwargs: Additional keyword arguments.
 
         Returns:
-            AsyncCallbackManagerForToolRun: The async callback manager
-                for the tool run.
+            The async callback manager for the tool run.
         """
         if run_id is None:
             run_id = uuid.uuid4()
@@ -2155,7 +2026,7 @@ class AsyncCallbackManager(BaseCallbackManager):
         self,
         name: str,
         data: Any,
-        run_id: Optional[UUID] = None,
+        run_id: UUID | None = None,
         **kwargs: Any,
     ) -> None:
         """Dispatch an adhoc event to the handlers (async version).
@@ -2167,9 +2038,12 @@ class AsyncCallbackManager(BaseCallbackManager):
         Args:
             name: The name of the adhoc event.
             data: The data for the adhoc event.
-            run_id: The ID of the run. Defaults to None.
+            run_id: The ID of the run.
+
+        Raises:
+            ValueError: If additional keyword arguments are passed.
 
-        .. versionadded:: 0.2.14
+        !!! version-added "Added in version 0.2.14"
         """
         if not self.handlers:
             return
@@ -2197,24 +2071,23 @@ class AsyncCallbackManager(BaseCallbackManager):
     @override
     async def on_retriever_start(
         self,
-        serialized: Optional[dict[str, Any]],
+        serialized: dict[str, Any] | None,
         query: str,
-        run_id: Optional[UUID] = None,
-        parent_run_id: Optional[UUID] = None,
+        run_id: UUID | None = None,
+        parent_run_id: UUID | None = None,
         **kwargs: Any,
     ) -> AsyncCallbackManagerForRetrieverRun:
         """Run when the retriever starts running.
 
         Args:
-            serialized (Optional[dict[str, Any]]): The serialized retriever.
-            query (str): The query.
-            run_id (UUID, optional): The ID of the run. Defaults to None.
-            parent_run_id (UUID, optional): The ID of the parent run. Defaults to None.
-            **kwargs (Any): Additional keyword arguments.
+            serialized: The serialized retriever.
+            query: The query.
+            run_id: The ID of the run.
+            parent_run_id: The ID of the parent run.
+            **kwargs: Additional keyword arguments.
 
         Returns:
-            AsyncCallbackManagerForRetrieverRun: The async callback manager
-                for the retriever run.
+            The async callback manager for the retriever run.
         """
         if run_id is None:
             run_id = uuid.uuid4()
@@ -2249,30 +2122,24 @@ class AsyncCallbackManager(BaseCallbackManager):
         inheritable_callbacks: Callbacks = None,
         local_callbacks: Callbacks = None,
         verbose: bool = False,  # noqa: FBT001,FBT002
-        inheritable_tags: Optional[list[str]] = None,
-        local_tags: Optional[list[str]] = None,
-        inheritable_metadata: Optional[dict[str, Any]] = None,
-        local_metadata: Optional[dict[str, Any]] = None,
+        inheritable_tags: list[str] | None = None,
+        local_tags: list[str] | None = None,
+        inheritable_metadata: dict[str, Any] | None = None,
+        local_metadata: dict[str, Any] | None = None,
     ) -> AsyncCallbackManager:
         """Configure the async callback manager.
 
         Args:
-            inheritable_callbacks (Optional[Callbacks], optional): The inheritable
-                callbacks. Defaults to None.
-            local_callbacks (Optional[Callbacks], optional): The local callbacks.
-                Defaults to None.
-            verbose (bool, optional): Whether to enable verbose mode. Defaults to False.
-            inheritable_tags (Optional[list[str]], optional): The inheritable tags.
-                Defaults to None.
-            local_tags (Optional[list[str]], optional): The local tags.
-                Defaults to None.
-            inheritable_metadata (Optional[dict[str, Any]], optional): The inheritable
-                metadata. Defaults to None.
-            local_metadata (Optional[dict[str, Any]], optional): The local metadata.
-                Defaults to None.
+            inheritable_callbacks: The inheritable callbacks.
+            local_callbacks: The local callbacks.
+            verbose: Whether to enable verbose mode.
+            inheritable_tags: The inheritable tags.
+            local_tags: The local tags.
+            inheritable_metadata: The inheritable metadata.
+            local_metadata: The local metadata.
 
         Returns:
-            AsyncCallbackManager: The configured async callback manager.
+            The configured async callback manager.
         """
         return _configure(
             cls,
@@ -2292,8 +2159,8 @@ class AsyncCallbackManagerForChainGroup(AsyncCallbackManager):
     def __init__(
         self,
         handlers: list[BaseCallbackHandler],
-        inheritable_handlers: Optional[list[BaseCallbackHandler]] = None,
-        parent_run_id: Optional[UUID] = None,
+        inheritable_handlers: list[BaseCallbackHandler] | None = None,
+        parent_run_id: UUID | None = None,
         *,
         parent_run_manager: AsyncCallbackManagerForChainRun,
         **kwargs: Any,
@@ -2301,13 +2168,11 @@ class AsyncCallbackManagerForChainGroup(AsyncCallbackManager):
         """Initialize the async callback manager.
 
         Args:
-            handlers (list[BaseCallbackHandler]): The list of handlers.
-            inheritable_handlers (Optional[list[BaseCallbackHandler]]): The list of
-                inheritable handlers. Defaults to None.
-            parent_run_id (Optional[UUID]): The ID of the parent run. Defaults to None.
-            parent_run_manager (AsyncCallbackManagerForChainRun):
-                The parent run manager.
-            **kwargs (Any): Additional keyword arguments.
+            handlers: The list of handlers.
+            inheritable_handlers: The list of inheritable handlers.
+            parent_run_id: The ID of the parent run.
+            parent_run_manager: The parent run manager.
+            **kwargs: Additional keyword arguments.
         """
         super().__init__(
             handlers,
@@ -2319,7 +2184,7 @@ class AsyncCallbackManagerForChainGroup(AsyncCallbackManager):
         self.ended = False
 
     def copy(self) -> AsyncCallbackManagerForChainGroup:
-        """Copy the async callback manager."""
+        """Return a copy the async callback manager."""
         return self.__class__(
             handlers=self.handlers.copy(),
             inheritable_handlers=self.inheritable_handlers.copy(),
@@ -2341,31 +2206,35 @@ class AsyncCallbackManagerForChainGroup(AsyncCallbackManager):
         from the current object.
 
         Returns:
-            AsyncCallbackManagerForChainGroup: A copy of the current AsyncCallbackManagerForChainGroup
-                with the handlers, tags, etc. of the other callback manager merged in.
+            A copy of the current AsyncCallbackManagerForChainGroup
+            with the handlers, tags, etc. of the other callback manager merged in.
 
         Example: Merging two callback managers.
 
-            .. code-block:: python
-
-                from langchain_core.callbacks.manager import CallbackManager, atrace_as_chain_group
-                from langchain_core.callbacks.stdout import StdOutCallbackHandler
-
-                manager = CallbackManager(handlers=[StdOutCallbackHandler()], tags=["tag2"])
-                async with atrace_as_chain_group("My Group Name", tags=["tag1"]) as group_manager:
-                    merged_manager = group_manager.merge(manager)
-                    print(type(merged_manager))
-                    # <class 'langchain_core.callbacks.manager.AsyncCallbackManagerForChainGroup'>
-
-                    print(merged_manager.handlers)
-                    # [
-                    #    <langchain_core.callbacks.stdout.LangChainTracer object at ...>,
-                    #    <langchain_core.callbacks.streaming_stdout.StdOutCallbackHandler object at ...>,
-                    # ]
-
-                    print(merged_manager.tags)
-                    #    ['tag2', 'tag1']
-
+            ```python
+            from langchain_core.callbacks.manager import (
+                CallbackManager,
+                atrace_as_chain_group,
+            )
+            from langchain_core.callbacks.stdout import StdOutCallbackHandler
+
+            manager = CallbackManager(handlers=[StdOutCallbackHandler()], tags=["tag2"])
+            async with atrace_as_chain_group(
+                "My Group Name", tags=["tag1"]
+            ) as group_manager:
+                merged_manager = group_manager.merge(manager)
+                print(type(merged_manager))
+                # <class 'langchain_core.callbacks.manager.AsyncCallbackManagerForChainGroup'>
+
+                print(merged_manager.handlers)
+                # [
+                #    <langchain_core.callbacks.stdout.LangChainTracer object at ...>,
+                #    <langchain_core.callbacks.streaming_stdout.StdOutCallbackHandler object at ...>,
+                # ]
+
+                print(merged_manager.tags)
+                #    ['tag2', 'tag1']
+            ```
         """  # noqa: E501
         manager = self.__class__(
             parent_run_id=self.parent_run_id or other.parent_run_id,
@@ -2390,14 +2259,12 @@ class AsyncCallbackManagerForChainGroup(AsyncCallbackManager):
             manager.add_handler(handler, inherit=True)
         return manager
 
-    async def on_chain_end(
-        self, outputs: Union[dict[str, Any], Any], **kwargs: Any
-    ) -> None:
+    async def on_chain_end(self, outputs: dict[str, Any] | Any, **kwargs: Any) -> None:
         """Run when traced chain group ends.
 
         Args:
-            outputs (Union[dict[str, Any], Any]): The outputs of the chain.
-            **kwargs (Any): Additional keyword arguments.
+            outputs: The outputs of the chain.
+            **kwargs: Additional keyword arguments.
         """
         self.ended = True
         await self.parent_run_manager.on_chain_end(outputs, **kwargs)
@@ -2410,8 +2277,8 @@ class AsyncCallbackManagerForChainGroup(AsyncCallbackManager):
         """Run when chain errors.
 
         Args:
-            error (Exception or KeyboardInterrupt): The error.
-            **kwargs (Any): Additional keyword arguments.
+            error: The error.
+            **kwargs: Additional keyword arguments.
         """
         self.ended = True
         await self.parent_run_manager.on_chain_error(error, **kwargs)
@@ -2424,44 +2291,35 @@ def _configure(
     callback_manager_cls: type[T],
     inheritable_callbacks: Callbacks = None,
     local_callbacks: Callbacks = None,
-    inheritable_tags: Optional[list[str]] = None,
-    local_tags: Optional[list[str]] = None,
-    inheritable_metadata: Optional[dict[str, Any]] = None,
-    local_metadata: Optional[dict[str, Any]] = None,
+    inheritable_tags: list[str] | None = None,
+    local_tags: list[str] | None = None,
+    inheritable_metadata: dict[str, Any] | None = None,
+    local_metadata: dict[str, Any] | None = None,
     *,
     verbose: bool = False,
 ) -> T:
     """Configure the callback manager.
 
     Args:
-        callback_manager_cls (Type[T]): The callback manager class.
-        inheritable_callbacks (Optional[Callbacks], optional): The inheritable
-            callbacks. Defaults to None.
-        local_callbacks (Optional[Callbacks], optional): The local callbacks.
-            Defaults to None.
-        verbose (bool, optional): Whether to enable verbose mode. Defaults to False.
-        inheritable_tags (Optional[list[str]], optional): The inheritable tags.
-            Defaults to None.
-        local_tags (Optional[list[str]], optional): The local tags. Defaults to None.
-        inheritable_metadata (Optional[dict[str, Any]], optional): The inheritable
-            metadata. Defaults to None.
-        local_metadata (Optional[dict[str, Any]], optional): The local metadata.
-            Defaults to None.
+        callback_manager_cls: The callback manager class.
+        inheritable_callbacks: The inheritable callbacks.
+        local_callbacks: The local callbacks.
+        inheritable_tags: The inheritable tags.
+        local_tags: The local tags.
+        inheritable_metadata: The inheritable metadata.
+        local_metadata: The local metadata.
+        verbose: Whether to enable verbose mode.
+
+    Raises:
+        RuntimeError: If `LANGCHAIN_TRACING` is set but `LANGCHAIN_TRACING_V2` is not.
 
     Returns:
-        T: The configured callback manager.
+        The configured callback manager.
     """
-    from langchain_core.tracers.context import (
-        _configure_hooks,
-        _get_tracer_project,
-        _tracing_v2_is_enabled,
-        tracing_v2_callback_var,
-    )
-
     tracing_context = get_tracing_context()
     tracing_metadata = tracing_context["metadata"]
     tracing_tags = tracing_context["tags"]
-    run_tree: Optional[Run] = tracing_context["parent"]
+    run_tree: Run | None = tracing_context["parent"]
     parent_run_id = None if run_tree is None else run_tree.id
     callback_manager = callback_manager_cls(
         handlers=[],
@@ -2534,9 +2392,6 @@ def _configure(
     tracer_project = _get_tracer_project()
     debug = _get_debug()
     if verbose or debug or tracing_v2_enabled_:
-        from langchain_core.tracers.langchain import LangChainTracer
-        from langchain_core.tracers.stdout import ConsoleCallbackHandler
-
         if verbose and not any(
             isinstance(handler, StdOutCallbackHandler)
             for handler in callback_manager.handlers
@@ -2609,99 +2464,103 @@ def _configure(
 
 
 async def adispatch_custom_event(
-    name: str, data: Any, *, config: Optional[RunnableConfig] = None
+    name: str, data: Any, *, config: RunnableConfig | None = None
 ) -> None:
     """Dispatch an adhoc event to the handlers.
 
     Args:
         name: The name of the adhoc event.
         data: The data for the adhoc event. Free form data. Ideally should be
-              JSON serializable to avoid serialization issues downstream, but
-              this is not enforced.
+            JSON serializable to avoid serialization issues downstream, but
+            this is not enforced.
         config: Optional config object. Mirrors the async API but not strictly needed.
 
-    Example:
-
-        .. code-block:: python
+    Raises:
+        RuntimeError: If there is no parent run ID available to associate
+            the event with.
 
-            from langchain_core.callbacks import (
-                AsyncCallbackHandler,
-                adispatch_custom_event
-            )
-            from langchain_core.runnable import RunnableLambda
-
-            class CustomCallbackManager(AsyncCallbackHandler):
-                async def on_custom_event(
-                    self,
-                    name: str,
-                    data: Any,
-                    *,
-                    run_id: UUID,
-                    tags: Optional[list[str]] = None,
-                    metadata: Optional[dict[str, Any]] = None,
-                    **kwargs: Any,
-                ) -> None:
-                    print(f"Received custom event: {name} with data: {data}")
-
-            callback = CustomCallbackManager()
-
-            async def foo(inputs):
-                await adispatch_custom_event("my_event", {"bar": "buzz})
-                return inputs
-
-            foo_ = RunnableLambda(foo)
-            await foo_.ainvoke({"a": "1"}, {"callbacks": [CustomCallbackManager()]})
+    Example:
+        ```python
+        from langchain_core.callbacks import (
+            AsyncCallbackHandler,
+            adispatch_custom_event
+        )
+        from langchain_core.runnable import RunnableLambda
+
+        class CustomCallbackManager(AsyncCallbackHandler):
+            async def on_custom_event(
+                self,
+                name: str,
+                data: Any,
+                *,
+                run_id: UUID,
+                tags: list[str] | None = None,
+                metadata: dict[str, Any] | None = None,
+                **kwargs: Any,
+            ) -> None:
+                print(f"Received custom event: {name} with data: {data}")
+
+        callback = CustomCallbackManager()
+
+        async def foo(inputs):
+            await adispatch_custom_event("my_event", {"bar": "buzz})
+            return inputs
+
+        foo_ = RunnableLambda(foo)
+        await foo_.ainvoke({"a": "1"}, {"callbacks": [CustomCallbackManager()]})
+        ```
 
     Example: Use with astream events
 
-        .. code-block:: python
-
-            from langchain_core.callbacks import (
-                AsyncCallbackHandler,
-                adispatch_custom_event
-            )
-            from langchain_core.runnable import RunnableLambda
-
-            class CustomCallbackManager(AsyncCallbackHandler):
-                async def on_custom_event(
-                    self,
-                    name: str,
-                    data: Any,
-                    *,
-                    run_id: UUID,
-                    tags: Optional[list[str]] = None,
-                    metadata: Optional[dict[str, Any]] = None,
-                    **kwargs: Any,
-                ) -> None:
-                    print(f"Received custom event: {name} with data: {data}")
-
-            callback = CustomCallbackManager()
-
-            async def foo(inputs):
-                await adispatch_custom_event("event_type_1", {"bar": "buzz})
-                await adispatch_custom_event("event_type_2", 5)
-                return inputs
-
-            foo_ = RunnableLambda(foo)
-
-            async for event in foo_.ainvoke_stream(
-                {"a": "1"},
-                version="v2",
-                config={"callbacks": [CustomCallbackManager()]}
-            ):
-                print(event)
+        ```python
+        from langchain_core.callbacks import (
+            AsyncCallbackHandler,
+            adispatch_custom_event
+        )
+        from langchain_core.runnable import RunnableLambda
+
+        class CustomCallbackManager(AsyncCallbackHandler):
+            async def on_custom_event(
+                self,
+                name: str,
+                data: Any,
+                *,
+                run_id: UUID,
+                tags: list[str] | None = None,
+                metadata: dict[str, Any] | None = None,
+                **kwargs: Any,
+            ) -> None:
+                print(f"Received custom event: {name} with data: {data}")
+
+        callback = CustomCallbackManager()
+
+        async def foo(inputs):
+            await adispatch_custom_event("event_type_1", {"bar": "buzz})
+            await adispatch_custom_event("event_type_2", 5)
+            return inputs
+
+        foo_ = RunnableLambda(foo)
+
+        async for event in foo_.ainvoke_stream(
+            {"a": "1"},
+            version="v2",
+            config={"callbacks": [CustomCallbackManager()]}
+        ):
+            print(event)
+        ```
 
-    .. warning::
+    !!! warning
         If using python <= 3.10 and async, you MUST
         specify the `config` parameter or the function will raise an error.
         This is due to a limitation in asyncio for python <= 3.10 that prevents
         LangChain from automatically propagating the config object on the user's
         behalf.
 
-    .. versionadded:: 0.2.15
+    !!! version-added "Added in version 0.2.15"
 
     """
-    from langchain_core.runnables.config import (
+    # Import locally to prevent circular imports.
+    from langchain_core.runnables.config import (  # noqa: PLC0415
         ensure_config,
         get_async_callback_manager_for_config,
     )
@@ -2730,49 +2589,53 @@ async def adispatch_custom_event(
 
 
 def dispatch_custom_event(
-    name: str, data: Any, *, config: Optional[RunnableConfig] = None
+    name: str, data: Any, *, config: RunnableConfig | None = None
 ) -> None:
     """Dispatch an adhoc event.
 
     Args:
         name: The name of the adhoc event.
         data: The data for the adhoc event. Free form data. Ideally should be
-              JSON serializable to avoid serialization issues downstream, but
-              this is not enforced.
+            JSON serializable to avoid serialization issues downstream, but
+            this is not enforced.
         config: Optional config object. Mirrors the async API but not strictly needed.
 
-    Example:
-
-        .. code-block:: python
+    Raises:
+        RuntimeError: If there is no parent run ID available to associate
+            the event with.
 
-            from langchain_core.callbacks import BaseCallbackHandler
-            from langchain_core.callbacks import dispatch_custom_event
-            from langchain_core.runnable import RunnableLambda
-
-            class CustomCallbackManager(BaseCallbackHandler):
-                def on_custom_event(
-                    self,
-                    name: str,
-                    data: Any,
-                    *,
-                    run_id: UUID,
-                    tags: Optional[list[str]] = None,
-                    metadata: Optional[dict[str, Any]] = None,
-                    **kwargs: Any,
-                ) -> None:
-                    print(f"Received custom event: {name} with data: {data}")
-
-            def foo(inputs):
-                dispatch_custom_event("my_event", {"bar": "buzz})
-                return inputs
-
-            foo_ = RunnableLambda(foo)
-            foo_.invoke({"a": "1"}, {"callbacks": [CustomCallbackManager()]})
-
-    .. versionadded:: 0.2.15
+    Example:
+        ```python
+        from langchain_core.callbacks import BaseCallbackHandler
+        from langchain_core.callbacks import dispatch_custom_event
+        from langchain_core.runnable import RunnableLambda
+
+        class CustomCallbackManager(BaseCallbackHandler):
+            def on_custom_event(
+                self,
+                name: str,
+                data: Any,
+                *,
+                run_id: UUID,
+                tags: list[str] | None = None,
+                metadata: dict[str, Any] | None = None,
+                **kwargs: Any,
+            ) -> None:
+                print(f"Received custom event: {name} with data: {data}")
+
+        def foo(inputs):
+            dispatch_custom_event("my_event", {"bar": "buzz})
+            return inputs
+
+        foo_ = RunnableLambda(foo)
+        foo_.invoke({"a": "1"}, {"callbacks": [CustomCallbackManager()]})
+        ```
+
+    !!! version-added "Added in version 0.2.15"
 
     """
-    from langchain_core.runnables.config import (
+    # Import locally to prevent circular imports.
+    from langchain_core.runnables.config import (  # noqa: PLC0415
         ensure_config,
         get_callback_manager_for_config,
     )