uipath 2.0.8__py3-none-any.whl → 2.0.10__py3-none-any.whl

uipath/_cli/_auth/_portal_service.py

@@ -158,6 +158,6 @@ def select_tenant(
         {
             "UIPATH_URL": f"https://{domain if domain else 'alpha'}.uipath.com/{account_name}/{tenant_name}",
             "UIPATH_TENANT_ID": tenants_and_organizations["tenants"][tenant_idx]["id"],
-            "UIPATH_ORG_ID": tenants_and_organizations["organization"]["id"],
+            "UIPATH_ORGANIZATION_ID": tenants_and_organizations["organization"]["id"],
         }
     )

uipath/_cli/_auth/auth_config.json

@@ -1,6 +1,6 @@
 {
   "client_id": "36dea5b8-e8bb-423d-8e7b-c808df8f1c00",
   "redirect_uri": "https://localhost:__PY_REPLACE_PORT__/oidc/login",
-  "scope": "offline_access OrchestratorApiUserAccess ConnectionService DataService DocumentUnderstanding EnterpriseContextService Directory JamJamApi LLMGateway LLMOps OMS",
+  "scope": "offline_access OrchestratorApiUserAccess ConnectionService DataService DocumentUnderstanding EnterpriseContextService Directory JamJamApi LLMGateway LLMOps OMS RCS.FolderAuthorization",
   "port": 8104
-}
+}

uipath/_cli/cli_init.py

@@ -20,7 +20,7 @@ def generate_env_file(target_directory):
         click.echo(f"Created {relative_path} file.")
         with open(env_path, "w") as f:
             f.write("UIPATH_ACCESS_TOKEN=YOUR_TOKEN_HERE\n")
-            f.write("UIPATH_URL=https://alpha.uipath.com/ACCOUNT_NAME/TENANT_NAME\n")
+            f.write("UIPATH_URL=https://cloud.uipath.com/ACCOUNT_NAME/TENANT_NAME\n")
 
 
 def get_user_script(directory: str, entrypoint: Optional[str] = None) -> Optional[str]:

uipath/_cli/cli_pack.py

@@ -292,6 +292,21 @@ def pack_fn(projectName, description, entryPoints, version, authors, directory):
 def read_toml_project(file_path: str) -> dict[str, any]:
     with open(file_path, "rb") as f:
         content = tomllib.load(f)
+        if "project" not in content:
+            raise Exception("pyproject.toml is missing the required field: project")
+        if "name" not in content["project"]:
+            raise Exception(
+                "pyproject.toml is missing the required field: project.name"
+            )
+        if "description" not in content["project"]:
+            raise Exception(
+                "pyproject.toml is missing the required field: project.description"
+            )
+        if "version" not in content["project"]:
+            raise Exception(
+                "pyproject.toml is missing the required field: project.version"
+            )
+
         return {
             "name": content["project"]["name"],
             "description": content["project"]["description"],
@@ -320,6 +335,20 @@ def pack(root):
         )
         return
     config = check_config(root)
+    if not config["project_name"] or config["project_name"].strip() == "":
+        raise Exception("Project name cannot be empty")
+
+    if not config["description"] or config["description"].strip() == "":
+        raise Exception("Project description cannot be empty")
+
+    invalid_chars = ["&", "<", ">", '"', "'", ";"]
+    for char in invalid_chars:
+        if char in config["project_name"]:
+            raise Exception(f"Project name contains invalid character: '{char}'")
+
+    for char in invalid_chars:
+        if char in config["description"]:
+            raise Exception(f"Project description contains invalid character: '{char}'")
     click.echo(
         f"Packaging project {config['project_name']}:{version or config['version']} description {config['description']} authored by {config['authors']}"
     )

uipath/models/interrupt_models.py

@@ -8,11 +8,15 @@ from .job import Job
 
 class InvokeProcess(BaseModel):
     name: str
+    process_folder_path: Optional[str] = None
+    process_folder_key: Optional[str] = None
     input_arguments: Optional[Dict[str, Any]]
 
 
 class WaitJob(BaseModel):
     job: Job
