a
    ”˜ëjXc ã                   @  s\  d Z ddlmZ ddlZddlZddlZddlZddlmZm	Z	 ddl
mZ ddlmZmZ ddlmZ ddlmZmZmZmZmZmZmZ dd	lmZ dd
lmZ ddlmZmZ ddl m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z( ddl)m*Z* ddl+m,Z, ddl-m.Z.m/Z/ ddl0m1Z1m2Z2m3Z3m4Z4m5Z5 ddl6m7Z7 ddl8m9Z9 ddl:m;Z; ddl<m=Z= ddl>m?Z? e�rÂddl@mAZAmBZBmCZCmDZD ddlEmFZF ddlGmHZHmIZI ddlJmKZK ddlLmMZMmNZNmOZO ddlPmQZQ e ReS¡ZTddœdd„ZUed{ddddddd œd!d"d#d$d%d&d'd#d(d)œ	d*d+„ƒZVed|ddddddd œd!d,d#d$d%d&d'd#d-d)œ	d.d/„ƒZWed0ed1�ZXd0d0d2œd3d4„ZYd5d!d$d6d6d7d8œd9d:„ZZd;d7d<œd=d>„Z[d?d!d$d6d6d7d@œdAdB„Z\d5d!d$d6d6d7d8œdCdD„Z]G dEdF„ dFe'ƒZ^G dGdH„ dHe^ƒZ_G dIdJ„ dJe_ƒZ`G dKdL„ dLe^eƒZaG dMdN„ dNeaƒZbG dOdP„ dPe_e%ƒZcG dQdR„ dReae%ƒZdG dSdT„ dTe`e$ƒZeG dUdV„ dVebe$ƒZfG dWdX„ dXe`e(ƒZgG dYdZ„ dZebe(ƒZhG d[d\„ d\e`e&ƒZiG d]d^„ d^ebe&ƒZjG d_d`„ d`e"ƒZkG dadb„ dbekƒZlG dcdd„ dde"ƒZmG dedf„ dfemƒZnedgekemƒZod}dhdiœdjdkdkd'd'd#d#ddgdlœ	dmdn„Zpddoœd!d6dpd7dqœdrds„Zqddoœd!d6dpd7dqœdtdu„Zrejsdvdw�dxdœdydz„ƒZtdS )~zRun managers.é    )ÚannotationsN)ÚABCÚabstractmethod)ÚThreadPoolExecutor)ÚasynccontextmanagerÚcontextmanager)Úcopy_context)ÚTYPE_CHECKINGÚAnyÚCallableÚOptionalÚTypeVarÚUnionÚcast)ÚUUID)Úget_tracing_context)ÚSelfÚoverride)ÚBaseCallbackHandlerÚBaseCallbackManagerÚ	CallbacksÚChainManagerMixinÚLLMManagerMixinÚRetrieverManagerMixinÚRunManagerMixinÚToolManagerMixin)ÚStdOutCallbackHandler©Ú	get_debug)ÚBaseMessageÚget_buffer_string)Ú_configure_hooksÚ_get_trace_callbacksÚ_get_tracer_projectÚ_tracing_v2_is_enabledÚtracing_v2_callback_var)ÚLangChainTracer)ÚRun)ÚConsoleCallbackHandler)Úenv_var_is_set©Úuuid7)ÚAsyncGeneratorÚ	CoroutineÚ	GeneratorÚSequence)ÚRetryCallState)ÚAgentActionÚAgentFinish)ÚDocument)ÚChatGenerationChunkÚGenerationChunkÚ	LLMResult)ÚRunnableConfigÚbool©Úreturnc                   C  s   t ƒ S ©Nr   © r<   r<   ú_/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/langchain_core/callbacks/manager.pyÚ
_get_debug:   s    r>   )ÚinputsÚproject_nameÚ
example_idÚrun_idÚtagsÚmetadataÚstrzOptional[CallbackManager]úOptional[dict[str, Any]]úOptional[str]zOptional[Union[str, UUID]]úOptional[UUID]úOptional[list[str]]z3Generator[CallbackManagerForChainGroup, None, None])	Ú
group_nameÚcallback_managerr?   r@   rA   rB   rC   rD   r:   c             
   c  sº   t |||d�}tj|||d�}	|	jd| i|p.i |d�}
|
 ¡ }t|j|j|j|
|j	|j
|j|jd�}z
|V  W n6 ty¤ } z|jsŽ|
 |¡ ‚ W Y d}~nd}~0 0 |js¶|
 i ¡ dS )aÖ  Get a callback manager for a chain group in a context manager.

    Useful for grouping different calls together as a single run even if
    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.

    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})

    ©rK   ©Úinheritable_callbacksÚinheritable_tagsÚinheritable_metadataÚname©rB   ©Úparent_run_managerrC   rO   rD   rP   N)r"   ÚCallbackManagerÚ	configureÚon_chain_startÚ	get_childÚCallbackManagerForChainGroupÚhandlersÚinheritable_handlersÚparent_run_idrC   rO   rD   rP   Ú	ExceptionÚendedÚon_chain_errorÚon_chain_end©rJ   rK   r?   r@   rA   rB   rC   rD   ÚcbÚcmZrun_managerZchild_cmZgroup_cmÚer<   r<   r=   Útrace_as_chain_group>   s8    4ÿýø


re   zOptional[AsyncCallbackManager]z7AsyncGenerator[AsyncCallbackManagerForChainGroup, None]c             
   C sÌ   t |||d�}tj|||d�}	|	jd| i|p.i |d�I dH }
|
 ¡ }t|j|j|j|
|j	|j
|j|jd�}z
|V  W n< ty° } z$|jsš|
 |¡I dH  ‚ W Y d}~n d}~0 0 |jsÈ|
 i ¡I dH  dS )aA  Get an async callback manager for a chain group in a context manager.

    Useful for grouping different async calls together as a single run even if
    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.

    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})

    rL   rM   rQ   rR   NrS   )r"   ÚAsyncCallbackManagerrV   rW   rX   Ú!AsyncCallbackManagerForChainGrouprZ   r[   r\   rC   rO   rD   rP   r]   r^   r_   r`   ra   r<   r<   r=   Úatrace_as_chain_group’   s8    4ÿÿÿø

rh   ÚFunc)Úbound)Úfuncr:   c                   s*   t  ˆ ¡ddddœ‡ fdd„ƒ}td|ƒS )zºMakes so an awaitable method is always shielded from cancellation.

    Args:
        func (Callable): The function to shield.

    Returns:
        Callable: The shielded function

    r
   )ÚargsÚkwargsr:   c                  Ÿ  s   t  ˆ | i |¤Ž¡I d H S r;   )ÚasyncioZshield)rl   rm   ©rk   r<   r=   Úwrappedô   s    zshielded.<locals>.wrappedri   )Ú	functoolsÚwrapsr   )rk   rp   r<   ro   r=   Úshieldedé   s    rs   úlist[BaseCallbackHandler]r
   ÚNone)rZ   Ú
