uipath 2.0.63__py3-none-any.whl → 2.0.64__py3-none-any.whl

uipath/_cli/_runtime/_escalation.py

@@ -0,0 +1,235 @@
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+from uipath import UiPath
+from uipath.models.actions import Action
+
+logger = logging.getLogger(__name__)
+
+
+class Escalation:
+    """Class to handle default escalation."""
+
+    def __init__(self, config_path: Union[str, Path] = "uipath.json"):
+        """Initialize the escalation with a config file path.
+
+        Args:
+            config_path: Path to the configuration file (string or Path object)
+        """
+        self.config_path = Path(config_path)
+        self._config = None
+        self._enabled = False
+        self._load_config()
+
+    def _load_config(self) -> None:
+        """Load and validate the default escalation from the config file.
+
+        If the 'defaultEscalation' section exists, validates required fields.
+        Raises error if required fields are missing.
+        """
+        try:
+            config_data = json.loads(self.config_path.read_text(encoding="utf-8"))
+            escalation_config = config_data.get("defaultEscalation")
+
+            if escalation_config:
+                required_fields = {"request", "title"}
+                missing_fields = [
+                    field for field in required_fields if field not in escalation_config
+                ]
+
+                if not any(key in escalation_config for key in ("appName", "appKey")):
+                    missing_fields.append("appName or appKey")
+
+                if missing_fields:
+                    raise ValueError(
+                        f"Missing required fields in configuration: {', '.join(missing_fields)}"
+                    )
+
+                self._config = escalation_config
+                self._enabled = True
+                logger.debug("Escalation configuration loaded successfully")
+            else:
+                self._enabled = False
+
+        except FileNotFoundError:
+            logger.debug(f"Config file not found: {self.config_path}")
+            self._enabled = False
+
+        except json.JSONDecodeError:
+            logger.warning(
+                f"Failed to parse config file {self.config_path}: Invalid JSON"
+            )
+            self._enabled = False
+
+        except ValueError as e:
+            logger.error(str(e))
+            raise
+
+        except Exception as e:
+            logger.error(f"Unexpected error loading config {self.config_path}: {e}")
+            self._enabled = False
+
+    @property
+    def enabled(self) -> bool:
+        """Check if escalation is enabled.
+
+        Returns:
+            True if configuration is valid and loaded
+        """
+        return self._enabled
+
+    def prepare_data(self, value: Any) -> Dict[str, Any]:
+        """Prepare action data by replacing $VALUE placeholders with the provided value.
+
+        Args:
+            value: The value to substitute into the template
+
+        Returns:
+            Prepared data dictionary with substitutions applied
+        """
+        if not self.enabled or not self._config:
+            return {}
+
+        template = self._config.get("request", {})
+
+        if isinstance(value, str):
+            try:
+                value_obj = json.loads(value)
+            except json.JSONDecodeError:
+                value_obj = value
+        else:
+            value_obj = value
+
+        return self._substitute_values(template, value_obj)
+
+    def _substitute_values(
+        self, template: Dict[str, Any], value: Any
+    ) -> Dict[str, Any]:
+        """Replace template placeholders with actual values.
+
+        Args:
+            template: Template dictionary containing placeholders
+            value: Values to substitute into the template
+
+        Returns:
+            Template with values substituted
+        """
+
+        def process_value(template_value):
+            if isinstance(template_value, dict):
+                return {k: process_value(v) for k, v in template_value.items()}
+            elif isinstance(template_value, list):
+                return [process_value(item) for item in template_value]
+            elif isinstance(template_value, str):
+                if template_value == "$VALUE":
+                    return value
+                elif template_value.startswith("$VALUE."):
+                    return self._resolve_value_path(template_value, value)
+
+            return template_value
+
+        return process_value(template)
+
+    def _resolve_value_path(self, path_expr: str, value: Any) -> Any:
+        """Resolve a dot-notation path expression against a value.
+
+        Args:
+            path_expr: Path expression (e.g. "$VALUE.user.name")
+            value: Value object to extract data from
+
+        Returns:
+            Extracted value or None if path doesn't exist
+        """
+        path_parts = path_expr.replace("$VALUE.", "").split(".")
+        current = value
+
+        for part in path_parts:
+            if not isinstance(current, dict) or part not in current:
+                return None
+            current = current.get(part)
+
+        return current
+
+    def extract_response_value(self, action_data: Dict[str, Any]) -> Any:
+        if not self._config:
+            return ""
+
+        response_template = self._config.get("response")
+        if not response_template:
+            return ""
+
+        for key, template_value in response_template.items():
+            if key in action_data:
+                extracted_value = None
+
+                if template_value == "$VALUE":
+                    extracted_value = action_data[key]
+                elif isinstance(template_value, str) and template_value.startswith(
+                    "$VALUE."
+                ):
+                    path_parts = template_value.replace("$VALUE.", "").split(".")
+                    current = action_data[key]
+
+                    valid_path = True
+                    for part in path_parts:
+                        if not isinstance(current, dict) or part not in current:
+                            valid_path = False
+                            break
+                        current = current.get(part)
+
+                    if valid_path:
+                        extracted_value = current
+
+                if extracted_value is not None:
+                    if isinstance(extracted_value, str):
+                        if extracted_value.lower() == "true":
+                            return True
+                        elif extracted_value.lower() == "false":
+                            return False
+
+                        try:
+                            if "." in extracted_value:
+                                return float(extracted_value)
+                            else:
+                                return int(extracted_value)
+                        except ValueError:
+                            pass
+
+                    return extracted_value
+
+        return action_data
+
+    async def create(self, value: Any) -> Optional[Action]:
+        """Create an escalation Action with the prepared data.
+
+        Args:
+            value: The dynamic value to be substituted into the template
+
+        Returns:
+            The created Action object or None if creation fails
+        """
+        if not self.enabled or not self._config:
+            return None
+
+        action_data = self.prepare_data(value)
+
+        if not action_data:
+            logger.warning("Action creation skipped: empty data after preparation")
+            return None
+
+        try:
+            uipath = UiPath()
+            action = uipath.actions.create(
+                title=self._config.get("title", "Default escalation"),
+                app_name=self._config.get("appName"),
+                app_key=self._config.get("appKey"),
+                app_version=self._config.get("appVersion", 1),
+                data=action_data,
+            )
+            logger.info(f"Action created successfully: {action.key}")
+            return action
+        except Exception as e:
+            logger.error(f"Error creating action: {e}")
+            return None