+    process_folder_path: Optional[str] = None
+    process_folder_key: Optional[str] = None
 
 
 class CreateAction(BaseModel):
@@ -28,3 +32,5 @@ class CreateAction(BaseModel):
 
 class WaitAction(BaseModel):
     action: Action
+    app_folder_path: Optional[str] = None
+    app_folder_key: Optional[str] = None

uipath/tracing/__init__.py

@@ -0,0 +1,3 @@
+from ._traced import TracedDecoratorRegistry, traced, wait_for_tracers  # noqa: D104
+
+__all__ = ["TracedDecoratorRegistry", "traced", "wait_for_tracers"]

uipath/tracing/_otel_exporters.py

@@ -0,0 +1,67 @@
+import json
+import logging
+import os
+from typing import Sequence
+
+from httpx import Client
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import (
+    SpanExporter,
+    SpanExportResult,
+)
+
+from ._utils import _SpanUtils
+
+logger = logging.getLogger(__name__)
+
+
+class LlmOpsHttpExporter(SpanExporter):
+    """An OpenTelemetry span exporter that sends spans to UiPath LLM Ops."""
+
+    def __init__(self, **kwargs):
+        """Initialize the exporter with the base URL and authentication token."""
+        super().__init__(**kwargs)
+        self.base_url = self._get_base_url()
+        self.auth_token = os.environ.get("UIPATH_ACCESS_TOKEN")
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.auth_token}",
+        }
+
+        self.http_client = Client(headers=self.headers)
+
+    def export(self, spans: Sequence[ReadableSpan]):
+        """Export spans to UiPath LLM Ops."""
+        logger.debug(
+            f"Exporting {len(spans)} spans to {self.base_url}/llmopstenant_/api/Traces/spans"
+        )
+
+        span_list = [
+            _SpanUtils.otel_span_to_uipath_span(span).to_dict() for span in spans
+        ]
+
+        trace_id = str(span_list[0]["TraceId"])
+        url = f"{self.base_url}/llmopstenant_/api/Traces/spans?traceId={trace_id}&source=Robots"
+
+        logger.debug("payload: ", json.dumps(span_list))
+
+        res = self.http_client.post(url, json=span_list)
+
+        if res.status_code == 200:
+            return SpanExportResult.SUCCESS
+        else:
+            return SpanExportResult.FAILURE
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        """Force flush the exporter."""
+        return True
+
+    def _get_base_url(self) -> str:
+        uipath_url = (
+            os.environ.get("UIPATH_URL")
+            or "https://cloud.uipath.com/dummyOrg/dummyTennant/"
+        )
+
+        uipath_url = uipath_url.rstrip("/")
+
+        return uipath_url

uipath/tracing/_traced.py