event_nameÚignore_condition_namerl   rm   r:   c                 O  sô  g }�zˆd}| D �]}z>|du s*t ||ƒsRt ||ƒ|i |¤Ž}t |¡rR| |¡ W q tyä }	 zx|dkr´|du r†dd„ |d D ƒ}t|gdd|d |g|d	d… ¢R i |¤Ž n|jj}
t 	d
|
|t
|	ƒ¡ W Y d}	~	qd}	~	0  t�y* }	 z.t 	d|jj|t
|	ƒ¡ |j�r‚ W Y d}	~	qd}	~	0 0 qW |�rðzt ¡  d}W n t�y^   d}Y n0 |�r†tƒ  tdtƒ jƒt|¡ ¡  nt|ƒ n`|�rîzt ¡  d}W n t�y¾   d}Y n0 |�rætƒ  tdtƒ jƒt|¡ ¡  nt|ƒ 0 dS )a/  Generic event handler for CallbackManager.

    .. 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'``).
        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

    NÚon_chat_model_startc                 S  s   g | ]}t |ƒ‘qS r<   ©r    ©Ú.0Úmr<   r<   r=   Ú
<listcomp>  ó    z handle_event.<locals>.<listcomp>é   Úon_llm_startÚ
ignore_llmr   é   ú)NotImplementedError in %s.%s callback: %súError in %s.%s callback: %sTFr   )Úgetattrrn   ÚiscoroutineÚappendÚNotImplementedErrorÚhandle_eventÚ	__class__Ú__name__ÚloggerÚwarningÚreprr]   Úraise_errorZget_running_loopÚRuntimeErrorÚ	_executorZsubmitr   r   ÚrunÚ
_run_corosÚresult)rZ   rv   rw   rl   rm   ÚcorosÚmessage_stringsÚhandlerÚeventrd   Zhandler_nameZloop_runningr<   r<   r=   r‰   û   s€    

ÿ
û
úù
üü
ÿ

í
ÿ
r‰   zlist[Coroutine[Any, Any, Any]])r•   r:   c                 C  sø   t tdƒr¦t ¡ �‚}| D ]H}z| |¡ W q ty^ } zt dt|ƒ¡ W Y d }~qd }~0 0 qt | 	¡ ¡ }r†| t 
|¡¡ qbW d   ƒ qô1 sš0    Y  nN| D ]H}zt |¡ W qª tyð } zt dt|ƒ¡ W Y d }~qªd }~0 0 qªd S )NÚRunnerzError in callback coroutine: %s)Úhasattrrn   r™   r’   r]   rŒ   r�   rŽ   Z	all_tasksZget_loopÚwait)r•   ÚrunnerÚcorord   Úpendingr<   r<   r=   r“   Q  s    

(2r“   r   )r—   rv   rw   rl   rm   r:   c              
   Ï  sb  zŒ|d u st | |ƒsŠt | |ƒ}t |¡r>||i |¤ŽI d H  nL| jrT||i |¤Ž n6t ¡  d tdtjt	ƒ j
|g|¢R i |¤Žƒ¡I d H  W nÐ t�y } zp|dkrêdd„ |d D ƒ}t| dd|d |g|d	d … ¢R i |¤ŽI d H  nt d
| jj|t|ƒ¡ W Y d }~nPd }~0  t�y\ } z.t d| jj|t|ƒ¡ | j�rH‚ W Y d }~n
d }~0 0 d S )Nr   rx   c                 S  s   g | ]}t |ƒ‘qS r<   ry   rz   r<   r<   r=   r}   †  r~   z._ahandle_event_for_handler.<locals>.<listcomp>r   r€   r�   r   r‚   rƒ   r„   )r…   rn   ÚiscoroutinefunctionÚ
run_inlineZget_event_loopZrun_in_executorr   rq   Úpartialr   r’   rˆ   Ú_ahandle_event_for_handlerrŒ   r�   rŠ   r‹   rŽ   r]   r�   )r—   rv   rw   rl   rm   r˜   rd   r–   r<   r<   r=   r¢   n  sV    

þþû
úù
üür¢   c                 �  s\   dd„ | D ƒD ]$}t |ˆˆgˆ ¢R i ˆ¤ŽI dH  qtj‡ ‡‡‡fdd„| D ƒŽ I dH  dS )a?  Async generic event handler for ``AsyncCallbackManager``.

    .. 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'``).
        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.

    c                 S  s   g | ]}|j r|‘qS r<   ©r    )r{   Úhr<   r<   r=   r}   ·  r~   z!ahandle_event.<locals>.<listcomp>Nc                 3  s.   | ]&}|j st|ˆˆgˆ ¢R i ˆ¤ŽV  qd S r;   )r    r¢   ©r{   r—   ©rl   rv   rw   rm   r<   r=   Ú	<genexpr>¼  s   øýüûz ahandle_event.<locals>.<genexpr>)r¢   rn   Úgather)rZ   rv   rw   rl   rm   r—   r<   r¦   r=   Úahandle_event¢  s    ÿÿÿøÿr©   c                   @  sN   e Zd ZdZddddddœddddddddd	d
œ	dd„Zeddœdd„ƒZdS )ÚBaseRunManagerz6Base class for run manager (a bound callback manager).N)r\   rC   rO   rD   rP   r   rt   rH   rI   rF   ru   )	rB   rZ   r[   r\   rC   rO   rD   rP   r:   c          	      C  sD   || _ || _|| _|| _|pg | _|p(g | _|p2i | _|p<i | _dS )a  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.

        N©rB   rZ   r[   r\   rC   rO   rD   rP   )	ÚselfrB   rZ   r[   r\   rC   rO   rD   rP   r<   r<   r=   Ú__init__Í  s    


zBaseRunManager.__init__r   r9   c              	   C  s   | t ƒ g g g g i i d�S )zReturn a manager that doesn't perform any operations.

        Returns:
            BaseRunManager: The noop manager.

        )rB   rZ   r[   rC   rO   rD   rP   r*   )Úclsr<   r<   r=   Úget_noop_managerô  s    ùzBaseRunManager.get_noop_manager)r‹   Ú
__module__Ú__qualname__Ú__doc__r­   Úclassmethodr¯   r<   r<   r<   r=   rª   Ê  s   ö"'rª   c                   @  s4   e Zd ZdZddddœdd„Zdddd	œd
d„ZdS )Ú
RunManagerzSync Run Manager.rE   r
   ru   ©Útextrm   r:   c                 K  s4   | j s
dS t| j dd|f| j| j| jdœ|¤Ž dS ©z™Run when a text is received.

        Args:
            text (str): The received text.
            **kwargs (Any): Additional keyword arguments.
        NÚon_text©rB   r\   rC   ©rZ   r‰   rB   r\   rC   ©r¬   r¶   rm   r<   r<   r=   r¸   
  s    üùøzRunManager.on_textr0   ©Úretry_staterm   r:   c                 K  s4   | j s
dS t| j dd|f| j| j| jdœ|¤Ž dS )z«Run when a retry is received.

        Args:
            retry_state (RetryCallState): The retry state.
            **kwargs (Any): Additional keyword arguments.

        NÚon_retryÚignore_retryr¹   rº   ©r¬   r½   rm   r<   r<   r=   r¾   "  s    üùøzRunManager.on_retryN)r‹   r°   r±   r²   r¸   r¾   r<   r<   r<   r=   r´     s   r´   c                   @  s"   e Zd ZdZddddœdd„ZdS )	ÚParentRunManagerzSync Parent Run Manager.NrG   rU   ©Útagr:   c                 C  sN   t g | jd�}| | j¡ | | j¡ | | j¡ |durJ|j|gdd� |S )zìGet a child callback manager.

        Args:
            tag (str, optional): The tag for the child callback manager.
                Defaults to None.

        Returns:
            CallbackManager: The child callback manager.

        ©rZ   r\   NF©Zinherit)rU   rB   Úset_handlersr[   Úadd_tagsrO   Úadd_metadatarP   ©r¬   rÃ   Úmanagerr<   r<   r=   rX   ?  s    zParentRunManager.get_child)N©r‹   r°   r±   r²   rX   r<   r<   r<   r=   rÁ   <  s   rÁ   c                   @  sF   e Zd ZdZeddœdd„ƒZdddd	œd
d„Zddddœdd„ZdS )ÚAsyncRunManagerzAsync Run Manager.r´   r9   c                 C  s   dS )zlGet the equivalent sync RunManager.

        Returns:
            RunManager: The sync RunManager.

        Nr<   ©r¬   r<   r<   r=   Úget_syncV  s    zAsyncRunManager.get_syncrE   r
   ru   rµ   c                 Ë  s:   | j s
dS t| j dd|f| j| j| jdœ|¤ŽI dH  dS r·   ©rZ   r©   rB   r\   rC   r»   r<   r<   r=   r¸   _  s    üùøzAsyncRunManager.on_textr0   r¼   c                 Ë  s:   | j s
dS t| j dd|f| j| j| jdœ|¤ŽI dH  dS )z±Async run when a retry is received.

        Args:
            retry_state (RetryCallState): The retry state.
            **kwargs (Any): Additional keyword arguments.

        Nr¾   r¿   r¹   rÏ   rÀ   r<   r<   r=   r¾   w  s    üùøzAsyncRunManager.on_retryN)r‹   r°   r±   r²   r   rÎ   r¸   r¾   r<   r<   r<   r=   rÌ   S  s
   rÌ   c                   @  s"   e Zd ZdZddddœdd„ZdS )	ÚAsyncParentRunManagerzAsync Parent Run Manager.NrG   rf   rÂ   c                 C  sN   t g | jd�}| | j¡ | | j¡ | | j¡ |durJ|j|gdd� |S )zñGet a child callback manager.

        Args:
            tag (str, optional): The tag for the child callback manager.
                Defaults to None.

        Returns:
            AsyncCallbackManager: The child callback manager.

        rÄ   NFrÅ   )rf   rB   rÆ   r[   rÇ   rO   rÈ   rP   rÉ   r<   r<   r=   rX   ”  s    zAsyncParentRunManager.get_child)NrË   r<   r<   r<   r=   rÐ   ‘  s   rÐ   c                   @  sN   e Zd ZdZddœdddddœd	d
„Zddddœdd„Zddddœdd„ZdS )ÚCallbackManagerForLLMRunzCallback manager for LLM run.N©ÚchunkrE   ú5Optional[Union[GenerationChunk, ChatGenerationChunk]]r
   ru   ©ÚtokenrÓ   rm   r:   c                K  s6   | j s
dS t| j ddf|| j| j| j|dœ|¤Ž dS )á   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.

        NÚon_llm_new_tokenr�   )rÖ   rB   r\   rC   rÓ   rº   ©r¬   rÖ   rÓ   rm   r<   r<   r=   rØ   «  s    ýø	÷z)CallbackManagerForLLMRun.on_llm_new_tokenr6   ©Úresponserm   r:   c                 K  s4   | j s
dS t| j dd|f| j| j| jdœ|¤Ž dS ©zŸRun when LLM ends running.

        Args:
            response (LLMResult): The LLM result.
            **kwargs (Any): Additional keyword arguments.

        NÚ
on_llm_endr�   r¹   rº   ©r¬   rÛ   rm   r<   r<   r=   rÝ   É  s    üùøz#CallbackManagerForLLMRun.on_llm_endÚBaseException©Úerrorrm   r:   c                 K  s4   | j s
dS t| j dd|f| j| j| jdœ|¤Ž dS )a  Run when LLM errors.

        Args:
            error (Exception or KeyboardInterrupt): The error.
            kwargs (Any): Additional keyword arguments.
                - response (LLMResult): The response which was generated before
                    the error occurred.
        NÚon_llm_errorr�   r¹   rº   ©r¬   rá   rm   r<   r<   r=   râ   Þ  s    üùøz%CallbackManagerForLLMRun.on_llm_error)r‹   r°   r±   r²   rØ   rÝ   râ   r<   r<   r<   r=   rÑ   ¨  s
   ürÑ   c                   @  sd   e Zd ZdZddœdd„Zddœdd	d
ddœdd„Zedd
ddœdd„ƒZedd
ddœdd„ƒZdS )ÚAsyncCallbackManagerForLLMRunz#Async callback manager for LLM run.rÑ   r9   c              
   C  s(   t | j| j| j| j| j| j| j| jd�S )zzGet the equivalent sync RunManager.

        Returns:
            CallbackManagerForLLMRun: The sync RunManager.

        r«   )	rÑ   rB   rZ   r[   r\   rC   rO   rD   rP   rÍ   r<   r<   r=   rÎ   ü  s    øz&AsyncCallbackManagerForLLMRun.get_syncNrÒ   rE   rÔ   r
   ru   rÕ   c                Ë  s<   | j s
dS t| j dd|f|| j| j| jdœ|¤ŽI dH  dS )r×   NrØ   r�   )rÓ   rB   r\   rC   rÏ   rÙ   r<   r<   r=   rØ     s    üø	÷z.AsyncCallbackManagerForLLMRun.on_llm_new_tokenr6   rÚ   c                 Ë  s:   | j s
dS t| j dd|f| j| j| jdœ|¤ŽI dH  dS rÜ   rÏ   rÞ   r<   r<   r=   rÝ   ,  s    	üùøz(AsyncCallbackManagerForLLMRun.on_llm_endrß   rà   c                 Ë  s:   | j s
dS t| j dd|f| j| j| jdœ|¤ŽI dH  dS )a  Run when LLM errors.

        Args:
            error (Exception or KeyboardInterrupt): The error.
            kwargs (Any): Additional keyword arguments.
                - response (LLMResult): The response which was generated before
                    the error occurred.



        Nrâ   r�   r¹   rÏ   rã   r<   r<   r=   râ   B  s    üùøz*AsyncCallbackManagerForLLMRun.on_llm_error)	r‹   r°   r±   r²   rÎ   rØ   rs   rÝ   râ   r<   r<   r<   r=   rä   ù  s   ürä   c                   @  sX   e Zd ZdZddddœdd„Zdddd	œd
d„Zddddœdd„Zddddœdd„ZdS )ÚCallbackManagerForChainRunzCallback manager for chain run.úUnion[dict[str, Any], Any]r
   ru   ©Úoutputsrm   r:   c                 K  s4   | j s
dS t| j dd|f| j| j| jdœ|¤Ž dS )z»Run when chain ends running.

        Args:
            outputs (Union[dict[str, Any], Any]): The outputs of the chain.
            **kwargs (Any): Additional keyword arguments.

        Nr`   Úignore_chainr¹   rº   ©r¬   rè   rm   r<   r<   r=   r`   d  s    üùøz'CallbackManagerForChainRun.on_chain_endrß   rà   c                 K  s4   | j s
dS t| j dd|f| j| j| jdœ|¤Ž dS ©ú¨Run when chain errors.

        Args:
            error (Exception or KeyboardInterrupt): The error.
            **kwargs (Any): Additional keyword arguments.

        Nr_   ré   r¹   rº   rã   r<   r<   r=   r_   y  s    üùøz)CallbackManagerForChainRun.on_chain_errorr1   ©Úactionrm   r:   c                 K  s4   | j s
dS t| j dd|f| j| j| jdœ|¤Ž dS ©z¨Run when agent action is received.

        Args:
            action (AgentAction): The agent action.
            **kwargs (Any): Additional keyword arguments.
        NÚon_agent_actionÚignore_agentr¹   rº   ©r¬   rî   rm   r<   r<   r=   rð   ’  s    üùøz*CallbackManagerForChainRun.on_agent_actionr2   ©Úfinishrm   r:   c                 K  s4   | j s
dS t| j dd|f| j| j| jdœ|¤Ž dS ©z¨Run when agent finish is received.

        Args:
            finish (AgentFinish): The agent finish.
            **kwargs (Any): Additional keyword arguments.
        NÚon_agent_finishrñ   r¹   rº   ©r¬   rô   rm   r<   r<   r=   rö   ¦  s    üùøz*CallbackManagerForChainRun.on_agent_finishN)r‹   r°   r±   r²   r`   r_   rð   rö   r<   r<   r<   r=   rå   a  s
   rå   c                   @  sn   e Zd ZdZddœdd„Zedddd	œd