uipath/_cli/_runtime/_hitl.py

@@ -0,0 +1,194 @@
+import json
+import uuid
+from dataclasses import dataclass
+from functools import cached_property
+from typing import Any, Optional
+
+from uipath import UiPath
+from uipath.models import CreateAction, InvokeProcess, WaitAction, WaitJob
+
+from .._runtime._contracts import (
+    UiPathApiTrigger,
+    UiPathErrorCategory,
+    UiPathResumeTrigger,
+    UiPathResumeTriggerType,
+    UiPathRuntimeError,
+    UiPathRuntimeStatus,
+)
+from .._utils._common import serialize_object
+from ._escalation import Escalation
+
+
+def _try_convert_to_json_format(value: str) -> str:
+    try:
+        return json.loads(value)
+    except json.decoder.JSONDecodeError:
+        return value
+
+
+default_escalation = Escalation()
+
+
+class HitlReader:
+    @classmethod
+    async def read(cls, resume_trigger: UiPathResumeTrigger) -> Optional[str]:
+        uipath = UiPath()
+        match resume_trigger.trigger_type:
+            case UiPathResumeTriggerType.ACTION:
+                if resume_trigger.item_key:
+                    action = await uipath.actions.retrieve_async(
+                        resume_trigger.item_key,
+                        app_folder_key=resume_trigger.folder_key,
+                        app_folder_path=resume_trigger.folder_path,
+                    )
+
+                    if default_escalation.enabled:
+                        return default_escalation.extract_response_value(action.data)
+
+                    return action.data
+
+            case UiPathResumeTriggerType.JOB:
+                if resume_trigger.item_key:
+                    job = await uipath.jobs.retrieve_async(
+                        resume_trigger.item_key,
+                        folder_key=resume_trigger.folder_key,
+                        folder_path=resume_trigger.folder_path,
+                    )
+                    if (
+                        job.state
+                        and not job.state.lower()
+                        == UiPathRuntimeStatus.SUCCESSFUL.value.lower()
+                    ):
+                        raise UiPathRuntimeError(
+                            "INVOKED_PROCESS_FAILURE",
+                            "Invoked process did not finish successfully.",
+                            _try_convert_to_json_format(str(job.job_error or job.info)),
+                        )
+                    return job.output_arguments
+
+            case UiPathResumeTriggerType.API:
+                if resume_trigger.api_resume and resume_trigger.api_resume.inbox_id:
+                    try:
+                        return await uipath.jobs.retrieve_api_payload_async(
+                            resume_trigger.api_resume.inbox_id
+                        )
+                    except Exception as e:
+                        raise UiPathRuntimeError(
+                            "API_CONNECTION_ERROR",
+                            "Failed to get trigger payload",
+                            f"Error fetching API trigger payload for inbox {resume_trigger.api_resume.inbox_id}: {str(e)}",
+                            UiPathErrorCategory.SYSTEM,
+                        ) from e
+            case _:
+                raise UiPathRuntimeError(
+                    "UNKNOWN_TRIGGER_TYPE",
+                    "Unexpected trigger type received",
+                    f"Trigger type :{type(resume_trigger.trigger_type)} is invalid",
+                    UiPathErrorCategory.USER,
+                )
+
+        raise UiPathRuntimeError(
+            "HITL_FEEDBACK_FAILURE",
+            "Failed to receive payload from HITL action",
+            detail="Failed to receive payload from HITL action",
+            category=UiPathErrorCategory.SYSTEM,
+        )
+
+
+@dataclass
+class HitlProcessor:
+    """Processes events in a Human-(Robot/Agent)-In-The-Loop scenario."""
+
+    value: Any
+
+    @cached_property
+    def type(self) -> UiPathResumeTriggerType:
+        """Returns the type of the interrupt value."""
+        if isinstance(self.value, CreateAction) or isinstance(self.value, WaitAction):
+            return UiPathResumeTriggerType.ACTION
+        if isinstance(self.value, InvokeProcess) or isinstance(self.value, WaitJob):
+            return UiPathResumeTriggerType.JOB
+        # default to API trigger
+        return UiPathResumeTriggerType.API
+
+    async def create_resume_trigger(self) -> UiPathResumeTrigger:
+        """Returns the resume trigger."""
+        uipath = UiPath()
+        try:
+            hitl_input = self.value
+            resume_trigger = UiPathResumeTrigger(
+                trigger_type=self.type, payload=serialize_object(hitl_input)
+            )
+
+            # check for default escalation config
+            if default_escalation.enabled and isinstance(hitl_input, str):
+                resume_trigger.trigger_type = UiPathResumeTriggerType.ACTION
+                action = await default_escalation.create(hitl_input)
+                if not action:
+                    raise Exception("Failed to create default escalation")
+                resume_trigger.item_key = action.key
+                return resume_trigger
+
+            match self.type:
+                case UiPathResumeTriggerType.ACTION:
+                    resume_trigger.folder_path = hitl_input.app_folder_path
+                    resume_trigger.folder_key = hitl_input.app_folder_key
+                    if isinstance(hitl_input, WaitAction):
+                        resume_trigger.item_key = hitl_input.action.key
+                    elif isinstance(hitl_input, CreateAction):
+                        action = await uipath.actions.create_async(
+                            title=hitl_input.title,
+                            app_name=hitl_input.app_name if hitl_input.app_name else "",
+                            app_folder_path=hitl_input.app_folder_path
+                            if hitl_input.app_folder_path
+                            else "",
+                            app_folder_key=hitl_input.app_folder_key
+                            if hitl_input.app_folder_key
+                            else "",
+                            app_key=hitl_input.app_key if hitl_input.app_key else "",
+                            app_version=hitl_input.app_version
+                            if hitl_input.app_version
+                            else 1,
+                            assignee=hitl_input.assignee if hitl_input.assignee else "",
+                            data=hitl_input.data,
+                        )
+                        if not action:
+                            raise Exception("Failed to create action")
+                        resume_trigger.item_key = action.key
+
+                case UiPathResumeTriggerType.JOB:
+                    resume_trigger.folder_path = hitl_input.process_folder_path
+                    resume_trigger.folder_key = hitl_input.process_folder_key
+                    if isinstance(hitl_input, WaitJob):
+                        resume_trigger.item_key = hitl_input.job.key
+                    elif isinstance(hitl_input, InvokeProcess):
+                        job = await uipath.processes.invoke_async(
+                            name=hitl_input.name,
+                            input_arguments=hitl_input.input_arguments,
+                            folder_path=hitl_input.process_folder_path,
+                            folder_key=hitl_input.process_folder_key,
+                        )
+                        if not job:
+                            raise Exception("Failed to invoke process")
+                        resume_trigger.item_key = job.key
+
+                case UiPathResumeTriggerType.API:
+                    resume_trigger.api_resume = UiPathApiTrigger(
+                        inbox_id=str(uuid.uuid4()), request=serialize_object(hitl_input)
+                    )
+                case _:
+                    raise UiPathRuntimeError(
+                        "UNKNOWN_HITL_MODEL",
+                        "Unexpected model received",
+                        f"{type(hitl_input)} is not a valid Human(Robot/Agent)-In-The-Loop model",
+                        UiPathErrorCategory.USER,
+                    )
+        except Exception as e:
+            raise UiPathRuntimeError(
+                "HITL_ACTION_CREATION_FAILED",
+                "Failed to create HITL action",
+                f"{str(e)}",
+                UiPathErrorCategory.SYSTEM,
+            ) from e
+
+        return resume_trigger