@@ -0,0 +1,165 @@
+import inspect
+import json
+import logging
+from functools import wraps
+from typing import Any
+
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+from ._otel_exporters import LlmOpsHttpExporter
+from ._utils import _SpanUtils
+
+logger = logging.getLogger(__name__)
+
+trace.set_tracer_provider(TracerProvider())
+trace.get_tracer_provider().add_span_processor(BatchSpanProcessor(LlmOpsHttpExporter()))  # type: ignore
+tracer = trace.get_tracer(__name__)
+
+
+def wait_for_tracers():
+    """Wait for all tracers to finish."""
+    trace.get_tracer_provider().shutdown()  # type: ignore
+
+
+class TracedDecoratorRegistry:
+    """Registry for tracing decorators."""
+
+    _decorators: dict[str, Any] = {}
+    _active_decorator = "opentelemetry"
+
+    @classmethod
+    def register_decorator(cls, name, decorator_factory):
+        """Register a decorator factory function with a name."""
+        cls._decorators[name] = decorator_factory
+        cls._active_decorator = name
+        return cls
+
+    @classmethod
+    def get_decorator(cls):
+        """Get the currently active decorator factory."""
+        return cls._decorators.get(cls._active_decorator)
+
+
+def _opentelemetry_traced():
+    def decorator(func):
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            with tracer.start_as_current_span(func.__name__) as span:
+                span.set_attribute("span_type", "function_call_sync")
+                span.set_attribute(
+                    "inputs",
+                    _SpanUtils.format_args_for_trace_json(
+                        inspect.signature(func), *args, **kwargs
+                    ),
+                )
+                try:
+                    result = func(*args, **kwargs)
+                    span.set_attribute(
+                        "output", json.dumps(result, default=str)
+                    )  # Record output
+                    return result
+                except Exception as e:
+                    span.record_exception(e)
+                    span.set_status(
+                        trace.status.Status(trace.status.StatusCode.ERROR, str(e))
+                    )
+                    raise
+
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            with tracer.start_as_current_span(func.__name__) as span:
+                span.set_attribute("span_type", "function_call_async")
+                span.set_attribute(
+                    "inputs",
+                    _SpanUtils.format_args_for_trace_json(
+                        inspect.signature(func), *args, **kwargs
+                    ),
+                )
+                try:
+                    result = await func(*args, **kwargs)
+                    span.set_attribute(
+                        "output", json.dumps(result, default=str)
+                    )  # Record output
+                    return result
+                except Exception as e:
+                    span.record_exception(e)
+                    span.set_status(
+                        trace.status.Status(trace.status.StatusCode.ERROR, str(e))
+                    )
+                    raise
+
+        @wraps(func)
+        def generator_wrapper(*args, **kwargs):
+            with tracer.start_as_current_span(func.__name__) as span:
+                span.set_attribute("span_type", "function_call_generator_sync")
+                span.set_attribute(
+                    "inputs",
+                    _SpanUtils.format_args_for_trace_json(
+                        inspect.signature(func), *args, **kwargs
+                    ),
+                )
+                outputs = []
+                try:
+                    for item in func(*args, **kwargs):
+                        outputs.append(item)
+                        span.add_event(f"Yielded: {item}")  # Add event for each yield
+                        yield item
+                    span.set_attribute(
+                        "output", json.dumps(outputs, default=str)
+                    )  # Record aggregated outputs
+                except Exception as e:
+                    span.record_exception(e)
+                    span.set_status(
+                        trace.status.Status(trace.status.StatusCode.ERROR, str(e))
+                    )
+                    raise
+
+        @wraps(func)
+        async def async_generator_wrapper(*args, **kwargs):
+            with tracer.start_as_current_span(func.__name__) as span:
+                span.set_attribute("span_type", "function_call_generator_async")
+                span.set_attribute(
+                    "inputs",
+                    _SpanUtils.format_args_for_trace_json(
+                        inspect.signature(func), *args, **kwargs
+                    ),
+                )
+                outputs = []
+                try:
+                    async for item in func(*args, **kwargs):
+                        outputs.append(item)
+                        span.add_event(f"Yielded: {item}")  # Add event for each yield
+                        yield item
+                    span.set_attribute(
+                        "output", json.dumps(outputs, default=str)
+                    )  # Record aggregated outputs
+                except Exception as e:
+                    span.record_exception(e)
+                    span.set_status(
+                        trace.status.Status(trace.status.StatusCode.ERROR, str(e))
+                    )
+                    raise
+
+        if inspect.iscoroutinefunction(func):
+            return async_wrapper
+        elif inspect.isgeneratorfunction(func):
+            return generator_wrapper
+        elif inspect.isasyncgenfunction(func):
+            return async_generator_wrapper
+        else:
+            return sync_wrapper
+
+    return decorator
+
+
+def traced():
+    """Decorator that will trace function invocations."""
+    decorator_factory = TracedDecoratorRegistry.get_decorator()
+
+    if decorator_factory:
+        return decorator_factory()
+    else:
+        # Fallback to original implementation if no active decorator
+        return _opentelemetry_traced()

uipath/tracing/_utils.py

