uipath 2.1.74__tar.gz → 2.1.75__tar.gz

{uipath-2.1.74 → uipath-2.1.75}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.74
+Version: 2.1.75
 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 → uipath-2.1.75}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.74"
+version = "2.1.75"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

{uipath-2.1.74 → uipath-2.1.75}/samples/calculator/evals/eval-sets/default.json

@@ -4,7 +4,8 @@
   "name": "Basic Calculator Evaluation Set",
   "batchSize": 10,
   "evaluatorRefs": [
-    "equality"
+    "equality",
+    "llm-as-a-judge"
   ],
   "evaluations": [
     {

uipath-2.1.75/samples/calculator/evals/evaluators/llm-as-a-judge.json

@@ -0,0 +1,13 @@
+{
+  "fileName": "llm-as-a-judge.json",
+  "id": "llm-as-a-judge",
+  "name": "LLMAsAJudge Evaluator",
+  "description": "An evaluator that judges the agent based on it's run history and expected behavior",
+  "category": 3,
+  "type": 7,
+  "prompt": "As an expert evaluator, determine how well the agent did on a scale of 0-100. Focus on if the simulation was successful and if the agent behaved according to the expected output accounting for alternative valid expressions, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.\n----\nUserOrSyntheticInputGivenToAgent:\n{{UserOrSyntheticInput}}\n----\nSimulationInstructions:\n{{SimulationInstructions}}\n----\nExpectedAgentBehavior:\n{{ExpectedAgentBehavior}}\n----\nAgentRunHistory:\n{{AgentRunHistory}}\n",
+  "targetOutputKey": "*",
+  "model":"gpt-4.1-2025-04-14",
+  "createdAt": "2025-08-21T15:12:58.695Z",
+  "updatedAt": "2025-08-21T15:12:58.695Z"
+}

uipath-2.1.75/src/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, eval_item_payload) -> str:
+        """Extract clean error message from evaluation item."""
+        if hasattr(eval_item_payload, "_error_message"):
+            error_message = getattr(eval_item_payload, "_error_message", None)
+            if error_message:
+                return str(error_message) or "Execution failed"
+        return "Execution failed"
+
+    def _display_failed_evaluation(self, eval_name: str, error_msg: 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)
+
+        error_text = Text()
+        error_text.append("    ", style="")
+        error_text.append(error_msg, style="red")
+        self.console.print(error_text)
+
+    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}")
+
+    async def handle_update_eval_run(self, payload: EvalRunUpdatedEvent) -> None:
+        """Handle evaluation run updates."""
+        try:
+            if payload.success:
+                # Store results for final display
+                self.eval_results_by_name[payload.eval_item.name] = payload.eval_results
+                self._display_successful_evaluation(
+                    payload.eval_item.name, payload.eval_results
+                )
+            else:
+                error_msg = self._extract_error_message(payload.eval_item)
+                self._display_failed_evaluation(payload.eval_item.name, error_msg)
+
+            logs = payload.logs
+
+            self.console.print(
+                Rule(
+                    f"[dim italic]Execution Logs: {payload.eval_item.name}[/dim italic]",
+                    style="dim",
+                    align="center",
+                )
+            )
+
+            if len(logs) > 0:
+                for record in logs:
+                    log_line = f"  [dim]{record.getMessage()}[/dim]"
+                    self.console.print(log_line)
+            else:
+                self.console.print("  [dim italic]No execution logs[/dim italic]")
+
+            self.console.print(Rule(style="dim"))
+        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-2.1.74 → uipath-2.1.75}/src/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-2.1.74 → uipath-2.1.75}/src/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-2.1.74 → uipath-2.1.75}/src/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
@@ -25,6 +27,7 @@ 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
@@ -72,6 +75,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 +126,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 +142,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 +155,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 +171,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 +182,87 @@ 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.context.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,
-            )
+                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:
+                error_msg = str(e)
+                eval_item._error_message = error_msg  # type: ignore[attr-defined]
+
+                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.execution_id,
+                        eval_item=eval_item,
+                        eval_results=[],
+                        success=False,
+                        agent_output={},
+                        agent_execution_time=0.0,
+                        spans=[],
+                        logs=[],
+                    ),
+                    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,
@@ -221,10 +277,12 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
     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),
         )
         attributes = {
             "evalId": eval_item.id,
@@ -247,15 +305,24 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
         spans = self.span_exporter.get_spans(runtime_context.execution_id)
         self.span_exporter.clear(runtime_context.execution_id)
 
+        logs = self.logs_exporter.get_logs(runtime_context.execution_id)
+        self.logs_exporter.clear(runtime_context.execution_id)
+
         if result is None:
             raise ValueError("Execution result cannot be None for eval runs")
 
         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-2.1.74 → uipath-2.1.75}/src/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(