uipath/_cli/_utils/_common.py

@@ -43,3 +43,29 @@ def get_env_vars(spinner: Optional[Spinner] = None) -> list[str | None]:
         click.get_current_context().exit(1)
 
     return [base_url, token]
+
+
+def serialize_object(obj):
+    """Recursively serializes an object and all its nested components."""
+    # Handle Pydantic models
+    if hasattr(obj, "model_dump"):
+        return serialize_object(obj.model_dump(by_alias=True))
+    elif hasattr(obj, "dict"):
+        return serialize_object(obj.dict())
+    elif hasattr(obj, "to_dict"):
+        return serialize_object(obj.to_dict())
+    # Handle dictionaries
+    elif isinstance(obj, dict):
+        return {k: serialize_object(v) for k, v in obj.items()}
+    # Handle lists
+    elif isinstance(obj, list):
+        return [serialize_object(item) for item in obj]
+    # Handle other iterable objects (convert to dict first)
+    elif hasattr(obj, "__iter__") and not isinstance(obj, (str, bytes)):
+        try:
+            return serialize_object(dict(obj))
+        except (TypeError, ValueError):
+            return obj
+    # Return primitive types as is
+    else:
+        return obj

uipath/_cli/_utils/_tracing.py

@@ -0,0 +1,52 @@
+import datetime
+import logging
+from zoneinfo import ZoneInfo
+
+
+class IgnoreSpecificUrl(logging.Filter):
+    def __init__(self, url_to_ignore):
+        super().__init__()
+        self.url_to_ignore = url_to_ignore
+
+    def filter(self, record):
+        try:
+            if record.msg == 'HTTP Request: %s %s "%s %d %s"':
+                # Ignore the log if the URL matches the one we want to ignore
+                method = record.args[0]
+                url = record.args[1]
+
+                if method == "POST" and url.path.endswith(self.url_to_ignore):
+                    # Check if the URL contains the specific path we want to ignore
+                    return True
+                return False
+
+        except Exception:
+            return False
+
+
+def setup_tracer_httpx_logging(url: str):
+    # Create a custom logger for httpx
+    # Add the custom filter to the root logger
+    logging.getLogger("httpx").addFilter(IgnoreSpecificUrl(url))
+
+
+def simple_serialize_defaults(obj):
+    if hasattr(obj, "model_dump"):
+        return obj.model_dump(exclude_none=True, mode="json")
+    if hasattr(obj, "dict"):
+        return obj.dict()
+    if hasattr(obj, "to_dict"):
+        return obj.to_dict()
+
+    if isinstance(obj, (set, tuple)):
+        if hasattr(obj, "_asdict") and callable(obj._asdict):
+            return obj._asdict()
+        return list(obj)
+
+    if isinstance(obj, datetime.datetime):
+        return obj.isoformat()
+
+    if isinstance(obj, (datetime.timezone, ZoneInfo)):
+        return obj.tzname(None)
+
+    return str(obj)