d„ƒZeddddœdd„ƒZddddœdd„Zddddœdd„Z	dS )ÚAsyncCallbackManagerForChainRunz%Async callback manager for chain run.rå   r9   c              
   C  s(   t | j| j| j| j| j| j| j| jd�S )z{Get the equivalent sync RunManager.

        Returns:
            CallbackManagerForChainRun: The sync RunManager.
        r«   )	rå   rB   rZ   r[   r\   rC   rO   rD   rP   rÍ   r<   r<   r=   rÎ   ¾  s    øz(AsyncCallbackManagerForChainRun.get_syncræ   r
   ru   rç   c                 Ë  s:   | j s
dS t| j dd|f| j| j| jdœ|¤ŽI dH  dS )z½Run when a chain ends running.

        Args:
            outputs (Union[dict[str, Any], Any]): The outputs of the chain.
            **kwargs (Any): Additional keyword arguments.

        Nr`   ré   r¹   rÏ   rê   r<   r<   r=   r`   Ï  s    üùøz,AsyncCallbackManagerForChainRun.on_chain_endrß   rà   c                 Ë  s:   | j s
dS t| j dd|f| j| j| jdœ|¤ŽI dH  dS rë   rÏ   rã   r<   r<   r=   r_   ç  s    üùøz.AsyncCallbackManagerForChainRun.on_chain_errorr1   rí   c                 Ë  s:   | j s
dS t| j dd|f| j| j| jdœ|¤ŽI dH  dS rï   rÏ   rò   r<   r<   r=   rð     s    üùøz/AsyncCallbackManagerForChainRun.on_agent_actionr2   ró   c                 Ë  s:   | j s
dS t| j dd|f| j| j| jdœ|¤ŽI dH  dS rõ   rÏ   r÷   r<   r<   r=   rö     s    üùøz/AsyncCallbackManagerForChainRun.on_agent_finishN)
r‹   r°   r±   r²   rÎ   rs   r`   r_   rð   rö   r<   r<   r<   r=   rø   »  s   rø   c                   @  s4   e Zd ZdZddddœdd„Zddddœd	d
„ZdS )ÚCallbackManagerForToolRunzCallback manager for tool run.r
   ru   ©Úoutputrm   r:   c                 K  s4   | j s
dS t| j dd|f| j| j| jdœ|¤Ž dS )z¹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

        NÚon_tool_endrñ   r¹   rº   ©r¬   rû   rm   r<   r<   r=   rü   -  s    üùøz%CallbackManagerForToolRun.on_tool_endrß   rà   c                 K  s4   | j s
dS t| j dd|f| j| j| jdœ|¤Ž dS ©z§Run when tool errors.

        Args:
            error (Exception or KeyboardInterrupt): The error.
            **kwargs (Any): Additional keyword arguments.

        NÚon_tool_errorrñ   r¹   rº   rã   r<   r<   r=   rÿ   F  s    üùøz'CallbackManagerForToolRun.on_tool_errorN)r‹   r°   r±   r²   rü   rÿ   r<   r<   r<   r=   rù   *  s   rù   c                   @  sB   e Zd ZdZddœdd„Zddddœd	d
„Zddddœdd„ZdS )ÚAsyncCallbackManagerForToolRunz$Async callback manager for tool run.rù   r9   c              
   C  s(   t | j| j| j| j| j| j| j| jd�S )zzGet the equivalent sync RunManager.

        Returns:
            CallbackManagerForToolRun: The sync RunManager.
        r«   )	rù   rB   rZ   r[   r\   rC   rO   rD   rP   rÍ   r<   r<   r=   rÎ   c  s    øz'AsyncCallbackManagerForToolRun.get_syncr
   ru   rú   c                 Ë  s:   | j s
dS t| j dd|f| j| j| jdœ|¤ŽI dH  dS )zªAsync run when the tool ends running.

        Args:
            output (Any): The output of the tool.
            **kwargs (Any): Additional keyword arguments.

        Nrü   rñ   r¹   rÏ   rý   r<   r<   r=   rü   t  s    üùøz*AsyncCallbackManagerForToolRun.on_tool_endrß   rà   c                 Ë  s:   | j s
dS t| j dd|f| j| j| jdœ|¤ŽI dH  dS rþ   rÏ   rã   r<   r<   r=   rÿ   ‰  s    üùøz,AsyncCallbackManagerForToolRun.on_tool_errorN)r‹   r°   r±   r²   rÎ   rü   rÿ   r<   r<   r<   r=   r   `  s   r   c                   @  s4   e Zd ZdZddddœdd„Zdddd	œd
d„ZdS )ÚCallbackManagerForRetrieverRunz#Callback manager for retriever run.úSequence[Document]r
   ru   ©Ú	documentsrm   r:   c                 K  s4   | j s