@@ -0,0 +1,267 @@
+import inspect
+import json
+import logging
+import os
+import random
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime
+from os import environ as env
+from typing import Any, Dict, Optional
+
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.trace import StatusCode
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class UiPathSpan:
+    """Represents a span in the UiPath tracing system."""
+
+    id: uuid.UUID
+    trace_id: uuid.UUID
+    name: str
+    attributes: str
+    parent_id: Optional[uuid.UUID] = None
+    start_time: str = field(default_factory=lambda: datetime.now().isoformat())
+    end_time: str = field(default_factory=lambda: datetime.now().isoformat())
+    status: int = 1
+    created_at: str = field(default_factory=lambda: datetime.now().isoformat() + "Z")
+    updated_at: str = field(default_factory=lambda: datetime.now().isoformat() + "Z")
+    organization_id: Optional[str] = field(
+        default_factory=lambda: env.get("UIPATH_ORGANIZATION_ID", "")
+    )
+    tenant_id: Optional[str] = field(
+        default_factory=lambda: env.get("UIPATH_TENANT_ID", "")
+    )
+    expiry_time_utc: Optional[str] = None
+    folder_key: Optional[str] = field(
+        default_factory=lambda: env.get("UIPATH_FOLDER_KEY_XYZ", "")
+    )
+    source: Optional[str] = None
+    span_type: str = "Coded Agents"
+    process_key: Optional[str] = field(
+        default_factory=lambda: env.get("UIPATH_PROCESS_UUID")
+    )
+    job_key: Optional[str] = field(default_factory=lambda: env.get("UIPATH_JOB_KEY"))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the Span to a dictionary suitable for JSON serialization."""
+        return {
+            "Id": str(self.id),
+            "TraceId": str(self.trace_id),
+            "ParentId": str(self.parent_id) if self.parent_id else None,
+            "Name": self.name,
+            "StartTime": self.start_time,
+            "EndTime": self.end_time,
+            "Attributes": self.attributes,
+            "Status": self.status,
+            "CreatedAt": self.created_at,
+            "UpdatedAt": self.updated_at,
+            "OrganizationId": self.organization_id,
+            "TenantId": self.tenant_id,
+            "ExpiryTimeUtc": self.expiry_time_utc,
+            "FolderKey": self.folder_key,
+            "Source": self.source,
+            "SpanType": self.span_type,
+            "ProcessKey": self.process_key,
+            "JobKey": self.job_key,
+        }
+
+
+class _SpanUtils:
+    @staticmethod
+    def span_id_to_uuid4(span_id: int) -> uuid.UUID:
+        """Convert a 64-bit span ID to a valid UUID4 format.
+
+        Creates a UUID where:
+        - The 64 least significant bits contain the span ID
+        - The UUID version (bits 48-51) is set to 4
+        - The UUID variant (bits 64-65) is set to binary 10
+        """
+        # Generate deterministic high bits using the span_id as seed
+        temp_random = random.Random(span_id)
+        high_bits = temp_random.getrandbits(64)
+
+        # Combine high bits and span ID into a 128-bit integer
+        combined = (high_bits << 64) | span_id
+
+        # Set version to 4 (UUID4)
+        combined = (combined & ~(0xF << 76)) | (0x4 << 76)
+
+        # Set variant to binary 10
+        combined = (combined & ~(0x3 << 62)) | (2 << 62)
+
+        # Convert to hex string in UUID format
+        hex_str = format(combined, "032x")
+        return uuid.UUID(hex_str)
+
+    @staticmethod
+    def trace_id_to_uuid4(trace_id: int) -> uuid.UUID:
+        """Convert a 128-bit trace ID to a valid UUID4 format.
+
+        Modifies the trace ID to conform to UUID4 requirements:
+        - The UUID version (bits 48-51) is set to 4
+        - The UUID variant (bits 64-65) is set to binary 10
+        """
+        # Set version to 4 (UUID4)
+        uuid_int = (trace_id & ~(0xF << 76)) | (0x4 << 76)
+
+        # Set variant to binary 10
+        uuid_int = (uuid_int & ~(0x3 << 62)) | (2 << 62)
+
+        # Convert to hex string in UUID format
+        hex_str = format(uuid_int, "032x")
+        return uuid.UUID(hex_str)
+
+    @staticmethod
+    def otel_span_to_uipath_span(otel_span: ReadableSpan) -> UiPathSpan:
+        """Convert an OpenTelemetry span to a UiPathSpan."""
+        # Extract the context information from the OTel span
+        span_context = otel_span.get_span_context()
+
+        # OTel uses hexadecimal strings, we need to convert to UUID
+        trace_id = _SpanUtils.trace_id_to_uuid4(span_context.trace_id)
+        span_id = _SpanUtils.span_id_to_uuid4(span_context.span_id)
+
+        trace_id_str = os.environ.get("UIPATH_TRACE_ID")
+        if trace_id_str:
+            trace_id = uuid.UUID(trace_id_str)
+
+        # Get parent span ID if it exists
+        parent_id = None
+        if otel_span.parent is not None:
+            parent_id = _SpanUtils.span_id_to_uuid4(otel_span.parent.span_id)
+
+        # Map status
+        status = 1  # Default to OK
+        if otel_span.status.status_code == StatusCode.ERROR:
+            status = 2  # Error
+
+        # Convert attributes to a format compatible with UiPathSpan
+        attributes_dict: dict[str, Any] = (
+            dict(otel_span.attributes) if otel_span.attributes else {}
+        )
+
+        original_inputs = attributes_dict.get("inputs", None)
+        original_outputs = attributes_dict.get("outputs", None)
+
+        if original_inputs:
+            try:
+                if isinstance(original_inputs, str):
+                    json_inputs = json.loads(original_inputs)
+                    attributes_dict["inputs"] = json_inputs
+                else:
+                    attributes_dict["inputs"] = original_inputs
+            except Exception as e:
+                print(f"Error parsing inputs: {e}")
+                attributes_dict["inputs"] = str(original_inputs)
+
+        if original_outputs:
+            try:
+                if isinstance(original_outputs, str):
+                    json_outputs = json.loads(original_outputs)
+                    attributes_dict["outputs"] = json_outputs
+                else:
+                    attributes_dict["outputs"] = original_outputs
+            except Exception as e:
+                print(f"Error parsing outputs: {e}")
+                attributes_dict["outputs"] = str(original_outputs)
+
+        # Add events as additional attributes if they exist
+        if otel_span.events:
+            events_list = [
+                {
+                    "name": event.name,
+                    "timestamp": event.timestamp,
+                    "attributes": dict(event.attributes) if event.attributes else {},
+                }
+                for event in otel_span.events
+            ]
+            attributes_dict["events"] = events_list
+
+        # Add links as additional attributes if they exist
+        if hasattr(otel_span, "links") and otel_span.links:
+            links_list = [
+                {
+                    "trace_id": link.context.trace_id,
+                    "span_id": link.context.span_id,
+                    "attributes": dict(link.attributes) if link.attributes else {},
+                }
+                for link in otel_span.links
+            ]
+            attributes_dict["links"] = links_list
+
+        span_type_value = attributes_dict.get("span_type", "OpenTelemetry")
+        span_type = str(span_type_value)
+
+        # Create UiPathSpan from OpenTelemetry span
+        start_time = datetime.fromtimestamp(
+            (otel_span.start_time or 0) / 1e9
+        ).isoformat()
+
+        end_time_str = None
+        if otel_span.end_time is not None:
+            end_time_str = datetime.fromtimestamp(
+                (otel_span.end_time or 0) / 1e9
+            ).isoformat()
+        else:
+            end_time_str = datetime.now().isoformat()
+
+        return UiPathSpan(
+            id=span_id,
+            trace_id=trace_id,
+            parent_id=parent_id,
+            name=otel_span.name,
+            attributes=json.dumps(attributes_dict),
+            start_time=start_time,
+            end_time=end_time_str,
+            status=status,
+            span_type=span_type,
+        )
+
+    @staticmethod
+    def format_args_for_trace_json(
+        signature: inspect.Signature, *args: Any, **kwargs: Any
+    ) -> str:
+        """Return a JSON string of inputs from the function signature."""
+        result = _SpanUtils.format_args_for_trace(signature, *args, **kwargs)
+        return json.dumps(result, default=str)
+
+    @staticmethod
+    def format_args_for_trace(
+        signature: inspect.Signature, *args: Any, **kwargs: Any
+    ) -> Dict[str, Any]:
+        try:
+            """Return a dictionary of inputs from the function signature."""
+            # Create a parameter mapping by partially binding the arguments
+
+            parameter_binding = signature.bind_partial(*args, **kwargs)
+
+            # Fill in default values for any unspecified parameters
+            parameter_binding.apply_defaults()
+
+            # Extract the input parameters, skipping special Python parameters
+            result = {}
+            for name, value in parameter_binding.arguments.items():
+                # Skip class and instance references
+                if name in ("self", "cls"):
+                    continue
+
+                # Handle **kwargs parameters specially
+                param_info = signature.parameters.get(name)
+                if param_info and param_info.kind == inspect.Parameter.VAR_KEYWORD:
+                    # Flatten nested kwargs directly into the result
+                    if isinstance(value, dict):
+                        result.update(value)
+                else:
+                    # Regular parameter
+                    result[name] = value
+
+            return result
+        except Exception as e:
+            logger.warning(
+                f"Error formatting arguments for trace: {e}. Using args and kwargs directly."
+            )
+            return {"args": args, "kwargs": kwargs}

{uipath-2.0.8.dist-info → uipath-2.0.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.0.8
+Version: 2.0.10
 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
@@ -15,6 +15,7 @@ Classifier: Topic :: Software Development :: Build Tools
 Requires-Python: >=3.10
 Requires-Dist: click>=8.1.8
 Requires-Dist: httpx>=0.28.1
+Requires-Dist: opentelemetry-sdk>=1.32.1
 Requires-Dist: pydantic>=2.11.1
 Requires-Dist: pytest-asyncio>=0.25.3
 Requires-Dist: python-dotenv>=1.0.1

{uipath-2.0.8.dist-info → uipath-2.0.10.dist-info}/RECORD

@@ -8,18 +8,18 @@ uipath/_cli/README.md,sha256=GLtCfbeIKZKNnGTCsfSVqRQ27V1btT1i2bSAyW_xZl4,474
 uipath/_cli/__init__.py,sha256=CAyMecQhBBD6s4MzYQNa01bz0TIXXCqkQ5DR2kCb00w,1574
 uipath/_cli/cli_auth.py,sha256=ANaYUc2q1t0hDbGBRT3ags6K6Lef_3tyC8Mmc611jow,3141
 uipath/_cli/cli_deploy.py,sha256=h8qwJkXnW6JURsg4YcocJInGA4dwkl4CZkpT1Cn9A3c,268
-uipath/_cli/cli_init.py,sha256=8vpqo3xf1yCDZI8TatDYMjcw0iVS5Yzg6LVbnHzp8FE,3701
+uipath/_cli/cli_init.py,sha256=dPzwbfB0hJL5jRLxJJJ67DHI_i3b34_oepDHwqQN7Yw,3701
 uipath/_cli/cli_new.py,sha256=SP7eWOa5valmCpc8UsOCIezL25euhglB3yJkx-N92W8,1903
-uipath/_cli/cli_pack.py,sha256=gV7SKa3H4ftP1fx3cNLlUQs05ogtqBTIkBcgvvsoyj4,11582
+uipath/_cli/cli_pack.py,sha256=pszhSGxb6DZtYeHymS6Pys7kewx1hFvKKYilfw7aUzE,12859
 uipath/_cli/cli_publish.py,sha256=_b9rehjsbxwkpH5_DtgFUaWWJqcZTg5nate-M5BnE_c,3586
 uipath/_cli/cli_run.py,sha256=dV0a-sx78T0HJHArfZP2M9YhT8d8aOuf-9OdkBqj3fE,4577
 uipath/_cli/middlewares.py,sha256=IiJgjsqrJVKSXx4RcIKHWoH-SqWqpHPbhzkQEybmAos,3937
 uipath/_cli/_auth/_auth_server.py,sha256=vrzrE-hDx8exM5p2sFVoT9vKMblOyFWUvFXz-lTXceY,7077
 uipath/_cli/_auth/_models.py,sha256=sYMCfvmprIqnZxStlD_Dxx2bcxgn0Ri4D7uwemwkcNg,948
 uipath/_cli/_auth/_oidc_utils.py,sha256=WaX9jDlXrlX6yD8i8gsocV8ngjaT72Xd1tvsZMmSbco,2127
-uipath/_cli/_auth/_portal_service.py,sha256=G5wiBlinLTar28b4p-d5alje28hSVqfBUDU7fNezpg4,5984
+uipath/_cli/_auth/_portal_service.py,sha256=I7uCdtd0GCGD5DvsHGaQGksLBLBeFS1el-atKVs0oo8,5993
 uipath/_cli/_auth/_utils.py,sha256=9nb76xe5XmDZ0TAncp-_1SKqL6FdwRi9eS3C2noN1lY,1591
-uipath/_cli/_auth/auth_config.json,sha256=zEhtozwLot3ZOypxyEaZu53OWVSYy-NVoVZfVoJ991I,317
+uipath/_cli/_auth/auth_config.json,sha256=NTb_ZZor5xEgya2QbK51GiTL5_yVqG_QpV4VYIp8_mk,342
 uipath/_cli/_auth/index.html,sha256=ML_xDOcKs0ETYucufJskiYfWSvdrD_E26C0Qd3qpGj8,6280
 uipath/_cli/_auth/localhost.crt,sha256=oGl9oLLOiouHubAt39B4zEfylFvKEtbtr_43SIliXJc,1226
 uipath/_cli/_auth/localhost.key,sha256=X31VYXD8scZtmGA837dGX5l6G-LXHLo5ItWJhZXaz3c,1679
@@ -64,13 +64,17 @@ uipath/models/connections.py,sha256=perIqW99YEg_0yWZPdpZlmNpZcwY_toR1wkqDUBdAN0,
 uipath/models/context_grounding.py,sha256=ak3cjlA90X1FceAAI0ry4jioTtK6Zxo0oqmKY_xs8bo,352
 uipath/models/context_grounding_index.py,sha256=vHBu069j1Y1m5PydLj6uoVH0rNIxuOohKLknHn5KvQw,2508
 uipath/models/exceptions.py,sha256=WEUw2_sh-aE0HDiqPoBZyh9KIk1BaDFY5O7Lzo8KRws,324
-uipath/models/interrupt_models.py,sha256=06c8kp_qexhR2YULH5fJ4PZH-d1scBSEB07vPDmDnQI,616
+uipath/models/interrupt_models.py,sha256=UzuVTMVesI204YQ4qFQFaN-gN3kksddkrujofcaC7zQ,881
 uipath/models/job.py,sha256=f9L6_kg_VP0dAYvdcz1DWEWzy4NZPdlpHREod0uNK1E,3099
 uipath/models/llm_gateway.py,sha256=0sl5Wtve94V14H3AHwmJSoXAhoc-Fai3wJxP8HrnBPg,1994
 uipath/models/processes.py,sha256=Atvfrt6X4TYST3iA62jpS_Uxc3hg6uah11p-RaKZ6dk,2029
 uipath/models/queues.py,sha256=N_s0GKucbyjh0RnO8SxPk6wlRgvq8KIIYsfaoIY46tM,6446
-uipath-2.0.8.dist-info/METADATA,sha256=bfn9_q4LedEKwTkj5hwSY05MQx_nOLNxfTxkIMi3ez4,6006
-uipath-2.0.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.0.8.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.0.8.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.0.8.dist-info/RECORD,,
+uipath/tracing/__init__.py,sha256=mQEKHs47ufpy3MxphTJRh6AQsH90y6pWW80Nqbs0Q9c,157
+uipath/tracing/_otel_exporters.py,sha256=Fo10ofCWGd6PN5ndEsHkw6FZgQT5zOlob2XGnkiWvZE,2056
+uipath/tracing/_traced.py,sha256=HareJwZXD_z1EtaMrSDdK14AVH_sBmelIkG3hag6WaY,6271
+uipath/tracing/_utils.py,sha256=5SwsTGpHkIouXBndw-u8eCLnN4p7LM8DsTCCuf2jJgs,10165
+uipath-2.0.10.dist-info/METADATA,sha256=vUcBFQGPWH6AawCi2VEudyEzy2bsucbWu3ZuIJllwqM,6048
+uipath-2.0.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.0.10.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.0.10.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.0.10.dist-info/RECORD,,