uipath/_services/jobs_service.py

@@ -272,6 +272,59 @@ class JobsService(FolderContext, BaseService):
         response = response.json()
         return self._extract_first_inbox_id(response)
 
+    def retrieve_api_payload(self, inbox_id: str) -> Any:
+        """Fetch payload data for API triggers.
+
+        Args:
+            inbox_id: The Id of the inbox to fetch the payload for.
+
+        Returns:
+            The value field from the API response payload.
+        """
+        spec = self._retrieve_api_payload_spec(inbox_id=inbox_id)
+
+        response = self.request(
+            spec.method,
+            url=spec.endpoint,
+            headers=spec.headers,
+        )
+
+        data = response.json()
+        return data.get("payload")
+
+    async def retrieve_api_payload_async(self, inbox_id: str) -> Any:
+        """Asynchronously fetch payload data for API triggers.
+
+        Args:
+            inbox_id: The Id of the inbox to fetch the payload for.
+
+        Returns:
+            The value field from the API response payload.
+        """
+        spec = self._retrieve_api_payload_spec(inbox_id=inbox_id)
+
+        response = await self.request_async(
+            spec.method,
+            url=spec.endpoint,
+            headers=spec.headers,
+        )
+
+        data = response.json()
+        return data.get("payload")
+
+    def _retrieve_api_payload_spec(
+        self,
+        *,
+        inbox_id: str,
+    ) -> RequestSpec:
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint(f"/orchestrator_/api/JobTriggers/GetPayload/{inbox_id}"),
+            headers={
+                **self.folder_headers,
+            },
+        )
+
     def _extract_first_inbox_id(self, response: Any) -> str:
         if len(response["value"]) > 0:
             return response["value"][0]["ItemKey"]

