uipath 2.1.27__py3-none-any.whl → 2.1.28__py3-none-any.whl

uipath/_cli/_dev/_terminal/_traces/_exporter.py

@@ -0,0 +1,119 @@
+import logging
+from datetime import datetime
+from typing import Callable, Sequence
+
+from opentelemetry import trace
+from opentelemetry.sdk.trace import Event, ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+from opentelemetry.trace import StatusCode
+
+from .._models._messages import LogMessage, TraceMessage
+
+
+class RunContextExporter(SpanExporter):
+    """Custom trace exporter that sends traces and logs to CLI UI."""
+
+    def __init__(
+        self,
+        on_trace: Callable[[TraceMessage], None],
+        on_log: Callable[[LogMessage], None],
+    ):
+        self.on_trace = on_trace
+        self.on_log = on_log
+        self.logger = logging.getLogger(__name__)
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        """Export spans to CLI UI."""
+        try:
+            for span in spans:
+                self._export_span(span)
+            return SpanExportResult.SUCCESS
+        except Exception as e:
+            self.logger.error(f"Failed to export spans: {e}")
+            return SpanExportResult.FAILURE
+
+    def _export_span(self, span: ReadableSpan):
+        """Export a single span to CLI UI."""
+        # Calculate duration
+        start_time = (
+            span.start_time / 1_000_000_000 if span.start_time is not None else 0
+        )
+        end_time = span.end_time / 1_000_000_000 if span.end_time is not None else None
+        duration_ms = (end_time - start_time) * 1000 if end_time else None
+
+        # Determine status
+        if span.status.status_code == StatusCode.ERROR:
+            status = "failed"
+        elif end_time:
+            status = "completed"
+        else:
+            status = "running"
+
+        # Extract span context information
+        span_context = span.get_span_context()
+
+        # Convert span IDs to string format (they're usually int64)
+        span_id = f"{span_context.span_id:016x}"  # 16-char hex string
+        trace_id = f"{span_context.trace_id:032x}"  # 32-char hex string
+
+        run_id = span.attributes.get("execution.id") if span.attributes else None
+        run_id_val = str(run_id) if run_id is not None else None
+
+        if run_id_val is None:
+            return
+
+        # Get parent span ID if available
+        parent_span_id = None
+        if hasattr(span, "parent") and span.parent:
+            parent_span_id = f"{span.parent.span_id:016x}"
+
+        # Create trace message with all required fields
+        trace_msg = TraceMessage(
+            run_id=run_id_val,
+            span_name=span.name,
+            span_id=span_id,
+            parent_span_id=parent_span_id,
+            trace_id=trace_id,
+            status=status,
+            duration_ms=duration_ms,
+            timestamp=datetime.fromtimestamp(start_time),
+            attributes=dict(span.attributes) if span.attributes else {},
+        )
+
+        # Send to UI
+        self.on_trace(trace_msg)
+
+        # Also send logs if there are events
+        if hasattr(span, "events") and span.events:
+            for event in span.events:
+                log_level = self._determine_log_level(event, span.status)
+                log_msg = LogMessage(
+                    run_id=run_id_val,
+                    level=log_level,
+                    message=event.name,
+                    timestamp=datetime.fromtimestamp(event.timestamp / 1_000_000_000),
+                )
+                self.on_log(log_msg)
+
+    def _determine_log_level(self, event: Event, span_status: trace.Status) -> str:
+        """Determine log level from span event."""
+        event_name = event.name.lower()
+
+        if span_status.status_code == StatusCode.ERROR:
+            return "ERROR"
+        elif "error" in event_name or "exception" in event_name:
+            return "ERROR"
+        elif "warn" in event_name:
+            return "WARNING"
+        elif "debug" in event_name:
+            return "DEBUG"
+        else:
+            return "INFO"
+
+    def shutdown(self) -> None:
+        """Shutdown the exporter."""
+        pass
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        """Force flush any pending spans."""
+        return True

uipath/_cli/_dev/_terminal/_traces/_logger.py

