uipath-langchain 0.0.89__py3-none-any.whl → 0.0.91__py3-none-any.whl

uipath_langchain/_cli/_runtime/_input.py

@@ -58,10 +58,12 @@ class LangGraphInputProcessor:
         if not trigger:
             return Command(resume=self.context.input_json)
 
-        type, key = trigger
+        type, key, folder_path, folder_key, payload = trigger
         logger.debug(f"ResumeTrigger: {type} {key}")
         if type == UiPathResumeTriggerType.ACTION.value and key:
-            action = self.uipath.actions.retrieve(key)
+            action = await self.uipath.actions.retrieve_async(
+                key, app_folder_key=folder_key, app_folder_path=folder_path
+            )
             logger.debug(f"Action: {action}")
             if action.data is None:
                 return Command(resume={})
@@ -95,7 +97,7 @@ class LangGraphInputProcessor:
                 return Command(resume=try_convert_to_json_format(job.output_arguments))
         return Command(resume=self.context.input_json)
 
-    async def _get_latest_trigger(self) -> Optional[tuple[str, str]]:
+    async def _get_latest_trigger(self) -> Optional[tuple[str, str, str, str, str]]:
         """Fetch the most recent trigger from the database."""
         if self.context.memory is None:
             return None
@@ -106,7 +108,7 @@ class LangGraphInputProcessor:
                 self.context.memory.conn.cursor() as cur,
             ):
                 await cur.execute(f"""
-                    SELECT type, key
+                    SELECT type, key, folder_path, folder_key, payload
                     FROM {self.context.resume_triggers_table}
                     ORDER BY timestamp DESC
                     LIMIT 1
@@ -114,7 +116,7 @@ class LangGraphInputProcessor:
                 result = await cur.fetchone()
                 if result is None:
                     return None
-                return cast(tuple[str, str], tuple(result))
+                return cast(tuple[str, str, str, str, str], tuple(result))
         except Exception as e:
             raise LangGraphRuntimeError(
                 "DB_QUERY_FAILED",

uipath_langchain/_cli/_runtime/_output.py

@@ -232,6 +232,9 @@ class LangGraphOutputProcessor:
                             id INTEGER PRIMARY KEY AUTOINCREMENT,
                             type TEXT NOT NULL,
                             key TEXT,
+                            folder_key TEXT,
+                            folder_path TEXT,
+                            payload TEXT,
                             timestamp DATETIME DEFAULT (strftime('%Y-%m-%d %H:%M:%S', 'now', 'utc'))
                         )
                     """)
@@ -280,6 +283,12 @@ class LangGraphOutputProcessor:
                                     app_name=self.interrupt_value.app_name
                                     if self.interrupt_value.app_name
                                     else "",
+                                    app_folder_path=self.interrupt_value.app_folder_path
+                                    if self.interrupt_value.app_folder_path
+                                    else "",
+                                    app_folder_key=self.interrupt_value.app_folder_key
+                                    if self.interrupt_value.app_folder_key
+                                    else "",
                                     app_key=self.interrupt_value.app_key
                                     if self.interrupt_value.app_key
                                     else "",
@@ -295,11 +304,25 @@ class LangGraphOutputProcessor:
                                     self._resume_trigger = UiPathResumeTrigger(
                                         trigger_type=UiPathResumeTriggerType.ACTION,
                                         item_key=action.key,
+                                        payload=self.interrupt_value.model_dump_json(),
+                                        folder_path=self.interrupt_value.app_folder_path
+                                        if self.interrupt_value.app_folder_path
+                                        else None,
+                                        folder_key=self.interrupt_value.app_folder_key
+                                        if self.interrupt_value.app_folder_key
+                                        else None,
                                     )
                             elif isinstance(self.interrupt_value, WaitAction):
                                 self._resume_trigger = UiPathResumeTrigger(
                                     triggerType=UiPathResumeTriggerType.ACTION,
                                     itemKey=self.interrupt_value.action.key,
+                                    payload=self.interrupt_value.model_dump_json(),
+                                    folder_path=self.interrupt_value.app_folder_path
+                                    if self.interrupt_value.app_folder_path
+                                    else None,
+                                    folder_key=self.interrupt_value.app_folder_key
+                                    if self.interrupt_value.app_folder_key
+                                    else None,
                                 )
 
                 except Exception as e:
@@ -324,8 +347,14 @@ class LangGraphOutputProcessor:
                 try:
                     logger.debug(f"ResumeTrigger: {trigger_type} {trigger_key}")
                     await cur.execute(
-                        f"INSERT INTO {self.context.resume_triggers_table} (type, key) VALUES (?, ?)",
-                        (trigger_type, trigger_key),
+                        f"INSERT INTO {self.context.resume_triggers_table} (type, key, payload, folder_path, folder_key) VALUES (?, ?, ?, ?, ?)",
+                        (
+                            trigger_type,
+                            trigger_key,
+                            self.resume_trigger.payload,
+                            self.resume_trigger.folder_path,
+                            self.resume_trigger.folder_key,
+                        ),
                     )
                     await self.context.memory.conn.commit()
                 except Exception as e:

uipath_langchain/_cli/_runtime/_runtime.py

@@ -15,7 +15,7 @@ from uipath._cli._runtime._contracts import (
     UiPathRuntimeResult,
 )
 
-from ..._utils import _instrument_traceable
+from ..._utils import _instrument_traceable_attributes
 from ...tracers import AsyncUiPathTracer
 from ._context import LangGraphRuntimeContext
 from ._exception import LangGraphRuntimeError
@@ -45,7 +45,7 @@ class LangGraphRuntime(UiPathBaseRuntime):
         Raises:
             LangGraphRuntimeError: If execution fails
         """
-        _instrument_traceable()
+        _instrument_traceable_attributes()
 
         await self.validate()
 
@@ -94,6 +94,14 @@ class LangGraphRuntime(UiPathBaseRuntime):
                     "callbacks": callbacks,
                 }
 
+                recursion_limit = os.environ.get("LANGCHAIN_RECURSION_LIMIT", None)
+                max_concurrency = os.environ.get("LANGCHAIN_MAX_CONCURRENCY", None)
+
+                if recursion_limit is not None:
+                    graph_config["recursion_limit"] = int(recursion_limit)
+                if max_concurrency is not None:
+                    graph_config["max_concurrency"] = int(max_concurrency)
+
                 # Stream the output at debug time
                 if self.context.job_id is None:
                     # Get final chunk while streaming

uipath_langchain/_utils/__init__.py

@@ -1,4 +1,4 @@
-from ..tracers._instrument_traceable import _instrument_traceable
+from ..tracers._instrument_traceable import _instrument_traceable_attributes
 from ._request_mixin import UiPathRequestMixin
 
-__all__ = ["UiPathRequestMixin", "_instrument_traceable"]
+__all__ = ["UiPathRequestMixin", "_instrument_traceable_attributes"]

uipath_langchain/tracers/__init__.py

@@ -1,5 +1,5 @@
-from ._instrument_traceable import _instrument_traceable
+from ._instrument_traceable import _instrument_traceable_attributes
 from .AsyncUiPathTracer import AsyncUiPathTracer
 from .UiPathTracer import UiPathTracer
 
-__all__ = ["AsyncUiPathTracer", "UiPathTracer", "_instrument_traceable"]
+__all__ = ["AsyncUiPathTracer", "UiPathTracer", "_instrument_traceable_attributes"]

uipath_langchain/tracers/_instrument_traceable.py

@@ -4,9 +4,10 @@ import inspect
 import logging
 import sys
 import uuid
-from typing import Any, Dict, List, Literal, Optional
+from typing import Any, Callable, Dict, List, Literal, Optional
 
 from langchain_core.callbacks import dispatch_custom_event
+from uipath.tracing import TracedDecoratorRegistry
 
 from ._events import CustomTraceEvents, FunctionCallEventData
 
@@ -82,26 +83,228 @@ def format_args_for_trace(
         return {"args": args, "kwargs": kwargs}
 
 
-# Create patched version of traceable
-def patched_traceable(*decorator_args, **decorator_kwargs):
-    # Handle the case when @traceable is used directly as decorator without arguments
-    if (
-        len(decorator_args) == 1
-        and callable(decorator_args[0])
-        and not decorator_kwargs
-    ):
-        func = decorator_args[0]
-        return _create_appropriate_wrapper(func, original_traceable(func), {})
-
-    # Handle the case when @traceable(args) is used with parameters
-    original_decorated = original_traceable(*decorator_args, **decorator_kwargs)
+def _create_traced_wrapper(
+    func: Callable[..., Any],
+    wrapper_func: Optional[Callable[..., Any]] = None,
+    func_name: Optional[str] = None,
+    run_type: Optional[str] = None,
+    span_type: Optional[str] = None,
+    tags: Optional[List[str]] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    input_processor: Optional[Callable[..., Any]] = None,
+    output_processor: Optional[Callable[..., Any]] = None,
+):
+    """Create a traced wrapper based on function type."""
+    # Use function name if not provided
+    actual_func_name = func_name or func.__name__
+    # Function to actually call (the wrapped function or original)
+    target_func = wrapper_func or func
+    # Ensure we have metadata
+    actual_metadata = metadata or {}
+
+    # Define all wrapper functions
+
+    @functools.wraps(target_func)
+    async def async_gen_wrapper(*args, **kwargs):
+        try:
+            call_uuid = str(uuid.uuid4())
+
+            # Get inputs and process them if needed
+            inputs = format_args_for_trace(inspect.signature(func), *args, **kwargs)
+            if input_processor is not None:
+                inputs = input_processor(inputs)
+
+            # Add span_type to metadata if provided
+            if span_type:
+                actual_metadata["span_type"] = (
+                    span_type or "function_call_generator_async"
+                )
 
-    def uipath_trace_decorator(func):
-        # Apply the original decorator with its arguments
-        wrapped_func = original_decorated(func)
-        return _create_appropriate_wrapper(func, wrapped_func, decorator_kwargs)
+            dispatch_trace_event(
+                actual_func_name,
+                inputs,
+                "call",
+                call_uuid,
+                run_type=run_type,  # type: ignore
+                tags=tags,
+                metadata=actual_metadata,
+            )
+
+            outputs = []
+            async_gen = target_func(*args, **kwargs)
+            async for item in async_gen:
+                outputs.append(item)
+                yield item
+
+            # Process output if needed
+            output_to_record = outputs
+            if output_processor is not None:
+                output_to_record = output_processor(outputs)
+
+            dispatch_trace_event(
+                actual_func_name,
+                inputs,
+                "completion",
+                call_uuid,
+                result=output_to_record,
+            )
+        except Exception as e:
+            dispatch_trace_event(
+                actual_func_name, inputs, "completion", call_uuid, exception=e
+            )
+            raise
+
+    @functools.wraps(target_func)
+    def gen_wrapper(*args, **kwargs):
+        try:
+            call_uuid = str(uuid.uuid4())
+
+            # Get inputs and process them if needed
+            inputs = format_args_for_trace(inspect.signature(func), *args, **kwargs)
+            if input_processor is not None:
+                inputs = input_processor(inputs)
+
+            # Add span_type to metadata if provided
+            if span_type:
+                actual_metadata["span_type"] = (
+                    span_type or "function_call_generator_sync"
+                )
 
-    return uipath_trace_decorator
+            dispatch_trace_event(
+                actual_func_name,
+                inputs,
+                "call",
+                call_uuid,
+                run_type=run_type,  # type: ignore
+                tags=tags,
+                metadata=actual_metadata,
+            )
+
+            outputs = []
+            gen = target_func(*args, **kwargs)
+            for item in gen:
+                outputs.append(item)
+                yield item
+
+            # Process output if needed
+            output_to_record = outputs
+            if output_processor is not None:
+                output_to_record = output_processor(outputs)
+
+            dispatch_trace_event(
+                actual_func_name,
+                inputs,
+                "completion",
+                call_uuid,
+                result=output_to_record,
+            )
+        except Exception as e:
+            dispatch_trace_event(
+                actual_func_name, inputs, "completion", call_uuid, exception=e
+            )
+            raise
+
+    @functools.wraps(target_func)
+    async def async_wrapper(*args, **kwargs):
+        try:
+            call_uuid = str(uuid.uuid4())
+
+            # Get inputs and process them if needed
+            inputs = format_args_for_trace(inspect.signature(func), *args, **kwargs)
+            if input_processor is not None:
+                inputs = input_processor(inputs)
+
+            # Add span_type to metadata if provided
+            if span_type:
+                actual_metadata["span_type"] = span_type or "function_call_async"
+
+            dispatch_trace_event(
+                actual_func_name,
+                inputs,
+                "call",
+                call_uuid,
+                run_type=run_type,  # type: ignore
+                tags=tags,
+                metadata=actual_metadata,
+            )
+
+            result = await target_func(*args, **kwargs)
+
+            # Process output if needed
+            output_to_record = result
+            if output_processor is not None:
+                output_to_record = output_processor(result)
+
+            dispatch_trace_event(
+                actual_func_name,
+                inputs,
+                "completion",
+                call_uuid,
+                result=output_to_record,
+            )
+
+            return result
+        except Exception as e:
+            dispatch_trace_event(
+                actual_func_name, inputs, "completion", call_uuid, exception=e
+            )
+            raise
+
+    @functools.wraps(target_func)
+    def sync_wrapper(*args, **kwargs):
+        try:
+            call_uuid = str(uuid.uuid4())
+
+            # Get inputs and process them if needed
+            inputs = format_args_for_trace(inspect.signature(func), *args, **kwargs)
+            if input_processor is not None:
+                inputs = input_processor(inputs)
+
+            # Add span_type to metadata if provided
+            if span_type:
+                actual_metadata["span_type"] = span_type or "function_call_sync"
+
+            dispatch_trace_event(
+                actual_func_name,
+                inputs,
+                "call",
+                call_uuid,
+                run_type=run_type,  # type: ignore
+                tags=tags,
+                metadata=actual_metadata,
+            )
+
+            result = target_func(*args, **kwargs)
+
+            # Process output if needed
+            output_to_record = result
+            if output_processor is not None:
+                output_to_record = output_processor(result)
+
+            dispatch_trace_event(
+                actual_func_name,
+                inputs,
+                "completion",
+                call_uuid,
+                result=output_to_record,
+            )
+
+            return result
+        except Exception as e:
+            dispatch_trace_event(
+                actual_func_name, inputs, "completion", call_uuid, exception=e
+            )
+            raise
+
+    # Return the appropriate wrapper based on the function type
+    if inspect.isasyncgenfunction(target_func):
+        return async_gen_wrapper
+    elif inspect.isgeneratorfunction(target_func):
+        return gen_wrapper
+    elif inspect.iscoroutinefunction(target_func):
+        return async_wrapper
+    else:
+        return sync_wrapper
 
 
 def _create_appropriate_wrapper(
@@ -115,154 +318,72 @@ def _create_appropriate_wrapper(
     metadata = decorator_kwargs.get("metadata", None)
     run_type = decorator_kwargs.get("run_type", None)
 
-    # Async generator function
-    if inspect.isasyncgenfunction(wrapped_func):
-
-        @functools.wraps(wrapped_func)
-        async def async_gen_wrapper(*args, **kwargs):
-            try:
-                call_uuid = str(uuid.uuid4())
-
-                inputs = format_args_for_trace(
-                    inspect.signature(original_func), *args, **kwargs
-                )
-
-                dispatch_trace_event(
-                    func_name,
-                    inputs,
-                    "call",
-                    call_uuid,
-                    run_type=run_type,
-                    tags=tags,
-                    metadata=metadata,
-                )
-                async_gen = wrapped_func(*args, **kwargs)
-
-                results = []
-
-                async for item in async_gen:
-                    results.append(item)
-                    yield item
-
-                dispatch_trace_event(
-                    func_name, inputs, "completion", call_uuid, results
-                )
-            except Exception as e:
-                dispatch_trace_event(
-                    func_name, inputs, "completion", call_uuid, exception=e
-                )
-                raise
-
-        return async_gen_wrapper
-
-    # Sync generator function
-    elif inspect.isgeneratorfunction(wrapped_func):
-
-        @functools.wraps(wrapped_func)
-        def gen_wrapper(*args, **kwargs):
-            try:
-                call_uuid = str(uuid.uuid4())
-
-                inputs = format_args_for_trace(
-                    inspect.signature(original_func), *args, **kwargs
-                )
-
-                results = []
-
-                dispatch_trace_event(
-                    func_name,
-                    inputs,
-                    "call",
-                    call_uuid,
-                    run_type=run_type,
-                    tags=tags,
-                    metadata=metadata,
-                )
-                gen = wrapped_func(*args, **kwargs)
-                for item in gen:
-                    results.append(item)
-                    yield item
-                dispatch_trace_event(
-                    func_name, inputs, "completion", call_uuid, results
-                )
-            except Exception as e:
-                dispatch_trace_event(
-                    func_name, inputs, "completion", call_uuid, exception=e
-                )
-                raise
-
-        return gen_wrapper
+    return _create_traced_wrapper(
+        func=original_func,
+        wrapper_func=wrapped_func,
+        func_name=func_name,
+        run_type=run_type,
+        tags=tags,
+        metadata=metadata,
+    )
 
-    # Async function
-    elif inspect.iscoroutinefunction(wrapped_func):
 
-        @functools.wraps(wrapped_func)
-        async def async_wrapper(*args, **kwargs):
-            try:
-                call_uuid = str(uuid.uuid4())
+def _uipath_traced(
+    run_type: Optional[str] = None,
+    span_type: Optional[str] = None,
+    input_processor: Optional[Callable[..., Any]] = None,
+    output_processor: Optional[Callable[..., Any]] = None,
+):
+    """Decorator factory that creates traced functions using dispatch_trace_event."""
+
+    def decorator(func):
+        return _create_traced_wrapper(
+            func=func,
+            run_type=run_type,
+            span_type=span_type,
+            input_processor=input_processor,
+            output_processor=output_processor,
+        )
 
-                inputs = format_args_for_trace(
-                    inspect.signature(original_func), *args, **kwargs
-                )
+    return decorator
 
-                dispatch_trace_event(
-                    func_name,
-                    inputs,
-                    "call",
-                    call_uuid,
-                    run_type=run_type,
-                    tags=tags,
-                    metadata=metadata,
-                )
-                result = await wrapped_func(*args, **kwargs)
-                dispatch_trace_event(func_name, inputs, "completion", call_uuid, result)
-                return result
-            except Exception as e:
-                dispatch_trace_event(
-                    func_name, inputs, "completion", call_uuid, exception=e
-                )
-                raise
 
-        return async_wrapper
+# Create patched version of traceable
+def patched_traceable(*decorator_args, **decorator_kwargs):
+    # Handle the case when @traceable is used directly as decorator without arguments
+    if (
+        len(decorator_args) == 1
+        and callable(decorator_args[0])
+        and not decorator_kwargs
+    ):
+        func = decorator_args[0]
+        return _create_appropriate_wrapper(func, original_traceable(func), {})
 
-    # Regular sync function (default case)
-    else:
+    # Handle the case when @traceable(args) is used with parameters
+    original_decorated = original_traceable(*decorator_args, **decorator_kwargs)
 
-        @functools.wraps(wrapped_func)
-        def sync_wrapper(*args, **kwargs):
-            try:
-                call_uuid = str(uuid.uuid4())
+    def uipath_trace_decorator(func):
+        # Apply the original decorator with its arguments
+        wrapped_func = original_decorated(func)
+        return _create_appropriate_wrapper(func, wrapped_func, decorator_kwargs)
 
-                inputs = format_args_for_trace(
-                    inspect.signature(original_func), *args, **kwargs
-                )
+    return uipath_trace_decorator
 
-                dispatch_trace_event(
-                    func_name,
-                    inputs,
-                    "call",
-                    call_uuid,
-                    run_type=run_type,
-                    tags=tags,
-                    metadata=metadata,
-                )
-                result = wrapped_func(*args, **kwargs)
-                dispatch_trace_event(func_name, inputs, "completion", call_uuid, result)
-                return result
-            except Exception as e:
-                dispatch_trace_event(
-                    func_name, inputs, "completion", call_uuid, exception=e
-                )
-                raise
 
-        return sync_wrapper
+# Register the UIPath traced decorator
+def register_uipath_tracing():
+    """Register the UIPath tracing decorator with TracedDecoratorRegistry."""
+    TracedDecoratorRegistry.register_decorator("uipath", _uipath_traced)
 
 
 # Apply the patch
-def _instrument_traceable():
+def _instrument_traceable_attributes():
     """Apply the patch to langsmith module at import time."""
     global original_langsmith, original_traceable
 
+    # Register our custom tracing decorator
+    register_uipath_tracing()
+
     # Import the original module if not already done
     if original_langsmith is None:
         # Temporarily remove our custom module from sys.modules

{uipath_langchain-0.0.89.dist-info → uipath_langchain-0.0.91.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-langchain
-Version: 0.0.89
+Version: 0.0.91
 Summary: UiPath Langchain
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-langchain-python
@@ -25,7 +25,7 @@ Requires-Dist: pydantic-settings>=2.6.0
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: requests>=2.23.3
 Requires-Dist: types-requests>=2.32.0.20241016
-Requires-Dist: uipath<2.1.0,>=2.0.7
+Requires-Dist: uipath<2.1.0,>=2.0.13
 Provides-Extra: langchain
 Description-Content-Type: text/markdown
 

{uipath_langchain-0.0.89.dist-info → uipath_langchain-0.0.91.dist-info}/RECORD

@@ -6,11 +6,11 @@ uipath_langchain/_cli/cli_run.py,sha256=zMn2P1gB1ogM8_EmZsIhqNpeI9Oc02Z5Gj-oni7e
 uipath_langchain/_cli/_runtime/_context.py,sha256=wr4aNn06ReIXmetEZ6b6AnpAt64p13anQ2trZ5Bzgio,807
 uipath_langchain/_cli/_runtime/_escalation.py,sha256=oA5NvZvCo8ngELFJRyhZNM69DxVHrshhMY6CUk_cukQ,8055
 uipath_langchain/_cli/_runtime/_exception.py,sha256=USKkLYkG-dzjX3fEiMMOHnVUpiXJs_xF0OQXCCOvbYM,546
-uipath_langchain/_cli/_runtime/_input.py,sha256=aaqU7ZiTwVmE1CgaiqgOtArr925bYr9c4CuWt1oC-jk,5418
-uipath_langchain/_cli/_runtime/_output.py,sha256=0SksiIoFxtfSvy7_VL49KwGD_ljs76SvFbn5B8O_Pls,14254
-uipath_langchain/_cli/_runtime/_runtime.py,sha256=P6VQtfQYot0c0wt-7BB8NjkQu39zWuGuZUcMYKk4I18,11387
+uipath_langchain/_cli/_runtime/_input.py,sha256=gKzPaGW-EzgeAskWJjbCWnfZRLu_BM7lCXkq0XkVGLU,5614
+uipath_langchain/_cli/_runtime/_output.py,sha256=WQSrsvGaaclZ6GLWEh6Nk1Mz1iGaIB45PgIX3DS3AN4,16130
+uipath_langchain/_cli/_runtime/_runtime.py,sha256=wj6e6tQdP2GjuSM-6G6Ug-FMqwOHwfUq-DGbd1gMfIg,11825
 uipath_langchain/_cli/_utils/_graph.py,sha256=WLBSJfPc3_C07SqJhePRe17JIc5wcBvEqLviMcNOdTA,6950
-uipath_langchain/_utils/__init__.py,sha256=Sp2qnEXLAp9ftQ09x7CZMenYnpXIIGFJNv8zNN7vAsw,172
+uipath_langchain/_utils/__init__.py,sha256=WoY66enCygRXTh6v5B1UrRcFCnQYuPJ8oqDkwomXzLc,194
 uipath_langchain/_utils/_request_mixin.py,sha256=t_1HWBxqEl-wsSk9ubmIM-8vs9BlNy4ZVBxtDxktn6U,18489
 uipath_langchain/_utils/_settings.py,sha256=MhwEVj4gVRSar0RBf2w2hTjO-5Qm-HpCuufqN3gSWjA,3390
 uipath_langchain/_utils/_sleep_policy.py,sha256=e9pHdjmcCj4CVoFM1jMyZFelH11YatsgWfpyrfXzKBQ,1251
@@ -24,17 +24,17 @@ uipath_langchain/retrievers/__init__.py,sha256=rOn7PyyHgZ4pMnXWPkGqmuBmx8eGuo-Oy
 uipath_langchain/retrievers/context_grounding_retriever.py,sha256=CeVSMEz5xTQIladkzDLeQXGC1_ycW72gb0RB41JZeYA,2000
 uipath_langchain/tracers/AsyncUiPathTracer.py,sha256=8eGWZ56iJcmhtRQU4cHuZYt6aJXqc8RB2OL_BCMp-Ow,10463
 uipath_langchain/tracers/UiPathTracer.py,sha256=V5g1nlB0TI1wYvUIkfCEcAdhy4thqeMBmjflWtxc-_M,5601
-uipath_langchain/tracers/__init__.py,sha256=8DeXfBFhu6IaqDRj_ffjRV01I8q5i_8wXbnhBZTwXnc,219
+uipath_langchain/tracers/__init__.py,sha256=eKTSVS7R7PMk9qtzn036gdFmxUQxfExnCprI073EPOg,241
 uipath_langchain/tracers/_events.py,sha256=CJri76SSdu7rGJIkXurJ2C5sQahfSK4E5UWwWYdEAtE,922
-uipath_langchain/tracers/_instrument_traceable.py,sha256=csPMKd-dk4jrnrxWyS177mLxUBKs-xZyj1tfRQgWrYE,9244
+uipath_langchain/tracers/_instrument_traceable.py,sha256=ouFefzXLjfEQFaBQOXSsYWkkJ8Nfv73MKhIZg4qalhw,13152
 uipath_langchain/tracers/_utils.py,sha256=JOT1tKMdvqjMDtj2WbmbOWMeMlTXBWavxWpogX7KlRA,1543
 uipath_langchain/utils/__init__.py,sha256=-w-4TD9ZnJDCpj4VIPXhJciukrmDJJbmnOFnhAkAaEU,81
 uipath_langchain/utils/_request_mixin.py,sha256=WFyTDyAthSci1DRwUwS21I3hLntD7HdVzYc0ZPoi3ys,18296
 uipath_langchain/utils/_settings.py,sha256=MhwEVj4gVRSar0RBf2w2hTjO-5Qm-HpCuufqN3gSWjA,3390
 uipath_langchain/utils/_sleep_policy.py,sha256=e9pHdjmcCj4CVoFM1jMyZFelH11YatsgWfpyrfXzKBQ,1251
 uipath_langchain/vectorstores/context_grounding_vectorstore.py,sha256=eTa5sX43-ydB1pj9VNHUPbB-hC36fZK_CGrNe5U2Nrw,9393
-uipath_langchain-0.0.89.dist-info/METADATA,sha256=ZHZswhIZpl3k73iZpuwlNa9tHCp5Y-AhqQAcRfsS9II,3818
-uipath_langchain-0.0.89.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath_langchain-0.0.89.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
-uipath_langchain-0.0.89.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
-uipath_langchain-0.0.89.dist-info/RECORD,,
+uipath_langchain-0.0.91.dist-info/METADATA,sha256=kmtrEsEsF9xA0UWzMG-tTCQJp4-uZUIOiWEltcmvuxA,3819
+uipath_langchain-0.0.91.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath_langchain-0.0.91.dist-info/entry_points.txt,sha256=FUtzqGOEntlJKMJIXhQUfT7ZTbQmGhke1iCmDWZaQZI,81
+uipath_langchain-0.0.91.dist-info/licenses/LICENSE,sha256=JDpt-uotAkHFmxpwxi6gwx6HQ25e-lG4U_Gzcvgp7JY,1063
+uipath_langchain-0.0.91.dist-info/RECORD,,