dS t| j dd|f| j| j| jdœ|¤Ž dS )z¸Run when retriever ends running.

        Args:
            documents (Sequence[Document]): The retrieved documents.
            **kwargs (Any): Additional keyword arguments.

        NÚon_retriever_endÚignore_retrieverr¹   rº   ©r¬   r  rm   r<   r<   r=   r  ¦  s    üùøz/CallbackManagerForRetrieverRun.on_retriever_endrß   rà   c                 K  s4   | j s
dS t| j dd|f| j| j| jdœ|¤Ž dS ©z›Run when retriever errors.

        Args:
            error (BaseException): The error.
            **kwargs (Any): Additional keyword arguments.

        NÚon_retriever_errorr  r¹   rº   rã   r<   r<   r=   r	  ¿  s    üùøz1CallbackManagerForRetrieverRun.on_retriever_errorN)r‹   r°   r±   r²   r  r	  r<   r<   r<   r=   r  £  s   r  c                   @  sJ   e Zd ZdZddœdd„Zedddd	œd
d„ƒZeddddœdd„ƒZdS )Ú#AsyncCallbackManagerForRetrieverRunz)Async callback manager for retriever run.r  r9   c              
   C  s(   t | j| j| j| j| j| j| j| jd�S )z€Get the equivalent sync RunManager.

        Returns:
            CallbackManagerForRetrieverRun: The sync RunManager.

        r«   )	r  rB   rZ   r[   r\   rC   rO   rD   rP   rÍ   r<   r<   r=   rÎ   ß  s    øz,AsyncCallbackManagerForRetrieverRun.get_syncr  r
   ru   r  c                 Ë  s:   | j s
dS t| j dd|f| j| j| jdœ|¤ŽI dH  dS )z¼Run when the retriever ends running.

        Args:
            documents (Sequence[Document]): The retrieved documents.
            **kwargs (Any): Additional keyword arguments.

        Nr  r  r¹   rÏ   r  r<   r<   r=   r  ñ  s    üùøz4AsyncCallbackManagerForRetrieverRun.on_retriever_endrß   rà   c                 Ë  s:   | j s