@@ -0,0 +1,32 @@
+import logging
+from datetime import datetime
+from typing import Callable
+
+from .._models._messages import LogMessage
+
+
+class RunContextLogHandler(logging.Handler):
+    """Custom log handler that sends logs to CLI UI."""
+
+    def __init__(
+        self,
+        run_id: str,
+        on_log: Callable[[LogMessage], None],
+    ):
+        super().__init__()
+        self.run_id = run_id
+        self.on_log = on_log
+
+    def emit(self, record: logging.LogRecord):
+        """Emit a log record to CLI UI."""
+        try:
+            log_msg = LogMessage(
+                run_id=self.run_id,
+                level=record.levelname,
+                message=self.format(record),
+                timestamp=datetime.fromtimestamp(record.created),
+            )
+            self.on_log(log_msg)
+        except Exception:
+            # Don't let logging errors crash the app
+            pass

uipath/_cli/_runtime/_contracts.py

@@ -8,10 +8,22 @@ import traceback
 from abc import ABC, abstractmethod
 from enum import Enum
 from functools import cached_property
-from typing import Any, Dict, Generic, Optional, Type, TypeVar, Union
-
+from typing import Any, Callable, Dict, Generic, List, Optional, Type, TypeVar, Union
+
+from opentelemetry import context as context_api
+from opentelemetry import trace
+from opentelemetry.instrumentation.instrumentor import BaseInstrumentor  # type: ignore
+from opentelemetry.sdk.trace import Span, SpanProcessor, TracerProvider
+from opentelemetry.sdk.trace.export import (
+    BatchSpanProcessor,
+    SimpleSpanProcessor,
+    SpanExporter,
+)
+from opentelemetry.trace import Tracer
 from pydantic import BaseModel, Field
 
+from uipath.tracing import TracingManager
+
 from ._logging import LogsInterceptor
 
 logger = logging.getLogger(__name__)
@@ -144,6 +156,7 @@ class UiPathRuntimeContext(BaseModel):
     input: Optional[str] = None
     input_json: Optional[Any] = None
     job_id: Optional[str] = None
+    execution_id: Optional[str] = None
     trace_id: Optional[str] = None
     trace_context: Optional[UiPathTraceContext] = None
     tracing_enabled: Union[bool, str] = False
@@ -159,7 +172,7 @@ class UiPathRuntimeContext(BaseModel):
     execution_output_file: Optional[str] = None
     input_file: Optional[str] = None
     is_eval_run: bool = False
-
+    log_handler: Optional[logging.Handler] = None
     model_config = {"arbitrary_types_allowed": True}
 
     @classmethod
@@ -328,6 +341,7 @@ class UiPathBaseRuntime(ABC):
             file=self.context.logs_file,
             job_id=self.context.job_id,
             is_debug_run=self.is_debug_run(),
+            log_handler=self.context.log_handler,
         )
         self.logs_interceptor.setup()
 
@@ -487,6 +501,34 @@ class UiPathRuntimeFactory(Generic[T, C]):
 
         self.runtime_class = runtime_class
         self.context_class = context_class
+        self.tracer_provider: TracerProvider = TracerProvider()
+        self.tracer_span_processors: List[SpanProcessor] = []
+        trace.set_tracer_provider(self.tracer_provider)
+
+    def add_span_exporter(
+        self,
+        span_exporter: SpanExporter,
+        batch: bool = True,
+    ) -> "UiPathRuntimeFactory[T, C]":
+        """Add a span processor to the tracer provider."""
+        span_processor: SpanProcessor
+        if batch:
+            span_processor = UiPathExecutionBatchTraceProcessor(span_exporter)
+        else:
+            span_processor = UiPathExecutionSimpleTraceProcessor(span_exporter)
+        self.tracer_span_processors.append(span_processor)
+        self.tracer_provider.add_span_processor(span_processor)
+        return self
+
+    def add_instrumentor(
+        self,
+        instrumentor_class: Type[BaseInstrumentor],
+        get_current_span_func: Callable[[], Optional[Span]],
+    ) -> "UiPathRuntimeFactory[T, C]":
+        """Add and instrument immediately."""
+        instrumentor_class().instrument(tracer_provider=self.tracer_provider)
+        TracingManager.register_current_span_provider(get_current_span_func)
+        return self
 
     def new_context(self, **kwargs) -> C:
         """Create a new context instance."""
@@ -499,4 +541,52 @@ class UiPathRuntimeFactory(Generic[T, C]):
     async def execute(self, context: C) -> Optional[UiPathRuntimeResult]:
         """Execute runtime with context."""
         async with self.from_context(context) as runtime:
-            return await runtime.execute()
+            result = await runtime.execute()
+            for span_processor in self.tracer_span_processors:
+                span_processor.force_flush()
+            return result
+
+    async def execute_in_root_span(
+        self, context: C, root_span: str = "root"
+    ) -> Optional[UiPathRuntimeResult]:
+        """Execute runtime with context."""
+        async with self.from_context(context) as runtime:
+            tracer: Tracer = trace.get_tracer("uipath-runtime")
+            with tracer.start_as_current_span(
+                root_span,
+                attributes={"execution.id": context.execution_id}
+                if context.execution_id
+                else {},
+            ):
+                result = await runtime.execute()
+            for span_processor in self.tracer_span_processors:
+                span_processor.force_flush()
+            return result
+
+
+class UiPathExecutionTraceProcessorMixin:
+    def on_start(
+        self, span: Span, parent_context: Optional[context_api.Context] = None
+    ):
+        """Called when a span is started."""
+        if parent_context:
+            parent_span = trace.get_current_span(parent_context)
+        else:
+            parent_span = trace.get_current_span()
+
+        if parent_span and parent_span.is_recording():
+            run_id = parent_span.attributes.get("execution.id")  # type: ignore[attr-defined]
+            if run_id:
+                span.set_attribute("execution.id", run_id)
+
+
+class UiPathExecutionBatchTraceProcessor(
+    UiPathExecutionTraceProcessorMixin, BatchSpanProcessor
+):
+    """Batch span processor that propagates execution.id."""
+
+
+class UiPathExecutionSimpleTraceProcessor(
+    UiPathExecutionTraceProcessorMixin, SimpleSpanProcessor
+):
+    """Simple span processor that propagates execution.id."""

uipath/_cli/_runtime/_logging.py

@@ -30,6 +30,7 @@ class LogsInterceptor:
         file: Optional[str] = "execution.log",
         job_id: Optional[str] = None,
         is_debug_run: bool = False,
+        log_handler: Optional[logging.Handler] = None,
     ):
         """Initialize the log interceptor.
 
@@ -39,6 +40,7 @@ class LogsInterceptor:
             file (str): The log file name.
             job_id (str, optional): If provided, logs go to file; otherwise, to stdout.
             is_debug_run (bool, optional): If True, log the output to stdout/stderr.
+            log_handler (logging.Handler, optional): Custom log handler to use.
         """
         min_level = min_level or "INFO"
         self.job_id = job_id
@@ -57,21 +59,26 @@ class LogsInterceptor:
         self.original_stdout = cast(TextIO, sys.stdout)
         self.original_stderr = cast(TextIO, sys.stderr)
 
-        self.log_handler: Union[PersistentLogsHandler, logging.StreamHandler[TextIO]]
+        self.log_handler: Union[
+            PersistentLogsHandler, logging.StreamHandler[TextIO], logging.Handler
+        ]
 
-        # Create either file handler (runtime) or stdout handler (debug)
-        if is_debug_run:
-            # Use stdout handler when not running as a job or eval
-            self.log_handler = logging.StreamHandler(sys.stdout)
-            formatter = logging.Formatter("%(message)s")
-            self.log_handler.setFormatter(formatter)
+        if log_handler:
+            self.log_handler = log_handler
         else:
-            # Ensure directory exists for file logging
-            dir = dir or "__uipath"
-            file = file or "execution.log"
-            os.makedirs(dir, exist_ok=True)
-            log_file = os.path.join(dir, file)
-            self.log_handler = PersistentLogsHandler(file=log_file)
+            # Create either file handler (runtime) or stdout handler (debug)
+            if is_debug_run:
+                # Use stdout handler when not running as a job or eval
+                self.log_handler = logging.StreamHandler(sys.stdout)
+                formatter = logging.Formatter("%(message)s")
+                self.log_handler.setFormatter(formatter)
+            else:
+                # Ensure directory exists for file logging
+                dir = dir or "__uipath"
+                file = file or "execution.log"
+                os.makedirs(dir, exist_ok=True)
+                log_file = os.path.join(dir, file)
+                self.log_handler = PersistentLogsHandler(file=log_file)
 
         self.log_handler.setLevel(self.numeric_min_level)
         self.logger = logging.getLogger("runtime")

uipath/_cli/_runtime/_runtime.py