uipath/tracing/_traced.py

@@ -11,7 +11,18 @@ from ._utils import _SpanUtils
 
 logger = logging.getLogger(__name__)
 
-tracer = trace.get_tracer(__name__)
+_tracer_instance: Optional[trace.Tracer] = None
+
+
+def get_tracer() -> trace.Tracer:
+    """Lazily initializes and returns the tracer instance."""
+    global _tracer_instance
+    if _tracer_instance is None:
+        logger.warning(
+            "Initializing tracer instance. This should only be done once per process."
+        )
+        _tracer_instance = trace.get_tracer(__name__)
+    return _tracer_instance
 
 
 class TracingManager:
@@ -22,13 +33,45 @@ class TracingManager:
     _traced_registry: List[Tuple[Callable[..., Any], Callable[..., Any], Any]] = []
 
     # Custom tracer implementation
-    _custom_tracer_implementation = None
+    _custom_tracer_implementation = None  # Custom span provider function
+    _current_span_provider: Optional[Callable[[], Any]] = None
 
     @classmethod
     def get_custom_tracer_implementation(cls):
         """Get the currently set custom tracer implementation."""
         return cls._custom_tracer_implementation
 
+    @classmethod
+    def register_current_span_provider(
+        cls, current_span_provider: Optional[Callable[[], Any]]
+    ):
+        """Register a custom current span provider function.
+
+        Args:
+            current_span_provider: A function that returns the current span from an external
+                                 tracing framework. If None, no custom span parenting will be used.
+        """
+        cls._current_span_provider = current_span_provider
+
+    @classmethod
+    def get_parent_context(cls):
+        """Get the parent context using the registered current span provider.
+
+        Returns:
+            Context object with the current span set, or None if no provider is registered.
+        """
+        if cls._current_span_provider is not None:
+            try:
+                current_span = cls._current_span_provider()
+                if current_span is not None:
+                    from opentelemetry.trace import set_span_in_context
+
+                    return set_span_in_context(current_span)
+            except Exception as e:
+                logger.warning(f"Error getting current span from provider: {e}")
+                return None
+        return None
+
     @classmethod
     def register_traced_function(cls, original_func, decorated_func, params):
         """Register a function decorated with @traced and its parameters.
@@ -137,7 +180,11 @@ def _opentelemetry_traced(
 
         @wraps(func)
         def sync_wrapper(*args, **kwargs):
-            with tracer.start_as_current_span(trace_name) as span:
+            context = TracingManager.get_parent_context()
+
+            with get_tracer().start_as_current_span(
+                trace_name, context=context
+            ) as span:
                 default_span_type = "function_call_sync"
                 span.set_attribute(
                     "span_type",
@@ -172,7 +219,11 @@ def _opentelemetry_traced(
 
         @wraps(func)
         async def async_wrapper(*args, **kwargs):
-            with tracer.start_as_current_span(trace_name) as span:
+            context = TracingManager.get_parent_context()
+
+            with get_tracer().start_as_current_span(
+                trace_name, context=context
+            ) as span:
                 default_span_type = "function_call_async"
                 span.set_attribute(
                     "span_type",
@@ -207,7 +258,12 @@ def _opentelemetry_traced(
 
         @wraps(func)
         def generator_wrapper(*args, **kwargs):
-            with tracer.start_as_current_span(trace_name) as span:
+            context = TracingManager.get_parent_context()
+
+            with get_tracer().start_as_current_span(
+                trace_name, context=context
+            ) as span:
+                span.get_span_context()
                 default_span_type = "function_call_generator_sync"
                 span.set_attribute(
                     "span_type",
@@ -248,7 +304,11 @@ def _opentelemetry_traced(
 
         @wraps(func)
         async def async_generator_wrapper(*args, **kwargs):
-            with tracer.start_as_current_span(trace_name) as span:
+            context = TracingManager.get_parent_context()
+
+            with get_tracer().start_as_current_span(
+                trace_name, context=context
+            ) as span:
                 default_span_type = "function_call_generator_async"
                 span.set_attribute(
                     "span_type",

{uipath-2.0.63.dist-info → uipath-2.0.64.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.0.63
+Version: 2.0.64
 Summary: Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools.
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-python

{uipath-2.0.63.dist-info → uipath-2.0.64.dist-info}/RECORD

@@ -26,6 +26,8 @@ uipath/_cli/_auth/index.html,sha256=ML_xDOcKs0ETYucufJskiYfWSvdrD_E26C0Qd3qpGj8,
 uipath/_cli/_auth/localhost.crt,sha256=oGl9oLLOiouHubAt39B4zEfylFvKEtbtr_43SIliXJc,1226
 uipath/_cli/_auth/localhost.key,sha256=X31VYXD8scZtmGA837dGX5l6G-LXHLo5ItWJhZXaz3c,1679
 uipath/_cli/_runtime/_contracts.py,sha256=Rxs-uEOA490fLPNimB8LqZW7KI-72O0BLY4Jm7Fa1ms,14316
+uipath/_cli/_runtime/_escalation.py,sha256=x3vI98qsfRA-fL_tNkRVTFXioM5Gv2w0GFcXJJ5eQtg,7981
+uipath/_cli/_runtime/_hitl.py,sha256=zcyQmU-lTMklMpAPY8ifAbyo9Dv6ZDp6iCOoVFZxE0c,8331
 uipath/_cli/_runtime/_logging.py,sha256=lA2LsakOrcSLnJWgo80-BYzIQBUWfqzzJGI1M61Gu0s,7874
 uipath/_cli/_runtime/_runtime.py,sha256=-ZA7MZctX3e_YX_SN9XFjtsQKaCZCdBL3YRYFmsacN4,10162
 uipath/_cli/_templates/.psmdcp.template,sha256=C7pBJPt98ovEljcBvGtEUGoWjjQhu9jls1bpYjeLOKA,611
@@ -33,13 +35,14 @@ uipath/_cli/_templates/.rels.template,sha256=-fTcw7OA1AcymHr0LzBqbMAAtzZTRXLTNa_
 uipath/_cli/_templates/[Content_Types].xml.template,sha256=bYsKDz31PkIF9QksjgAY_bqm57YC8U_owsZeNZAiBxQ,584
 uipath/_cli/_templates/main.py.template,sha256=QB62qX5HKDbW4lFskxj7h9uuxBITnTWqu_DE6asCwcU,476
 uipath/_cli/_templates/package.nuspec.template,sha256=YZyLc-u_EsmIoKf42JsLQ55OGeFmb8VkIU2VF7DFbtw,359
-uipath/_cli/_utils/_common.py,sha256=h0-lvaAzz-4iM7WuEqZhlTo5QadBpsQyAdlggx73-PA,1123
+uipath/_cli/_utils/_common.py,sha256=wQ0a_lGj0bsuNvwxUfnLwg6T3IdatdfkrPcZMoufJNU,2058
 uipath/_cli/_utils/_console.py,sha256=rj4V3yeR1wnJzFTHnaE6wcY9OoJV-PiIQnLg_p62ClQ,6664
 uipath/_cli/_utils/_constants.py,sha256=mCeSWLURgw_dOMXjzyYBAvxKN3Vcd1vf7XKHgbdrOds,25
 uipath/_cli/_utils/_folders.py,sha256=usjLNOMdhvelEv0wsJ-v6q-qiUR1tbwXJL4Sd_SOocI,970
 uipath/_cli/_utils/_input_args.py,sha256=pyQhEcQXHdFHYTVNzvfWp439aii5StojoptnmCv5lfs,4094
 uipath/_cli/_utils/_parse_ast.py,sha256=A-QToBIf-oP7yP2DQTHO6blkk6ik5z_IeaIwtEWO4e0,19516
 uipath/_cli/_utils/_processes.py,sha256=iCGNf1y_K_r3bdmX9VWA70UP20bdUzKlMRrAxkdkdm4,1669
+uipath/_cli/_utils/_tracing.py,sha256=2igb03j3EHjF_A406UhtCKkPfudVfFPjUq5tXUEG4oo,1541
 uipath/_services/__init__.py,sha256=10xtw3ENC30yR9CCq_b94RMZ3YrUeyfHV33yWYUd8tU,896
 uipath/_services/_base_service.py,sha256=y-QATIRF9JnUFKIwmjOWMHlE2BrJYgD8y4sGAve2kEM,5338
 uipath/_services/actions_service.py,sha256=LYKvG4VxNGQgZ46AzGK9kI1Txb-YmVvZj5ScPOue8Ls,15989
@@ -50,7 +53,7 @@ uipath/_services/buckets_service.py,sha256=Ikqt1Cgs_o2-2kuzcogcaBkNceSQDXLEe63kz
 uipath/_services/connections_service.py,sha256=qh-HNL_GJsyPUD0wSJZRF8ZdrTE9l4HrIilmXGK6dDk,4581
 uipath/_services/context_grounding_service.py,sha256=zS991jW8C8CLkXvJwB2SuY3edTRG84SUOmiXpKId2Go,24381
 uipath/_services/folder_service.py,sha256=h0CWNqF2-8w2QLrfy-D8P3z_qA81Te689OXlFKtnby0,2001
-uipath/_services/jobs_service.py,sha256=JiqHhfpe-a9G7sQq_TyHUvGkce5I1e_Bda533b5LvkY,29406
+uipath/_services/jobs_service.py,sha256=CnDd7BM4AMqcMIR1qqu5ohhxf9m0AF4dnGoF4EX38kw,30872
 uipath/_services/llm_gateway_service.py,sha256=ySg3sflIoXmY9K7txlSm7bkuI2qzBT0kAKmGlFBk5KA,12032
 uipath/_services/processes_service.py,sha256=b-c4ynjcgS0ymp130r0lI93z7DF989u8HWOmWCux754,5727
 uipath/_services/queues_service.py,sha256=VaG3dWL2QK6AJBOLoW2NQTpkPfZjsqsYPl9-kfXPFzA,13534
@@ -85,10 +88,10 @@ uipath/telemetry/_constants.py,sha256=RVymOX07CRzcGMn1OWzh-TR6bZMvLG3vdCA6fvRrrC
 uipath/telemetry/_track.py,sha256=v0e3hgwtetMsUco4yosBzNU00Ek5SI9RxUTumrTTNyo,3872
 uipath/tracing/__init__.py,sha256=GKRINyWdHVrDsI-8mrZDLdf0oey6GHGlNZTOADK-kgc,224
 uipath/tracing/_otel_exporters.py,sha256=x0PDPmDKJcxashsuehVsSsqBCzRr6WsNFaq_3_HS5F0,3014
-uipath/tracing/_traced.py,sha256=UL0TBqUexYb2PuUIY_am9l0TEeRGXFdxKEcDq5J-NXQ,16319
+uipath/tracing/_traced.py,sha256=qeVDrds2OUnpdUIA0RhtF0kg2dlAZhyC1RRkI-qivTM,18528
 uipath/tracing/_utils.py,sha256=ZeensQexnw69jVcsVrGyED7mPlAU-L1agDGm6_1A3oc,10388
-uipath-2.0.63.dist-info/METADATA,sha256=5KVy_f28alxFsAHE2alkPSAa89ppEVaRm3ELkU9xV4c,6304
-uipath-2.0.63.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.0.63.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.0.63.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.0.63.dist-info/RECORD,,
+uipath-2.0.64.dist-info/METADATA,sha256=3wKXRRMa7h8XVtGrCXXr6S9YUkHwsr_C-MYQ2eSqn_k,6304
+uipath-2.0.64.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.0.64.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.0.64.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.0.64.dist-info/RECORD,,