o +i8%@sUdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z mZmZmZmZmZddlmZddlmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#ddl$m%Z%m&Z&m'Z'm(Z(ddl)m*m+Z+ddl,m-Z.dd l,m/Z/m0Z0m1Z1dd l2m3Z4dd l5m6Z6dd l7m8Z8erdd l9m:Z:ddl;mZ?e+j@e+jAe+jBe+jCe+jDe+jEe/jFe/jGdZHdeId<dZJdaKdeId<dddZLdddZM ddd!d"ZNejOddddddddd#dd4d5ZPeLZQdd8d9ZRdddddddddd: ddGdHZSddKdLZTGdMdNdNedOdPZUedQdRdSZVe%dTZWe#GdUdVdVeeeWeVfZXddWdd]d^ZYe"dd_d`ZZe" addddddddddddOdb ddhd`ZZddkd`ZZGdldmdmZ[ddndoZ\ddrdsZ]hdtZ^GdudvdvedOdPZ_GdwdxdxedOdPZ`  ddd}d~ZadddZb ddddZc   ddddZd   ddddZedddZfdddZgdddZhddddZi ddddZjejkdd ddddZl ddddZmdddddZnddddZo ddddZpdddddZqedZrGdddeerZsGdddeseerZtGdddeseerZuddd„ZvdddƄZwdddȄZxdddʄZye+jAZAe+jBZBe+jCZCe+jDZDe+jEZEe+j@Z@dS)z1Decorator for creating a run tree from functions.) annotationsN)AsyncGenerator AsyncIterator Awaitable GeneratorIteratorMappingSequence) copy_context) TYPE_CHECKING AnnotatedAnyCallableGenericLiteralOptionalProtocol TypedDictTypeVarUnioncastget_type_hintsoverloadruntime_checkable) ParamSpec TypeGuardget_args get_originclient) run_treesschemasutils)_aiter) _runtime_env) WriteReplica) TracebackType)Runnableparent project_nametagsmetadataenabledrreplicasdistributed_parent_idz!dict[str, contextvars.ContextVar] _CONTEXT_KEYSzlangsmith/run_helpers.pyOptional[bool]_OTEL_AVAILABLEreturnOptional[run_trees.RunTree]cCs tjS)zGet the current run tree.)_context_PARENT_RUN_TREEgetr8r8R/var/www/html/psymed-ai/venv/lib/python3.10/site-packages/langsmith/run_helpers.pyget_current_run_treeHs r:r,r NonecKs,t}|durtddS|j|dS)z(Update metadata on the current run tree.NzFNo active run tree found. Call `set_run_metadata` inside a traced run.)r:LOGGERwarningr,update)r,run_treer8r8r9set_run_metadataMs r@contextOptional[contextvars.Context]dict[str, Any]c sddur'tjtjtjtjtjtjtj tj dSfddt DS)z Get the current tracing context.Nr(csi|] \}}||qSr8r7.0kvrAr8r9 hsz'get_tracing_context..) r5r6r7 _PROJECT_NAME_TAGS _METADATA_TRACING_ENABLED_CLIENTr _REPLICAS_DISTRIBUTED_PARENT_IDr0itemsrIr8rIr9get_tracing_contextYs rS)r*r+r,r)r-rr.r/r* Optional[str]r+Optional[list[str]]Optional[dict[str, Any]]r)@Optional[Union[run_trees.RunTree, Mapping, str, Literal[False]]]r-'Optional[Union[bool, Literal['local']]]rOptional[ls_client.Client]r. Optional[Sequence[WriteReplica]]r/kwargsGenerator[None, None, None]c ks|r td|dtt} |durtd|p|dind} |} | durF| durFtt|p0gt| jp6gB}i| j |pAi}| j } |durL|n| d}t | ||||||| dz dVWt | dSt | w) aSet the tracing context for a block of code. Args: project_name: The name of the project to log the run to. tags: The tags to add to the run. metadata: The metadata to add to the run. 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. client: The client to use for logging the run to LangSmith. enabled: Whether tracing is enabled. Defaults to `None`, meaning it will use the current context value or environment variables. replicas: A sequence of `WriteReplica` dictionaries to send runs to. Example: `[{"api_url": "https://api.example.com", "api_key": "key", "project_name": "proj"}]` or `[{"project_name": "my_experiment", "updates": {"reference_example_id": None}}]` distributed_parent_id: The distributed parent ID for distributed tracing. Defaults to None. z Unrecognized keyword arguments: .Fr) parent_runNr-r() warningswarnDeprecationWarningrS_get_parent_runr7sortedsetr+r,id_set_tracing_context) r*r+r,r)r-rr.r/r[current_contextr^distributed_parent_id_to_user8r8r9tracing_contextks>!  rifunc'TypeGuard[SupportsLangsmithExtra[P, R]]cCs2t|pt|tjot|jpt|dot|jS)z.Check if a function is `@traceable` decorated.__call__)_is_traceable_function isinstance functoolspartialrjhasattrrlrjr8r8r9is_traceable_functions rs namer,r+r reduce_fnr*process_inputsprocess_outputs process_chunkCallable[P, R]ruOptional[Mapping[str, Any]]rv0Optional[Callable[[Sequence], Union[dict, str]]]rw Optional[Callable[[dict], dict]]rxOptional[Callable[..., dict]]ryOptional[Callable]SupportsLangsmithExtra[P, R]c Cs*t|r|St||||||||| d |S)z$Ensure that a function is traceable.rt)rs traceable) rjrur,r+rrvr*rwrxryr8r8r9ensure_traceables rrboolcCs t|pt|dot|jS)z;Inspect function or wrapped function to see if it is async. __wrapped__)inspectiscoroutinefunctionrqrrrr8r8r9is_asyncs rc@seZdZUdZded< ded< ded< ded < d ed < ded < d ed< ded< ded< ded< ded<ded<dS)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"})) ``` !!! example "Streaming data with a generator" ```python @traceable def my_generator(n: int) -> Iterable: for i in range(n): yield i for item in my_generator(5): print(item) ``` !!! example "Async streaming data" ```python @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()) ``` !!! example "Specifying a run type and name" ```python @traceable(name="CustomName", run_type="tool") def another_function(a: float, b: float) -> float: return a * b another_function(5, 6) ``` !!! example "Logging with custom metadata and tags" ```python @traceable( metadata={"version": "1.0", "author": "John Doe"}, tags=["beta", "test"] ) def tagged_function(x): return x**2 tagged_function(5) ``` !!! example "Specifying a custom client and project name" ```python 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"}) ``` !!! example "Manually passing `langsmith_extra`" ```python @traceable def manual_extra_function(x): return x**2 manual_extra_function(5, langsmith_extra={"metadata": {"version": "1.0"}}) ``` rrNrzUnrecognized 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.rvrur,r+rr*rwryrrF) extra_outerrur,r+rr*rrwryinvocation_params_fnrrx)outputs_processorzHThe following keyword arguments are not recognized and will be ignored: r]rjrc st}|jdddu|jdddutdddfd d }tdddfd d}tdddfdd}tdddfdd}tdddfdd}tdddfdd}tr|}ntr|}ntrr|}n |}nr|}n|}t |ddt|} | jds| j gdd| j Dtj dtj j dddd| j Dd} | |_|S) Nr?configrrr rrr[r3c ss ddtjt|dIdH}zt}r$|dd<t|drgfdd}|rEtj||dd IdH}nXtd it |d|IdH}Wdn1sawYn6i}|r}tj||dd IdH}n td it |d |IdH}Wdn1swYWnt y}zt |t tj||d IdHd}~wwtj||d IdH|S) z"Async version of wrapper function.rNcontainer_inputrrr[new_runr?cs>iIdHWdS1swYdSrr8r8rrjr[otel_context_managerr8r9run_with_otel_context4s$zRtraceable..decorator..async_wrapper..run_with_otel_contextrArIerrorrr8) pop aitertools aio_to_thread _setup_runasyncio_accepts_context_maybe_create_otel_contextasyncio create_taskrirS BaseException_cleanup_tracebackshield) rrr[ run_containeraccepts_contextrfunction_resultfr_coroe) _on_run_endrrjfunc_accepts_configfunc_accepts_parent_runrr[rr9 async_wrappersj          z3traceable..decorator..async_wrapperrc ss |ddtjt|||dIdH}g}zsr"|d|d<t|d}|i|}t}t|rg|rGtj ||ddIdH}n t d it |d |IdH}Wdn1sbwYt |||dru|dj dknd||d |d 2z 3dHW}|Vq6Wn#ty} zt| ttj|| t|d IdHd} ~ wwtj|t|d IdHdS)Nrrrr?rArIllmFry) generatorr is_llm_runrresultsryrrrrr8)rrrrrrr iscoroutinerrrirS_process_async_iteratorrr7rrr_get_function_result) rrr[rrrasync_gen_resultritemrrrrjrrrvr8r9async_generator_wrapperZsz         z=traceable..decorator..async_generator_wrapperc ssddt|d}tjdddu}z1|r&|dd<t|dr?fdd}|d|}n|djgRi}Wntye}z t |||d d}~ww||d |S) >Create a new run or create_child() if run is passed in kwargs.rNrr?rcs6iWdS1swYdSrr8r8rr8r9rs $zLtraceable..decorator..wrapper..run_with_otel_contextrArr) rrr signature parametersr7rrunrr)rrr[rrrrr)rrrjrrr9wrappersL    z-traceable..decorator..wrapperc ?ss |ddt|||d}tjdddu}g}d}z9|r+|d|d<|djg|Ri|}t|d}t||dk|d|dEdH}|durZ| |Wnt yv} zt | || t |d d} ~ ww|t |d |S) Nrrr?rrArry)rrryrrr) rrrrrr7rr_process_iteratorappendrrr) rrr[rrrfunction_returngenerator_resultrr)rrrjrrvrr8r9generator_wrappersX    z7traceable..decorator..generator_wrapperc ss|ddt|||d}zr|d|d<|djg|Ri|}Wnty@}z t|||dd}~wwt|drLt||St|drWt||S||d |S) Nrrrr?rAr__iter__ __aiter__r)rrr Exceptionrrq _TracedStream_TracedAsyncStreamrrr[trace_containerstreamrrr8r9stream_wrappers2         z4traceable..decorator..stream_wrapperc ss |ddtjt|||dIdH}zr |d|d<|i|IdH}WntyC}z tj||dIdHd}~wwt|drOt||St|drZt||Stj||dIdH|S) Nrrrr?rrrr)rrrrrrqrrrrr8r9async_stream_wrapper)s4        z:traceable..decorator..async_stream_wrapper__langsmith_traceable__Tcss"|] }|jtjjkr|VqdSrkindr Parameter VAR_KEYWORDrFparamr8r8r9 ]z/traceable..decorator..)defaultcss"|] }|jtjjkr|VqdSrrrr8r8r9rer)r)rr rrr[r r3r )rr rrr[r r3r)rrrr7rowrapsisasyncgenfunctionisgeneratorfunctionrsetattrreplacevaluesr KEYWORD_ONLY __signature__) rjfunc_sigrrrrrrselected_wrappersigrrrvr)rjrrr9 decoratorsh AG-7        ztraceable..decorator)rjr)r ls_client RUN_TYPE_Trnstrr_VALID_RUN_TYPESr_r`lenra_ContainerInputrorp_handle_container_endrckeyscallable)rr[rr r8r r9r>sp!                ` c @seZdZdZ d6dddddddddddd d7dd Zd8d#d$Zd9d,d-Zd8d.d/Z   d:d9d0d1Zd8d2d3Z   d:d9d4d5Z dS);traceaManage a LangSmith run in context. This class can be used as both a synchronous and asynchronous context manager. Args: name: Name of the run. run_type: Type of run (e.g., `'chain'`, `'llm'`, `'tool'`). inputs: Initial input data for the run. project_name: Project name to associate the run with. parent: Parent run. Can be a `RunTree`, dotted order string, or tracing headers. tags: List of tags for the run. metadata: Additional metadata for the run. client: LangSmith client for custom settings. run_id: Preset identifier for the run. reference_example_id: Associates run with a dataset example. Only for root runs in evaluation. exceptions_to_handle: Exception types to ignore. extra: Extra data to send to LangSmith. Use 'metadata' instead. Examples: Synchronous usage: ```python with trace("My Operation", run_type="tool", tags=["important"]) as run: result = "foo" # Perform operation run.metadata["some-key"] = "some-value" run.end(outputs={"result": result}) ``` Asynchronous usage: ```python async def main(): async with trace("Async Operation", run_type="tool", tags=["async"]) as run: result = "foo" # Await 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()) ``` Handling specific exceptions: ```python import pytest import sys with trace("Test", exceptions_to_handle=(pytest.skip.Exception,)): if sys.platform == "win32": # Just an example pytest.skip("Skipping test for windows") result = "foo" # Perform test operation ``` rN) inputsrr*r)r+r,rrrexceptions_to_handle attachmentsrurrrrrrr*rTr)COptional[Union[run_trees.RunTree, str, Mapping, Literal['ignore']]]r+rUr,r{rrYrrrr)Optional[tuple[type[BaseException], ...]]rOptional[schemas.Attachments]r[r c Ks|dd|_|rtdt|dt||_||_||_ | |_ ||_ ||_ ||_ |d|_||_||_| |_| |_| |_| |_d|_d|_dS)z_Initialize the trace context manager. Warns if unsupported kwargs are passed. _end_on_exitTzEThe `trace` context manager no longer supports the following kwargs: r]r?N)rrr_r`rcrrarurrrrr*r)r7r?r+r,rrrrrold_ctx)rrurrrr*r)r+r,rrrrrr[r8r8r9__init__s0   ztrace.__init__r3rc Cst|_t|j}tjptj}tjptj }|j p"|jd}t |j |j ||jd}tt|jp5g|p8g}i|jpAi|pEiddi}|jpOi}||d<t|j} |durr|rr|j|j|j|j||j||jd|_n(tj|jt|jtj|j dd |j|| pd tj!|jpi|||jpid |_|dur|j"|rtj|tj|tj#|jtj$| tj%||jS) 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)r)r?rr* ls_methodrr,N)rurrrrr+rT accept_nullr) rurerrrr*r.rr+rr)&rSrr"tracing_is_enabledr5rLr7 _GLOBAL_TAGSrM_GLOBAL_METADATArrbr)r?r*rcrdr+r,r_get_project_name create_childrurrrrrr RunTreer  _ensure_uuidrrPpostr6rKrO) rr- outer_tagsouter_metadataclient_ parent_run_tags_r,r project_name_r8r8r9_setupsr             z trace._setupexc_typeOptional[type[BaseException]] exc_valueOptional[BaseException] tracebackOptional[TracebackType]r;cCs|jdurdS|dur-|jrt||jrd}nt}|jd|d|}|jj|d|jdurKt|j}|durD|j rD|j t |jdSt dtdS)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:  rTz(Tracing context was not set up properly.)rr issubclassr" _format_excrendrr#rpatchrfr_r`RuntimeWarning)rr2r4r6tbr-r8r8r9 _teardown3s    ztrace._teardowncCs|S)zyEnter the context manager synchronously. Returns: run_trees.RunTree: The newly created run. )r1rr8r8r9 __enter__Wsztrace.__enter__cCs||||dS)aExit the context manager synchronously. 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)r@)rr2r4r6r8r8r9__exit___s ztrace.__exit__cs.t}tj|j|dIdH}tt||S)zzEnter the context manager asynchronously. Returns: run_trees.RunTree: The newly created run. __ctxN)r rrr1rfrS)rctxresultr8r8r9 __aenter__ns  ztrace.__aenter__c s`t}|durttj|j||||dIdHntj|j||||dIdHtt|dS)aExit the context manager asynchronously. 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. NrD)r rrrrr@rfrS)rr2r4r6rFr8r8r9 __aexit__zs     ztrace.__aexit__r)rurrrrrrrr*rTr)rr+rUr,r{rrYrrrrrrrrr[r )r3r)r2r3r4r5r6r7r3r;NNN) rrrrrr1r@rBrCrHrIr8r8r8r9rws8A 2 K $  rcCs6|r|St}tjp|r|jndptjptSr)r6r7r5rK session_name_GLOBAL_PROJECT_NAMEr"get_tracer_project)r*prtr8r8r9r&s  r& traceable_fnr'c szddlmm}ddlmmWnty#}ztd|d}~wwt|sEzt |}Wn t y:d}Ynwt d|d|Gfd d d |}||S) aConvert a function wrapped by the LangSmith `@traceable` decorator to a `Runnable`. Args: traceable_fn: The function wrapped by the `@traceable` decorator. Returns: Runnable: A `Runnable` object that maintains a consistent LangSmith tracing context. Raises: ImportError: If `langchain` module is not installed. ValueError: If the provided function is not wrapped by the `@traceable` decorator. Example: >>> @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: csVeZdZdZ ddfd d Zedfd d Zedfdd ZZS)z&as_runnable..RunnableTraceablezConverts a `@traceable` decorated function to a `Runnable`. This helps maintain a consistent LangSmith tracing context. Nrjrafunc*Optional[Callable[..., Awaitable[Output]]]r3r;c sd}||}t|r!|durtdttgf||}nt|r2ttgf||}|durAt|jj d|t |tt tgt f|dS)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 TypeErrorrrrs _wrap_sync ValueError __class__rsuperrrr)rrjrUwrappedawrapped)rSrTr[r8r9rs.  z/as_runnable..RunnableTraceable.__init__Callable[..., Output])Callable[[Input, RunnableConfig], Output]cs$d fdd }ttgf|S) z4Wrap a synchronous function to make it asynchronous.rdictrrQr3r cs,tjtt|}di|dd|iiSNrr?r8r r(from_runnable_configrrarrr?rrr8r9wrap_traceableszIas_runnable..RunnableTraceable._wrap_sync..wrap_traceableNrrarrQr3r )rr)rjrfrSrTrQrrr9rYsz1as_runnable..RunnableTraceable._wrap_sync>Optional[Callable[[Input, RunnableConfig], Awaitable[Output]]]cs`|durdSt|std|ttdtf|d fd d }ttgtf|S) z.Wrap an async function to make it synchronous.NzXRunnableTraceable expects a function wrapped by the LangSmith @traceable decorator. Got .rrarrQr3r cs4tjtt|}di|dd|iiIdHSrbrcreafunc_r8r9awrap_traceable s zKas_runnable..RunnableTraceable._wrap_async..awrap_traceablerg)rsrZrrr)rUrlrhrjr9rWsz2as_runnable..RunnableTraceable._wrap_asyncr)rjrrUrVr3r;)rjr_r3r`)rUrVr3ri) rrrrr staticmethodrYrW __classcell__r8rhr[r9RunnableTraceables  rp) langchain_core.runnablesrQrRlangchain_core.runnables.utilsrSrT ImportErrorrsr getsourcerrZ)rPrRrfn_srcrpr8rhr9 as_runnables4 Irv>rtoolrparserprompt embedding retrieverc@sZeZdZUdZded<ded<ded<ded<d ed <d ed <d ed <ded<ded<dS)_TraceableContainer3Typed response when initializing a run a traceable.r4rrTr* outer_projectrVr,rUr+rrrzcontextvars.ContextrAr1_token_event_loggedNrr8r8r8r9r|#s  r|c@sreZdZUdZded<ded<ded<ded <d ed <d ed <ded<ded<ded<d ed<ded<ded<dS)rr}rrrTrurVr,rUr+rYrrrvr*rrr}rwryrr1rNrr8r8r8r9r1s  r container Optional[Any]rr5c Cs|d}|dur dSt|tr|}nD|durSt|drSt|jrSt|tsSz |jddd}Wn'tyR}zt dt|d|d |i}WYd}~n d}~wwd |i}t ||d }durf||j d <|rvt }t|d |}n.d}|d } rt| rz| |Wnty}ztd|WYd}~nd}~ww|j||dt dur||d} rt| rz| |WdSty}ztd|WYd}~dSd}~wwdSdS)z End the run.rN model_dumpTjson) exclude_nonemodez&Failed to use model_dump to serialize z to JSON: output)r?rrr9rz$Failed to run _on_success function: rrrzFailed to run on_end function: )r7rnrarqrrtyperr<debugrr,r"r;reprrr_r`r<r#r=) rrrr? dict_outputsrusage stacktrace error_reprrrr8r8r9_container_endBs\     rrrarcCs(|dd}|ri||}|S|}|S)NrrD)rrr extra_innerr8r8r9_collect_extrats  rrcCs|d}|dkr dSt|tjr|St|tr)tjj||dt|ddSt|trAtjj||dt|dd}|S|d}|rJ|St }t durstjj ||dd}rs|rq|durk|dsq|j |j krs|S|S) Nr)ignorerr*)rr*r?r callbacks)r7rnr r(r from_headersr&rfrom_dotted_orderr:r$get_langchain_core_versionrd dotted_order)rrr)dortr?crtrtr8r8r9rb}s@           rbrrc$ Cs|dpi}|d}|d}|d}|dpd} |dd} tj} |p,t}|d p6|d } |d|pAtj} ti|d| i|d }tj}|pm|r\|jnd pm|d pm|d pmtjpmt }|d }|d}|st st t j dtd || d d |d|dtdd St|}| pt|}t||}tjptj}tjptj}t}i|dpi|pi}|tjj|||pid|d<||d<t|g|Rd|i|\}}|d}|r2zdd||D}|rt|tr||Wnty1}zt !d|d|WYd }~nd }~ww|d}|r_z||}Wnty^}zt !d|d|WYd }~nd }~ww|dpfg|pjg} |tjj| | |pyg7} |d ur|j"|| || |||d}!n-||| t#j$|dd|t%j&|| | || d }"|d urt#$||"d!<t%j'd%it(t)|"}!t durz|!*Wnty}zt !d"|!j+d|WYd }~nd }~wwt|!|| |||d|d|dd# }#|tjj|#d |t,j|#d$|#S)&rrr,r+rrrrFrurNr*rrz>LangSmith tracing is not enabled, returning original function.rr) rr*r~r,r+rrrArrr rjrcSsi|] \}}|dur||qSrr8rEr8r8r9rJsz_setup_run..z&Failed to infer invocation params for r8rwzFailed to filter inputs for )rurrr+rrrTr!) rurrrr*r.rr+rrrrezFailed to post run ) rr*r~r,r+rrrArrr8)-r7r5rKrrOrbrLrMr"rNr#log_onceloggingDEBUGr|r rr_get_function_namerrMr%rLr$rrdr> _get_inputs_and_attachments_saferRrnrarr<rr'r r)r rPr(rr r*rer6)$rjrrrr[rr,r+rrrr~rur-r. project_cvselected_projectrid_rname_rr,r+rA metadata_rrrinvocation_paramsrrwr/rrun_tree_kwargsresponse_containerr8r8r9rs               "  "    $ rrc Cs`z|dur ||}t|||dWdSty/}ztdt|WYd}~dSd}~ww)zHandle the end of run.Nrz!Unable to process trace outputs: )rrr<r=r)rrrrrr8r8r9r=s"rcCs t|ddS)NrF)getattrrrr8r8r9rmL rmrinspect.SignaturecOs|j|i|}|t|j}|dd|dd|jD]\}}|jtj j kr=||vr=| ||||q"|S)z:Return a dictionary of inputs from the function signature.rNcls) bind_partialapply_defaultsra argumentsrrrRrrrrr>)rrr[boundr param_namerr8r8r9 _get_inputsPs    rc Os^z t|g|Ri|WSty.}ztd|d|||dWYd}~Sd}~wwNzFailed to get inputs for r8)rr[)rrr<r)rrr[rr8r8r9_get_inputs_safedsrrinspect.Parameterc Cs|jtjkst|jtkrtddt|jDrdS|dur]t|jtr]z*t |dd}| |j }|durM|tjkpKt|tkoKtddt|DWSWdSt t tfy\YdSwdS)Ncs|]}|tjkVqdSrr! AttachmentrFargr8r8r9rqsz!_is_attachment..T)include_extrascsrrrrr8r8r9r~s  F) annotationr!rrr anyrrnrrr7ru NameErrorrXAttributeError)rrj type_hintsresolved_annotationr8r8r9_is_attachmentns.      rset[str]csfdd|jDS)Ncsh|] \}}t|r|qSr8)r)rFrurrrr8r9 s z*_attachment_args_helper..)rrRrrjr8rrr9_attachment_args_helpers ri)maxsizecCs t||Sr)rrr8r8r9_cached_attachment_argss rcCs*zt||WStyt||YSwr)rrXrrr8r8r9_attachment_argss   rrr tuple[dict, schemas.Attachments]c Osz7t|g|Ri|}t||}|r3ii}}|D]\}} ||vr)| ||<q| ||<q||fWS|ifWSty[} ztd|d| ||difWYd} ~ Sd} ~ wwr)rrrRrr<r=) rrjrr[inferredattachment_argsrrrGrHrr8r8r9rs       rcCsP|durtD] \}}|dqdS|D] \}}t|}||qdS)zSet the tracing context.N)r0rRrd)rArGrHvarr8r8r9rfs  rfr Iterator[T]rrr list[Any]rGenerator[T, None, Any]c #szP |rfdd}d|}ndt}|r#||}n|}|rIdrIdsIddtjtjjd|id dd<| ||Vqt yf} z | j WYd} ~ Sd} ~ ww) NTcsNd}|r#t|}|r#| tWdS1swYtSNr)r7rnextr?fresh_otel_contextrrr8r9next_with_otel_contexts  z1_process_iterator..next_with_otel_contextrArr new_tokentokenrutimer[) rrr7 add_eventdatetimenowtimezoneutc isoformatr StopIterationvalue) rrrrryrrr traced_itemrr8rr9rsB    %r)rAsyncIterator[T]rAsyncGenerator[T, None]c sfz |r>fdd}|rtj|ddIdH}nWtd itd|IdH}Wdn1s8wYn5|rPtjtddIdH}n#td itdtIdH}Wdn1snwY|rz||} n|} |rdrdsddtj tj j  d | id dd<| | |VqtyYdSw) NTcs`d}|r(t|}|r(|tIdHWdS1s#wYtIdHSr)r7rrpy_anextrrr8r9anext_with_otel_contexts  z8_process_async_iterator..anext_with_otel_contextrArIrrrrrr8)rrrirSrrr7rrrrrrrStopAsyncIteration) rrrrrryrrrrr8rr9rsf       9rTc@sTeZdZdZ ddd d Zdd dZddZddZddZddZ ddddZ dS)_TracedStreamBasez%Base class for traced stream objects.Nr$Union[Iterator[T], AsyncIterator[T]]rr|rvrcCsD||_||_d|_||_g|_|dr|djdk|_dSd|_dS)NFrr) __ls_stream____ls_trace_container____ls_completed____ls_reduce_fn____ls_accumulated_output__r__is_llm_run__)rrrrvr8r8r9rGsz_TracedStreamBase.__init__rurcCs t|j|Sr)rr)rrur8r8r9 __getattr__Xrz_TracedStreamBase.__getattr__cCsttt|jt|jSr)listrddirr[rrAr8r8r9__dir__[sz_TracedStreamBase.__dir__cCsd|jdS)Nz Traceable())rrAr8r8r9__repr__^sz_TracedStreamBase.__repr__cCs t|jSr)rrrAr8r8r9__str__as z_TracedStreamBase.__str__cCsLz |js|Wn tyYnwz|jWdSty%YdSwr)r _end_tracerr__del__rAr8r8r9rds  z_TracedStreamBase.__del__rr5cCsJ|jrdSz|jr||j}n|j}t|j||dWd|_dSd|_w)NrT)rrrrr)rrreduced_outputr8r8r9rosz_TracedStreamBase._end_tracer)rrrr|rvr)rurrr5) rrrrrrrrrrrr8r8r8r9rDs  rcsLeZdZdZ  ddfd d ZdddZdddZddZddZZ S)rz>A wrapper for synchronous stream objects that handles tracing.Nrrrr|rvrrycs8tj|||d||_t|j|j|j|j|d|_dS)Nrrrv)rrry)r\rrrrrr __ls__gen__rrrrvryror8r9rs z_TracedStream.__init__r3rcCs&zt|jWSty|wr)rrrrrAr8r8r9__next__s   z_TracedStream.__next__c csNz|jEdHWnty }z t||j|dd}~ww|dSNr)rrrr)rrr8r8r9rs  z_TracedStream.__iter__cCs|j|Sr)rrBrAr8r8r9rBs z_TracedStream.__enter__c CsJz|j|||W|j|r|dSddS|j|r |dwddwr)rrCrrr2exc_valexc_tbr8r8r9rCs8z_TracedStream.__exit__NN)rrrr|rvrryrr3r)r3r) rrrrrrrrBrCrnr8r8ror9rs   rcsXeZdZdZ  ddfd d ZddddZdddZdddZddZddZ Z S) rz?A wrapper for asynchronous stream objects that handles tracing.Nrrrr|rvrrycs>tj|||d||_t|j|j|jt|j|d|_ dS)Nr)rrrrrry) r\rrrrrrrr_TracedAsyncStream__ls_genrror8r9rs z_TracedAsyncStream.__init__rr5cs6t}ttj|j||dIdHtt|dS)NrD)r rrrrrrfrS)rrrFr8r8r9 _aend_traces  z_TracedAsyncStream._aend_tracer3rcs<z ttt|jIdHWSty|IdHwr)rrrrrrrrAr8r8r9 __anext__s z_TracedAsyncStream.__anext__cCsTz|j2z 3dHW}|Vq6Wnty |IdHw|IdHdSr)rrr)rrr8r8r9rs z_TracedAsyncStream.__aiter__cs|jIdH|Sr)rrHrAr8r8r9rHsz_TracedAsyncStream.__aenter__cs:z|j|||IdHW|IdHS|IdHwr)rrIrrr8r8r9rIs z_TracedAsyncStream.__aexit__r)rrrr|rvrryrrrr)r3r) rrrrrrrrrHrIrnr8r8ror9rs    rrc CsR|r'|dur%z||WSty$}z t||WYd}~Sd}~ww|SdSr)rr<r)rrvrr8r8r9rs  rrrcCsR|j}|r'|jdur"|jjjtr"|j}|jdur"|jjjts||_dSdSr) __traceback__tb_nexttb_framef_code co_filenameendswith_EXCLUDED_FRAME_FNAME)rtb_r8r8r9rs rcCs8tdurz ddl}daWtStydaYtSwtS)zCache for otel import check.NrTF)r2opentelemetry.tracers) opentelemetryr8r8r9_is_otel_availables rc Cs|rtds dStsdSddlm}m}m}m}m}ddl m }m }||j }||j } ||| d||j|d} || } || S)zCreate OpenTelemetry context manager if OTEL is enabled and available. Args: run_tree: The current run tree. Returns: Context manager for use_span or None if not available. OTEL_ENABLEDNr)NonRecordingSpan SpanContext TraceFlags TraceStateuse_span)get_otel_span_id_from_uuidget_otel_trace_id_from_uuidF)trace_idspan_id is_remote trace_flags trace_state)r"is_env_var_truishrrrrrrrlangsmith._internal._otel_utilsrrrreSAMPLED) r?rrrrrrrrr span_contextnon_recording_spanr8r8r9rs"   r)r3r4)r,r r3r;r)rArBr3rC)r*rTr+rUr,rVr)rWr-rXrrYr.rZr/rTr[r r3r\)rjr r3rk)rjrzrurTr,r{r+rUrrYrvr|r*rTrwr}rxr~ryrr3r)rjrr3r)r?rrrr[r r3r)rjrzr3rrJ)rrrurTr,r{r+rUrrYrvr|r*rTrwr}rxr~ryrrr}rrr3r)rr r[r r3r)r*rTr3rT)rPrr3r'r)rr|rrrr5r3r;)rrarrr3ra)rrrrr3r4rK) rjrrrrrrr r[r r3r|) rr|rrrr5rr~r3r;)rjr r3r)rrrr r[r r3rC)rrrjrr3r)rrrjrr3r) rrrr rjrr[r r3r)rArV)rrrr|rrrrryrrrr3r)rrrr|rrrrrrryrrrr3r)rrrvrr3r )rr)r3r)r?r4)zr __future__rr contextlib contextvarsrrorrr_collections.abcrrrrrrr r typingr r r rrrrrrrrrrrrtyping_extensionsrrrrlangsmith._internal._context _internalr5 langsmithrr r r!r"langsmith._internalr#r langsmith.envr$langsmith.run_treesr%typesr&rqr' getLoggerrr<r6rKrLrMrNrOrPrQr0rrr2r:r@rScontextmanagerriget_run_tree_contextrsrrrrrrrrrr&rvrr|rrrrbrrrmrrrr lru_cacherrrrfrrrrrrrrrrr8r8r8r9s$ $ D           F      = t  2 7          ;H<4 < +