f UdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddlm Z ddl mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"ddl#m$Z$m%Z%ddl&m'Z(ddl&m)Z)m*Z*dd l+m,Z-dd l.m/Z/er dd l0m1Z1dd l2m3Z3e jhe5Z6ejnee)jpd dZ9ejnee:ddZ;ejneee:ddZ<ejneee:efddZ=ejnee>ddZ?e9e;edZCd?dZDejdddddd d@dZFeBZG dAdZHdBdZIdCdZJGdded !ZKed"d#$ZLe$d%ZMe"Gd&d'eeeMeLfZNe! dBd(ZOe! dDdddddddddd) dEd*ZO dFd+ZOGd,d-ZPdGd.ZQdHd/ZRhd0ZSGd1d2ed !ZTGd3d4ed !ZU dI dJd5ZVdKd6ZW d= dLd7ZX dM dNd8ZYdCd9ZZ dOd:Z[ dOd;Z\y)Pz1Decorator for creating a run tree from functions.) annotationsN) copy_context) TYPE_CHECKINGAnyAsyncGenerator AwaitableCallableDict GeneratorGenericListMappingOptionalProtocolSequenceTupleType TypedDictTypeVarUnioncastoverloadruntime_checkable) ParamSpec TypeGuardclient) run_treesutils)_aiter) _runtime_env) TracebackType)Runnable_PARENT_RUN_TREEdefault _PROJECT_NAME_TAGS _METADATA_TRACING_ENABLEDparent project_nametagsmetadataenabledz!Dict[str, contextvars.ContextVar] _CONTEXT_KEYSc*tjS)zGet the current run tree.)r$getT/opt/lhia/ganansol/python/venv/lib/python3.12/site-packages/langsmith/run_helpers.pyget_current_run_treer7Fs    !!r5cD|btjtjtjtjt jdSt jDcic]\}}||j|c}}Scc}}w)z Get the current tracing context.r+)r$r3r'r(r)r*r1items)contextkvs r6get_tracing_contextr=Ksy&**,)--/IIK! '++-   +8*=*=*? @$!QAw{{1~  @@ @s<Bch|jD]\}}t|}|j|!y)zSet the tracing context.N)r9r1set)r:r;r<vars r6_set_tracing_contextrAZs0 1A  r5)r-r.r/r,r0c+K|rtjd|dtt}t d|xs|j di}|Ft t|xsgt|jxsgz}i|j|xsi}||n|j d}t|||||d dt|y#t|wxYww)ahSet the tracing context for a block of code. Args: project_name: The name of the project to log the run to. Defaults to None. tags: The tags to add to the run. Defaults to None. metadata: The metadata to add to the run. Defaults to None. parent: The parent run to use for the context. Can be a Run/RunTree object, request headers (for distributed tracing), or the dotted order string. Defaults to None. enabled: Whether tracing is enabled. Defaults to None, meaning it will use the current context value or environment variables. z Unrecognized keyword arguments: .r, parent_runNr0r+) warningswarnDeprecationWarningr=_get_parent_runr3sortedr?r.r/rA)r-r.r/r,r0kwargscurrent_contextrDs r6tracing_contextrLas. .vha 8  *+O (F,Nfjj6N!OPJc$*"oJOO,Ar(BBC>j))>hn"> ,g/2E2Ei2PG (   . _-_-sB9C<C C CCct|xsVt|tjxrt|jxs#t |dxrt|j S)z,Check if a function is @traceable decorated.__call__)_is_traceable_function isinstance functoolspartialfunchasattrrNrSs r6is_traceable_functionrVsU t$ Q tY.. / U4J4994U Q D* % O*@*Or5c<t|r|St|S)z$Ensure that a function is traceable.)rV traceablerUs r6ensure_traceablerYsT" 9;t r5ctj|xs-t|dxrtj|jS)z;Inspect function or wrapped function to see if it is async. __wrapped__)inspectiscoroutinefunctionrTr[rUs r6is_asyncr^s:  & &t , m$V)D)DTEUEU)Vr5ceZdZUdZded<ded<ded<ded <d ed <ded <d ed<ded<ded<ded<ded<y)LangSmithExtraz float: return x + y my_function(5, 6) @traceable async def my_async_function(query_params: dict) -> dict: async with httpx.AsyncClient() as http_client: response = await http_client.get( "https://api.example.com/data", params=query_params, ) return response.json() asyncio.run(my_async_function({"param": "value"})) # Streaming data with a generator: @traceable def my_generator(n: int) -> Iterable: for i in range(n): yield i for item in my_generator(5): print(item) # Async streaming data @traceable async def my_async_generator(query_params: dict) -> Iterable: async with httpx.AsyncClient() as http_client: response = await http_client.get( "https://api.example.com/data", params=query_params, ) for item in response.json(): yield item async def async_code(): async for item in my_async_generator({"param": "value"}): print(item) asyncio.run(async_code()) # Specifying a run type and name: @traceable(name="CustomName", run_type="tool") def another_function(a: float, b: float) -> float: return a * b another_function(5, 6) # Logging with custom metadata and tags: @traceable( metadata={"version": "1.0", "author": "John Doe"}, tags=["beta", "test"] ) def tagged_function(x): return x**2 tagged_function(5) # Specifying a custom client and project name: custom_client = Client(api_key="your_api_key") @traceable(client=custom_client, project_name="My Special Project") def project_specific_function(data): return data project_specific_function({"data": "to process"}) # Manually passing langsmith_extra: @traceable def manual_extra_function(x): return x**2 manual_extra_function(5, langsmith_extra={"metadata": {"version": "1.0"}}) rrNchainzUnrecognized run_type: z. Must be one of: z . Did you mean @traceable(name='z')?zThe `traceable()` decorator only accepts one positional argument, which should be the run_type. All other arguments should be passed as keyword arguments.extrazJThe `extra` keyword argument is deprecated. Please use `metadata` instead.rrbr/r.rr-rr) extra_outerrbr/r.rr-rrinvocation_params_fnrc:|r |}t|||y)zHandle the end of run.Noutputserror)_container_end) containerrroutputs_processors r6 _on_run_endztraceable.._on_run_ends$ (4'0Gy'?r5zHThe following keyword arguments are not recognized and will be ignored: rCc 2 tj}|jjdddu |jjdddut j dd d  fd}t j dd d  fd}t j dd d fd}t j dd d  fd}tj r|}n/tr r|}n|}n stjr|}n|}t|dd tj|}|jjds|jgd |jjDtjdtjjd d |jjD }||_|S)Nriconfigr|chKtjt |||d{} tj} r|d|d< s|j dd |i|}|r#t j ||dd{}n*td it|d5|d{}dddtj| d{|S77S72#1swY1xYw#t$r;}t jtj||d{7|d}~wwxYw7_w) z"Async version of wrapper function.container_inputr}rrJNnew_runrirr:r:rrr4) aitertools aio_to_thread _setup_runasyncio_accepts_contextpopasyncio create_taskrLr= BaseExceptionshield) r}rrJ run_containeraccepts_contextfr_corofunction_resulterrrSfunc_accepts_configfunc_accepts_parent_runs r6 async_wrapperz3traceable..decorator..async_wrappersR#-":": / / #M ","D"D"F*)6y)AF:&*JJx.//",3,?,?y)A-'O )-mI.FG818-8**]O  # "G"'+888! nn,,[-qQ    s#D2CD2AC)CC)"C(C)C-C)5D2D0D2C)CC&"C)) D-2.D( D#!D((D--D2cDKtjt |||d{}g} r|d|d< s|jdd |i|}tj}t j |rO|r#tj||dd{}n*td it|d5|d{}ddd |r6tjtj||dd{}n=td it|d5tj|d{}ddddk(rb|dr]|djdtjjtjj j#d id |j%|77(7#1swYxYw77#1swYxYw#t&$rYnwxYwnG#t($r;}tj*tj || d{7|d}~wwxYw|r<r7 |} n2#t($r!}t,j/||} Yd}~n d}~wwxYw|} nd} tj || d{7yw)Nrrrirr:rllm new_tokentokenrbtimerJrrr4)rrrrrr\ iscoroutinerrrLr=py_anext add_eventdatetimenowtimezoneutc isoformatappendStopAsyncIterationrrLOGGERr)r}rrJrresultsasync_gen_resultritemrrrrrSrrrrs r6async_generator_wrapperz=traceable..decorator..async_generator_wrappers#-":": / / #M"$G6 *)6y)AF:&+JJx.#'#8#8 ","D"D"F&&'78&181D1D,mI6N2,( -1- 2JKF6F/E,F*)0)<)< * 3 34D E(5i(@*$D "1""5mI6N"O"S.8-@-@AQ-R'RS$u,,Y7 -i 8 B B0;080A0A0E0E,4,=,=,A,A1**3)+3:D/ %&!" t," 1A,,0FFF$(SSS"*  nn,,[-qQ   2*3G*<(2 Q*12'.O"&**]O  s#J GJ A.G7GG79G ?GG G7 3G'GG'G6G7G;BG'J G7G  GG7G'GG$ G'' G30G72G33G76J 7 H;.H6.H1/H66H;;J I J  I6I1,J 1I66#J JJ cHt |||}tj jj dddu} |r|d|d< s|j dd|dj g|i|}|||S#t$r}|||d}~wwxYw) >Create a new run or create_child() if run is passed in kwargs.rriNrrr:rr)rr\ signature parametersr3rrunr) r}rrJrrrrrrrSrs r6wrapperz-traceable..decorator..wrapper?s' / / M!!$'2266z4HPTT $ *)6y)AF:&*JJx.">- ":">">t"Ud"Uf"U   ?" " ! M3 s7B B! BB!c?DKt |||}tj jj dddu}g} |r|d|d< s|j dd|dj g|i|} |dj t|}dk(rb|dr]|djdtjjtjjjd|id |j| |#t$rYnwxYwn#t $rYnwxYwn#t"$r} || |d}~wwxYw|r<r7 |} n2#t"$r!}t$j'||} Yd}~n d}~wwxYw|} nd}  || yw) Nrrirrr:rrrrrr)rr\rrr3rrnextrrrrrrr GeneratorExit StopIterationrrr)r}rrJrrrgenerator_resultrrrrrrSrrrs r6generator_wrapperz7traceable..decorator..generator_wrapper\s' / / M!!$'2266z4HPTT $"$G! *)6y)AF:&+JJx.#?=#;#?#?#Vt#Vv#V ,Y7;;DBRS#u,,Y7 -i 8 B B0;080A0A0E0E,4,=,=,A,A1**3)+3:D/ %&!" t,""&J -"!"!$! M3 2*3G*<(2 Q*12'.O"&   ?sAF 7D8BD(DD( D$!D(#D$$D('D8( D41D83D44D87F 8 E E  EF E#"F # F ,FF F  F __langsmith_traceable__Tc3nK|]-}|jtjjk7r|/ywrkindr\ Parameter VAR_KEYWORD.0params r6 z/traceable..decorator..0! ::):):)F)FF35r%c3nK|]-}|jtjjk(r|/ywrrrs r6rz/traceable..decorator..rr)r)rrr}rrJrrr)rrr}rrJrrr)r\rrr3rQwrapsisasyncgenfunctionr^isgeneratorfunctionsetattrreplacevaluesr KEYWORD_ONLY __signature__)rSfunc_sigrrrrselected_wrappersigrrrrrrs` @@r6 decoratorztraceable..decorators$$T*"*"5"5"9"9*d"KSW"W&1155hETQ  9=) #) #5) #) # ) #) # ) #V  DHP P )AP TWP  P P  P d  9= # #5 # #  #  #8  DH; @; @)A; @TW; @ ; @; @ ; @z  % %d +)@  d^#: #0 '55d;0 &  ";TB 01~~!!(+++%(^^%:%:%< %% '"3"3"@"@$ %(^^%:%:%<C".1  *r5NNr_TraceableContainerrz Optional[Any]rOptional[BaseException]rNone)rSr ) rPstrr_VALID_RUN_TYPESrErFlenrG_ContainerInputrIkeyscallable)rrJrrrrrrs @@@@@r6rXrXsR JtAw, QjjT*5g '' %hZ/ABRAST..6Zs <  4y1}  $ &     ;-I%JJw- ZZ %J- ZZ %zz(D)ZZ5zz"2D9#ZZ(?F O #4d;"&)-@&@@'@  @ Vfkkm$%Q (    F 4yA~(47+Fa!! r5c eZdZdZ d ddddddddddd d dZd dZ ddZd dZ d ddZd d Z d dd Z y)tracea Manage a langsmith run in context. This class can be used as both a synchronous and asynchronous context manager. Parameters: ----------- name : str Name of the run run_type : ls_client.RUN_TYPE_T, optional Type of run (e.g., "chain", "llm", "tool"). Defaults to "chain". inputs : Optional[Dict], optional Initial input data for the run project_name : Optional[str], optional Associates the run with a specific project, overriding defaults parent : Optional[Union[run_trees.RunTree, str, Mapping]], optional Parent run, accepts RunTree, dotted order string, or tracing headers tags : Optional[List[str]], optional Categorization labels for the run metadata : Optional[Mapping[str, Any]], optional Arbitrary key-value pairs for run annotation client : Optional[ls_client.Client], optional LangSmith client for specifying a different tenant, setting custom headers, or modifying API endpoint run_id : Optional[ls_client.ID_TYPE], optional Preset identifier for the run reference_example_id : Optional[ls_client.ID_TYPE], optional You typically won't set this. It associates this run with a dataset example. This is only valid for root runs (not children) in an evaluation context. exceptions_to_handle : Optional[Tuple[Type[BaseException], ...]], optional Typically not set. Exception types to ignore in what is sent up to LangSmith extra : Optional[Dict], optional Typically not set. Use 'metadata' instead. Extra data to be sent to LangSmith. Examples: --------- Synchronous usage: >>> with trace("My Operation", run_type="tool", tags=["important"]) as run: ... result = "foo" # Do some_operation() ... run.metadata["some-key"] = "some-value" ... run.end(outputs={"result": result}) Asynchronous usage: >>> async def main(): ... async with trace("Async Operation", run_type="tool", tags=["async"]) as run: ... result = "foo" # Can await some_async_operation() ... run.metadata["some-key"] = "some-value" ... # "end" just adds the outputs and sets error to None ... # The actual patching of the run happens when the context exits ... run.end(outputs={"result": result}) >>> asyncio.run(main()) Allowing pytest.skip in a test: >>> import sys >>> import pytest >>> with trace("OS-Specific Test", exceptions_to_handle=(pytest.skip.Exception,)): ... if sys.platform == "win32": ... pytest.skip("Not supported on Windows") ... result = "foo" # e.g., do some unix_specific_operation() N) inputsrr-r,r.r/rrlrdexceptions_to_handlec  b| r5tjdt| jdt||_||_||_||_||_ ||_ | jd|_ ||_ ||_| |_| |_| |_| |_d|_d|_y)z_Initialize the trace context manager. Warns if unsupported kwargs are passed. zEThe `trace` context manager no longer supports the following kwargs: rCriN)rErFrIrrGrbrrrr-r,r3rir.r/rrlrdrrold_ctx)rrbrrrr-r,r.r/rrlrdrrJs r6__init__ztrace.__init__s*  MMW&++-(),"       (  :.      $8!$8!48 '+ r5c t|_tj|j}tj }t j }t|j|j|jd}tt|jxsg|xsgz}i|jxsi|xsiddi}|jxsi}||d<t!|j"}|G|rE|j%|j&|j(|j*||j,||_nt1j2|j&t5j6|j(t5j6|j8d|j*||xsd|j,xsi||j |_|rx|j.j;tj|t j|t<j|j.t>j||j.S) a]Set up the tracing context and create a new run. This method initializes the tracing context, merges tags and metadata, creates a new run (either as a child of an existing run or as a new root run), and sets up the necessary context variables. Returns: run_trees.RunTree: The newly created run. )r,rir ls_methodrr/)rbrlrrrr.T accept_nullr&) rbidrdrrr-rr.r) r=rrtracing_is_enabledr(r3r)rHr,rirrIr?r.r/r_get_project_namer- create_childrbrlrrrrRunTree ls_client _ensure_uuidrdpostr$r') rr0 outer_tagsouter_metadata parent_run_tags_r/r project_name_s r6_setupz trace._setup.s+, **4<<8YY[ "%++ MM++  sDIIO 0@bABC }}" #    jj&B "* J)$*;*;<  "w&33YY{{!{{ 4DL%,,YY))$++6%.%;%;--4&!*7i{{(b{{ DL  LL    IIe  MM( #   .   m ,||r5c|jy|i|jrt||jrd}n(tj}|j d|d|}|jj ||jQtj|j}|r|jjt|jytjdty)aClean up the tracing context and finalize the run. This method handles exceptions, ends the run if necessary, patches the run if it's not disabled, and resets the tracing context. Args: exc_type: The type of the exception that occurred, if any. exc_value: The exception instance that occurred, if any. traceback: The traceback object associated with the exception, if any. N:  rz(Tracing context was not set up properly.)rr issubclassr _format_excrqendrrpatchrArErFRuntimeWarning)rexc_type exc_value tracebacktbr0s r6 _teardownztrace._teardownrs <<    ((Z$33.&&( ))*"YKtB4@ LL  2  & << #..t||>> @traceable ... def my_function(input_data): ... # Function implementation ... pass >>> runnable = as_runnable(my_function) r)RunnableConfigRunnableLambda)InputOutputzjas_runnable requires langchain-core to be installed. You can install it with `pip install langchain-core`.NzzRas_runnable expects a function wrapped by the LangSmith @traceable decorator. Got z defined as: c|eZdZdZ d dfd Ze dfd Ze dfd ZxZS) &as_runnable..RunnableTraceablezConverts a @traceable decorated function to a Runnable. This helps maintain a consistent LangSmith tracing context. c d}|j|}t|r3| tdttgf|j|}n0t |r%ttgf|j |}|$t|jjd|t|-|tttgtf|y)NzFunc was provided as a coroutine function, but afunc was also provided. If providing both, func should be a regular function to avoid ambiguity.zG expects a function wrapped by the LangSmith @traceable decorator. Got ) _wrap_asyncr^ TypeErrorrr rV _wrap_sync ValueError __class__rqsuperrrr)rrSafuncwrappedawrappedr5r6r>s r6rz/as_runnable..RunnableTraceable.__init__s <@G''.H~'#7 x8$:J:J4:PQ&t,x8$//$:OP ~~../02269 G Xugy/@&@AB r5c@dfd }ttgf|S)z4Wrap a synchronous function to make it asynchronous.cztjjtt|}di|dd|iiSNr}rir4rrfrom_runnable_configrdict)rrrirSs r6wrap_traceablezIas_runnable..RunnableTraceable._wrap_sync..wrap_traceable4s8$,,AA$tVBTUMfMz86LMMr5rrHrr3rr)rr )rSrIr5r6r3s` r6r<z1as_runnable..RunnableTraceable._wrap_sync.s'  N%!8&!@A>R Rr5c|yt|std|ttdtf|dfd }ttgtf|S)z.Wrap an async function to make it synchronous.NzXRunnableTraceable expects a function wrapped by the LangSmith @traceable decorator. Got .cKtjjtt|}di|dd|iid{S7wrErF)rrriafunc_s r6awrap_traceablezKas_runnable..RunnableTraceable._wrap_async..awrap_traceableIsB$,,AA$tVBTU#UfUz8>TUUUUs?A AA rJ)rVr=rr r)r@rNrMr5r6r3s @r6r:z2as_runnable..RunnableTraceable._wrap_async:s| }(/ 227:(3 &(9#9:EBF V%0)F2CCDo r5r)rSr r@*Optional[Callable[..., Awaitable[Output]]]rr)rSzCallable[..., Output]rz)Callable[[Input, RunnableConfig], Output])r@rOrz>Optional[Callable[[Input, RunnableConfig], Awaitable[Output]]]) rqrrrsrtr staticmethodr<r: __classcell__)r>r5r6r3s@r6RunnableTraceabler8s} AE  >   @  S' S 6 S  S  =  K   r5rR) langchain_core.runnablesr3r4langchain_core.runnables.utilsr5r6 ImportErrorrVr\ getsource Exceptionr=) traceable_fnr4rfn_srcrRr5r6r3s @@@r6 as_runnablerZs*K@ ! . ,&&|4F**6~fX O  GGNGR \ **q  D   ,+F ,s(AA; A8' A33A8; B B >rtoolrparserprompt embedding retrievercXeZdZUdZded<ded<ded<ded<d ed <d ed <d ed<y)r3Typed response when initializing a run a traceable.rhrrar- outer_projectrjr rkr rnrozcontextvars.Contextr:Nrpr4r5r6rras/= ((  ,,## 88  r5rcveZdZUdZded<ded<ded<ded <d ed <d ed <ded<ded<ded<ded<y)rrarerrarbrjr/rkr.rmrzOptional[Callable]rr-r+r Optional[Callable[[dict], dict]]rrNrpr4r5r6rrmsA= &&  &&!!""44::r5rc|jd}|yt|tr|nd|i}d}|r$tj}t |d|}|j |||j|jd}|t|r ||yyy#t$r"}tjd|Yd}~yd}~wwxYw)z End the run.rNoutputrrrozFailed to run on_end function: ) r3rPrHrrreprrrrrrwarning) rrrrioutputs_error_ stacktracerors r6rr|s }}Y'H$Wd3w(G9LH F &&( K=ZL1 LLL0 NN ]]8 $F hv. B 8 / B NN+>~+NO .  &#  22 "&&x0*?+>+>~+NO 3   "":.H  C..0<""77 ?..x88  2 &6::k+B ??S%5%55 Jr5c  |jdxsi}|jd}|jd}|jd}|jdxsd} tj} |xs t}|jdxs|jd} |jd|} ti|d| i|jd} tj}|xs@| r | jnd xs.|jd xs|d xst j }|jd }|jd }| sat jsMt jtjd td || d d |jdtS|xsttj}t!j"|}| xs |j$}|j&}t)||}t*j}t,j}t}i|jdxsi|xsi}|j/t*j0||j3|xsid|d<||d<t5|g|i|}|jd}|rP ||j7Dcic] \}}| || }}}|r!t9|t:r|j3||jd} | r | |}|jdxsg|xsgz}!|j/t,j0|!|!|xsgz }!| &| jC|| | t||d||!||}"nTtEjFtIjJ||| t||d|| tIjJ|d|||!|  }" |"jMt|"|| |||jd|}#|j/tj0|#d |j/tPj0|#d|#Scc}}w#t<$r&}t>jAd|d|Yd }~d }~wwxYw#t<$r&}t>jAd|d|Yd }~d }~wwxYw#t<$r0}t>jAd|"jNd|Yd }~d }~wwxYw)rrr/r.rrrrbrNr-rdrlz:LangSmith tracing is enabled, returning original function.ro)rr-rbr r ror:rXrrz&Failed to infer invocation params for rrzFailed to filter inputs for )rbrdoc)rbr serializedrr.rrlTr) rrbrzrrrdr-rr.rzFailed to post run r))r3r'r`rHr/rr0rlog_onceloggingDEBUGrrruuiduuid4r\rrqrtrnr)r(rr?update_get_inputs_safer9rPrHrrrrrrrr r rr$)$rSrr}rrJrr/r.rrrbrbclient_r  project_cvselected_projectrdid_rname_ docstringrmr r r: metadata_rrr;r<invocation_paramsrrrrresponse_containers$ r6rrs"%%m4:K"":.H   v &D   *F"":.9'H!%%'M%9)9O   v & E/*=*=f*ED!!(F3G!.?.Hg. 80DK""$J &(3K $ $ &   ~ .  & > *  &  # # %+../EF   h 'C u779  MMW #)'"&&x0 N    "TZZ\"C!!$'I  !DMME I o>K]]_NJnG   z * 0b  RI KK y) X^$(Ik'K  i 9$ 9& 9F*../EF P!5f!=!C!C!E!A1! !!Z0A4%H  !23%(()9:N F#F+F  ( .B:3C DE KK 5! TZRE** ^  +  ##%%c* ^  !*!7!7$$"*! $> -%#%""8, KK !!#5n#EF KK $$&8&CD A!  P LLA%1#N O O P  F LL7wbD E E FP > *7::,b<==>s`Q/ Q)'Q),&Q/&R!0S)Q// R8RR! S*S  S T %TT ct|ddS)NrF)getattrrUs r6rOrOTs 42E ::r5c|j|i|}|jt|j}|j dd|j dd|j j D]W\}}|jtjjk(s.||vs3|j|||j |Y|S)z:Return a dictionary of inputs from the function signature.rNcls) bind_partialapply_defaultsrH argumentsrrr9rr\rrr)rrrJboundr param_namers r6 _get_inputsrXs #I " "D 3F 3E U__%I MM&$ MM%&11779* E ::**66 6Y&  :!67 j) * r5c t|g|i|S#t$r*}tjd|d|||dcYd}~Sd}~wwxYw)NzFailed to get inputs for r)rrJ)rrrdebug)rrrJrs r6rrlsQ096t6v66 0 0 2aSAB//0s A?AA)rrhr)r:zOptional[contextvars.Context]rDict[str, Any])r:r)r-rar.rkr/rjr,z0Optional[Union[run_trees.RunTree, Mapping, str]]r0zOptional[bool]rJrrzGenerator[None, None, None])rSCallable[P, R]rz'TypeGuard[SupportsLangsmithExtra[P, R]])rSrrzSupportsLangsmithExtra[P, R])rSr rboolr*)rr+rbrar/r,r.rkrrmrz$Optional[Callable[[Sequence], dict]]r-rarrdrzOptional[Callable[..., dict]]rrdrz8Callable[[Callable[P, R]], SupportsLangsmithExtra[P, R]])rrrJrrz/Union[Callable, Callable[[Callable], Callable]])r-rarra)rXr rr#rr)rrHr}r`rrH)r}r`rzOptional[dict]rrhr-) rSr rrr}rrrrJrrr)rzinspect.SignaturerrrJrrr)]rt __future__rr contextlib contextvarsrrQr\r|r~rErtypingrrrrr r r r r rrrrrrrrrrrrtyping_extensionsrr langsmithrrrrlangsmith._internalr r langsmith.envr!typesr"rSr# getLoggerrqr ContextVarrr$rr'r(r)rr*r1rur7r=rAcontextmanagerrLget_run_tree_contextrVrYr^r`rwryr{rXrrrZrrrrrnrHrrOrrr4r5r6rs7" $03)&4&#1   8 $F;))(93D3D*EF6 &&x}5otT 3 xS 23GTJ B C" C  C* C  C ' C4 C  C5 C3 C< C> C  CC CC5CLM7M7` p+j !)5 ! ;iu ;""%)B"B B #B B2"/#/ /!/j15 A A$A.A  A  A  AH; ),8;(0 0),08;00r5