dS t| j dd|f| j| j| jdœ|¤ŽI dH  dS r  rÏ   rã   r<   r<   r=   r	  	  s    üùøz6AsyncCallbackManagerForRetrieverRun.on_retriever_errorN)r‹   r°   r±   r²   rÎ   rs   r  r	  r<   r<   r<   r=   r
  Ù  s   r
  c                   @  sÐ   e Zd ZdZd)ddddddœd	d
„Zd*ddddddœdd„Zd+ddddddœdd„Zed,ddddddddœdd„ƒZed-dddddddœdd„ƒZ	d.ddddddœd d!„Z
ed/d#d#d$d%d%ddd d&œd'd(„ƒZdS )0rU   zCallback manager for LangChain.Núdict[str, Any]ú	list[str]rH   r
   zlist[CallbackManagerForLLMRun]©Ú
serializedÚpromptsrB   rm   r:   c           	      K  sŒ   g }t |ƒD ]z\}}|dkr(|dur(|ntƒ }t| jdd||gf|| j| j| jdœ|¤Ž | t|| j| j	| j| j| j
| j| jd�¡ q|S )a¬  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.

        Returns:
            list[CallbackManagerForLLMRun]: A callback manager for each
                prompt as an LLM run.

        r   Nr€   r�   ©rB   r\   rC   rD   r«   )Ú	enumerater+   r‰   rZ   r\   rC   rD   r‡   rÑ   r[   rO   rP   )	r¬   r  r  rB   rm   ÚmanagersÚiÚpromptÚrun_id_r<   r<   r=   r€   '  s<    û÷
öøÿzCallbackManager.on_llm_startúlist[list[BaseMessage]]©r  ÚmessagesrB   rm   r:   c                 K  s‚   g }|D ]t}|dur|}d}nt ƒ }t| jdd||gf|| j| j| jdœ|¤Ž | t|| j| j| j| j| j	| j| j
d�¡ q|S )aÍ  Run when chat model starts running.

        Args:
            serialized (dict[str, Any]): The serialized LLM.
            messages (list[list[BaseMessage]]): The list of messages.
            run_id (UUID, optional): The ID of the run. Defaults to None.
            **kwargs (Any): Additional keyword arguments.

        Returns:
            list[CallbackManagerForLLMRun]: A callback manager for each
                list of messages as an LLM run.

        Nrx   Úignore_chat_modelr  r«   )r+   r‰   rZ   r\   rC   rD   r‡   rÑ   r[   rO   rP   )r¬   r  r  rB   rm   r  Úmessage_listr  r<   r<   r=   rx   [  sB    û÷
öøÿz#CallbackManager.on_chat_model_startrF   ræ   rå   ©r  r?   rB   rm   r:   c              
   K  s^   |du rt ƒ }t| jdd||f|| j| j| jdœ|¤Ž t|| j| j| j| j| j| j| j	d�S )a°  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.

        Returns:
            CallbackManagerForChainRun: The callback manager for the chain run.

        NrW   ré   r  r«   )
