f3fi'M JdZddlmZddlZddlZddlZddlZddlmZm Z ddl m Z ddl m Z ddlmZmZddlmZdd lmZmZmZmZdd lmZdd lmZmZdd lmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%dd l&m'Z'ddl(m)Z)ddl*m+Z+m,Z,ddl-m.Z.m/Z/m0Z0m1Z1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8Z8ddl9m:Z:erZ>ddl?m@Z@ddlAmBZBddlCmDZDmEZEddlFmGZGddlHmIZImJZJmKZKddlLmMZMddlNmOZOejeQZRdTdZSe dUddddddd dVdZTe dUddddddd dWd ZUed!e "ZVdXd#ZW dYd$ZXdZd%ZY d[d&ZZ dYd'Z[Gd(d)e$Z\Gd*d+e\Z]Gd,d-e]Z^Gd.d/e\eZ_Gd0d1e_Z`Gd2d3e]e"ZaGd4d5e_e"ZbGd6d7e^e!ZcGd8d9e`e!ZdGd:d;e^e%ZeGd<d=e`e%ZfGd>d?e^e#ZgGd@dAe`e#ZhGdBdCeZiGdDdEeiZjGdFdGeZkGdHdIekZledJeiekZm d\dKdL d]dMZnddN d^dOZoddN d^dPZpejdQRd_dSZry)`z Run managers.) annotationsN)ABCabstractmethod)Callable)ThreadPoolExecutor)asynccontextmanagercontextmanager) copy_context) TYPE_CHECKINGAnyTypeVarcast)get_tracing_context)Selfoverride)BaseCallbackHandlerBaseCallbackManager CallbacksChainManagerMixinLLMManagerMixinRetrieverManagerMixinRunManagerMixinToolManagerMixin)StdOutCallbackHandler get_debug) BaseMessageget_buffer_string)_configure_hooks_get_trace_callbacks_get_tracer_project_tracing_v2_is_enabledtracing_v2_callback_var)LangChainTracer)ConsoleCallbackHandler)env_var_is_setuuid7)AsyncGenerator Coroutine GeneratorSequence)UUID)RetryCallState) AgentAction AgentFinish)Document)ChatGenerationChunkGenerationChunk LLMResult)RunnableConfig)RunctSNr^/var/www/auto_recruiter/arenv/lib/python3.12/site-packages/langchain_core/callbacks/manager.py _get_debugr<;s ;r:)inputs project_name example_idrun_idtagsmetadatac #Kt|||}tj|||} | jd|i|xsi|} | j } t | j | j| j| | j| j| j| j} | | js| jiyy#t$r#} | js| j!| d} ~ wwxYww)aCGet 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: 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: ```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}) ``` callback_managerinheritable_callbacksinheritable_tagsinheritable_metadatanamer@parent_run_managerrArHrBrIN)r CallbackManager configureon_chain_start get_childCallbackManagerForChainGrouphandlersinheritable_handlers parent_run_idrArHrBrIended on_chain_end Exceptionon_chain_error group_namerEr=r>r?r@rArBcbcm run_managerchild_cmgroup_cmes r;trace_as_chain_grouprb?sV j3C B  " " % # B ##VZ$8&,Bv#VK$$&H+%%& ]]!22""%:: H) ~~  $ $R ( ~~  & &q ) s*B*C?-C1C? C<C77C<<C?c >Kt|||}tj|||} | jd|i|xsi|d{} | j } t | j | j| j| | j| j| j| j} | | js| jid{yy77#t$r,} | js| j!| d{7d} ~ wwxYww)aGet 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: 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: ```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}) ``` rDrFrJrKNrL)r AsyncCallbackManagerrOrPrQ!AsyncCallbackManagerForChainGrouprSrTrUrArHrBrIrVrWrXrYrZs r;atrace_as_chain_grouprfs%\ j3C B  ' ' 4h ( B)) fl6*K$$&H0%%& ]]!22""%:: H/ ~~**2. . .+, / ~~,,Q/ / / sUADC!A-D5C%: DC#D#D% D. DDDDDFunc)boundcXtjdfd }td|S)zMakes so an awaitable method is always shielded from cancellation. Args: func: The function to shield. Returns: The shielded function c"Kt}|i|} tj||}tj|d{S7#t$r6tj|}tj|d{7cYSwxYww)N)context)r asyncio create_taskshield TypeError)argskwargsctxcorotaskfuncs r;wrappedzshielded..wrappedsnT$V$ .&&tS9D -- -- .&&t,D --- -  .sFB/A A A B A 6B BB  B B  Brg)rpr rqr returnr ) functoolswrapsr)rurvs` r;shieldedrzs/__T..(   r:c g} d}|D]I} | t||s8t|||i|}tj|r|j|K |ro tjd } | rJt!j#t%d t'j(t*|j-yt+|yy#t$r} |dk(r>|!|dD cgc] } t | ncc} w}} t |gdd|d|g|ddi|n7|jj} tjd| |t| Yd} ~ Hd} ~ wt$rM} tjd |jj|t| |jrYd} ~ d} ~ wwxYw#t$rd } YLwxYw#|r tjd } n#t$rd } YnwxYw| rJt!j#t%d t'j(t*|j-wt+|wwxYw) 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 Non_chat_model_start on_llm_start ignore_llmr)NotImplementedError in %s.%s callback: %sError in %s.%s callback: %sTFr)getattrrl iscoroutineappendNotImplementedErrorr handle_event __class____name__loggerwarningreprrX raise_errorget_running_loop RuntimeError _executorsubmitrr run _run_corosresult) rS event_nameignore_condition_namerprqcorosmessage_stringshandlereventram handler_name loop_runnings r;rrsD*-/E<",0% G$ (0299GGZ8$I&IE**51 U+% N  %((*#   ""\^%7%78*e&(5!' ?' !66&.IMa*QA+ACF>F, F)EC10AE F> F)AF$F>$F))F>, F;:F;>IGI G'$I&G''AIc ttdrtj5}|D]} |j|tj|jx}rJ|jtj|tj|jx}rJdddy|D]} tj|y#t$r)}t j dt|Yd}~d}~wwxYw#1swYyxYw#t$r)}t j dt|Yd}~d}~wwxYw)NRunnerzError in callback coroutine: %s) hasattrrlrrrXrrr all_tasksget_loopwait)rrunnerrsrapendings r;rrTs"w!^^  2 OOJJt$ O%..v/@AA'A 7<<01%..v/@AA'A 2 2 KD K D! K!ONN#Dd1gNNO 2 2" K@$q'JJ KsLD CA0D =D DD=D DD  D EEEc ZK | t||st||}tj|r||i|d{y|jr ||i|ytjj dt dtjtj|g|i|d{yy7|7#t$r}|dk(rD|dDcgc] }t|ncc}w}}t|dd|d|g|ddi|d{7n:tjd|j j"|t%|Yd}~yYd}~yd}~wt&$rL}tjd |j j"|t%||j(rYd}~yd}~wwxYww) Nrr|r}r~rrrrr)rrliscoroutinefunction run_inlineget_event_looprun_in_executorrrxpartialr rrr_ahandle_event_for_handlerrrrrrrXr) rrrrprqrrarrs r;rrqs* (AV0WGZ0E**51T,V,,,##t&v&,,.>>"!)),.*<*z ahandle_event..sF %% '%       s'*)rrrlgather)rSrrrprqhrs ```` r; ahandle_eventrs* (8!1<B!r:c 0|tggggiiS)zoReturn a manager that doesn't perform any operations. Returns: The noop manager. )r@rSrTrArHrBrIr')clss r;get_noop_managerzBaseRunManager.get_noop_managers(7!#!#  r:)r@r-rSlist[BaseCallbackHandler]rTrrU UUID | NonerAlist[str] | NonerHrrBdict[str, Any] | NonerIrrwNone)rwr)r __module__ __qualname____doc__r classmethodrr9r:r;rrs@&*!%-1*.6: ? ?, ? 8 ? # ? ?+ ?( ?4 ?  ?D  r:rc8eZdZdZ ddZ ddZy) RunManagerzSync Run Manager.c |jsyt|jdd|f|j|j|jd|yzRun when a text is received. Args: text: The received text. **kwargs: Additional keyword arguments. Non_textr@rUrArSrr@rUrArtextrqs r;rzRunManager.on_textsN}}  MM    ;;,,  r:c |jsyt|jdd|f|j|j|jd|y)zRun when a retry is received. Args: retry_state: The retry state. **kwargs: Additional keyword arguments. Non_retry ignore_retryrrr retry_staterqs r;rzRunManager.on_retry sN}}  MM    ;;,,  r:Nrstrrqr rwrrr.rqr rwr)rrrrrrr9r:r;rrsG      0 #     r:rceZdZdZdddZy)ParentRunManagerzSync Parent Run Manager.Nctg|j}|j|j|j |j |j |j||j |gd|SzGet a child callback manager. Args: tag: The tag for the child callback manager. Returns: The child callback manager. rSrUFinherit)rNr@ set_handlersrTadd_tagsrH add_metadatarIrtagmanagers r;rQzParentRunManager.get_child=so"2T[[IT667../T667 ?   cUE  2r:r8)r str | NonerwrNrrrrrQr9r:r;rr:s "r:rcJeZdZdZeddZ ddZ ddZy) AsyncRunManagerzAsync Run Manager.cy)`Get the equivalent sync RunManager. Returns: The sync RunManager. Nr9rs r;get_synczAsyncRunManager.get_syncSsr:cK|jsyt|jdd|f|j|j|jd|d{y7wrrSrr@rUrArs r;rzAsyncRunManager.on_text\s\}}  MM     ;;,,    A AAAcK|jsyt|jdd|f|j|j|jd|d{y7w)zAsync run when a retry is received. Args: retry_state: The retry state. **kwargs: Additional keyword arguments. Nrrrrrs r;rzAsyncRunManager.on_retryts\}}  MM     ;;,,    rN)rwrrr)rrrrrrrrr9r:r;rrPsY        0 #     r:rceZdZdZdddZy)AsyncParentRunManagerzAsync Parent Run Manager.Nctg|j}|j|j|j |j |j |j||j |gd|Sr)rdr@rrTrrHrrIrs r;rQzAsyncParentRunManager.get_childso'$++NT667../T667 ?   cUE  2r:r8)rrrwrdrr9r:r;rrs #r:rcHeZdZdZdd ddZddZ d dZy) CallbackManagerForLLMRunzCallback manager for LLM run.Nchunkc |jsyt|jddf||j|j|j|d|y)Run when LLM generates a new token. Args: token: The new token. chunk: The chunk. **kwargs: Additional keyword arguments. Non_llm_new_tokenr)tokenr@rUrArrrrrrqs r;rz)CallbackManagerForLLMRun.on_llm_new_tokensQ}}  MM   ;;,,  r:c |jsyt|jdd|f|j|j|jd|yzRun when LLM ends running. Args: response: The LLM result. **kwargs: Additional keyword arguments. N on_llm_endrrrrresponserqs r;rz#CallbackManagerForLLMRun.on_llm_endsN}}  MM    ;;,,  r:c |jsyt|jdd|f|j|j|jd|y)zRun when LLM errors. Args: error: The error. **kwargs: Additional keyword arguments. - response (LLMResult): The response which was generated before the error occurred. N on_llm_errorrrrrerrorrqs r;rz%CallbackManagerForLLMRun.on_llm_errorsN}}  MM    ;;,,  r:rrrz,GenerationChunk | ChatGenerationChunk | Nonerqr rwrrr4rqr rwrr BaseExceptionrqr rwr)rrrrrrrr9r:r;rrs\' ?C   <      : *      r:rcdeZdZdZddZdd d dZed dZe d dZy) AsyncCallbackManagerForLLMRunz#Async callback manager for LLM run.c t|j|j|j|j|j |j |j|jSrr) rr@rSrTrUrArHrBrIrs r;rz&AsyncCallbackManagerForLLMRun.get_syncsQ(;;]]!%!:!:,,!22]]!%!:!:  r:NrcK|jsyt|jdd|f||j|j|jd|d{y7w)rNrr)rr@rUrArrs r;rz.AsyncCallbackManagerForLLMRun.on_llm_new_token s_}}  MM     ;;,,    sA AAAcK|jsyt|jdd|f|j|j|jd|d{y7wrrrs r;rz(AsyncCallbackManagerForLLMRun.on_llm_end&s\}}  MM     ;;,,    rcK|jsyt|jdd|f|j|j|jd|d{y7w)zRun when LLM errors. Args: error: The error. **kwargs: Additional keyword arguments. - response (LLMResult): The response which was generated before the error occurred. Nrrrrrs r;rz*AsyncCallbackManagerForLLMRun.on_llm_error<s\"}}  MM     ;;,,    r)rwrrrr) rrrrrrrzrrr9r:r;r r s- ,?C   <      :  *       r:r c<eZdZdZddZ ddZd dZd dZy) CallbackManagerForChainRunzCallback manager for chain run.c |jsyt|jdd|f|j|j|jd|y)zRun when chain ends running. Args: outputs: The outputs of the chain. **kwargs: Additional keyword arguments. NrW ignore_chainrrroutputsrqs r;rWz'CallbackManagerForChainRun.on_chain_end^sN}}  MM    ;;,,  r:c |jsyt|jdd|f|j|j|jd|yRun when chain errors. Args: error: The error. **kwargs: Additional keyword arguments. NrYrrrrs r;rYz)CallbackManagerForChainRun.on_chain_errorssN}}  MM    ;;,,  r:c |jsyt|jdd|f|j|j|jd|yzRun when agent action is received. Args: action: The agent action. **kwargs: Additional keyword arguments. Non_agent_action ignore_agentrrractionrqs r;rz*CallbackManagerForChainRun.on_agent_actionN}}  MM    ;;,,  r:c |jsyt|jdd|f|j|j|jd|yzRun when agent finish is received. Args: finish: The agent finish. **kwargs: Additional keyword arguments. Non_agent_finishrrrrfinishrqs r;r"z*CallbackManagerForChainRun.on_agent_finishrr:Nrdict[str, Any] | Anyrqr rwrrrr/rqr rwrr$r0rqr rwr)rrrrrWrYrr"r9r:r;rr[s5) *      2 ( r:rcXeZdZdZddZed dZe d dZd dZd dZ y) AsyncCallbackManagerForChainRunz%Async callback manager for chain run.c t|j|j|j|j|j |j |j|jSz_Get the equivalent sync RunManager. Returns: The sync RunManager. r) rr@rSrTrUrArHrBrIrs r;rz(AsyncCallbackManagerForChainRun.get_syncsQ *;;]]!%!:!:,,!22]]!%!:!:  r:cK|jsyt|jdd|f|j|j|jd|d{y7w)zRun when a chain ends running. Args: outputs: The outputs of the chain. **kwargs: Additional keyword arguments. NrWrrrrs r;rWz,AsyncCallbackManagerForChainRun.on_chain_ends\}}  MM     ;;,,    rcK|jsyt|jdd|f|j|j|jd|d{y7wrrrs r;rYz.AsyncCallbackManagerForChainRun.on_chain_errors\}}  MM     ;;,,    rcK|jsyt|jdd|f|j|j|jd|d{y7wrrrs r;rz/AsyncCallbackManagerForChainRun.on_agent_action\}}  MM     ;;,,    rcK|jsyt|jdd|f|j|j|jd|d{y7wr!rr#s r;r"z/AsyncCallbackManagerForChainRun.on_agent_finish r0rN)rwrr%rr'r() rrrrrrzrWrYrr"r9r:r;r*r*sX/ "  *       2 ( r:r*c8eZdZdZ ddZ ddZy)CallbackManagerForToolRunzCallback manager for tool run.c |jsyt|jdd|f|j|j|jd|y)zRun when the tool ends running. Args: output: The output of the tool. **kwargs: The keyword arguments to pass to the event handler N on_tool_endrrrroutputrqs r;r5z%CallbackManagerForToolRun.on_tool_end%sN}}  MM    ;;,,  r:c |jsyt|jdd|f|j|j|jd|yzRun when tool errors. Args: error: The error. **kwargs: Additional keyword arguments. N on_tool_errorrrrrs r;r:z'CallbackManagerForToolRun.on_tool_error>sN}}  MM    ;;,,  r:Nr7r rqr rwrr)rrrrr5r:r9r:r;r3r3"sG(      2      r:r3c4eZdZdZddZddZ ddZy) AsyncCallbackManagerForToolRunz$Async callback manager for tool run.c t|j|j|j|j|j |j |j|jSr,) r3r@rSrTrUrArHrBrIrs r;rz'AsyncCallbackManagerForToolRun.get_sync[sQ );;]]!%!:!:,,!22]]!%!:!:  r:cK|jsyt|jdd|f|j|j|jd|d{y7w)zAsync run when the tool ends running. Args: output: The output of the tool. **kwargs: Additional keyword arguments. Nr5rrrr6s r;r5z*AsyncCallbackManagerForToolRun.on_tool_endls\}}  MM     ;;,,    rcK|jsyt|jdd|f|j|j|jd|d{y7wr9rrs r;r:z,AsyncCallbackManagerForToolRun.on_tool_errors\}}  MM     ;;,,    rN)rwr3r;r)rrrrrr5r:r9r:r;r=r=Xs0. " *      r:r=c8eZdZdZ ddZ ddZy)CallbackManagerForRetrieverRunz#Callback manager for retriever run.c |jsyt|jdd|f|j|j|jd|y)zRun when retriever ends running. Args: documents: The retrieved documents. **kwargs: Additional keyword arguments. Non_retriever_endignore_retrieverrrr documentsrqs r;rDz/CallbackManagerForRetrieverRun.on_retriever_endsN}}  MM    ;;,,  r:c |jsyt|jdd|f|j|j|jd|yzRun when retriever errors. Args: error: The error. **kwargs: Additional keyword arguments. Non_retriever_errorrErrrs r;rJz1CallbackManagerForRetrieverRun.on_retriever_errorsN}}  MM   ;;,,  r:NrGzSequence[Document]rqr rwrr)rrrrrDrJr9r:r;rBrBsG- %     2      r:rBcTeZdZdZddZe ddZe ddZy) #AsyncCallbackManagerForRetrieverRunz)Async callback manager for retriever run.c t|j|j|j|j|j |j |j|jSr ) rBr@rSrTrUrArHrBrIrs r;rz,AsyncCallbackManagerForRetrieverRun.get_syncsQ.;;]]!%!:!:,,!22]]!%!:!:  r:cK|jsyt|jdd|f|j|j|jd|d{y7w)zRun when the retriever ends running. Args: documents: The retrieved documents. **kwargs: Additional keyword arguments. NrDrErrrFs r;rDz4AsyncCallbackManagerForRetrieverRun.on_retriever_ends\}}  MM     ;;,,    rcK|jsyt|jdd|f|j|j|jd|d{y7wrIrrs r;rJz6AsyncCallbackManagerForRetrieverRun.on_retriever_errors\}}  MM    ;;,,    rN)rwrBrKr)rrrrrrzrDrJr9r:r;rMrMsh4 $ + 7:   .       r:rMc*eZdZdZ d d dZ d d dZ d d dZe d ddZe d ddZ d ddZ e d dd Z y)rNzCallback manager for LangChain.Nc g}t|D]\}}|dk(r||n t}t|jdd||gf||j|j |j d||jt||j|j|j|j |j|j |j|S)a6Run when LLM starts running. Args: serialized: The serialized LLM. prompts: The list of prompts. run_id: The ID of the run. **kwargs: Additional keyword arguments. Returns: A callback manager for each prompt as an LLM run. rr~rr@rUrArBr) enumerater(rrSrUrArBrrrTrHrI) r serializedpromptsr@rqmanagersipromptrun_id_s r;r~zCallbackManager.on_llm_starts&"7+ IAv !Q6+=f57G    "00YY   OO("!]])-)B)B"&"4"4%)%:%:!]])-)B)B  ! :r:c g}|D]}||}d}n t}t|jdd||gf||j|j|j d||j t||j|j|j|j|j|j |j|S)aIRun when chat model starts running. Args: serialized: The serialized LLM. messages: The list of messages. run_id: The ID of the run. **kwargs: Additional keyword arguments. Returns: A callback manager for each list of messages as an LLM run. Nr|ignore_chat_modelrSr) r(rrSrUrArBrrrTrHrI)rrUmessagesr@rqrW message_listrZs r;r|z#CallbackManager.on_chat_model_startRs&$ L! '  %#  "00YY   OO("!]])-)B)B"&"4"4%)%:%:!]])-)B)B  ' @r:c F| t}t|jdd||f||j|j|j d|t ||j|j|j|j|j|j |jS)a3Run when chain starts running. Args: serialized: The serialized chain. inputs: The inputs to the chain. run_id: The ID of the run. **kwargs: Additional keyword arguments. Returns: The callback manager for the chain run. rPrrSr) r(rrSrUrArBrrTrHrIrrUr=r@rqs r;rPzCallbackManager.on_chain_starts& >WF MM     ,,]]  *]]!%!:!:,,!22]]!%!:!:  r:c H| t}t|jdd||f||j|j|j |d|t ||j|j|j|j|j|j |jS)aRun 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. 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: The keyword arguments to pass to the event handler Returns: The callback manager for the tool run. on_tool_startr)r@rUrArBr=r) r(rrSrUrArBr3rTrHrI)rrU input_strr@rUr=rqs r;rbzCallbackManager.on_tool_starts: >WF MM     ,,]]  )]]!%!:!:,,!22]]!%!:!:  r:c F| t}t|jdd||f||j|j|j d|t ||j|j|j|j|j|j |jS)ahRun when the retriever starts running. Args: 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. on_retriever_startrErSr) r(rrSrUrArBrBrTrHrIrrUqueryr@rUrqs r;rez"CallbackManager.on_retriever_starts* >WF MM    ,,]]  .]]!%!:!:,,!22]]!%!:!:  r:c |jsy|r d}t|| t}t|jdd||||j|j yaDispatch 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. Raises: ValueError: If additional keyword arguments are passed. NzThe 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_eventignore_custom_event)r@rArB)rS ValueErrorr(rrArBrrJdatar@rqmsgs r;rjzCallbackManager.on_custom_events_*}}  2  S/ ! >WF MM  !  ]] r:c (t||||||||S)aConfigure the callback manager. Args: 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: The configured callback manager. verbose _configurerrGlocal_callbacksrrrH local_tagsrIlocal_metadatas r;rOzCallbackManager.configureJ)2  !      r:r8) rUdict[str, Any]rV list[str]r@rrqr rwlist[CallbackManagerForLLMRun]) rUrzr]list[list[BaseMessage]]r@rrqr rwr|) rUrr=r&r@rrqr rwr)NNN)rUrrcrr@rrUrr=rrqr rwr3NN) rUrrgrr@rrUrrqr rwrB rJrrnr r@rrqr rwrNNFNNNN)rGrrvrrrboolrHrrwrrIrrxrrwrN) rrrrr~r|rPrrbrerjrrOr9r:r;rNrNs%) # 1"11 1  1 ( 1n# 4"4*4 4  4 ( 4t# + )+ %+  +  + $ + Z #%)(, 6 )6 6  6 # 6 & 6 6  #6 6 p #%) - )- -  - # -  -  (- - f# * * *  *  *  * X,0%)-1'+6:04! (! #!  ! + ! % ! 4! .!  ! ! r:rNceZdZdZ d dfd Zed dZ d dZd dZ d dZ xZ S) rRz%Callback manager for the chain group.c Ft||||fi|||_d|_y)aJInitialize the callback manager. Args: 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. FNsuperrrMrVrrSrTrUrMrqrs r;rz%CallbackManagerForChainGroup.__init__rs6&      #5 r:c ||j|jj|jj|j|j j|j j|jj|jj|jS)NrSrTrUrArHrBrIrM rrScopyrTrUrArHrBrIrMrs r;rz!CallbackManagerForChainGroup.copy~~]]'')!%!:!:!?!?!A,,!!22779]]'')!%!:!:!?!?!A#66  r:c |j|jxs |jggtt|j|jztt|j |j zi|j |j |j}|j|jz}|j|jz}|D]}|j||D]}|j|d|S)aMerge 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 object with the handlers, tags, and other attributes merged from the other object. Example: Merging two callback managers. ```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)) # print(merged_manager.handlers) # [ # , # , # ] print(merged_manager.tags) # ['tag2', 'tag1'] ``` rUrSrTrArHrBrMTr rrUlistsetrArHrBrMrSrT add_handlerrotherrrSrTrs r;mergez"CallbackManagerForChainGroup.mergesL..,,C0C0C!#c$))ejj012!#d&;&;e>T>T&T"UV--.. $66!  ==5>>1#885;U;UU )G    ( ), 7G     6 7r:c Jd|_|jj|fi|S)zRun when traced chain group ends. Args: outputs: The outputs of the chain. **kwargs: Additional keyword arguments. TrVrMrWrs r;rWz)CallbackManagerForChainGroup.on_chain_ends) 3t&&33GFvFFr:c Jd|_|jj|fi|S)rTrVrMrYrs r;rYz+CallbackManagerForChainGroup.on_chain_errors) 5t&&55eFvFFr:r~) rSrrT list[BaseCallbackHandler] | NonerUrrMrrqr rwr)rwrR)rrRrrrwrRr%r) rrrrrrrrrWrY __classcell__rs@r;rRrRos/ BF%) +?#  7  8    ;*;3F; %;z G G G G  Gr:rRc6eZdZdZed dZ d d dZ d ddZ d ddZe d ddZ d ddZ e d dd Z e d dd Zy)rdz=Async callback manager that handles callbacks from LangChain.cy)z$Return whether the handler is async.Tr9rs r;is_asynczAsyncCallbackManager.is_asyncsr:Nc >Kg}g}|jDcgc]}|js|}}|jDcgc]}|jr|} }g} |D]} ||} d}n t} |rD|jt |dd|| gf| |j |j |jd|nC|jt | dd|| gf| |j |j |jd|| jt| |j|j|j |j |j|j|j|D] } | d{|rtj|d{| Scc}wcc}w7.7w)agRun when LLM starts running. Args: serialized: The serialized LLM. prompts: The list of prompts. run_id: The ID of the run. **kwargs: Additional keyword arguments. Returns: The list of async callback managers, one for each LLM Run corresponding to each prompt. Nr~rrSr)rSrr(rrrUrArBr rTrHrIrlr)rrUrVr@rq inline_tasksnon_inline_tasksrinline_handlersnon_inline_handlersrWrYrZ inline_tasks r;r~z!AsyncCallbackManager.on_llm_starts& 26--Vw7CUCU7VV#'== 8J8JG  1 F! '##!'&$"  '&*&8&8!YY!% !  !''!+&$"  '&*&8&8!YY!% !   OO-"!]])-)B)B"&"4"4%)%:%:!]])-)B)B  M1 h( K    .."23 3 3CW t  4sDFFFFF FDF*F+FF FFc fKg}g}g}|D]}||} d}n t} |jD]f} t| gdd||gf| |j|j|j d|} | j r|j| V|j| h|jt| |j|j|j|j|j|j |j|D] } | d{|rtj|d{|S7$7w)a|Async run when LLM starts running. Args: serialized: The serialized LLM. messages: The list of messages. run_id: The ID of the run. **kwargs: Additional keyword arguments. Returns: The list of async callback managers, one for each LLM Run corresponding to each inner message list. Nr|r\rSr)r(rSrrUrArBrrr rTrHrIrlr) rrUr]r@rqrrrWr^rZrrts r;r|z(AsyncCallbackManager.on_chat_model_startSsS& $$ L! '== 2$I)'!N  #"&"4"4!]]  %% ''-$++D1! 2$ OO-"!]])-)B)B"&"4"4%)%:%:!]])-)B)B  3$ N! DJJ  .."23 3 3  4s$DD1D- D1&D/'D1/D1c bK| t}t|jdd||f||j|j|j d|d{t ||j|j|j|j|j|j |jS7]w)a>Async run when chain starts running. Args: serialized: The serialized chain. inputs: The inputs to the chain. run_id: The ID of the run. **kwargs: Additional keyword arguments. Returns: The async callback manager for the chain run. NrPrrSr) r(rrSrUrArBr*rTrHrIr`s r;rPz#AsyncCallbackManager.on_chain_starts$ >WF MM      ,,]]    /]]!%!:!:,,!22]]!%!:!:   A B/B-AB/c bK| t}t|jdd||f||j|j|j d|d{t ||j|j|j|j|j|j |jS7]w)aoRun when the tool starts running. Args: 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: The async callback manager for the tool run. NrbrrSr) r(rrSrUrArBr=rTrHrI)rrUrcr@rUrqs r;rbz"AsyncCallbackManager.on_tool_starts* >WF MM      ,,]]    .]]!%!:!:,,!22]]!%!:!:   rc K|jsy| t}|r d}t|t|jdd||||j|j d{y7wri)rSr(rlrrArBrms r;rjz$AsyncCallbackManager.on_custom_eventsm*}}  >WF 2  S/ ! MM  !  ]]  sAA'A% A'c bK| t}t|jdd||f||j|j|j d|d{t ||j|j|j|j|j|j |jS7]w)anRun when the retriever starts running. Args: 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 async callback manager for the retriever run. NrerErSr) r(rrSrUrArBrMrTrHrIrfs r;rez'AsyncCallbackManager.on_retriever_start#s* >WF MM     ,,]]    3]]!%!:!:,,!22]]!%!:!:   rc (t||||||||S)aConfigure the async callback manager. Args: 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: The configured async callback manager. rqrsrus r;rOzAsyncCallbackManager.configureSryr:rwrr8) rUrzrVr{r@rrqr rw#list[AsyncCallbackManagerForLLMRun]) rUrzr]r}r@rrqr rwr) rUrr=r&r@rrqr rwr*r~) rUrrcrr@rrUrrqr rwr=r) rUrrgrr@rrUrrqr rwrMr)rGrrvrrrrrHrrwrrIrrxrrwrd)rrrrpropertyrr~r|rPrrbrjrerrOr9r:r;rdrds6G # V"VV V  V - Vx# E"E*E E  E - EV# + )+ %+  +  + ) + Z #%) - )- -  - # -  -  (- - f# * * *  *  *  * X #%) - )- -  - # -  -  -- - ^,0%)-1'+6:04! (! #!  ! + ! % ! 4! .!  ! ! r:rdcxeZdZdZ d dfd Zd dZ d dZd dZ d dZxZ S) rez+Async callback manager for the chain group.c Ft||||fi|||_d|_y)aOInitialize the async callback manager. Args: 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. FNrrs r;rz*AsyncCallbackManagerForChainGroup.__init__{s6$      #5 r:c ||j|jj|jj|j|j j|j j|jj|jj|jS)z)Return a copy the async callback manager.rrrs r;rz&AsyncCallbackManagerForChainGroup.copyrr:c |j|jxs |jggtt|j|jztt|j |j zi|j |j |j}|j|jz}|j|jz}|D]}|j||D]}|j|d|S)aMerge 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. ```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)) # print(merged_manager.handlers) # [ # , # , # ] print(merged_manager.tags) # ['tag2', 'tag1'] ``` rTrrrs r;rz'AsyncCallbackManagerForChainGroup.mergesP..,,C0C0C!#c$))ejj012!#d&;&;e>T>T&T"UV--.. $66!  ==5>>1#885;U;UU )G    ( ), 7G     6 7r:chKd|_|jj|fi|d{y7w)zRun when traced chain group ends. Args: outputs: The outputs of the chain. **kwargs: Additional keyword arguments. TNrrs r;rWz.AsyncCallbackManagerForChainGroup.on_chain_ends0 2d%%227EfEEE (202chKd|_|jj|fi|d{y7w)zRun when chain errors. Args: error: The error. **kwargs: Additional keyword arguments. TNrrs r;rYz0AsyncCallbackManagerForChainGroup.on_chain_errors0 4d%%44UEfEEErr~) rSrrTrrUrrMr*rqr rwr)rwre)rrerrrwrer%r) rrrrrrrrWrYrrs@r;rerexs5 BF%) +?#  <  6  =/=8K= *=~F F F F  Fr:reTFrqc  t}|d} |d} |d} | dn | j} |g| } |s|rFt|ts|.|xsg}||j |j | } n|j }| || rt || jvr| }||jj |jj ||jj |jj |jj |jj } t|tr|n|r |jng}|D]}| j|d |s|r,| j|xsg| j|xsgd |s|r,| j!|xsi| j!|xsid | r| j!| j | r| j| j t#d xs t#d }t%j&}t)}|r|s d }t+|t-}t/}|s|s|rK|r:t1d | jDs|rn| jt3d |r5t1d| jDs| jt5|rat1d| jDsE|r| j|n1 t7|| | j8n|d| }| j|| s| jD]d}t|t6s| jB| jf|jD| j<| |jFt | j<ftHD]\}}}|duxrt#|xrdu}|j'|s2|j'xstKd2t1fd| jDrv| j|t1fd| jDr| j|| S#t:$r*}t<j?dtA|Yd}~gd}~wwxYw)aUConfigure the callback manager. Args: 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: The configured callback manager. rBrAparentNr)rSrTrU)rSrTrUrArHrBrIFrLANGCHAIN_TRACINGLANGCHAIN_HANDLERzTracing using LangChainTracerV1 is no longer supported. Please set the LANGCHAIN_TRACING_V2 environment variable to enable tracing instead.c3<K|]}t|tywr8) isinstancerrrs r;rz_configure..g s   w 5 6 c3<K|]}t|tywr8)rr%rs r;rz_configure..o s   w 6 7 rc3<K|]}t|tywr8)rr$rs r;rz_configure..t s+  w 0+ rclient)r>rrAz{Unable to load requested LangChainTracer. To disable this warning, unset the LANGCHAIN_TRACING_V2 environment variables. %sztype[BaseCallbackHandler]c3&K|]}|u ywr8r9)rr var_handlers r;rz_configure.. s{*sc36K|]}t|ywr8)r)rr handler_classs r;rz_configure.. s 7M2s)&ridrrrrUr dotted_orderrSrTrArHrBrIrrrr&r#getr"rr!r<anyrr%r$rrXrrrtrace_id order_maprun_maprr)callback_manager_clsrGrvrHrwrIrxrrtracing_contexttracing_metadata tracing_tagsrun_treerUrEinheritable_callbacks_parent_run_id_local_handlers_rv1_tracing_enabled_ tracer_v2tracing_v2_enabled_rotracer_projectdebugravar inheritableenv_var create_onerrs @@r;rtrts:*+O&z2"6*L*84H$,D(++M+# +T 26K6S%:%@b "3/446%;%@%@%B+   3@@N(&^!48M8M!M!. 4.77<<>%:%O%O%T%T%V,*//446!6!G!G!L!L!N.77<<>%:%O%O%T%T%V  /40 .=/**2  ' AG  ( (% ( @ A:!!"2"8b9!!*"2E!B~%%&:&@bA%%n&:E%J%%&6&;&;&=>!!,"3"3"56()<=B(++-I02#6  3(*N LE%. 3 +44   ,,-B-De,T  +44    ( ()?)A B s+ +44+ (  ,,Y7-%3 (3%OO!0!:)G%009  +44 Ag7 )) --6G%%hkk29AGOOC $45  A5EG0[- 4  *w' *T)  779 J OMT"=}MO $#3#<#<%00kJ/88!,,[+F)G* K!NNQ s+0R SSS)configcKddlm}m}||}||}|j d}t ||j |||jd{y7w)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: ```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 ```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 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. 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.rK)langchain_core.runnables.configrrrUrrj)rJrnrrrrEros r;adispatch_custom_eventr st| 6 "F 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()]}) ``` r)rget_callback_manager_for_configNrrK)rrrrUrrj)rJrnrrrrEros r;dispatch_custom_eventr( sfX 6 "F6v> %%- = 3$$  --%r:r})maxsizec`td}tj|jd|S)N ) max_workersT)r)ratexitregistershutdown)cuties r;rro s% 2 .E OOENN. Lr:rr8)r[rrEzCallbackManager | Noner=rr>rr?str | UUID | Noner@rrArrBrrwz3Generator[CallbackManagerForChainGroup, None, None])r[rrEzAsyncCallbackManager | Noner=rr>rr?rr@rrArrBrrwz7AsyncGenerator[AsyncCallbackManagerForChainGroup, None])rurgrwrg) rSrrrrrrpr rqr rwr)rzlist[Coroutine[Any, Any, Any]]rwr) rrrrrrrpr rqr rwr)NNNNNN)rztype[T]rGrrvrrHrrwrrIrrxrrrrrwr)rJrrnr rzRunnableConfig | Nonerwr)rwr)sr __future__rrlrrxloggingabcrrcollections.abcrconcurrent.futuresr contextlibrr contextvarsr typingr r r rlangsmith.run_helpersrtyping_extensionsrrlangchain_core.callbacks.baserrrrrrrrlangchain_core.callbacks.stdoutrlangchain_core.globalsrlangchain_core.messagesrrlangchain_core.tracers.contextrr r!r"r# langchain_core.tracers.langchainr$langchain_core.tracers.stdoutr%langchain_core.utils.envr&langchain_core.utils.uuidr(r)r*r+r,uuidr-tenacityr.langchain_core.agentsr/r0langchain_core.documentsr1langchain_core.outputsr2r3r4rr5langchain_core.tracers.schemasr6 getLoggerrrr<rbrfrgrzrrrrrrrrrrr rr*r3r=rBrMrNrRrdrerrtrr lru_cacherr9r:r;r s" #$1:$445,   B,B=@3+NN'>1VV>2   8 $04G)%)#$(!&*G)G),G) " G)  G) " G) G) G)$G)9G)G)T59J/%)#$(!&*J/J/1J/ " J/  J/ " J/ J/ J/$J/=J/J/ZvX& !FS"'S"S"&S"  S"  S"  S"lK:1 11&1  1  1  1h%'%%&%  %  %  %P5 _5 p2 2 jz,; nc; |O,M z?M `d O_d NW !13DW tj &;=Nj Z3 02B3 l@ %:Bw ww%:w wv>BD DD%:D DNQ   r: