uipath 2.1.119__tar.gz → 2.1.121__tar.gz

{uipath-2.1.119 → uipath-2.1.121}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.119"
+version = "2.1.121"
 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.119 → uipath-2.1.121}/src/uipath/_cli/_evals/_progress_reporter.py

@@ -210,7 +210,7 @@ class StudioWebProgressReporter:
         }
 
     @gracefully_handle_errors
-    async def create_eval_set_run(
+    async def create_eval_set_run_sw(
         self,
         eval_set_id: str,
         agent_snapshot: StudioWebAgentSnapshot,
@@ -352,13 +352,15 @@ class StudioWebProgressReporter:
             is_coded = self._is_coded_evaluator(payload.evaluators)
             self.is_coded_eval[payload.execution_id] = is_coded
 
-            eval_set_run_id = await self.create_eval_set_run(
-                eval_set_id=payload.eval_set_id,
-                agent_snapshot=self._extract_agent_snapshot(payload.entrypoint),
-                no_of_evals=payload.no_of_evals,
-                evaluators=payload.evaluators,
-                is_coded=is_coded,
-            )
+            eval_set_run_id = payload.eval_set_run_id
+            if not eval_set_run_id:
+                eval_set_run_id = await self.create_eval_set_run_sw(
+                    eval_set_id=payload.eval_set_id,
+                    agent_snapshot=self._extract_agent_snapshot(payload.entrypoint),
+                    no_of_evals=payload.no_of_evals,
+                    evaluators=payload.evaluators,
+                    is_coded=is_coded,
+                )
             self.eval_set_run_ids[payload.execution_id] = eval_set_run_id
             current_span = trace.get_current_span()
             if current_span.is_recording():

{uipath-2.1.119 → uipath-2.1.121}/src/uipath/_cli/_evals/_runtime.py

@@ -151,6 +151,7 @@ class UiPathEvalContext(UiPathRuntimeContext):
     workers: Optional[int] = 1
     eval_set: Optional[str] = None
     eval_ids: Optional[List[str]] = None
+    eval_set_run_id: Optional[str] = None
     verbose: bool = False
 
 
@@ -214,6 +215,7 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
             EvalSetRunCreatedEvent(
                 execution_id=self.execution_id,
                 entrypoint=self.context.entrypoint or "",
+                eval_set_run_id=self.context.eval_set_run_id,
                 eval_set_id=evaluation_set.id,
                 no_of_evals=len(evaluation_set.evaluations),
                 evaluators=evaluators,

{uipath-2.1.119 → uipath-2.1.121}/src/uipath/_cli/_utils/_constants.py

@@ -45,8 +45,6 @@ PYTHON_BINARY_EXTENSIONS = {".pickle", ".pkl"}
 
 SPECIAL_EXTENSIONS = {""}  # Extensionless binary files
 
-UIPATH_PROJECT_ID = "UIPATH_PROJECT_ID"
-
 # Pre-compute the union for optimal performance
 BINARY_EXTENSIONS = (
     IMAGE_EXTENSIONS

{uipath-2.1.119 → uipath-2.1.121}/src/uipath/_cli/cli_eval.py

@@ -12,9 +12,9 @@ from uipath._cli._evals._runtime import (
     UiPathEvalContext,
 )
 from uipath._cli._runtime._runtime_factory import generate_runtime_factory
-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._config import UiPathConfig
 from uipath._events._event_bus import EventBus
 from uipath.eval._helpers import auto_discover_entrypoint
 from uipath.tracing import LlmOpsHttpExporter
@@ -39,12 +39,13 @@ def setup_reporting_prereq(no_report: bool) -> bool:
     if no_report:
         return False
 
-    if not os.getenv(UIPATH_PROJECT_ID, False):
+    if not UiPathConfig.is_studio_project:
         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"):
+
+    if not UiPathConfig.folder_key:
         folder_key = asyncio.run(get_personal_workspace_key_async())
         if folder_key:
             os.environ["UIPATH_FOLDER_KEY"] = folder_key
@@ -55,6 +56,12 @@ def setup_reporting_prereq(no_report: bool) -> bool:
 @click.argument("entrypoint", required=False)
 @click.argument("eval_set", required=False)
 @click.option("--eval-ids", cls=LiteralOption, default="[]")
+@click.option(
+    "--eval-set-run-id",
+    required=False,
+    type=str,
+    help="Custom evaluation set run ID (if not provided, a UUID will be generated)",
+)
 @click.option(
     "--no-report",
     is_flag=True,
@@ -78,6 +85,7 @@ def eval(
     entrypoint: Optional[str],
     eval_set: Optional[str],
     eval_ids: List[str],
+    eval_set_run_id: Optional[str],
     no_report: bool,
     workers: int,
     output_file: Optional[str],
@@ -88,6 +96,7 @@ def eval(
         entrypoint: Path to the agent script to evaluate (optional, will auto-discover if not specified)
         eval_set: Path to the evaluation set JSON file (optional, will auto-discover if not specified)
         eval_ids: Optional list of evaluation IDs
+        eval_set_run_id: Custom evaluation set run ID (optional, will generate UUID if not specified)
         workers: Number of parallel workers for running evaluations
         no_report: Do not report the evaluation results
     """
@@ -95,6 +104,7 @@ def eval(
         "entrypoint": entrypoint or auto_discover_entrypoint(),
         "eval_set": eval_set,
         "eval_ids": eval_ids,
+        "eval_set_run_id": eval_set_run_id,
         "workers": workers,
         "no_report": no_report,
         "output_file": output_file,
@@ -130,6 +140,7 @@ def eval(
 
         eval_context.no_report = no_report
         eval_context.workers = workers
+        eval_context.eval_set_run_id = eval_set_run_id
 
         # Load eval set to resolve the path
         eval_set_path = eval_set or EvalHelpers.auto_discover_eval_set()

{uipath-2.1.119 → uipath-2.1.121}/src/uipath/_cli/cli_init.py

@@ -10,6 +10,7 @@ from typing import Any, Dict, Optional
 
 import click
 
+from .._config import UiPathConfig
 from .._utils.constants import ENV_TELEMETRY_ENABLED
 from ..telemetry import track
 from ..telemetry._constants import _PROJECT_KEY, _TELEMETRY_CONFIG_FILE
@@ -43,9 +44,7 @@ def create_telemetry_config_file(target_directory: str) -> None:
         return
 
     os.makedirs(uipath_dir, exist_ok=True)
-    telemetry_data = {
-        _PROJECT_KEY: os.getenv("UIPATH_PROJECT_ID", None) or str(uuid.uuid4())
-    }
+    telemetry_data = {_PROJECT_KEY: UiPathConfig.project_id or str(uuid.uuid4())}
 
     with open(telemetry_file, "w") as f:
         json.dump(telemetry_data, f, indent=4)

{uipath-2.1.119 → uipath-2.1.121}/src/uipath/_cli/cli_pack.py

@@ -8,8 +8,8 @@ from string import Template
 import click
 from pydantic import TypeAdapter
 
-from uipath._cli._utils._constants import UIPATH_PROJECT_ID
 from uipath._cli.models.runtime_schema import Bindings, RuntimeSchema
+from uipath._config import UiPathConfig
 
 from ..telemetry import track
 from ..telemetry._constants import _PROJECT_KEY, _TELEMETRY_CONFIG_FILE
@@ -35,8 +35,8 @@ def get_project_id() -> str:
         Project ID string (either from telemetry file or newly generated).
     """
     # first check if this is a studio project
-    if os.getenv(UIPATH_PROJECT_ID, None):
-        return os.getenv(UIPATH_PROJECT_ID)
+    if project_id := UiPathConfig.project_id:
+        return project_id
 
     telemetry_file = os.path.join(".uipath", _TELEMETRY_CONFIG_FILE)
 

{uipath-2.1.119 → uipath-2.1.121}/src/uipath/_cli/cli_pull.py

@@ -11,14 +11,13 @@ It handles:
 
 # type: ignore
 import asyncio
-import os
 from pathlib import Path
 
 import click
 
+from .._config import UiPathConfig
 from ..telemetry import track
 from ._utils._console import ConsoleLogger
-from ._utils._constants import UIPATH_PROJECT_ID
 from ._utils._project_files import ProjectPullError, pull_project
 
 console = ConsoleLogger()
@@ -49,10 +48,9 @@ def pull(root: Path) -> None:
         $ uipath pull
         $ uipath pull /path/to/project
     """
-    project_id = os.getenv(UIPATH_PROJECT_ID)
+    project_id = UiPathConfig.project_id
     if not project_id:
         console.error("UIPATH_PROJECT_ID environment variable not found.")
-        return
 
     download_configuration = {
         "source_code": root,

{uipath-2.1.119 → uipath-2.1.121}/src/uipath/_cli/cli_push.py

@@ -1,6 +1,5 @@
 # type: ignore
 import asyncio
-import os
 from typing import Any, AsyncIterator, Optional
 from urllib.parse import urlparse
 
@@ -8,12 +7,10 @@ import click
 
 from uipath.models.exceptions import EnrichedException
 
+from .._config import UiPathConfig
 from ..telemetry import track
 from ._push.sw_file_handler import FileOperationUpdate, SwFileHandler
 from ._utils._console import ConsoleLogger
-from ._utils._constants import (
-    UIPATH_PROJECT_ID,
-)
 from ._utils._project_files import (
     ensure_config_file,
     get_project_config,
@@ -99,7 +96,7 @@ def push(root: str, nolock: bool) -> None:
     config = get_project_config(root)
     validate_config(config)
 
-    project_id = os.getenv(UIPATH_PROJECT_ID)
+    project_id = UiPathConfig.project_id
     if not project_id:
         console.error("UIPATH_PROJECT_ID environment variable not found.")
 

uipath-2.1.121/src/uipath/_config.py

@@ -0,0 +1,44 @@
+import os
+from pathlib import Path
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class Config(BaseModel):
+    base_url: str
+    secret: str
+
+
+class ConfigurationManager:
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @property
+    def bindings_file_path(self) -> Path:
+        from uipath._utils.constants import UIPATH_BINDINGS_FILE
+
+        return Path(UIPATH_BINDINGS_FILE)
+
+    @property
+    def project_id(self) -> Optional[str]:
+        from uipath._utils.constants import ENV_UIPATH_PROJECT_ID
+
+        return os.getenv(ENV_UIPATH_PROJECT_ID, None)
+
+    @property
+    def folder_key(self) -> Optional[str]:
+        from uipath._utils.constants import ENV_FOLDER_KEY
+
+        return os.getenv(ENV_FOLDER_KEY, None)
+
+    @property
+    def is_studio_project(self) -> bool:
+        return self.project_id is not None
+
+
+UiPathConfig = ConfigurationManager()

{uipath-2.1.119 → uipath-2.1.121}/src/uipath/_events/_events.py

@@ -20,6 +20,7 @@ class EvalSetRunCreatedEvent(BaseModel):
     execution_id: str
     entrypoint: str
     eval_set_id: str
+    eval_set_run_id: Optional[str] = None
     no_of_evals: int
     # skip validation to avoid abstract class instantiation
     evaluators: SkipValidation[List[AnyEvaluator]]

{uipath-2.1.119 → uipath-2.1.121}/src/uipath/_resources/CLI_REFERENCE.md

@@ -100,6 +100,7 @@ uv run uipath run --resume
         entrypoint: Path to the agent script to evaluate (optional, will auto-discover if not specified)
         eval_set: Path to the evaluation set JSON file (optional, will auto-discover if not specified)
         eval_ids: Optional list of evaluation IDs
+        eval_set_run_id: Custom evaluation set run ID (optional, will generate UUID if not specified)
         workers: Number of parallel workers for running evaluations
         no_report: Do not report the evaluation results
     
@@ -115,6 +116,7 @@ uv run uipath run --resume
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
+| `--eval-set-run-id` | value | `Sentinel.UNSET` | Custom evaluation set run ID (if not provided, a UUID will be generated) |
 | `--no-report` | flag | false | Do not report the evaluation results |
 | `--workers` | value | `1` | Number of parallel workers for running evaluations (default: 1) |
 | `--output-file` | value | `Sentinel.UNSET` | File path where the output will be written |

{uipath-2.1.119 → uipath-2.1.121}/src/uipath/_utils/constants.py

@@ -12,6 +12,7 @@ ENV_ROBOT_KEY = "UIPATH_ROBOT_KEY"
 ENV_TENANT_ID = "UIPATH_TENANT_ID"
 ENV_ORGANIZATION_ID = "UIPATH_ORGANIZATION_ID"
 ENV_TELEMETRY_ENABLED = "UIPATH_TELEMETRY_ENABLED"
+ENV_UIPATH_PROJECT_ID = "UIPATH_PROJECT_ID"
 
 # Headers
 HEADER_FOLDER_KEY = "x-uipath-folderkey"
@@ -47,6 +48,7 @@ COMMUNITY_agents_SUFFIX = "-community-agents"
 
 # File names
 UIPATH_CONFIG_FILE = "uipath.json"
+UIPATH_BINDINGS_FILE = "bindings.json"
 
 # Evaluators
 CUSTOM_EVALUATOR_PREFIX = "file://"

{uipath-2.1.119 → uipath-2.1.121}/src/uipath/tracing/_otel_exporters.py

@@ -32,20 +32,25 @@ def _get_llm_messages(attributes: Dict[str, Any], prefix: str) -> List[Dict[str,
     """Extracts and reconstructs LLM messages from flattened attributes."""
     messages: dict[int, dict[str, Any]] = {}
     message_prefix = f"{prefix}."
+    prefix_len = len(message_prefix)
 
     for key, value in attributes.items():
         if key.startswith(message_prefix):
-            parts = key[len(message_prefix) :].split(".")
+            # Avoid repeated string slicing and splits
+            parts = key[prefix_len:].split(".")
             if len(parts) >= 2 and parts[0].isdigit():
                 index = int(parts[0])
                 if index not in messages:
                     messages[index] = {}
                 current: Any = messages[index]
 
-                for i, part in enumerate(parts[1:-1]):
+                # Traverse parts except the last one
+                parts_len = len(parts)
+                for i in range(1, parts_len - 1):
+                    part = parts[i]
                     key_part: str | int = part
                     if part.isdigit() and (
-                        i + 2 < len(parts) and parts[i + 2].isdigit()
+                        i + 2 < parts_len and parts[i + 2].isdigit()
                     ):
                         key_part = int(part)
 
@@ -60,6 +65,10 @@ def _get_llm_messages(attributes: Dict[str, Any], prefix: str) -> List[Dict[str,
 
                 current[parts[-1]] = value
 
+    # Convert dict to list, ordered by index, avoid sorted() if we can use range
+    if not messages:
+        return []
+
     # Convert dict to list, ordered by index
     return [messages[i] for i in sorted(messages.keys())]
 
@@ -112,18 +121,30 @@ class LlmOpsHttpExporter(SpanExporter):
             f"Exporting {len(spans)} spans to {self.base_url}/llmopstenant_/api/Traces/spans"
         )
 
+        # Use optimized path: keep attributes as dict for processing
+        # Only serialize at the very end
         span_list = [
             _SpanUtils.otel_span_to_uipath_span(
-                span, custom_trace_id=self.trace_id
-            ).to_dict()
+                span, custom_trace_id=self.trace_id, serialize_attributes=False
+            ).to_dict(serialize_attributes=False)
             for span in spans
         ]
+
         url = self._build_url(span_list)
 
+        # Process spans in-place if needed - work directly with dict
         if self._extra_process_spans:
-            span_list = [self._process_span_attributes(span) for span in span_list]
+            for span_data in span_list:
+                self._process_span_attributes(span_data)
 
-        logger.debug("Payload: %s", json.dumps(span_list))
+        # Serialize attributes once at the very end
+        for span_data in span_list:
+            if isinstance(span_data.get("Attributes"), dict):
+                span_data["Attributes"] = json.dumps(span_data["Attributes"])
+
+        # Only serialize for logging if debug is enabled to avoid allocation
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug("Payload: %s", json.dumps(span_list))
 
         return self._send_with_retries(url, span_list)
 
@@ -133,7 +154,8 @@ class LlmOpsHttpExporter(SpanExporter):
 
     def _map_llm_call_attributes(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
         """Maps attributes for LLM calls, handling flattened keys."""
-        result = attributes.copy()  # Keep original attributes including basic mappings
+        # Modify attributes in place to avoid copy
+        result = attributes
 
         # Token Usage
         token_keys = {
@@ -202,7 +224,8 @@ class LlmOpsHttpExporter(SpanExporter):
 
     def _map_tool_call_attributes(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
         """Maps attributes for tool calls."""
-        result = attributes.copy()  # Keep original attributes
+        # Modify attributes in place to avoid copy
+        result = attributes
 
         result["type"] = "toolCall"
         result["callId"] = attributes.get("call_id") or attributes.get("id")
@@ -225,22 +248,32 @@ class LlmOpsHttpExporter(SpanExporter):
             return self.Status.ERROR
         return self.Status.SUCCESS
 
-    def _process_span_attributes(self, span_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Extracts, transforms, and maps attributes for a span."""
+    def _process_span_attributes(self, span_data: Dict[str, Any]) -> None:
+        """Extracts, transforms, and maps attributes for a span in-place.
+
+        Args:
+            span_data: Span dict with Attributes as dict or JSON string
+
+        Note:
+            Modifies span_data in-place. When optimized path is used (dict),
+            modifies dict directly. When legacy path is used (str), parse → modify → serialize.
+        """
         if "Attributes" not in span_data:
-            return span_data
+            return
 
         attributes_val = span_data["Attributes"]
         if isinstance(attributes_val, str):
+            # Legacy path: parse JSON string
             try:
                 attributes: Dict[str, Any] = json.loads(attributes_val)
             except json.JSONDecodeError as e:
                 logger.warning(f"Failed to parse attributes JSON: {e}")
-                return span_data
+                return
         elif isinstance(attributes_val, dict):
+            # Optimized path: work directly with dict
             attributes = attributes_val
         else:
-            return span_data
+            return
 
         # Determine SpanType
         if "openinference.span.kind" in attributes:
@@ -258,23 +291,23 @@ class LlmOpsHttpExporter(SpanExporter):
                     attributes[new_key] = attributes[old_key]
 
         # Apply detailed mapping based on SpanType
+        # Modify attributes dict in place to avoid allocations
         span_type = span_data.get("SpanType")
         if span_type == "completion":
-            processed_attributes = self._map_llm_call_attributes(attributes)
+            self._map_llm_call_attributes(attributes)
         elif span_type == "toolCall":
-            processed_attributes = self._map_tool_call_attributes(attributes)
-        else:
-            processed_attributes = attributes.copy()
+            self._map_tool_call_attributes(attributes)
 
-        span_data["Attributes"] = json.dumps(processed_attributes)
+        # If attributes were a string (legacy path), serialize back
+        # If dict (optimized path), leave as dict - caller will serialize once at the end
+        if isinstance(attributes_val, str):
+            span_data["Attributes"] = json.dumps(attributes)
 
         # Determine status based on error information
         error = attributes.get("error") or attributes.get("exception.message")
         status = self._determine_status(error)
         span_data["Status"] = status
 
-        return span_data
-
     def _build_url(self, span_list: list[Dict[str, Any]]) -> str:
         """Construct the URL for the API request."""
         trace_id = str(span_list[0]["TraceId"])
@@ -323,7 +356,10 @@ class JsonLinesFileExporter(SpanExporter):
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         try:
             uipath_spans = [
-                _SpanUtils.otel_span_to_uipath_span(span).to_dict() for span in spans
+                _SpanUtils.otel_span_to_uipath_span(
+                    span, serialize_attributes=True
+                ).to_dict(serialize_attributes=True)
+                for span in spans
             ]
 
             with open(self.file_path, "a") as f:

{uipath-2.1.119 → uipath-2.1.121}/src/uipath/tracing/_utils.py

@@ -63,12 +63,15 @@ def _simple_serialize_defaults(obj):
 
 @dataclass
 class UiPathSpan:
-    """Represents a span in the UiPath tracing system."""
+    """Represents a span in the UiPath tracing system.
+
+    Note: attributes can be either a JSON string (backwards compatible) or a dict (optimized).
+    """
 
     id: uuid.UUID
     trace_id: uuid.UUID
     name: str
-    attributes: str
+    attributes: str | Dict[str, Any]  # Support both str (legacy) and dict (optimized)
     parent_id: Optional[uuid.UUID] = None
     start_time: str = field(default_factory=lambda: datetime.now().isoformat())
     end_time: str = field(default_factory=lambda: datetime.now().isoformat())
@@ -96,16 +99,32 @@ class UiPathSpan:
 
     job_key: Optional[str] = field(default_factory=lambda: env.get("UIPATH_JOB_KEY"))
 
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert the Span to a dictionary suitable for JSON serialization."""
+    def to_dict(self, serialize_attributes: bool = True) -> Dict[str, Any]:
+        """Convert the Span to a dictionary suitable for JSON serialization.
+
+        Args:
+            serialize_attributes: If True and attributes is a dict, serialize to JSON string.
+                                 If False, keep attributes as-is (dict or str).
+                                 Default True for backwards compatibility.
+        """
+        # Cache UUID string conversions to avoid repeated str() calls
+        id_str = str(self.id)
+        trace_id_str = str(self.trace_id)
+        parent_id_str = str(self.parent_id) if self.parent_id else None
+
+        # Handle attributes serialization
+        attributes_out = self.attributes
+        if serialize_attributes and isinstance(self.attributes, dict):
+            attributes_out = json.dumps(self.attributes)
+
         return {
-            "Id": str(self.id),
-            "TraceId": str(self.trace_id),
-            "ParentId": str(self.parent_id) if self.parent_id else None,
+            "Id": id_str,
+            "TraceId": trace_id_str,
+            "ParentId": parent_id_str,
             "Name": self.name,
             "StartTime": self.start_time,
             "EndTime": self.end_time,
-            "Attributes": self.attributes,
+            "Attributes": attributes_out,
             "Status": self.status,
             "CreatedAt": self.created_at,
             "UpdatedAt": self.updated_at,
@@ -168,9 +187,18 @@ class _SpanUtils:
 
     @staticmethod
     def otel_span_to_uipath_span(
-        otel_span: ReadableSpan, custom_trace_id: Optional[str] = None
+        otel_span: ReadableSpan,
+        custom_trace_id: Optional[str] = None,
+        serialize_attributes: bool = True,
     ) -> UiPathSpan:
-        """Convert an OpenTelemetry span to a UiPathSpan."""
+        """Convert an OpenTelemetry span to a UiPathSpan.
+
+        Args:
+            otel_span: The OpenTelemetry span to convert
+            custom_trace_id: Optional custom trace ID to use
+            serialize_attributes: If True, serialize attributes to JSON string (backwards compatible).
+                                 If False, keep as dict for optimized processing. Default True.
+        """
         # Extract the context information from the OTel span
         span_context = otel_span.get_span_context()
 
@@ -192,10 +220,11 @@ class _SpanUtils:
         if parent_span_id_str:
             parent_id = uuid.UUID(parent_span_id_str)
 
-        # Convert attributes to a format compatible with UiPathSpan
-        attributes_dict: dict[str, Any] = (
-            dict(otel_span.attributes) if otel_span.attributes else {}
-        )
+        # Build attributes dict efficiently
+        # Use the otel attributes as base - we only add new keys, don't modify existing
+        otel_attrs = otel_span.attributes if otel_span.attributes else {}
+        # Only copy if we need to modify - we'll build attributes_dict lazily
+        attributes_dict: dict[str, Any] = dict(otel_attrs) if otel_attrs else {}
 
         # Map status
         status = 1  # Default to OK
@@ -203,32 +232,31 @@ class _SpanUtils:
             status = 2  # Error
             attributes_dict["error"] = otel_span.status.description
 
-        original_inputs = attributes_dict.get("input", None)
-        original_outputs = attributes_dict.get("output", None)
-
+        # Process inputs - avoid redundant parsing if already parsed
+        original_inputs = otel_attrs.get("input", None)
         if original_inputs:
-            try:
-                if isinstance(original_inputs, str):
-                    json_inputs = json.loads(original_inputs)
-                    attributes_dict["input.value"] = json_inputs
+            if isinstance(original_inputs, str):
+                try:
+                    attributes_dict["input.value"] = json.loads(original_inputs)
                     attributes_dict["input.mime_type"] = "application/json"
-                else:
+                except Exception as e:
+                    logger.warning(f"Error parsing inputs: {e}")
                     attributes_dict["input.value"] = original_inputs
-            except Exception as e:
-                logger.warning(f"Error parsing inputs: {e}")
-                attributes_dict["input.value"] = str(original_inputs)
+            else:
+                attributes_dict["input.value"] = original_inputs
 
+        # Process outputs - avoid redundant parsing if already parsed
+        original_outputs = otel_attrs.get("output", None)
         if original_outputs:
-            try:
-                if isinstance(original_outputs, str):
-                    json_outputs = json.loads(original_outputs)
-                    attributes_dict["output.value"] = json_outputs
+            if isinstance(original_outputs, str):
+                try:
+                    attributes_dict["output.value"] = json.loads(original_outputs)
                     attributes_dict["output.mime_type"] = "application/json"
-                else:
+                except Exception as e:
+                    logger.warning(f"Error parsing output: {e}")
                     attributes_dict["output.value"] = original_outputs
-            except Exception as e:
-                logger.warning(f"Error parsing output: {e}")
-                attributes_dict["output.value"] = str(original_outputs)
+            else:
+                attributes_dict["output.value"] = original_outputs
 
         # Add events as additional attributes if they exist
         if otel_span.events:
@@ -275,7 +303,9 @@ class _SpanUtils:
             trace_id=trace_id,
             parent_id=parent_id,
             name=otel_span.name,
-            attributes=json.dumps(attributes_dict),
+            attributes=json.dumps(attributes_dict)
+            if serialize_attributes
+            else attributes_dict,
             start_time=start_time,
             end_time=end_time_str,
             status=status,