r+   r‰   rZ   r\   rC   rD   rå   r[   rO   rP   ©r¬   r  r?   rB   rm   r<   r<   r=   rW   ’  s4    û÷
öøzCallbackManager.on_chain_startrE   rù   )r  Ú	input_strrB   r\   r?   rm   r:   c              
   K  s`   |du rt ƒ }t| jdd||f|| j| j| j|dœ|¤Ž t|| j| j| j| j| j| j| j	d�S )a^  Run when tool starts running.

        Args:
            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.
            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

        Returns:
            CallbackManagerForToolRun: The callback manager for the tool run.

        NÚon_tool_startrñ   )rB   r\   rC   rD   r?   r«   )
r+   r‰   rZ   r\   rC   rD   rù   r[   rO   rP   )r¬   r  r  rB   r\   r?   rm   r<   r<   r=   r  ¿  s6    ûöõøzCallbackManager.on_tool_startr  ©r  ÚqueryrB   r\   rm   r:   c              
   K  s^   |du rt ƒ }t| jdd||f|| j| j| jdœ|¤Ž t|| j| j| j| j| j| j| j	d�S )aÕ  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.

        Returns:
            The callback manager for the retriever run.
        NÚon_retriever_startr  r  r«   )
r+   r‰   rZ   r\   rC   rD   r  r[   rO   rP   ©r¬   r  r   rB   r\   rm   r<   r<   r=   r!  ø  s4    û÷
öøz"CallbackManager.on_retriever_startru   ©rQ   ÚdatarB   rm   r:   c              
   K  sJ   | j s
dS |rd}t|ƒ‚|du r(tƒ }t| j dd|||| j| jd� dS )a2  Dispatch an adhoc event to the handlers (async version).

        This event should NOT be used in any internal LangChain code. The event
        is meant specifically for users of the library to dispatch custom
        events that are tailored to their application.

        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.

        Raises:
            ValueError: If additional keyword arguments are passed.

        .. versionadded:: 0.2.14

        NúœThe dispatcher API does not accept additional keyword arguments.Please do not pass any additional keyword arguments, instead include them in the data field.Úon_custom_eventÚignore_custom_event©rB   rC   rD   )rZ   Ú
ValueErrorr+   r‰   rC   rD   ©r¬   rQ   r$  rB   rm   Úmsgr<   r<   r=   r&  (  s$    ÿøzCallbackManager.on_custom_eventFr   r8   rI   ©rN   Úlocal_callbacksÚverboserO   Ú
local_tagsrP   Úlocal_metadatar:   c              
   C  s   t | |||||||d�S )a¯  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.

        Returns:
            CallbackManager: The configured callback manager.

        ©r.  ©Ú
_configure©r®   rN   r-  r.  rO   r/  rP   r0  r<   r<   r=   rV   W  s     øzCallbackManager.configure)N)N)N)NNN)NN)N)NNFNNNN)r‹   r°   r±   r²   r€   rx   rW   r   r  r!  r&  r³   rV   r<   r<   r<   r=   rU   $  s6    ü8 ü; ü-   ú8  û3 ü/       ørU   c                      sz   e Zd ZdZdddddddd	œ‡ fd
d„Zed dœdd„ƒZd dd dœdd„Zddddœdd„Zddddœdd„Z	‡  Z
S )rY   z%Callback manager for the chain group.Nrt   ú#Optional[list[BaseCallbackHandler]]rH   rå   r
   ru   ©rZ   r[   r\   rT   rm   r:   c                  s(   t ƒ j|||fi |¤Ž || _d| _dS )aô  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.

        FN©Úsuperr­   rT   r^   ©r¬   rZ   r[   r\   rT   rm   ©rŠ   r<   r=   r­   †  s    ýüz%CallbackManagerForChainGroup.__init__r9   c              
   C  sB   | j | j ¡ | j ¡ | j| j ¡ | j ¡ | j ¡ | j ¡ | j	d�S )N©rZ   r[   r\   rC   rO   rD   rP   rT   ©
rŠ   rZ   Úcopyr[   r\   rC   rO   rD   rP   rT   rÍ   r<   r<   r=   r=  £  s    øz!CallbackManagerForChainGroup.copyr   ©r¬   Úotherr:   c              	   C  s–   | j | jp|jg g tt| j|j ƒƒtt| j|j ƒƒi | j¥|j¥| jd�}| j|j }| j	|j	 }|D ]}| 
|¡ qj|D ]}|j
|dd� q~|S )aO  Merge the group callback manager with another callback manager.

        Overwrites the merge method in the base class to ensure that the
        parent run manager is preserved. Keeps the parent_run_manager
        from the current object.

        Returns:
            CallbackManagerForChainGroup: 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']

        ©r\   rZ   r[   rC   rO   rD   rT   TrÅ   ©rŠ   r\   ÚlistÚsetrC   rO   rD   rT   rZ   r[   Úadd_handler©r¬   r?  rÊ   rZ   r[   r—   r<   r<   r=   Úmerge°  s(    +
ÿþöz"CallbackManagerForChainGroup.mergeræ   rç   c                 K  s   d| _ | jj|fi |¤ŽS )zÀRun when traced chain group ends.

        Args:
            outputs (Union[dict[str, Any], Any]): The outputs of the chain.
            **kwargs (Any): Additional keyword arguments.

        T©r^   rT   r`   rê   r<   r<   r=   r`   ò  s    z)CallbackManagerForChainGroup.on_chain_endrß   rà   c                 K  s   d| _ | jj|fi |¤ŽS )rì   T©r^   rT   r_   rã   r<   r<   r=   r_   ý  s    z+CallbackManagerForChainGroup.on_chain_error)NN)r‹   r°   r±   r²   r­   r   r=  rF  r`   r_   Ú__classcell__r<   r<   r:  r=   rY   ƒ  s     üBrY   c                   @  sà   e Zd ZdZeddœdd„ƒZd,ddd	d
ddœdd„Zd-ddd	d
ddœdd„Zd.ddd	d
ddœdd„Ze	d/ddd	d	d
ddœdd„ƒZ
d0dd
d	d
ddœd d!„Ze	d1ddd	d	d
d"d#œd$d%„ƒZed2d'd'dd(d(ddd d)œd*d+„ƒZdS )3rf   z=Async callback manager that handles callbacks from LangChain.r8   r9   c                 C  s   dS )z$Return whether the handler is async.Tr<   rÍ   r<   r<   r=   Úis_async  s    zAsyncCallbackManager.is_asyncNr  r  rH   r
   z#list[AsyncCallbackManagerForLLMRun]r  c                 Ë  s  g }g }dd„ | j D ƒ}dd„ | j D ƒ}g }	|D ]®}
|durF|}d}ntƒ }|r‚| t|dd||
gf|| j| j| jdœ|¤Ž¡ n0| t|dd||
gf|| j| j| jdœ|¤Ž¡ |	 t|| j | j| j| j| j	| j| j
d�¡ q0|D ]}|I dH  qä|�r
tj|Ž I dH  |	S )	aæ  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.

        Returns:
            list[AsyncCallbackManagerForLLMRun]: The list of async
                callback managers, one for each LLM Run corresponding
                to each prompt.
        c                 S  s   g | ]}|j r|‘qS r<   r£   r¥   r<   r<   r=   r}   +  r~   z5AsyncCallbackManager.on_llm_start.<locals>.<listcomp>c                 S  s   g | ]}|j s|‘qS r<   r£   r¥   r<   r<   r=   r}   ,  s   Nr€   r�   r  r«   )rZ   r+   r‡   r©   r\   rC   rD   rä   r[   rO   rP   rn   r¨   )r¬   r  r  rB   rm   Úinline_tasksÚnon_inline_tasksZinline_handlersZnon_inline_handlersr  r  r  Zinline_taskr<   r<   r=   r€     s|    ÿû÷