@@ -8,13 +8,8 @@ import os
 from dataclasses import asdict, is_dataclass
 from typing import Any, Dict, Optional, Type, TypeVar, cast, get_type_hints
 
-from opentelemetry import trace
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor
 from pydantic import BaseModel
 
-from uipath.tracing import LlmOpsHttpExporter
-
 from ._contracts import (
     UiPathBaseRuntime,
     UiPathErrorCategory,
@@ -43,11 +38,6 @@ class UiPathRuntime(UiPathBaseRuntime):
         await self.validate()
 
         try:
-            trace.set_tracer_provider(TracerProvider())
-            trace.get_tracer_provider().add_span_processor(  # type: ignore
-                BatchSpanProcessor(LlmOpsHttpExporter())
-            )
-
             if self.context.entrypoint is None:
                 return None
 
@@ -74,8 +64,6 @@ class UiPathRuntime(UiPathBaseRuntime):
                 f"Error: {str(e)}",
                 UiPathErrorCategory.SYSTEM,
             ) from e
-        finally:
-            trace.get_tracer_provider().shutdown()  # type: ignore
 
     async def validate(self) -> None:
         """Validate runtime inputs."""
@@ -223,7 +211,7 @@ class UiPathRuntime(UiPathBaseRuntime):
         # Handle Pydantic models
         try:
             if inspect.isclass(cls) and issubclass(cls, BaseModel):
-                return cast(T, cls.model_validate(data))
+                return cls.model_validate(data)
         except TypeError:
             # issubclass can raise TypeError if cls is not a class
             pass
@@ -247,7 +235,7 @@ class UiPathRuntime(UiPathBaseRuntime):
                     value = self._convert_to_class(value, typed_field)
                 converted_data[field_name] = value
 
-            return cast(T, cls(**converted_data))
+            return cls(**converted_data)
 
         # Handle regular classes
         else:

uipath/_cli/cli_dev.py

@@ -0,0 +1,44 @@
+import asyncio
+from typing import Optional
+
+import click
+
+from ..telemetry import track
+from ._dev._terminal import UiPathDevTerminal
+from ._runtime._contracts import UiPathRuntimeContext, UiPathRuntimeFactory
+from ._runtime._runtime import UiPathRuntime
+from ._utils._console import ConsoleLogger
+from .middlewares import Middlewares
+
+console = ConsoleLogger()
+
+
+@click.command()
+@click.argument("interface", default="terminal")
+@track
+def dev(interface: Optional[str]) -> None:
+    """Launch interactive debugging interface."""
+    console.info("🚀 Starting UiPath Dev Terminal...")
+    console.info("Use 'q' to quit, 'n' for new run, 'r' to execute")
+
+    result = Middlewares.next(
+        "dev",
+        interface,
+    )
+
+    if result.should_continue is False:
+        return
+
+    try:
+        if interface == "terminal":
+            runtime_factory = UiPathRuntimeFactory(UiPathRuntime, UiPathRuntimeContext)
+            app = UiPathDevTerminal(runtime_factory)
+            asyncio.run(app.run_async())
+        else:
+            console.error(f"Unknown interface: {interface}")
+    except KeyboardInterrupt:
+        console.info("Debug session interrupted by user")
+    except Exception as e:
+        console.error(
+            f"Error running debug interface: {str(e)}", include_traceback=True
+        )

uipath/_cli/cli_run.py

@@ -10,6 +10,7 @@ import click
 from dotenv import load_dotenv
 
 from uipath._cli._utils._debug import setup_debugging
