uipath 2.1.74__py3-none-any.whl → 2.1.76__py3-none-any.whl

uipath/_cli/_evals/_console_progress_reporter.py

@@ -0,0 +1,241 @@
+"""Console progress reporter for evaluation runs with line-by-line output."""
+
+import logging
+from typing import Any, Dict
+
+from rich.console import Console
+from rich.rule import Rule
+from rich.table import Table
+
+from uipath._events._event_bus import EventBus
+from uipath._events._events import (
+    EvalRunCreatedEvent,
+    EvalRunUpdatedEvent,
+    EvalSetRunCreatedEvent,
+    EvalSetRunUpdatedEvent,
+    EvaluationEvents,
+)
+from uipath.eval.evaluators import BaseEvaluator
+from uipath.eval.models import ScoreType
+
+logger = logging.getLogger(__name__)
+
+
+class ConsoleProgressReporter:
+    """Handles displaying evaluation progress to the console with line-by-line output."""
+
+    def __init__(self):
+        self.console = Console()
+        self.evaluators: Dict[str, BaseEvaluator[Any]] = {}
+        self.display_started = False
+        self.eval_results_by_name: Dict[str, list[Any]] = {}
+
+    def _convert_score_to_numeric(self, eval_result) -> float:
+        """Convert evaluation result score to numeric value."""
+        score_value = eval_result.result.score
+        if eval_result.result.score_type == ScoreType.BOOLEAN:
+            score_value = 100 if score_value else 0
+        return score_value
+
+    def _get_evaluator_name(self, evaluator_id: str) -> str:
+        """Get evaluator name from ID, with fallback."""
+        return self.evaluators.get(
+            evaluator_id,
+            type(
+                "obj",
+                (object,),
+                {"name": f"Evaluator {evaluator_id[:8]}"},
+            )(),
+        ).name
+
+    def _display_successful_evaluation(self, eval_name: str, eval_results) -> None:
+        """Display results for a successful evaluation."""
+        from rich.text import Text
+
+        if eval_results:
+            result = Text()
+            result.append("▌", style="bold green")
+            result.append(" ", style="")
+            result.append(eval_name, style="bold green")
+            self.console.print(result)
+            table = Table(show_header=False, box=None, padding=(0, 2, 0, 2))
+
+            for eval_result in eval_results:
+                evaluator_name = self._get_evaluator_name(eval_result.evaluator_id)
+                score_value = self._convert_score_to_numeric(eval_result)
+                table.add_row(
+                    f"{evaluator_name}", f"[bold cyan]{score_value:.1f}[/bold cyan]"
+                )
+
+            self.console.print(table)
+        else:
+            result = Text()
+            result.append("  ✓ ", style="bold green")
+            result.append(eval_name, style="bold white")
+            result.append(" - No evaluators", style="dim")
+            self.console.print(result)
+
+    def _extract_error_message(self, payload: EvalRunUpdatedEvent) -> str:
+        return str(payload.exception_details.exception) or "Execution failed"  # type: ignore
+
+    def _display_failed_evaluation(self, eval_name: str) -> None:
+        """Display results for a failed evaluation."""
+        from rich.text import Text
+
+        result = Text()
+        result.append("  ✗ ", style="bold red")
+        result.append(eval_name, style="bold white")
+        self.console.print(result)
+
+    def start_display(self):
+        """Start the display."""
+        if not self.display_started:
+            self.console.print()
+            self.console.print("→ [bold]Running Evaluations[/bold]")
+            self.console.print()
+            self.display_started = True
+
+    async def handle_create_eval_set_run(self, payload: EvalSetRunCreatedEvent) -> None:
+        """Handle evaluation set run creation."""
+        try:
+            self.evaluators = {eval.id: eval for eval in payload.evaluators}
+        except Exception as e:
+            logger.error(f"Failed to handle create eval set run event: {e}")
+
+    async def handle_create_eval_run(self, payload: EvalRunCreatedEvent) -> None:
+        """Handle individual evaluation run creation."""
+        try:
+            if not self.display_started:
+                self.start_display()
+
+            self.console.print(f"  ○ [dim]{payload.eval_item.name}[/dim] - Running...")
+        except Exception as e:
+            logger.error(f"Failed to handle create eval run event: {e}")
+
+    def _display_logs_panel(self, eval_name: str, logs, error_msg: str = "") -> None:
+        """Display execution logs panel with optional exception at the end."""
+        self.console.print(
+            Rule(
+                f"[dim italic]Execution Logs: {eval_name}[/dim italic]",
+                style="dim",
+                align="center",
+            )
+        )
+
+        if logs:
+            for record in logs:
+                self.console.print(f"  [dim]{record.getMessage()}[/dim]")
+        elif not error_msg:
+            self.console.print("  [dim italic]No execution logs[/dim italic]")
+
+        if error_msg:
+            self.console.print(f"  [red]{error_msg}[/red]")
+
+        self.console.print(Rule(style="dim"))
+
+    async def handle_update_eval_run(self, payload: EvalRunUpdatedEvent) -> None:
+        """Handle evaluation run updates."""
+        try:
+            if payload.success:
+                self.eval_results_by_name[payload.eval_item.name] = payload.eval_results
+                self._display_successful_evaluation(
+                    payload.eval_item.name, payload.eval_results
+                )
+                self._display_logs_panel(payload.eval_item.name, payload.logs)
+            else:
+                error_msg = self._extract_error_message(payload)
+                self._display_failed_evaluation(payload.eval_item.name)
+
+                if payload.exception_details.runtime_exception:  # type: ignore
+                    self._display_logs_panel(
+                        payload.eval_item.name, payload.logs, error_msg
+                    )
+                else:
+                    self.console.print(f"  [red]{error_msg}[/red]")
+                    self.console.print()
+        except Exception as e:
+            logger.error(f"Console reporter error: {e}")
+
+    async def handle_update_eval_set_run(self, payload: EvalSetRunUpdatedEvent) -> None:
+        """Handle evaluation set run completion."""
+        try:
+            self.final_results = payload.evaluator_scores
+            self.display_final_results()
+        except Exception as e:
+            logger.error(f"Console reporter error: {e}")
+
+    def display_final_results(self):
+        """Display final results summary."""
+        self.console.print()
+
+        if hasattr(self, "final_results") and self.final_results:
+            from rich.table import Table
+
+            # Group evaluators by ID to organize display
+            evaluator_ids = list(self.final_results.keys())
+
+            # Print title
+            self.console.print("[bold]Evaluation Results[/bold]")
+            self.console.print()
+
+            # Create single summary table
+            summary_table = Table(show_header=True, padding=(0, 2))
+            summary_table.add_column("Evaluation", style="cyan")
+
+            # Add column for each evaluator
+            for evaluator_id in evaluator_ids:
+                evaluator_name = self._get_evaluator_name(evaluator_id)
+                summary_table.add_column(evaluator_name, justify="right")
+
+            # Add row for each evaluation
+            for eval_name, eval_results in self.eval_results_by_name.items():
+                row_values = [eval_name]
+
+                # Get score for each evaluator
+                for evaluator_id in evaluator_ids:
+                    score_found = False
+                    for eval_result in eval_results:
+                        if eval_result.evaluator_id == evaluator_id:
+                            score_value = self._convert_score_to_numeric(eval_result)
+                            row_values.append(f"{score_value:.1f}")
+                            score_found = True
+                            break
+
+                    if not score_found:
+                        row_values.append("-")
+
+                summary_table.add_row(*row_values)
+
+            # Add separator row before average
+            summary_table.add_section()
+
+            # Add average row
+            avg_row_values = ["[bold]Average[/bold]"]
+            for evaluator_id in evaluator_ids:
+                avg_score = self.final_results[evaluator_id]
+                avg_row_values.append(f"[bold]{avg_score:.1f}[/bold]")
+
+            summary_table.add_row(*avg_row_values)
+
+            self.console.print(summary_table)
+            self.console.print()
+        else:
+            self.console.print(
+                "→ [bold green]All evaluations completed successfully![/bold green]"
+            )
+            self.console.print()
+
+    async def subscribe_to_eval_runtime_events(self, event_bus: EventBus) -> None:
+        """Subscribe to evaluation runtime events."""
+        event_bus.subscribe(
+            EvaluationEvents.CREATE_EVAL_SET_RUN, self.handle_create_eval_set_run
+        )
+        event_bus.subscribe(
+            EvaluationEvents.CREATE_EVAL_RUN, self.handle_create_eval_run
+        )
+        event_bus.subscribe(
+            EvaluationEvents.UPDATE_EVAL_RUN, self.handle_update_eval_run
+        )
+        event_bus.subscribe(
+            EvaluationEvents.UPDATE_EVAL_SET_RUN, self.handle_update_eval_set_run
+        )