öÿû÷
öÿøÿz!AsyncCallbackManager.on_llm_startr  r  c                 Ë  sÚ   g }g }g }|D ]œ}|dur&|}	d}nt ƒ }	| jD ]L}
t|
gdd||gf|	| j| j| jdœ|¤Ž}|
jrt| |¡ q2| |¡ q2| t|	| j| j	| j| j| j
| j| jd�¡ q|D ]}|I dH  q²|rÖtj|Ž I dH  |S )a	  Async run when LLM starts running.

        Args:
            serialized (dict[str, Any]): The serialized LLM.
            messages (list[list[BaseMessage]]): The list of messages.
            run_id (UUID, optional): The ID of the run. Defaults to None.
            **kwargs (Any): Additional keyword arguments.

        Returns:
            list[AsyncCallbackManagerForLLMRun]: The list of
                async callback managers, one for each LLM Run
                corresponding to each inner  message list.
        Nrx   r  r  r«   )r+   rZ   r©   r\   rC   rD   r    r‡   rä   r[   rO   rP   rn   r¨   )r¬   r  r  rB   rm   rK  rL  r  r  r  r—   Ztaskr<   r<   r=   rx   n  sV    
û÷
öøÿz(AsyncCallbackManager.on_chat_model_startrF   ræ   rø   r  c              
   Ë  sd   |du rt ƒ }t| jdd||f|| j| j| jdœ|¤ŽI dH  t|| j| j| j| j| j| j| j	d�S )aÐ  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.

        Returns:
            AsyncCallbackManagerForChainRun: The async callback manager
                for the chain run.
        NrW   ré   r  r«   )
r+   r©   rZ   r\   rC   rD   rø   r[   rO   rP   r  r<   r<   r=   rW   ¶  s4    û÷
öøz#AsyncCallbackManager.on_chain_startrE   r   )r  r  rB   r\   rm   r:   c              
   Ë  sd   |du rt ƒ }t| jdd||f|| j| j| jdœ|¤ŽI dH  t|| j| j| j| j| j| j| j	d�S )a  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.

        Returns:
            AsyncCallbackManagerForToolRun: The async callback manager
                for the tool run.
        Nr  rñ   r  r«   )
r+   r©   rZ   r\   rC   rD   r   r[   rO   rP   )r¬   r  r  rB   r\   rm   r<   r<   r=   r  ä  s4    û÷
öøz"AsyncCallbackManager.on_tool_startru   r#  c              
   Ë  sP   | j s
dS |du rtƒ }|r(d}t|ƒ‚t| j dd|||| j| jd�I dH  dS )a1  Dispatch an adhoc event to the handlers (async version).

        This event should NOT be used in any internal LangChain code. The event
        is meant specifically for users of the library to dispatch custom
        events that are tailored to their application.

        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.

        Raises:
            ValueError: If additional keyword arguments are passed.

        .. versionadded:: 0.2.14
        Nr%  r&  r'  r(  )rZ   r+   r)  r©   rC   rD   r*  r<   r<   r=   r&    s$    ÿøz$AsyncCallbackManager.on_custom_eventr
  r  c              
   Ë  sd   |du rt ƒ }t| jdd||f|| j| j| jdœ|¤ŽI dH  t|| j| j| j| j| j| j| j	d�S )a  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.

        Returns:
            AsyncCallbackManagerForRetrieverRun: The async callback manager
                for the retriever run.
        Nr!  r  r  r«   )
r+   r©   rZ   r\   rC   rD   r
  r[   rO   rP   r"  r<   r<   r=   r!  D  s4    û÷
öøz'AsyncCallbackManager.on_retriever_startFr   rI   r,  c              
   C  s   t | |||||||d�S )a¿  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.

        Returns:
            AsyncCallbackManager: The configured async callback manager.
        r1  r2  r4  r<   r<   r=   rV   u  s    øzAsyncCallbackManager.configure)N)N)N)NN)N)NN)NNFNNNN)r‹   r°   r±   r²   ÚpropertyrJ  r€   rx   rW   r   r  r&  r!  r³   rV   r<   r<   r<   r=   rf     s8    ü] üL ü.  û5 ü.  û0       ørf   c                      sv   e Zd ZdZdddddddd	œ‡ fd
d„Zd dœdd„Zd dd dœdd„Zddddœdd„Zddddœdd„Z‡  Z	S )rg   z+Async callback manager for the chain group.Nrt   r5  rH   rø   r
   ru   r6  c                  s(   t ƒ j|||fi |¤Ž || _d| _dS )a  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.
        FNr7  r9  r:  r<   r=   r­   £  s    ýüz*AsyncCallbackManagerForChainGroup.__init__r9   c              
   C  sB   | j | j ¡ | j ¡ | j| j ¡ | j ¡ | j ¡ | j ¡ | j	d�S )z)Return a copy the async callback manager.r;  r<  rÍ   r<   r<   r=   r=  À  s    øz&AsyncCallbackManagerForChainGroup.copyr   r>  c              	   C  s–   | j | jp|jg g tt| j|j ƒƒtt| j|j ƒƒi | j¥|j¥| jd�}| j|j }| j	|j	 }|D ]}| 
|¡ qj|D ]}|j
|dd� q~|S )aP  Merge the group callback manager with another callback manager.

        Overwrites the merge method in the base class to ensure that the
        parent run manager is preserved. Keeps the parent_run_manager
        from the current object.

        Returns:
            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']

        r@  TrÅ   rA  rE  r<   r<   r=   rF  Í  s(    +
ÿþöz'AsyncCallbackManagerForChainGroup.mergeræ   rç   c                 Ë  s$   d| _ | jj|fi |¤ŽI dH  dS )z¿Run when traced chain group ends.

        Args:
            outputs (Union[dict[str, Any], Any]): The outputs of the chain.
            **kwargs (Any): Additional keyword arguments.
        TNrG  rê   r<   r<   r=   r`   	  s    	z.AsyncCallbackManagerForChainGroup.on_chain_endrß   rà   c                 Ë  s$   d| _ | jj|fi |¤ŽI dH  dS )z§Run when chain errors.

        Args:
            error (Exception or KeyboardInterrupt): The error.
            **kwargs (Any): Additional keyword arguments.
        TNrH  rã   r<   r<   r=   r_   	  s    z0AsyncCallbackManagerForChainGroup.on_chain_error)NN)
r‹   r°   r±   r²   r­   r=  rF  r`   r_   rI  r<   r<   r:  r=   rg      s     üBrg   ÚTFr1  ztype[T]r   )	Úcallback_manager_clsrN   r-  rO   r/  rP   r0  r.  r:   c             
     sà  t ƒ }|d }	|d }
|d }|du r*dn|j}| g |d�}|sF|�rt|tƒsX|du rx|p^g }| | ¡ | ¡ |d�}nf|j}|dur¤|du s |r¤t|ƒ|jv r¤|}| |j ¡ |j	 ¡ ||j
 ¡ |j ¡ |j ¡ |j ¡ d�}t|tƒrì|n|rö|jng }|D ]}|j|dd	� qþ|�s|�rB| |�p*g ¡ |j|�p:g dd	� |�sN|�rr| |�pZi ¡ |j|�pji dd	� |	�r†| |	 ¡ ¡ |
�rš| |
 ¡ ¡ td