+from uipath.tracing import LlmOpsHttpExporter
 
 from .._utils.constants import (
     ENV_JOB_ID,
@@ -18,6 +19,7 @@ from ..telemetry import track
 from ._runtime._contracts import (
     UiPathRuntimeContext,
     UiPathRuntimeError,
+    UiPathRuntimeFactory,
     UiPathTraceContext,
 )
 from ._runtime._runtime import UiPathRuntime
@@ -61,39 +63,42 @@ Usage: `uipath run <entrypoint_path> <input_arguments> [-f <input_json_file_path
         )
 
     try:
+        context = UiPathRuntimeContext.from_config(
+            env.get("UIPATH_CONFIG_PATH", "uipath.json"), **kwargs
+        )
+        context.entrypoint = entrypoint
+        context.input = input
+        context.resume = resume
+        context.job_id = env.get("UIPATH_JOB_KEY")
+        context.trace_id = env.get("UIPATH_TRACE_ID")
+        context.input_file = kwargs.get("input_file", None)
+        context.execution_output_file = kwargs.get("execution_output_file", None)
+        context.is_eval_run = kwargs.get("is_eval_run", False)
+        context.logs_min_level = env.get("LOG_LEVEL", "INFO")
+        context.tracing_enabled = env.get("UIPATH_TRACING_ENABLED", True)
+        context.trace_context = UiPathTraceContext(
+            trace_id=env.get("UIPATH_TRACE_ID"),
+            parent_span_id=env.get("UIPATH_PARENT_SPAN_ID"),
+            root_span_id=env.get("UIPATH_ROOT_SPAN_ID"),
+            enabled=env.get("UIPATH_TRACING_ENABLED", True),
+            job_id=env.get("UIPATH_JOB_KEY"),
+            org_id=env.get("UIPATH_ORGANIZATION_ID"),
+            tenant_id=env.get("UIPATH_TENANT_ID"),
+            process_key=env.get("UIPATH_PROCESS_UUID"),
+            folder_key=env.get("UIPATH_FOLDER_KEY"),
+            reference_id=env.get("UIPATH_JOB_KEY") or str(uuid4()),
+        )
+
+        runtime_factory = UiPathRuntimeFactory(UiPathRuntime, UiPathRuntimeContext)
+
+        if context.job_id:
+            runtime_factory.add_span_exporter(LlmOpsHttpExporter())
 
         async def execute():
-            context = UiPathRuntimeContext.from_config(
-                env.get("UIPATH_CONFIG_PATH", "uipath.json"), **kwargs
-            )
-            context.entrypoint = entrypoint
-            context.input = input
-            context.resume = resume
-            context.job_id = env.get("UIPATH_JOB_KEY")
-            context.trace_id = env.get("UIPATH_TRACE_ID")
-            context.input_file = kwargs.get("input_file", None)
-            context.execution_output_file = kwargs.get("execution_output_file", None)
-            context.is_eval_run = kwargs.get("is_eval_run", False)
-            context.tracing_enabled = env.get("UIPATH_TRACING_ENABLED", True)
-            context.trace_context = UiPathTraceContext(
-                trace_id=env.get("UIPATH_TRACE_ID"),
-                parent_span_id=env.get("UIPATH_PARENT_SPAN_ID"),
-                root_span_id=env.get("UIPATH_ROOT_SPAN_ID"),
-                enabled=env.get("UIPATH_TRACING_ENABLED", True),
-                job_id=env.get("UIPATH_JOB_KEY"),
-                org_id=env.get("UIPATH_ORGANIZATION_ID"),
-                tenant_id=env.get("UIPATH_TENANT_ID"),
-                process_key=env.get("UIPATH_PROCESS_UUID"),
-                folder_key=env.get("UIPATH_FOLDER_KEY"),
-                reference_id=env.get("UIPATH_JOB_KEY") or str(uuid4()),
-            )
-            context.logs_min_level = env.get("LOG_LEVEL", "INFO")
-            async with UiPathRuntime.from_context(context) as runtime:
-                await runtime.execute()
+            await runtime_factory.execute(context)
 
         asyncio.run(execute())
 
-        # Return success
         return MiddlewareResult(should_continue=False)
 
     except UiPathRuntimeError as e:

uipath/_cli/middlewares.py

@@ -28,6 +28,7 @@ class Middlewares:
         "pack": [],
         "publish": [],
         "run": [],
+        "dev": [],
     }
     _plugins_loaded = False
 

uipath/telemetry/_track.py

@@ -58,7 +58,7 @@ def _get_project_key() -> str:
 
 class _AzureMonitorOpenTelemetryEventHandler(LoggingHandler):
     @staticmethod
-    def _get_attributes(record: LogRecord) -> Attributes:
+    def _get_attributes(record: LogRecord) -> Attributes:  # type: ignore[override]
         attributes = dict(LoggingHandler._get_attributes(record) or {})
         attributes[_APP_INSIGHTS_EVENT_MARKER_ATTRIBUTE] = True
         attributes[_CLOUD_TENANT_ID] = os.getenv(ENV_TENANT_ID, _UNKNOWN)
@@ -75,7 +75,7 @@ class _AzureMonitorOpenTelemetryEventHandler(LoggingHandler):
         if _CODE_LINENO in attributes:
             del attributes[_CODE_LINENO]
 
-        return attributes
+        return attributes  # type: ignore[return-value]
 
 
 class _TelemetryClient:

{uipath-2.1.27.dist-info → uipath-2.1.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.27
+Version: 2.1.28
 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
@@ -17,12 +17,14 @@ Requires-Python: >=3.10
 Requires-Dist: azure-monitor-opentelemetry>=1.6.8
 Requires-Dist: click>=8.1.8
 Requires-Dist: httpx>=0.28.1
+Requires-Dist: opentelemetry-instrumentation>=0.52b1
 Requires-Dist: opentelemetry-sdk>=1.31.1
 Requires-Dist: pathlib>=1.0.1
 Requires-Dist: pydantic>=2.11.1
 Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: rich>=13.0.0
 Requires-Dist: tenacity>=9.0.0
+Requires-Dist: textual>=5.3.0
 Requires-Dist: tomli>=2.2.1
 Requires-Dist: truststore>=0.10.1
 Description-Content-Type: text/markdown

{uipath-2.1.27.dist-info → uipath-2.1.28.dist-info}/RECORD

@@ -5,9 +5,10 @@ uipath/_folder_context.py,sha256=UMMoU1VWEfYHAZW3Td2SIFYhw5dYsmaaKFhW_JEm6oc,192
 uipath/_uipath.py,sha256=ZfEcqpY7NRSm6rB2OPgyVXBl9DCnn750ikq8VzzTO_s,4146
 uipath/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 uipath/_cli/README.md,sha256=GLtCfbeIKZKNnGTCsfSVqRQ27V1btT1i2bSAyW_xZl4,474
-uipath/_cli/__init__.py,sha256=eMtRrLZO6DyNaDcbatrp0FvIQo6BuMWeTOgZm9kzkMo,2088
+uipath/_cli/__init__.py,sha256=UPT7j36tQWyF8_q-Bhbi9AQiUKUMM_Ikn_bpfy-87U0,2141
 uipath/_cli/cli_auth.py,sha256=-KgyI_IKWNWoEUFr4GxrQJF9qQHSYqTGvjNOj1mkxPc,7831
 uipath/_cli/cli_deploy.py,sha256=KPCmQ0c_NYD5JofSDao5r6QYxHshVCRxlWDVnQvlp5w,645
+uipath/_cli/cli_dev.py,sha256=_AzGYmjz_uT3u3BvD4l9sool866lqibitZMa5-Yjs7Y,1314
 uipath/_cli/cli_eval.py,sha256=INkfaZKadShtFOrVfTNM7K2kjXV-cwIqsOfIEYqDSGc,3656
 uipath/_cli/cli_init.py,sha256=jksza6bHfh4z1nKyEJBEEZlkO37yZoCz_FJWq_RPhWI,6093
 uipath/_cli/cli_invoke.py,sha256=4Oc6CM21Y24b_5I2MAqu-TffZL1aOKQwxfBmC6mPR8o,4000
@@ -16,8 +17,8 @@ uipath/_cli/cli_pack.py,sha256=NmwZTfwZ2fURiHyiX1BM0juAtBOjPB1Jmcpu-rD7p-4,11025
 uipath/_cli/cli_publish.py,sha256=QT17JTClAyLve6ZjB-WvQaJ-j4DdmNneV_eDRyXjeeQ,6578
 uipath/_cli/cli_pull.py,sha256=u14DmcEflvhMEro9ptdkZXPgl18H3YjUQ3SiIdkoLY0,6889
 uipath/_cli/cli_push.py,sha256=gHh0omtO_NjNUGPhkZuDQhKX_OXF4MqlbBIui-Hw-zI,3190
-uipath/_cli/cli_run.py,sha256=1W3cPMgaVzm1wTnTD4-tJQwJ5h4riKRUBQb1hzsGMcw,7767
-uipath/_cli/middlewares.py,sha256=CN-QqV69zZPI-hvizvEIb-zTcNh9WjsZIYCF3_nHSio,4915
+uipath/_cli/cli_run.py,sha256=6p-6kO20xyYbBQpieFNXqLGi7Q3pIms1aVor4pJX3Fc,7835
+uipath/_cli/middlewares.py,sha256=MffXgAeafn5AqUsbw4l-FVly9Dm9TOvfvGJ61XOTt2Y,4934
 uipath/_cli/spinner.py,sha256=bS-U_HA5yne11ejUERu7CQoXmWdabUD2bm62EfEdV8M,1107
 uipath/_cli/_auth/_auth_server.py,sha256=Wx3TaK5QvGzaJytp2cnYO3NFVIvTsNqxfVMwBquEyQs,7162
 uipath/_cli/_auth/_client_credentials.py,sha256=aC_xtEzWBQohRlxt85ZE8Ro0Pv9LmNltXECV8yjjO0U,5422
@@ -30,6 +31,15 @@ uipath/_cli/_auth/auth_config.json,sha256=UnAhdum8phjuZaZKE5KLp0IcPCbIltDEU1M_G8
 uipath/_cli/_auth/index.html,sha256=uGK0CDTP8Rys_p4O_Pbd2x4tz0frKNVcumjrXnal5Nc,22814
 uipath/_cli/_auth/localhost.crt,sha256=oGl9oLLOiouHubAt39B4zEfylFvKEtbtr_43SIliXJc,1226
 uipath/_cli/_auth/localhost.key,sha256=X31VYXD8scZtmGA837dGX5l6G-LXHLo5ItWJhZXaz3c,1679
+uipath/_cli/_dev/_terminal/__init__.py,sha256=lKmYSkiHivGPHa70dVktkZ4o0gX4ijnLMOVoT6Q2AtQ,8263
+uipath/_cli/_dev/_terminal/_components/_details.py,sha256=7tK7EpeInALfpkbhuQudbEZAavZ2ZnRESFcslzpUXWE,15208
+uipath/_cli/_dev/_terminal/_components/_history.py,sha256=bpIm2uLP9sIP6v4meN0i4Pk2xOwVwXI4iPrWpQIzlDc,1807
+uipath/_cli/_dev/_terminal/_components/_new.py,sha256=81FVClAl_ou8B861PsgwU5flXFfxYVOLEr5gCdKia8c,4450
+uipath/_cli/_dev/_terminal/_models/_execution.py,sha256=ZjlBQ0AiArHPkDQZr-2P-AYnadN7wuy1F2Xb7Jsu9Ek,1386
+uipath/_cli/_dev/_terminal/_models/_messages.py,sha256=TR7D1yLL0PNYGUMts_cGLgF8zj67urNwuX-5xSGqWgM,1762
+uipath/_cli/_dev/_terminal/_styles/terminal.tcss,sha256=k455ZxeB54hzPyH3CAj8VNLUtQPCCHr0IbTU1mqhD3U,5012
+uipath/_cli/_dev/_terminal/_traces/_exporter.py,sha256=oI6D_eMwrh_2aqDYUh4GrJg8VLGrLYhDahR-_o0uJns,4144
+uipath/_cli/_dev/_terminal/_traces/_logger.py,sha256=Dmfba3X9GmAZtXpzu_KDsleRCrpVo8_y-W6jizwFYq0,880
 uipath/_cli/_evals/evaluation_service.py,sha256=zqYRB-tZpTTFqMctjIpEli3joIlmrz3dCVZsxekxIps,22053
 uipath/_cli/_evals/progress_reporter.py,sha256=m1Dio1vG-04nFTFz5ijM_j1dhudlgOzQukmTkkg6wS4,11490
 uipath/_cli/_evals/_evaluators/__init__.py,sha256=jD7KNLjbsUpsESFXX11eW2MEPXDNuPp2-t-IPB-inlM,734
@@ -44,11 +54,11 @@ uipath/_cli/_evals/_models/__init__.py,sha256=Ewjp3u2YeTH2MmzY9LWf7EIbAoIf_nW9fM
 uipath/_cli/_evals/_models/_evaluation_set.py,sha256=tVHykSget-G3sOCs9bSchMYUTpFqzXVlYYbY8L9SI0c,1518
 uipath/_cli/_evals/_models/_evaluators.py,sha256=l57NEVyYmzSKuoIXuGkE94Br01hAMg35fiS2MlTkaQM,2115
 uipath/_cli/_push/sw_file_handler.py,sha256=5zAt03gSlni7RnJmZJP4d4RVC33u8lZWj3W9xwx-CFM,18064
-uipath/_cli/_runtime/_contracts.py,sha256=964pu4PJ29SNKU6I_iJXPEcwPWSZ9u2ab5EDlQX4sPM,17314
+uipath/_cli/_runtime/_contracts.py,sha256=jYEKjWXFogMS8nO-ioUieP1X0mD4uQmDWOqDEmKMOEI,20829
 uipath/_cli/_runtime/_escalation.py,sha256=x3vI98qsfRA-fL_tNkRVTFXioM5Gv2w0GFcXJJ5eQtg,7981
 uipath/_cli/_runtime/_hitl.py,sha256=aexwe0dIXvh6SlVS1jVnO_aGZc6e3gLsmGkCyha5AHo,11300
-uipath/_cli/_runtime/_logging.py,sha256=0_8OeF2w2zcryvozOsB3h4sFktiwnUqJr_fMRxwUFOc,8004
-uipath/_cli/_runtime/_runtime.py,sha256=Lee055XQBFe5sUiwo5T7XKOxKRCsv8gvy9wSZBnqVak,11917
+uipath/_cli/_runtime/_logging.py,sha256=MGklGKPjYKjs7J5Jy9eplA9zCDsdtEbkZdCbTwgut_4,8311
+uipath/_cli/_runtime/_runtime.py,sha256=tgoMYALRTMGL8pSYbSL5nXJfq0lf_RGuNc7fmS4dlf4,11419
 uipath/_cli/_templates/.psmdcp.template,sha256=C7pBJPt98ovEljcBvGtEUGoWjjQhu9jls1bpYjeLOKA,611
 uipath/_cli/_templates/.rels.template,sha256=-fTcw7OA1AcymHr0LzBqbMAAtzZTRXLTNa_ljq087Jk,406
 uipath/_cli/_templates/[Content_Types].xml.template,sha256=bYsKDz31PkIF9QksjgAY_bqm57YC8U_owsZeNZAiBxQ,584
@@ -109,15 +119,15 @@ uipath/models/processes.py,sha256=Atvfrt6X4TYST3iA62jpS_Uxc3hg6uah11p-RaKZ6dk,20
 uipath/models/queues.py,sha256=N_s0GKucbyjh0RnO8SxPk6wlRgvq8KIIYsfaoIY46tM,6446
 uipath/telemetry/__init__.py,sha256=Wna32UFzZR66D-RzTKlPWlvji9i2HJb82NhHjCCXRjY,61
 uipath/telemetry/_constants.py,sha256=uRDuEZayBYtBA0tMx-2AS_D-oiVA7oKgp9zid9jNats,763
-uipath/telemetry/_track.py,sha256=I8SzROQcySAXNfxx4QgZlJ6ib8DjTKn50CiZYsbjjr8,4598
+uipath/telemetry/_track.py,sha256=G_Pyq8n8iMvoCWhUpWedlptXUSuUSbQBBzGxsh4DW9c,4654
 uipath/tracing/__init__.py,sha256=GKRINyWdHVrDsI-8mrZDLdf0oey6GHGlNZTOADK-kgc,224
 uipath/tracing/_otel_exporters.py,sha256=X7cnuGqvxGbACZuFD2XYTWXwIse8pokOEAjeTPE6DCQ,3158
 uipath/tracing/_traced.py,sha256=qeVDrds2OUnpdUIA0RhtF0kg2dlAZhyC1RRkI-qivTM,18528
 uipath/tracing/_utils.py,sha256=wJRELaPu69iY0AhV432Dk5QYf_N_ViRU4kAUG1BI1ew,10384
 uipath/utils/__init__.py,sha256=VD-KXFpF_oWexFg6zyiWMkxl2HM4hYJMIUDZ1UEtGx0,105
 uipath/utils/_endpoints_manager.py,sha256=iRTl5Q0XAm_YgcnMcJOXtj-8052sr6jpWuPNz6CgT0Q,8408
-uipath-2.1.27.dist-info/METADATA,sha256=jHfcM06Sp1vBb5R2uUdxem7s7zHkmM_B11EI6WJ5fag,6367
-uipath-2.1.27.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.27.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.27.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.27.dist-info/RECORD,,
+uipath-2.1.28.dist-info/METADATA,sha256=IHdsL89Hy_10OmP8xD3mtH1VXVXb4fPZniCIg4CKplM,6450
+uipath-2.1.28.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.28.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.28.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.28.dist-info/RECORD,,