uipath/_cli/_evals/_models/_exceptions.py

@@ -0,0 +1,5 @@
+class EvaluationRuntimeException(Exception):
+    def __init__(self, spans, logs, root_exception):
+        self.spans = spans
+        self.logs = logs
+        self.root_exception = root_exception

uipath/_cli/_evals/_models/_output.py

@@ -1,3 +1,4 @@
+import logging
 from typing import List, Optional
 
 from opentelemetry.sdk.trace import ReadableSpan
@@ -15,6 +16,7 @@ class UiPathEvalRunExecutionOutput(BaseModel):
 
     execution_time: float
     spans: list[ReadableSpan]
+    logs: list[logging.LogRecord]
     result: UiPathRuntimeResult
 
 

uipath/_cli/_evals/_progress_reporter.py

@@ -7,6 +7,7 @@ import os
 from typing import Any, Dict, List
 
 from opentelemetry import trace
+from rich.console import Console
 
 from uipath import UiPath
 from uipath._cli._evals._models._evaluation_set import EvaluationItem, EvaluationStatus
@@ -68,6 +69,7 @@ class StudioWebProgressReporter:
 
         self._client = uipath.api_client
         self._console = console_logger
+        self._rich_console = Console()
         self._project_id = os.getenv("UIPATH_PROJECT_ID", None)
         if not self._project_id:
             logger.warning(
@@ -79,6 +81,10 @@ class StudioWebProgressReporter:
         self.evaluator_scores: Dict[str, List[float]] = {}
         self.eval_run_ids: Dict[str, str] = {}
 
+    def _format_error_message(self, error: Exception, context: str) -> None:
+        """Helper method to format and display error messages consistently."""
+        self._rich_console.print(f"    • \u26a0  [dim]{context}: {error}[/dim]")
+
     @gracefully_handle_errors
     async def create_eval_set_run(
         self,
@@ -182,7 +188,7 @@ class StudioWebProgressReporter:
             logger.debug(f"Created eval set run with ID: {eval_set_run_id}")
 
         except Exception as e:
-            logger.error(f"Failed to handle create eval set run event: {e}")
+            self._format_error_message(e, "StudioWeb create eval set run error")
 
     async def handle_create_eval_run(self, payload: EvalRunCreatedEvent) -> None:
         try:
@@ -197,7 +203,7 @@ class StudioWebProgressReporter:
                 logger.warning("Cannot create eval run: eval_set_run_id not available")
 
         except Exception as e:
-            logger.error(f"Failed to handle create eval run event: {e}")
+            self._format_error_message(e, "StudioWeb create eval run error")
 
     async def handle_update_eval_run(self, payload: EvalRunUpdatedEvent) -> None:
         try:
@@ -238,7 +244,7 @@ class StudioWebProgressReporter:
                 logger.debug(f"Updated eval run with ID: {eval_run_id}")
 
         except Exception as e:
-            logger.error(f"Failed to handle update eval run event: {e}")
+            self._format_error_message(e, "StudioWeb reporting error")
 
     async def handle_update_eval_set_run(self, payload: EvalSetRunUpdatedEvent) -> None:
         try:
@@ -254,7 +260,7 @@ class StudioWebProgressReporter:
                 )
 
         except Exception as e:
-            logger.error(f"Failed to handle update eval set run event: {e}")
+            self._format_error_message(e, "StudioWeb update eval set run error")
 
     async def subscribe_to_eval_runtime_events(self, event_bus: EventBus) -> None:
         event_bus.subscribe(
@@ -270,7 +276,7 @@ class StudioWebProgressReporter:
             EvaluationEvents.UPDATE_EVAL_SET_RUN, self.handle_update_eval_set_run
         )
 
-        logger.info("StudioWeb progress reporter subscribed to evaluation events")
+        logger.debug("StudioWeb progress reporter subscribed to evaluation events")
 
     def _extract_agent_snapshot(self, entrypoint: str) -> StudioWebAgentSnapshot:
         try:

uipath/_cli/_evals/_runtime.py

@@ -1,4 +1,6 @@
 import json
+import logging
+import uuid
 from collections import defaultdict
 from pathlib import Path
 from time import time
@@ -9,6 +11,7 @@ from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 
 from ..._events._event_bus import EventBus
 from ..._events._events import (
+    EvalItemExceptionDetails,
     EvalRunCreatedEvent,
     EvalRunUpdatedEvent,
     EvalSetRunCreatedEvent,
@@ -25,9 +28,11 @@ from .._runtime._contracts import (
     UiPathRuntimeResult,
     UiPathRuntimeStatus,
 )
+from .._runtime._logging import ExecutionLogHandler
 from .._utils._eval_set import EvalHelpers
 from ._evaluator_factory import EvaluatorFactory
 from ._models._evaluation_set import EvaluationItem, EvaluationSet
+from ._models._exceptions import EvaluationRuntimeException
 from ._models._output import (
     EvaluationResultDto,
     EvaluationRunResult,
@@ -72,6 +77,33 @@ class ExecutionSpanExporter(SpanExporter):
         self.clear()
 
 
+class ExecutionLogsExporter:
+    """Custom exporter that stores multiple execution log handlers."""
+
+    def __init__(self):
+        self._log_handlers: dict[str, ExecutionLogHandler] = {}
+
+    def register(self, execution_id: str, handler: ExecutionLogHandler) -> None:
+        self._log_handlers[execution_id] = handler
+
+    def get_logs(self, execution_id: str) -> list[logging.LogRecord]:
+        """Clear stored spans for one or all executions."""
+        log_handler = self._log_handlers.get(execution_id)
+        return log_handler.buffer if log_handler else []
+
+    def clear(self, execution_id: Optional[str] = None) -> None:
+        """Clear stored spans for one or all executions."""
+        if execution_id:
+            self._log_handlers.pop(execution_id, None)
+        else:
+            self._log_handlers.clear()
+
+    def flush_logs(self, execution_id: str, target_handler: logging.Handler) -> None:
+        log_handler = self._log_handlers.get(execution_id)
+        if log_handler:
+            log_handler.flush_execution_logs(target_handler)
+
+
 class UiPathEvalContext(UiPathRuntimeContext):
     """Context used for evaluation runs."""
 
@@ -96,6 +128,8 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         self.event_bus: EventBus = event_bus
         self.span_exporter: ExecutionSpanExporter = ExecutionSpanExporter()
         self.factory.add_span_exporter(self.span_exporter)
+        self.logs_exporter: ExecutionLogsExporter = ExecutionLogsExporter()
+        self.execution_id = str(uuid.uuid4())
 
     @classmethod
     def from_eval_context(
@@ -110,9 +144,6 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         if self.context.eval_set is None:
             raise ValueError("eval_set must be provided for evaluation runs")
 
-        if not self.context.execution_id:
-            raise ValueError("execution_id must be provided for evaluation runs")
-
         event_bus = self.event_bus
 
         evaluation_set = EvalHelpers.load_eval_set(
@@ -126,7 +157,7 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         await event_bus.publish(
             EvaluationEvents.CREATE_EVAL_SET_RUN,
             EvalSetRunCreatedEvent(
-                execution_id=self.context.execution_id,
+                execution_id=self.execution_id,
                 entrypoint=self.context.entrypoint or "",
                 eval_set_id=evaluation_set.id,
                 no_of_evals=len(evaluation_set.evaluations),
@@ -142,7 +173,7 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
             await event_bus.publish(
                 EvaluationEvents.CREATE_EVAL_RUN,
                 EvalRunCreatedEvent(
-                    execution_id=self.context.execution_id,
+                    execution_id=self.execution_id,
                     eval_item=eval_item,
                 ),
             )
@@ -153,60 +184,96 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
 
             results.evaluation_set_results.append(evaluation_run_results)
 
-            agent_execution_output = await self.execute_runtime(eval_item)
-            evaluation_item_results: list[EvalItemResult] = []
-
-            for evaluator in evaluators:
-                evaluation_result = await self.run_evaluator(
-                    evaluator=evaluator,
-                    execution_output=agent_execution_output,
-                    eval_item=eval_item,
-                )
+            try:
+                agent_execution_output = await self.execute_runtime(eval_item)
+                evaluation_item_results: list[EvalItemResult] = []
+
+                for evaluator in evaluators:
+                    evaluation_result = await self.run_evaluator(
+                        evaluator=evaluator,
+                        execution_output=agent_execution_output,
+                        eval_item=eval_item,
+                    )
 
-                dto_result = EvaluationResultDto.from_evaluation_result(
-                    evaluation_result
-                )
-                evaluator_counts[evaluator.id] += 1
-                count = evaluator_counts[evaluator.id]
-                evaluator_averages[evaluator.id] += (
-                    dto_result.score - evaluator_averages[evaluator.id]
-                ) / count
-
-                evaluation_run_results.evaluation_run_results.append(
-                    EvaluationRunResultDto(
-                        evaluator_name=evaluator.name,
-                        result=dto_result,
+                    dto_result = EvaluationResultDto.from_evaluation_result(
+                        evaluation_result
                     )
-                )
-                evaluation_item_results.append(
-                    EvalItemResult(
-                        evaluator_id=evaluator.id,
-                        result=evaluation_result,
+                    evaluator_counts[evaluator.id] += 1
+                    count = evaluator_counts[evaluator.id]
+                    evaluator_averages[evaluator.id] += (
+                        dto_result.score - evaluator_averages[evaluator.id]
+                    ) / count
+
+                    evaluation_run_results.evaluation_run_results.append(
+                        EvaluationRunResultDto(
+                            evaluator_name=evaluator.name,
+                            result=dto_result,
+                        )
                     )
+                    evaluation_item_results.append(
+                        EvalItemResult(
+                            evaluator_id=evaluator.id,
+                            result=evaluation_result,
+                        )
+                    )
+
+                evaluation_run_results.compute_average_score()
+
+                await event_bus.publish(
+                    EvaluationEvents.UPDATE_EVAL_RUN,
+                    EvalRunUpdatedEvent(
+                        execution_id=self.execution_id,
+                        eval_item=eval_item,
+                        eval_results=evaluation_item_results,
+                        success=not agent_execution_output.result.error,
+                        agent_output=agent_execution_output.result.output,
+                        agent_execution_time=agent_execution_output.execution_time,
+                        spans=agent_execution_output.spans,
+                        logs=agent_execution_output.logs,
+                    ),
+                    wait_for_completion=False,
                 )
+            except Exception as e:
+                exception_details = EvalItemExceptionDetails(exception=e)
 
-            evaluation_run_results.compute_average_score()
+                for evaluator in evaluators:
+                    evaluator_counts[evaluator.id] += 1
+                    count = evaluator_counts[evaluator.id]
+                    evaluator_averages[evaluator.id] += (
+                        0.0 - evaluator_averages[evaluator.id]
+                    ) / count
 
-            await event_bus.publish(
-                EvaluationEvents.UPDATE_EVAL_RUN,
-                EvalRunUpdatedEvent(
-                    execution_id=self.context.execution_id,
+                eval_run_updated_event = EvalRunUpdatedEvent(
+                    execution_id=self.execution_id,
                     eval_item=eval_item,
-                    eval_results=evaluation_item_results,
-                    success=not agent_execution_output.result.error,
-                    agent_output=agent_execution_output.result.output,
-                    agent_execution_time=agent_execution_output.execution_time,
-                    spans=agent_execution_output.spans,
-                ),
-                wait_for_completion=False,
-            )
+                    eval_results=[],
+                    success=False,
+                    agent_output={},
+                    agent_execution_time=0.0,
+                    exception_details=exception_details,
+                    spans=[],
+                    logs=[],
+                )
+                if isinstance(e, EvaluationRuntimeException):
+                    eval_run_updated_event.spans = e.spans
+                    eval_run_updated_event.logs = e.logs
+                    eval_run_updated_event.exception_details.exception = (  # type: ignore
+                        e.root_exception
+                    )
+                    eval_run_updated_event.exception_details.runtime_exception = True  # type: ignore
+
+                await event_bus.publish(
+                    EvaluationEvents.UPDATE_EVAL_RUN,
+                    eval_run_updated_event,
+                    wait_for_completion=False,
+                )
 
         results.compute_average_score()
 
         await event_bus.publish(
             EvaluationEvents.UPDATE_EVAL_SET_RUN,
             EvalSetRunUpdatedEvent(
-                execution_id=self.context.execution_id,
+                execution_id=self.execution_id,
                 evaluator_scores=evaluator_averages,
             ),
             wait_for_completion=False,
@@ -218,14 +285,30 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         )
         return self.context.result
 
+    def _get_and_clear_execution_data(
+        self, execution_id: str
+    ) -> tuple[List[ReadableSpan], list[logging.LogRecord]]:
+        spans = self.span_exporter.get_spans(execution_id)
+        self.span_exporter.clear(execution_id)
+
+        logs = self.logs_exporter.get_logs(execution_id)
+        self.logs_exporter.clear(execution_id)
+
+        return spans, logs
+
     async def execute_runtime(
         self, eval_item: EvaluationItem
     ) -> UiPathEvalRunExecutionOutput:
+        eval_item_id = eval_item.id
         runtime_context: C = self.factory.new_context(
-            execution_id=eval_item.id,
+            execution_id=eval_item_id,
             input_json=eval_item.inputs,
             is_eval_run=True,
+            log_handler=self._setup_execution_logging(eval_item_id),
         )
+        if runtime_context.execution_id is None:
+            raise ValueError("execution_id must be set for eval runs")
+
         attributes = {
             "evalId": eval_item.id,
             "span_type": "eval",
@@ -234,18 +317,22 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
             attributes["execution.id"] = runtime_context.execution_id
 
         start_time = time()
-
-        result = await self.factory.execute_in_root_span(
-            runtime_context, root_span=eval_item.name, attributes=attributes
-        )
+        try:
+            result = await self.factory.execute_in_root_span(
+                runtime_context, root_span=eval_item.name, attributes=attributes
+            )
+        except Exception as e:
+            spans, logs = self._get_and_clear_execution_data(
+                runtime_context.execution_id
+            )
+            raise EvaluationRuntimeException(
+                spans=spans,
+                logs=logs,
+                root_exception=e,
+            ) from e
 
         end_time = time()
-
-        if runtime_context.execution_id is None:
-            raise ValueError("execution_id must be set for eval runs")
-
-        spans = self.span_exporter.get_spans(runtime_context.execution_id)
-        self.span_exporter.clear(runtime_context.execution_id)
+        spans, logs = self._get_and_clear_execution_data(runtime_context.execution_id)
 
         if result is None:
             raise ValueError("Execution result cannot be None for eval runs")
@@ -253,9 +340,15 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         return UiPathEvalRunExecutionOutput(
             execution_time=end_time - start_time,
             spans=spans,
+            logs=logs,
             result=result,
         )
 
+    def _setup_execution_logging(self, eval_item_id: str) -> ExecutionLogHandler:
+        execution_log_handler = ExecutionLogHandler(eval_item_id)
+        self.logs_exporter.register(eval_item_id, execution_log_handler)
+        return execution_log_handler
+
     async def run_evaluator(
         self,
         evaluator: BaseEvaluator[Any],

uipath/_cli/_runtime/_contracts.py

@@ -519,7 +519,8 @@ class UiPathBaseRuntime(ABC):
 
         await self.validate()
 
-        # Intercept all stdout/stderr/logs and write them to a file (runtime/evals), stdout (debug)
+        # Intercept all stdout/stderr/logs
+        # write to file (runtime) or stdout (debug)
         self.logs_interceptor = LogsInterceptor(
             min_level=self.context.logs_min_level,
             dir=self.context.runtime_dir,
@@ -649,7 +650,7 @@ class UiPathBaseRuntime(ABC):
             raise
         finally:
             # Restore original logging
-            if self.logs_interceptor:
+            if hasattr(self, "logs_interceptor"):
                 self.logs_interceptor.teardown()
 
             await self.cleanup()
@@ -698,6 +699,7 @@ class UiPathRuntimeFactory(Generic[T, C]):
         self.context_generator = context_generator
         self.tracer_provider: TracerProvider = TracerProvider()
         self.tracer_span_processors: List[SpanProcessor] = []
+        self.logs_exporter: Optional[Any] = None
         trace.set_tracer_provider(self.tracer_provider)
 
     def add_span_exporter(

uipath/_cli/_runtime/_logging.py

@@ -10,6 +10,35 @@ current_execution_id: ContextVar[Optional[str]] = ContextVar(
 )
 
 
+class ExecutionLogHandler(logging.Handler):
+    """Handler for an execution unit."""
+
+    def __init__(self, execution_id: str):
+        """Initialize the buffered handler."""
+        super().__init__()
+        self.execution_id: str = execution_id
+        self.buffer: list[logging.LogRecord] = []
+        self.setFormatter(logging.Formatter("[%(asctime)s][%(levelname)s] %(message)s"))
+
+    def emit(self, record: logging.LogRecord):
+        """Store log record in buffer grouped by execution_id."""
+        self.buffer.append(record)
+
+    def flush_execution_logs(self, target_handler: logging.Handler) -> None:
+        """Flush buffered logs to a target handler.
+
+        Args:
+            target_handler: The handler to write the logs to
+        """
+        for record in self.buffer:
+            target_handler.handle(record)
+        target_handler.flush()
+
+    def clear_execution(self) -> None:
+        """Clear buffered logs without writing them."""
+        self.buffer.clear()
+
+
 class PersistentLogsHandler(logging.FileHandler):
     """A simple log handler that always writes to a single file without rotation."""
 

uipath/_cli/cli_eval.py

@@ -2,11 +2,11 @@
 import ast
 import asyncio
 import os
-import uuid
 from typing import List, Optional
 
 import click
 
+from uipath._cli._evals._console_progress_reporter import ConsoleProgressReporter
 from uipath._cli._evals._progress_reporter import StudioWebProgressReporter
 from uipath._cli._evals._runtime import (
     UiPathEvalContext,
@@ -17,6 +17,7 @@ from uipath._cli._runtime._contracts import (
     UiPathRuntimeFactory,
 )
 from uipath._cli._runtime._runtime import UiPathScriptRuntime
+from uipath._cli._utils._constants import UIPATH_PROJECT_ID
 from uipath._cli._utils._folders import get_personal_workspace_key_async
 from uipath._cli.middlewares import Middlewares
 from uipath._events._event_bus import EventBus
@@ -39,6 +40,22 @@ class LiteralOption(click.Option):
             raise click.BadParameter(value) from e
 
 
+def setup_reporting_prereq(no_report: bool) -> bool:
+    if no_report:
+        return False
+
+    if not os.getenv(UIPATH_PROJECT_ID, False):
+        console.warning(
+            "UIPATH_PROJECT_ID environment variable not set. Results will no be reported to Studio Web."
+        )
+        return False
+    if not os.getenv("UIPATH_FOLDER_KEY"):
+        os.environ["UIPATH_FOLDER_KEY"] = asyncio.run(
+            get_personal_workspace_key_async()
+        )
+    return True
+
+
 @click.command()
 @click.argument("entrypoint", required=False)
 @click.argument("eval_set", required=False)
@@ -79,10 +96,7 @@ def eval(
         workers: Number of parallel workers for running evaluations
         no_report: Do not report the evaluation results
     """
-    if not no_report and not os.getenv("UIPATH_FOLDER_KEY"):
-        os.environ["UIPATH_FOLDER_KEY"] = asyncio.run(
-            get_personal_workspace_key_async()
-        )
+    should_register_progress_reporter = setup_reporting_prereq(no_report)
 
     result = Middlewares.next(
         "eval",
@@ -92,6 +106,7 @@ def eval(
         no_report=no_report,
         workers=workers,
         execution_output_file=output_file,
+        register_progress_reporter=should_register_progress_reporter,
     )
 
     if result.error_message:
@@ -100,7 +115,7 @@ def eval(
     if result.should_continue:
         event_bus = EventBus()
 
-        if not no_report:
+        if should_register_progress_reporter:
             progress_reporter = StudioWebProgressReporter(LlmOpsHttpExporter())
             asyncio.run(progress_reporter.subscribe_to_eval_runtime_events(event_bus))
 
@@ -114,7 +129,6 @@ def eval(
         eval_context = UiPathEvalContext.with_defaults(
             execution_output_file=output_file,
             entrypoint=runtime_entrypoint,
-            execution_id=str(uuid.uuid4()),
         )
 
         eval_context.no_report = no_report
@@ -122,6 +136,9 @@ def eval(
         eval_context.eval_set = eval_set or EvalHelpers.auto_discover_eval_set()
         eval_context.eval_ids = eval_ids
 
+        console_reporter = ConsoleProgressReporter()
+        asyncio.run(console_reporter.subscribe_to_eval_runtime_events(event_bus))
+
         try:
             runtime_factory = UiPathRuntimeFactory(
                 UiPathScriptRuntime,
@@ -143,11 +160,9 @@ def eval(
             asyncio.run(execute())
         except Exception as e:
             console.error(
-                f"Error: Unexpected error occurred - {str(e)}", include_traceback=True
+                f"Error occurred: {e or 'Execution failed'}", include_traceback=True
             )
 
-    console.success("Evaluation completed successfully")
-
 
 if __name__ == "__main__":
     eval()

uipath/_cli/middlewares.py

@@ -121,20 +121,20 @@ class Middlewares:
                 ]
 
             if middlewares:
-                logger.info(f"Found {len(middlewares)} middleware plugins")
+                logger.debug(f"Found {len(middlewares)} middleware plugins")
 
                 for entry_point in middlewares:
                     try:
                         register_func = entry_point.load()
                         register_func()
-                        logger.info(f"Loaded middleware plugin: {entry_point.name}")
+                        logger.debug(f"Loaded middleware plugin: {entry_point.name}")
                     except Exception as e:
                         console.error(
                             f"Failed to load middleware plugin {entry_point.name}: {str(e)}",
                             include_traceback=True,
                         )
             else:
-                logger.info("No middleware plugins found")
+                logger.debug("No middleware plugins found")
 
         except Exception as e:
             logger.error(f"No middleware plugins loaded: {str(e)}")

uipath/_events/_events.py

@@ -1,8 +1,9 @@
 import enum
-from typing import Any, List, Union
+import logging
+from typing import Any, List, Optional, Union
 
 from opentelemetry.sdk.trace import ReadableSpan
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, model_validator
 
 from uipath._cli._evals._models._evaluation_set import EvaluationItem
 from uipath.eval.models import EvalItemResult
@@ -28,6 +29,13 @@ class EvalRunCreatedEvent(BaseModel):
     eval_item: EvaluationItem
 
 
+class EvalItemExceptionDetails(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    runtime_exception: bool = False
+    exception: Exception
+
+
 class EvalRunUpdatedEvent(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
@@ -38,6 +46,14 @@ class EvalRunUpdatedEvent(BaseModel):
     agent_output: Any
     agent_execution_time: float
     spans: List[ReadableSpan]
+    logs: List[logging.LogRecord]
+    exception_details: Optional[EvalItemExceptionDetails] = None
+
+    @model_validator(mode="after")
+    def validate_exception_details(self):
+        if not self.success and self.exception_details is None:
+            raise ValueError("exception_details must be provided when success is False")
+        return self
 
 
 class EvalSetRunUpdatedEvent(BaseModel):

uipath/_services/connections_service.py

@@ -1,14 +1,17 @@
 import json
 import logging
-from typing import Any, Dict
+from typing import Any, Dict, List, Optional
+
+from httpx import Response
 
 from .._config import Config
 from .._execution_context import ExecutionContext
-from .._utils import Endpoint, RequestSpec, infer_bindings
+from .._utils import Endpoint, RequestSpec, header_folder, infer_bindings
 from ..models import Connection, ConnectionToken, EventArguments
 from ..models.connections import ConnectionTokenType
 from ..tracing._traced import traced
 from ._base_service import BaseService
+from .folder_service import FolderService
 
 logger: logging.Logger = logging.getLogger("uipath")
 
@@ -20,9 +23,16 @@ class ConnectionsService(BaseService):
     and secure token management.
     """
 
-    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+    def __init__(
+        self,
+        config: Config,
+        execution_context: ExecutionContext,
+        folders_service: FolderService,
+    ) -> None:
         super().__init__(config=config, execution_context=execution_context)
+        self._folders_service = folders_service
 
+    @infer_bindings(resource_type="connection", name="key")
     @traced(
         name="connections_retrieve",
         run_type="uipath",
@@ -45,6 +55,117 @@ class ConnectionsService(BaseService):
         response = self.request(spec.method, url=spec.endpoint)
         return Connection.model_validate(response.json())
 
+    @traced(name="connections_list", run_type="uipath")
+    def list(
+        self,
+        *,
+        name: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        connector_key: Optional[str] = None,
+        skip: Optional[int] = None,
+        top: Optional[int] = None,
+    ) -> List[Connection]:
+        """Lists all connections with optional filtering.
+
+        Args:
+            name: Optional connection name to filter (supports partial matching)
+            folder_path: Optional folder path for filtering connections
+            folder_key: Optional folder key (mutually exclusive with folder_path)
+            connector_key: Optional connector key to filter by specific connector type
+            skip: Number of records to skip (for pagination)
+            top: Maximum number of records to return
+
+        Returns:
+            List[Connection]: List of connection instances
+
+        Raises:
+            ValueError: If both folder_path and folder_key are provided together, or if
+                folder_path is provided but cannot be resolved to a folder_key
+
+        Examples:
+            >>> # List all connections
+            >>> connections = sdk.connections.list()
+
+            >>> # Find connections by name
+            >>> salesforce_conns = sdk.connections.list(name="Salesforce")
+
+            >>> # List all Slack connections in Finance folder
+            >>> connections = sdk.connections.list(
+            ...     folder_path="Finance",
+            ...     connector_key="uipath-slack"
+            ... )
+        """
+        spec = self._list_spec(
+            name=name,
+            folder_path=folder_path,
+            folder_key=folder_key,
+            connector_key=connector_key,
+            skip=skip,
+            top=top,
+        )
+        response = self.request(
+            spec.method, url=spec.endpoint, params=spec.params, headers=spec.headers
+        )
+
+        return self._parse_and_validate_list_response(response)
+
+    @traced(name="connections_list", run_type="uipath")
+    async def list_async(
+        self,
+        *,
+        name: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        connector_key: Optional[str] = None,
+        skip: Optional[int] = None,
+        top: Optional[int] = None,
+    ) -> List[Connection]:
+        """Asynchronously lists all connections with optional filtering.
+
+        Args:
+            name: Optional connection name to filter (supports partial matching)
+            folder_path: Optional folder path for filtering connections
+            folder_key: Optional folder key (mutually exclusive with folder_path)
+            connector_key: Optional connector key to filter by specific connector type
+            skip: Number of records to skip (for pagination)
+            top: Maximum number of records to return
+
+        Returns:
+            List[Connection]: List of connection instances
+
+        Raises:
+            ValueError: If both folder_path and folder_key are provided together, or if
+                folder_path is provided but cannot be resolved to a folder_key
+
+        Examples:
+            >>> # List all connections
+            >>> connections = await sdk.connections.list_async()
+
+            >>> # Find connections by name
+            >>> salesforce_conns = await sdk.connections.list_async(name="Salesforce")
+
+            >>> # List all Slack connections in Finance folder
+            >>> connections = await sdk.connections.list_async(
+            ...     folder_path="Finance",
+            ...     connector_key="uipath-slack"
+            ... )
+        """
+        spec = self._list_spec(
+            name=name,
+            folder_path=folder_path,
+            folder_key=folder_key,
+            connector_key=connector_key,
+            skip=skip,
+            top=top,
+        )
+        response = await self.request_async(
+            spec.method, url=spec.endpoint, params=spec.params, headers=spec.headers
+        )
+
+        return self._parse_and_validate_list_response(response)
+
+    @infer_bindings(resource_type="connection", name="key")
     @traced(
         name="connections_retrieve",
         run_type="uipath",
@@ -213,3 +334,97 @@ class ConnectionsService(BaseService):
             endpoint=Endpoint(f"/connections_/api/v1/Connections/{key}/token"),
             params={"tokenType": token_type.value},
         )
+
+    def _parse_and_validate_list_response(self, response: Response) -> List[Connection]:
+        """Parse and validate the list response from the API.
+
+        Handles both OData response format (with 'value' field) and raw list responses.
+
+        Args:
+            response: The HTTP response from the API
+
+        Returns:
+            List of validated Connection instances
+        """
+        data = response.json()
+
+        # Handle both OData responses (dict with 'value') and raw list responses
+        if isinstance(data, dict):
+            connections_data = data.get("value", [])
+        elif isinstance(data, list):
+            connections_data = data
+        else:
+            connections_data = []
+
+        return [Connection.model_validate(conn) for conn in connections_data]
+
+    def _list_spec(
+        self,
+        name: Optional[str] = None,
+        folder_path: Optional[str] = None,
+        folder_key: Optional[str] = None,
+        connector_key: Optional[str] = None,
+        skip: Optional[int] = None,
+        top: Optional[int] = None,
+    ) -> RequestSpec:
+        """Build the request specification for listing connections.
+
+        Args:
+            name: Optional connection name to filter (supports partial matching)
+            folder_path: Optional folder path for filtering connections
+            folder_key: Optional folder key (mutually exclusive with folder_path)
+            connector_key: Optional connector key to filter by specific connector type
+            skip: Number of records to skip (for pagination)
+            top: Maximum number of records to return
+
+        Returns:
+            RequestSpec with endpoint, params, and headers configured
+
+        Raises:
+            ValueError: If both folder_path and folder_key are provided together, or if
+                folder_path is provided but cannot be resolved to a folder_key
+        """
+        # Validate mutual exclusivity of folder_path and folder_key
+        if folder_path is not None and folder_key is not None:
+            raise ValueError(
+                "folder_path and folder_key are mutually exclusive and cannot be provided together"
+            )
+
+        # Resolve folder_path to folder_key if needed
+        resolved_folder_key = folder_key
+        if not resolved_folder_key and folder_path:
+            resolved_folder_key = self._folders_service.retrieve_key(
+                folder_path=folder_path
+            )
+            if not resolved_folder_key:
+                raise ValueError(f"Folder with path '{folder_path}' not found")
+
+        # Build OData filters
+        filters = []
+        if name:
+            # Escape single quotes in name for OData
+            escaped_name = name.replace("'", "''")
+            filters.append(f"contains(Name, '{escaped_name}')")
+        if connector_key:
+            filters.append(f"connector/key eq '{connector_key}'")
+
+        params = {}
+        if filters:
+            params["$filter"] = " and ".join(filters)
+        if skip is not None:
+            params["$skip"] = str(skip)
+        if top is not None:
+            params["$top"] = str(top)
+
+        # Always expand connector and folder for complete information
+        params["$expand"] = "connector,folder"
+
+        # Use header_folder which handles validation
+        headers = header_folder(resolved_folder_key, None)
+
+        return RequestSpec(
+            method="GET",
+            endpoint=Endpoint("/connections_/api/v1/Connections"),
+            params=params,
+            headers=headers,
+        )

uipath/_uipath.py

@@ -60,6 +60,7 @@ class UiPath:
         self._folders_service: Optional[FolderService] = None
         self._buckets_service: Optional[BucketsService] = None
         self._attachments_service: Optional[AttachmentsService] = None
+        self._connections_service: Optional[ConnectionsService] = None
 
         setup_logging(debug)
         self._execution_context = ExecutionContext()
@@ -98,7 +99,15 @@ class UiPath:
 
     @property
     def connections(self) -> ConnectionsService:
-        return ConnectionsService(self._config, self._execution_context)
+        if not self._connections_service:
+            if not self._folders_service:
+                self._folders_service = FolderService(
+                    self._config, self._execution_context
+                )
+            self._connections_service = ConnectionsService(
+                self._config, self._execution_context, self._folders_service
+            )
+        return self._connections_service
 
     @property
     def context_grounding(self) -> ContextGroundingService:

uipath/_utils/_infer_bindings.py

@@ -28,8 +28,10 @@ def infer_bindings(
                     all_args.get(name),  # type: ignore
                     all_args.get(folder_path, None),
                 ) as (name_overwrite_or_default, folder_path_overwrite_or_default):
-                    all_args[name] = name_overwrite_or_default
-                    all_args[folder_path] = folder_path_overwrite_or_default
+                    if name in sig.parameters:
+                        all_args[name] = name_overwrite_or_default
+                    if folder_path in sig.parameters:
+                        all_args[folder_path] = folder_path_overwrite_or_default
 
             return func(**all_args)
 

uipath/telemetry/_track.py

@@ -2,7 +2,7 @@ import json
 import os
 from functools import wraps
 from importlib.metadata import version
-from logging import INFO, LogRecord, getLogger
+from logging import WARNING, LogRecord, getLogger
 from typing import Any, Callable, Dict, Optional, Union
 
 from azure.monitor.opentelemetry import configure_azure_monitor
@@ -102,7 +102,7 @@ class _TelemetryClient:
             )
 
             _logger.addHandler(_AzureMonitorOpenTelemetryEventHandler())
-            _logger.setLevel(INFO)
+            _logger.setLevel(WARNING)
 
             _TelemetryClient._initialized = True
         except Exception:

{uipath-2.1.74.dist-info → uipath-2.1.76.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.74
+Version: 2.1.76
 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.1.74.dist-info → uipath-2.1.76.dist-info}/RECORD

@@ -2,14 +2,14 @@ uipath/__init__.py,sha256=IaeKItOOQXMa95avueJ3dAq-XcRHyZVNjcCGwlSB000,634
 uipath/_config.py,sha256=pi3qxPzDTxMEstj_XkGOgKJqD6RTHHv7vYv8sS_-d5Q,92
 uipath/_execution_context.py,sha256=Qo8VMUFgtiL-40KsZrvul5bGv1CRERle_fCw1ORCggY,2374
 uipath/_folder_context.py,sha256=D-bgxdwpwJP4b_QdVKcPODYh15kMDrOar2xNonmMSm4,1861
-uipath/_uipath.py,sha256=u01pAYrVYfwgAWGeSyD-3Eg33uNHFxhQaH1KAg9NSTA,4616
+uipath/_uipath.py,sha256=xvBwczfjrvrB96ZK7wo0IgDcPDQWuEqu4dioH9CKd4k,5021
 uipath/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 uipath/_cli/README.md,sha256=GLtCfbeIKZKNnGTCsfSVqRQ27V1btT1i2bSAyW_xZl4,474
 uipath/_cli/__init__.py,sha256=2RUgXYd8uJaYjA67xWb0w4IZuBmZoY8G1ccNmEQk9oM,2343
 uipath/_cli/cli_auth.py,sha256=ZEA0Fwoo77Ez9ctpRAIq7sbAwj8F4OouAbMp1g1OvjM,2601
 uipath/_cli/cli_deploy.py,sha256=KPCmQ0c_NYD5JofSDao5r6QYxHshVCRxlWDVnQvlp5w,645
 uipath/_cli/cli_dev.py,sha256=nEfpjw1PZ72O6jmufYWVrueVwihFxDPOeJakdvNHdOA,2146
-uipath/_cli/cli_eval.py,sha256=DK7FBLrNiBVEZgNBarlgjO065hsmQYLas-1e7nfIjLk,4816
+uipath/_cli/cli_eval.py,sha256=Tg9mEf0T4qkp_YpcqJVxmPp69JkjHF68teX4CM061F0,5444
 uipath/_cli/cli_init.py,sha256=Ac3-9tIH3rpikIX1ehWTo7InW5tjVNoz_w6fjvgLK4w,7052
 uipath/_cli/cli_invoke.py,sha256=m-te-EjhDpk_fhFDkt-yQFzmjEHGo5lQDGEQWxSXisQ,4395
 uipath/_cli/cli_new.py,sha256=9378NYUBc9j-qKVXV7oja-jahfJhXBg8zKVyaon7ctY,2102
@@ -18,7 +18,7 @@ uipath/_cli/cli_publish.py,sha256=DgyfcZjvfV05Ldy0Pk5y_Le_nT9JduEE_x-VpIc_Kq0,64
 uipath/_cli/cli_pull.py,sha256=PZ2hkfsfN-ElNa3FHjNetTux8XH03tDY5kWWqydQ2OY,6832
 uipath/_cli/cli_push.py,sha256=-j-gDIbT8GyU2SybLQqFl5L8KI9nu3CDijVtltDgX20,3132
 uipath/_cli/cli_run.py,sha256=1FKv20EjxrrP1I5rNSnL_HzbWtOAIMjB3M--4RPA_Yo,3709
-uipath/_cli/middlewares.py,sha256=GvMhDnx1BmA7rIe12s6Uqv1JdqNZhvraU0a91oqGag4,4976
+uipath/_cli/middlewares.py,sha256=0D9a-wphyetnH9T97F08o7-1OKWF1lMweFHHAR0xiOw,4979
 uipath/_cli/spinner.py,sha256=bS-U_HA5yne11ejUERu7CQoXmWdabUD2bm62EfEdV8M,1107
 uipath/_cli/_auth/_auth_server.py,sha256=22km0F1NFNXgyLbvtAx3ssiQlVGHroLdtDCWEqiCiMg,7106
 uipath/_cli/_auth/_auth_service.py,sha256=Thtp2wXZQAHqossPPXuP6sAEe4Px9xThhZutMECRrdU,6386
@@ -44,13 +44,15 @@ uipath/_cli/_dev/_terminal/_styles/terminal.tcss,sha256=ktVpKwXIXw2VZp8KIZD6fO9i
 uipath/_cli/_dev/_terminal/_utils/_chat.py,sha256=YUZxYVdmEManwHDuZsczJT1dWIYE1dVBgABlurwMFcE,8493
 uipath/_cli/_dev/_terminal/_utils/_exporter.py,sha256=oI6D_eMwrh_2aqDYUh4GrJg8VLGrLYhDahR-_o0uJns,4144
 uipath/_cli/_dev/_terminal/_utils/_logger.py,sha256=_ipTl_oAiMF9I7keGt2AAFAMz40DNLVMVkoiq-07UAU,2943
+uipath/_cli/_evals/_console_progress_reporter.py,sha256=HgB6pdMyoS6YVwuI3EpM2LBcH3U69nrdaTyNgPG8ssg,9304
 uipath/_cli/_evals/_evaluator_factory.py,sha256=Gycv94VtGOpMir_Gba-UoiAyrSRfbSfe8_pTfjzcA9Q,3875
-uipath/_cli/_evals/_progress_reporter.py,sha256=hpSt0CXpIoFJGsbqZkqmwyGO_TBNesbWKlvDJUEDxd8,16455
-uipath/_cli/_evals/_runtime.py,sha256=fo-wtUxZ9bvo1ftt_yu7o2oUBvrMqVNKCjaGH556-Vo,11506
+uipath/_cli/_evals/_progress_reporter.py,sha256=kX7rNSa-QCLXIzK-vb9Jjf-XLEtucdeiQPgPlSkpp2U,16778
+uipath/_cli/_evals/_runtime.py,sha256=dz3mpZCLxwnLEdkwLo6W7qzBuVAklx6LMWtd4OMRk9w,15489
 uipath/_cli/_evals/_models/_evaluation_set.py,sha256=XgPNLWciE4FgCYzZXV2kRYHzdtbc33FWSQmZQqVSdMk,4747
 uipath/_cli/_evals/_models/_evaluator.py,sha256=fuC3UOYwPD4d_wdynHeLSCzbu82golNAnnPnxC8Y4rk,3315
 uipath/_cli/_evals/_models/_evaluator_base_params.py,sha256=lTYKOV66tcjW85KHTyOdtF1p1VDaBNemrMAvH8bFIFc,382
-uipath/_cli/_evals/_models/_output.py,sha256=LjwMBGI78sDFa2Dl8b9ReXJmjig57pdLWpuiwChrRLo,3096
+uipath/_cli/_evals/_models/_exceptions.py,sha256=-oXLTDa4ab9Boa34ZxuUrCezf8ajIGrIEUVwZnmBASE,195
+uipath/_cli/_evals/_models/_output.py,sha256=DmwFXh1YdLiMXyXmyoZr_4hgrrv3oiHbrrtIWMqGfsg,3145
 uipath/_cli/_evals/_models/_sw_reporting.py,sha256=tSBLQFAdOIun8eP0vsqt56K6bmCZz_uMaWI3hskg_24,536
 uipath/_cli/_evals/_models/_trajectory_span.py,sha256=8ukM8sB9rvzBMHfC_gnexAC3xlp4uMDevKZrRzcgrm4,3637
 uipath/_cli/_evals/mocks/__init__.py,sha256=2WXwAy_oZw5bKp6L0HB13QygCJeftOB_Bget0AI6Gik,32
@@ -60,10 +62,10 @@ uipath/_cli/_evals/mocks/mocker_factory.py,sha256=V5QKSTtQxztTo4-fK1TyAaXw2Z3mHf
 uipath/_cli/_evals/mocks/mockito_mocker.py,sha256=LtYT6lJM9vc3qtbSZJcUeCzDn4zarkBVj7In_EX7kYY,2087
 uipath/_cli/_evals/mocks/mocks.py,sha256=WqjWtHqKQXAsO1Wwom3Zcr1T09GQygwBWVp-EsxdW8o,4443
 uipath/_cli/_push/sw_file_handler.py,sha256=iE8Sk1Z-9hxmLFFj3j-k4kTK6TzNFP6hUCmxTudG6JQ,18251
-uipath/_cli/_runtime/_contracts.py,sha256=D57cq5V5CZ9p13n_vRDHRcwyJYQUcJLlAMbAOzIiBNI,28932
+uipath/_cli/_runtime/_contracts.py,sha256=E8Is7EQfAu7_hCbeZI68gmTxSxo4X7_U4vcSl7D3Syg,28988
 uipath/_cli/_runtime/_escalation.py,sha256=x3vI98qsfRA-fL_tNkRVTFXioM5Gv2w0GFcXJJ5eQtg,7981
 uipath/_cli/_runtime/_hitl.py,sha256=VKbM021nVg1HEDnTfucSLJ0LsDn83CKyUtVzofS2qTU,11369
-uipath/_cli/_runtime/_logging.py,sha256=CIJNZH4S8SL980VI3XV9NIFdc97T-KJRT8QE7X1uWYw,12865
+uipath/_cli/_runtime/_logging.py,sha256=jwBfsy0Hi4zkfPH-v9dQ7m5dcJeuE0j_OxdpI-DhHaw,13854
 uipath/_cli/_runtime/_runtime.py,sha256=gby9-avNNlEATEfSXtY8FfJ8nREsSCGA4wMgDlSXTDE,2297
 uipath/_cli/_runtime/_script_executor.py,sha256=PjbmEbyCMofGH2F85b8RFsxdV3Tqw0kVqdWOOk2ZLlI,9687
 uipath/_cli/_templates/.psmdcp.template,sha256=C7pBJPt98ovEljcBvGtEUGoWjjQhu9jls1bpYjeLOKA,611
@@ -86,7 +88,7 @@ uipath/_cli/_utils/_tracing.py,sha256=2igb03j3EHjF_A406UhtCKkPfudVfFPjUq5tXUEG4o
 uipath/_cli/_utils/_uv_helpers.py,sha256=6SvoLnZPoKIxW0sjMvD1-ENV_HOXDYzH34GjBqwT138,3450
 uipath/_events/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 uipath/_events/_event_bus.py,sha256=4-VzstyX69cr7wT1EY7ywp-Ndyz2CyemD3Wk_-QmRpo,5496
-uipath/_events/_events.py,sha256=FhSqbEW4lcBp_QWcDsMtF5XtUtQ8S3rts6uEtMDmGbA,1252
+uipath/_events/_events.py,sha256=EzDfzpVm-EIH27Onad5mo8Go6-WB3S6_-6zZQ7qV58w,1811
 uipath/_resources/AGENTS.md,sha256=YWhWuX9XIbyVhVT3PnPc4Of3_q6bsNJcuzYu3N8f_Ug,25850
 uipath/_services/__init__.py,sha256=eYZElMfYDQTQU6MMjIke5J-GGT9pzLD5QfbwLiTQkEE,1037
 uipath/_services/_base_service.py,sha256=x9-9jhPzn9Z16KRdFHhJNvV-FZHvTniMsDfxlS4Cutk,5782
@@ -95,7 +97,7 @@ uipath/_services/api_client.py,sha256=kGm04ijk9AOEQd2BMxvQg-2QoB8dmyoDwFFDPyutAG
 uipath/_services/assets_service.py,sha256=pG0Io--SeiRRQmfUWPQPl1vq3csZlQgx30LBNKRmmF8,12145
 uipath/_services/attachments_service.py,sha256=NPQYK7CGjfBaNT_1S5vEAfODmOChTbQZforllFM2ofU,26678
 uipath/_services/buckets_service.py,sha256=5s8tuivd7GUZYj774DDUYTa0axxlUuesc4EBY1V5sdk,18496
-uipath/_services/connections_service.py,sha256=Gt8zPY4oA7cMYAU2LI3lBieoBpV81BOGelnzDWJl_V4,7931
+uipath/_services/connections_service.py,sha256=EbM4ywaJsvafPEhL5bLZDWLMOUK1UyDVLRc4vZgu3Fo,15905
 uipath/_services/context_grounding_service.py,sha256=Pjx-QQQEiSKD-hY6ityj3QUSALN3fIcKLLHr_NZ0d_g,37117
 uipath/_services/documents_service.py,sha256=UnFS8EpOZ_Ng2TZk3OiJJ3iNANvFs7QxuoG_v-lQj6c,24815
 uipath/_services/entities_service.py,sha256=QKCLE6wRgq3HZraF-M2mljy-8il4vsNHrQhUgkewVVk,14028
@@ -106,7 +108,7 @@ uipath/_services/processes_service.py,sha256=O_uHgQ1rnwiV5quG0OQqabAnE6Rf6cWrMEN
 uipath/_services/queues_service.py,sha256=VaG3dWL2QK6AJBOLoW2NQTpkPfZjsqsYPl9-kfXPFzA,13534
 uipath/_utils/__init__.py,sha256=VdcpnENJIa0R6Y26NoxY64-wUVyvb4pKfTh1wXDQeMk,526
 uipath/_utils/_endpoint.py,sha256=yYHwqbQuJIevpaTkdfYJS9CrtlFeEyfb5JQK5osTCog,2489
-uipath/_utils/_infer_bindings.py,sha256=yTl3JBgoLwtQV-RCUkDY4qZne9FtE3HHIiYgCAKAOKw,1727
+uipath/_utils/_infer_bindings.py,sha256=eCxfUjd37fOFZ6vOfKl2BhWVUt7iSSJ-VQ0-nDTBcaA,1836
 uipath/_utils/_logs.py,sha256=adfX_0UAn3YBeKJ8DQDeZs94rJyHGQO00uDfkaTpNWQ,510
 uipath/_utils/_read_overwrites.py,sha256=OQgG9ycPpFnLub5ELQdX9V2Fyh6F9_zDR3xoYagJaMI,5287
 uipath/_utils/_request_override.py,sha256=fIVHzgHVXITUlWcp8osNBwIafM1qm4_ejx0ng5UzfJ4,573
@@ -158,15 +160,15 @@ uipath/models/processes.py,sha256=bV31xTyF0hRWZmwy3bWj5L8dBD9wttWxfJjwzhjETmk,19
 uipath/models/queues.py,sha256=gnbeEyYlHtdqdxBalio0lw8mq-78YBG9MPMSkv1BWOg,6934
 uipath/telemetry/__init__.py,sha256=Wna32UFzZR66D-RzTKlPWlvji9i2HJb82NhHjCCXRjY,61
 uipath/telemetry/_constants.py,sha256=uRDuEZayBYtBA0tMx-2AS_D-oiVA7oKgp9zid9jNats,763
-uipath/telemetry/_track.py,sha256=G_Pyq8n8iMvoCWhUpWedlptXUSuUSbQBBzGxsh4DW9c,4654
+uipath/telemetry/_track.py,sha256=N7EMUJi8cnpZqlVL-B746MGvH1hk3urqWbV0T67UDB8,4660
 uipath/tracing/__init__.py,sha256=GKRINyWdHVrDsI-8mrZDLdf0oey6GHGlNZTOADK-kgc,224
 uipath/tracing/_otel_exporters.py,sha256=c0GKU_oUrAwrOrqbyu64c55z1TR6xk01d3y5fLUN1lU,3215
 uipath/tracing/_traced.py,sha256=yBIY05PCCrYyx50EIHZnwJaKNdHPNx-YTR1sHQl0a98,19901
 uipath/tracing/_utils.py,sha256=qd7N56tg6VXQ9pREh61esBgUWLNA0ssKsE0QlwrRWFM,11974
 uipath/utils/__init__.py,sha256=VD-KXFpF_oWexFg6zyiWMkxl2HM4hYJMIUDZ1UEtGx0,105
 uipath/utils/_endpoints_manager.py,sha256=iRTl5Q0XAm_YgcnMcJOXtj-8052sr6jpWuPNz6CgT0Q,8408
-uipath-2.1.74.dist-info/METADATA,sha256=YI-VaC3UPoQGy3mDnKYd4in3JnlExWwD9QzMJdO-H6s,6593
-uipath-2.1.74.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.74.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.74.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.74.dist-info/RECORD,,
+uipath-2.1.76.dist-info/METADATA,sha256=zT48rJq2Cbsdva0uAbrjk7eNsLGxBiq2YTjp327fJg8,6593
+uipath-2.1.76.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.76.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.76.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.76.dist-info/RECORD,,