ƒ�pªtdƒ}t ¡ }tƒ }|�rÒ|�sÒd}t|ƒ‚tƒ }tƒ }|�sð|�sð|�r*|�r$tdd„ |jD ƒƒ�s$|�rn|jtƒ dd	� |�rLtdd„ |jD ƒƒ�sL| tƒ ¡ |�râtdd„ |jD ƒƒ�sâ|�rz| |¡ nhz0t||du�r�|jn|d |
d�}| |¡ W n6 t�yà } zt dt |ƒ¡ W Y d}~n
d}~0 0 |du�r*|jD ]6}t|tƒ�rò|j!|jf|j"|j< ||j#t|jƒ< �qòt$D ]¬\}}‰ }|du�oTt|ƒ�oTˆ du}| ¡ du�sj|�r.| ¡ �p~t%dˆ ƒƒ ‰ˆ du �r²t‡fdd„|jD ƒƒ�sØ| ˆ|¡ n&t‡ fdd„|jD ƒƒ�s.| ˆ|¡ �q.|S )aø  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.

    Raises:
        RuntimeError: If `LANGCHAIN_TRACING` is set but `LANGCHAIN_TRACING_V2` is not.

    Returns:
        T: The configured callback manager.
    rD   rC   ÚparentNrÄ   )rZ   r[   r\   )rZ   r[   r\   rC   rO   rD   rP   FrÅ   ZLANGCHAIN_TRACINGZLANGCHAIN_HANDLERz‹Tracing using LangChainTracerV1 is no longer supported. Please set the LANGCHAIN_TRACING_V2 environment variable to enable tracing instead.c                 s  s   | ]}t |tƒV  qd S r;   )Ú
isinstancer   r¥   r<   r<   r=   r§   ›	  s   ÿz_configure.<locals>.<genexpr>c                 s  s   | ]}t |tƒV  qd S r;   )rQ  r(   r¥   r<   r<   r=   r§   £	  s   ÿc                 s  s   | ]}t |tƒV  qd S r;   )rQ  r&   r¥   r<   r<   r=   r§   ¨	  s   ÿÚclient)r@   rR  rC   z{Unable to load requested LangChainTracer. To disable this warning, unset the LANGCHAIN_TRACING_V2 environment variables.
%sztype[BaseCallbackHandler]c                 3  s   | ]}|ˆ u V  qd S r;   r<   r¥   )Úvar_handlerr<   r=   r§   Õ	  s   ÿc                 3  s   | ]}t |ˆ ƒV  qd S r;   )rQ  r¥   )Úhandler_classr<   r=   r§   Ú	  s   ÿ)&r   ÚidrQ  rB  r=  r\   rE   Zdotted_orderrZ   r[   rC   rO   rD   rP   rD  rÇ   rÈ   r)   r%   Úgetr$   r�   r#   r>   Úanyr   r(   r&   rR  r]   rŒ   r�   rŽ   Ztrace_idZ	order_mapZrun_mapr!   r   )rO  rN   r-  rO   r/  rP   r0  r.  Ztracing_contextZtracing_metadataZtracing_tagsZrun_treer\   rK   Zinheritable_callbacks_Zparent_run_id_Zlocal_handlers_r—   Zv1_tracing_enabled_Z	tracer_v2Ztracing_v2_enabled_r+  Ztracer_projectÚdebugrd   ÚvarÚinheritableÚenv_varZ
create_oner<   )rT  rS  r=   r3  -	  sì    "þ
ýÿûûùÿýÿÿþ
þ
þ
ÿ
ù	û

þ
ÿýÿ
þ
þ
r3  )ÚconfigzOptional[RunnableConfig])rQ   r$  r\  r:   c                Ã  sR   ddl m}m} ||ƒ}||ƒ}|jdu r6d}t|ƒ‚|j| ||jd�I dH  dS )a“  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.
        config: Optional config object. Mirrors the async API but not strictly needed.

    Raises:
        RuntimeError: If there is no parent run ID available to associate
            the event with.

    Example:

        .. 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("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)

    .. 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

    r   )Úensure_configÚ%get_async_callback_manager_for_configNá&  Unable to dispatch an adhoc event without a parent run id.This function can only be called from within an existing run (e.g.,inside a tool or a RunnableLambda or a RunnableGenerator.)If you are doing that and still seeing this error, try explicitlypassing the config parameter to this function.rR   )Úlangchain_core.runnables.configr]  r^  r\   r�   r&  )rQ   r$  r\  r]  r^  rK   r+  r<   r<   r=   Úadispatch_custom_eventâ	  s    b
ÿýra  c                C  sL   ddl m}m} ||ƒ}||ƒ}|jdu r6d}t|ƒ‚|j| ||jd� dS )aà  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.
        config: Optional config object. Mirrors the async API but not strictly needed.

    Raises:
        RuntimeError: If there is no parent run ID available to associate
            the event with.

    Example:

        .. code-block:: 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: 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

    r   )r]  Úget_callback_manager_for_configNr_  rR   )r`  r]  rb  r\   r�   r&  )rQ   r$  r\  r]  rb  rK   r+  r<   r<   r=   Údispatch_custom_event`
  s    0
ÿýrc  r   )Úmaxsizer   c                  C  s   t dd�} tj| jdd� | S )Né
   )Úmax_workersT)r›   )r   ÚatexitÚregisterÚshutdown)Zcutier<   r<   r=   r‘   «
  s    
r‘   )N)N)NNNNNN)ur²   Ú
__future__r   rn   rg  rq   ÚloggingÚabcr   r   Úconcurrent.futuresr   Ú
contextlibr   r   Zcontextvarsr   Útypingr	   r
   r   r   r   r   r   Úuuidr   Zlangsmith.run_helpersr   Ztyping_extensionsr   r   Zlangchain_core.callbacks.baser   r   r   r   r   r   r   r   Zlangchain_core.callbacks.stdoutr   Zlangchain_core.globalsr   Zlangchain_core.messagesr   r    Zlangchain_core.tracers.contextr!   r"   r#   r$   r%   Z langchain_core.tracers.langchainr&   Zlangchain_core.tracers.schemasr'   Zlangchain_core.tracers.stdoutr(   Zlangchain_core.utils.envr)   Zlangchain_core.utils.uuidr+   Úcollections.abcr,   r-   r.   r/   Ztenacityr0   Zlangchain_core.agentsr1   r2   Zlangchain_core.documentsr3   Zlangchain_core.outputsr4   r5   r6   r`  r7   Ú	getLoggerr‹   rŒ   r>   re   rh   ri   rs   r‰   r“   r¢   r©   rª   r´   rÁ   rÌ   rÐ   rÑ   rä   rå   rø   rù   r   r  r
  rU   rY   rf   rg   rN  r3  ra  rc  Ú	lru_cacher‘   r<   r<   r<   r=   Ú<module>   sÌ   $(

 þ÷$S þ÷$SV4(=5>QhZo6C6
þK  a           ù	÷" 7ÿÿK
