uipath 2.1.102__py3-none-any.whl → 2.1.103__py3-none-any.whl

uipath/_cli/_runtime/_contracts.py

@@ -341,6 +341,7 @@ class UiPathRuntimeContext(BaseModel):
     result: Optional[UiPathRuntimeResult] = None
     execution_output_file: Optional[str] = None
     input_file: Optional[str] = None
+    trace_file: Optional[str] = None
     is_eval_run: bool = False
     log_handler: Optional[logging.Handler] = None
     chat_handler: Optional[UiPathConversationHandler] = None

uipath/_cli/cli_run.py

@@ -8,7 +8,7 @@ import click
 
 from uipath._cli._runtime._runtime_factory import generate_runtime_factory
 from uipath._cli._utils._debug import setup_debugging
-from uipath.tracing import LlmOpsHttpExporter
+from uipath.tracing import JsonLinesFileExporter, LlmOpsHttpExporter
 
 from .._utils.constants import (
     ENV_JOB_ID,
@@ -44,6 +44,12 @@ console = ConsoleLogger()
     type=click.Path(exists=False),
     help="File path where the output will be written",
 )
+@click.option(
+    "--trace-file",
+    required=False,
+    type=click.Path(exists=False),
+    help="File path where the trace spans will be written (JSON Lines format)",
+)
 @click.option(
     "--debug",
     is_flag=True,
@@ -63,6 +69,7 @@ def run(
     file: Optional[str],
     input_file: Optional[str],
     output_file: Optional[str],
+    trace_file: Optional[str],
     debug: bool,
     debug_port: int,
 ) -> None:
@@ -73,6 +80,7 @@ def run(
         "resume": resume,
         "input_file": file or input_file,
         "execution_output_file": output_file,
+        "trace_file": trace_file,
         "debug": debug,
     }
     input_file = file or input_file
@@ -87,6 +95,7 @@ def run(
         resume,
         input_file=input_file,
         execution_output_file=output_file,
+        trace_file=trace_file,
         debug=debug,
         debug_port=debug_port,
     )
@@ -110,7 +119,12 @@ def run(
                 context = runtime_factory.new_context(**context_args)
                 if context.job_id:
                     runtime_factory.add_span_exporter(LlmOpsHttpExporter())
+
+                if trace_file:
+                    runtime_factory.add_span_exporter(JsonLinesFileExporter(trace_file))
+
                 result = await runtime_factory.execute(context)
+
                 if not context.job_id:
                     console.info(result.output)
 

uipath/_resources/CLI_REFERENCE.md

@@ -65,6 +65,7 @@ uv run uipath init --infer-bindings
 | `-f`, `--file` | value | none | File path for the .json input |
 | `--input-file` | value | none | Alias for '-f/--file' arguments |
 | `--output-file` | value | none | File path where the output will be written |
+| `--trace-file` | value | none | File path where the trace spans will be written (JSON Lines format) |
 | `--debug` | flag | false | Enable debugging with debugpy. The process will wait for a debugger to attach. |
 | `--debug-port` | value | `5678` | Port for the debug server (default: 5678) |
 

uipath/tracing/__init__.py

@@ -1,4 +1,13 @@
-from ._otel_exporters import LlmOpsHttpExporter  # noqa: D104
+from ._otel_exporters import (  # noqa: D104
+    JsonLinesFileExporter,
+    LlmOpsHttpExporter,
+)
 from ._traced import TracingManager, traced, wait_for_tracers  # noqa: D104
 
-__all__ = ["TracingManager", "traced", "wait_for_tracers", "LlmOpsHttpExporter"]
+__all__ = [
+    "TracingManager",
+    "traced",
+    "wait_for_tracers",
+    "LlmOpsHttpExporter",
+    "JsonLinesFileExporter",
+]

uipath/tracing/_otel_exporters.py

@@ -2,7 +2,7 @@ import json
 import logging
 import os
 import time
-from typing import Any, Dict, Optional, Sequence
+from typing import Any, Dict, List, Optional, Sequence
 
 import httpx
 from opentelemetry.sdk.trace import ReadableSpan
@@ -18,18 +18,88 @@ from ._utils import _SpanUtils
 logger = logging.getLogger(__name__)
 
 
+def _safe_parse_json(s: Any) -> Any:
+    """Safely parse a JSON string, returning the original if not a string or on error."""
+    if not isinstance(s, str):
+        return s
+    try:
+        return json.loads(s)
+    except (json.JSONDecodeError, TypeError):
+        return s
+
+
+def _get_llm_messages(attributes: Dict[str, Any], prefix: str) -> List[Dict[str, Any]]:
+    """Extracts and reconstructs LLM messages from flattened attributes."""
+    messages: dict[int, dict[str, Any]] = {}
+    message_prefix = f"{prefix}."
+
+    for key, value in attributes.items():
+        if key.startswith(message_prefix):
+            parts = key[len(message_prefix) :].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]):
+                    key_part: str | int = part
+                    if part.isdigit() and (
+                        i + 2 < len(parts) and parts[i + 2].isdigit()
+                    ):
+                        key_part = int(part)
+
+                    if isinstance(current, dict):
+                        if key_part not in current:
+                            current[key_part] = {}
+                        current = current[key_part]
+                    elif isinstance(current, list) and isinstance(key_part, int):
+                        if key_part >= len(current):
+                            current.append({})
+                        current = current[key_part]
+
+                current[parts[-1]] = value
+
+    # Convert dict to list, ordered by index
+    return [messages[i] for i in sorted(messages.keys())]
+
+
 class LlmOpsHttpExporter(SpanExporter):
     """An OpenTelemetry span exporter that sends spans to UiPath LLM Ops."""
 
-    def __init__(self, trace_id: Optional[str] = None, **client_kwargs):
+    ATTRIBUTE_MAPPING: dict[str, str | tuple[str, Any]] = {
+        "input.value": ("input", _safe_parse_json),
+        "output.value": ("output", _safe_parse_json),
+        "llm.model_name": "model",
+    }
+
+    # Mapping of span types
+    SPAN_TYPE_MAPPING: dict[str, str] = {
+        "LLM": "completion",
+        "TOOL": "toolCall",
+        # Add more mappings as needed
+    }
+
+    class Status:
+        SUCCESS = 1
+        ERROR = 2
+        INTERRUPTED = 3
+
+    def __init__(
+        self,
+        trace_id: Optional[str] = None,
+        extra_process_spans: Optional[bool] = False,
+        **kwargs,
+    ):
         """Initialize the exporter with the base URL and authentication token."""
-        super().__init__(**client_kwargs)
+        super().__init__(**kwargs)
         self.base_url = self._get_base_url()
         self.auth_token = os.environ.get("UIPATH_ACCESS_TOKEN")
         self.headers = {
             "Content-Type": "application/json",
             "Authorization": f"Bearer {self.auth_token}",
         }
+        self._extra_process_spans = extra_process_spans
 
         client_kwargs = get_httpx_client_kwargs()
 
@@ -50,6 +120,9 @@ class LlmOpsHttpExporter(SpanExporter):
         ]
         url = self._build_url(span_list)
 
+        if self._extra_process_spans:
+            span_list = [self._process_span_attributes(span) for span in span_list]
+
         logger.debug("Payload: %s", json.dumps(span_list))
 
         return self._send_with_retries(url, span_list)
@@ -58,6 +131,150 @@ class LlmOpsHttpExporter(SpanExporter):
         """Force flush the exporter."""
         return True
 
+    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
+
+        # Token Usage
+        token_keys = {
+            "llm.token_count.prompt": "promptTokens",
+            "llm.token_count.completion": "completionTokens",
+            "llm.token_count.total": "totalTokens",
+        }
+        usage = {
+            new_key: attributes.get(old_key)
+            for old_key, new_key in token_keys.items()
+            if old_key in attributes
+        }
+        if usage:
+            result["usage"] = usage
+
+        # Input/Output Messages
+        result["input"] = _get_llm_messages(attributes, "llm.input_messages")
+        output_messages = _get_llm_messages(attributes, "llm.output_messages")
+        result["output"] = output_messages
+
+        # Invocation Parameters
+        invocation_params = _safe_parse_json(
+            attributes.get("llm.invocation_parameters", "{}")
+        )
+        if isinstance(invocation_params, dict):
+            result["model"] = invocation_params.get("model", result.get("model"))
+            settings: dict[str, Any] = {}
+            if "max_tokens" in invocation_params:
+                settings["maxTokens"] = invocation_params["max_tokens"]
+            if "temperature" in invocation_params:
+                settings["temperature"] = invocation_params["temperature"]
+            if settings:
+                result["settings"] = settings
+
+        # Tool Calls
+        tool_calls: list[dict[str, Any]] = []
+        for msg in output_messages:
+            # Ensure msg is a dictionary before proceeding
+            if not isinstance(msg, dict):
+                continue
+            msg_tool_calls = msg.get("message", {}).get("tool_calls", [])
+
+            # Ensure msg_tool_calls is a list
+            if not isinstance(msg_tool_calls, list):
+                continue
+
+            for tc in msg_tool_calls:
+                if not isinstance(tc, dict):
+                    continue
+                tool_call_data = tc.get("tool_call", {})
+                if not isinstance(tool_call_data, dict):
+                    continue
+                tool_calls.append(
+                    {
+                        "id": tool_call_data.get("id"),
+                        "name": tool_call_data.get("function", {}).get("name"),
+                        "arguments": _safe_parse_json(
+                            tool_call_data.get("function", {}).get("arguments", "{}")
+                        ),
+                    }
+                )
+        if tool_calls:
+            result["toolCalls"] = tool_calls
+
+        return result
+
+    def _map_tool_call_attributes(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
+        """Maps attributes for tool calls."""
+        result = attributes.copy()  # Keep original attributes
+
+        result["type"] = "toolCall"
+        result["callId"] = attributes.get("call_id") or attributes.get("id")
+        result["toolName"] = attributes.get("tool.name")
+        result["arguments"] = _safe_parse_json(
+            attributes.get("input", attributes.get("input.value", "{}"))
+        )
+        result["toolType"] = "Integration"
+        result["result"] = _safe_parse_json(
+            attributes.get("output", attributes.get("output.value"))
+        )
+        result["error"] = None
+
+        return result
+
+    def _determine_status(self, error: Optional[str]) -> int:
+        if error:
+            if error and error.startswith("GraphInterrupt("):
+                return self.Status.INTERRUPTED
+            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."""
+        if "Attributes" not in span_data:
+            return span_data
+
+        attributes_val = span_data["Attributes"]
+        if isinstance(attributes_val, str):
+            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
+        elif isinstance(attributes_val, dict):
+            attributes = attributes_val
+        else:
+            return span_data
+
+        # Determine SpanType
+        if "openinference.span.kind" in attributes:
+            span_type = attributes["openinference.span.kind"]
+            span_data["SpanType"] = self.SPAN_TYPE_MAPPING.get(span_type, span_type)
+
+        # Apply basic attribute mapping
+        for old_key, mapping in self.ATTRIBUTE_MAPPING.items():
+            if old_key in attributes:
+                if isinstance(mapping, tuple):
+                    new_key, func = mapping
+                    attributes[new_key] = func(attributes[old_key])
+                else:
+                    new_key = mapping
+                    attributes[new_key] = attributes[old_key]
+
+        # Apply detailed mapping based on SpanType
+        span_type = span_data.get("SpanType")
+        if span_type == "completion":
+            processed_attributes = self._map_llm_call_attributes(attributes)
+        elif span_type == "toolCall":
+            processed_attributes = self._map_tool_call_attributes(attributes)
+        else:
+            processed_attributes = attributes.copy()
+
+        span_data["Attributes"] = json.dumps(processed_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"])
@@ -93,3 +310,30 @@ class LlmOpsHttpExporter(SpanExporter):
         uipath_url = uipath_url.rstrip("/")
 
         return uipath_url
+
+
+class JsonLinesFileExporter(SpanExporter):
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        # Ensure the directory exists
+        dir_path = os.path.dirname(self.file_path)
+        if dir_path:  # Only create if there's an actual directory path
+            os.makedirs(dir_path, exist_ok=True)
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        try:
+            uipath_spans = [
+                _SpanUtils.otel_span_to_uipath_span(span).to_dict() for span in spans
+            ]
+
+            with open(self.file_path, "a") as f:
+                for span in uipath_spans:
+                    f.write(json.dumps(span) + "\n")
+            return SpanExportResult.SUCCESS
+        except Exception as e:
+            logger.error(f"Failed to export spans to {self.file_path}: {e}")
+            return SpanExportResult.FAILURE
+
+    def shutdown(self) -> None:
+        """Shuts down the exporter."""
+        pass

{uipath-2.1.102.dist-info → uipath-2.1.103.dist-info}/METADATA

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

@@ -18,7 +18,7 @@ uipath/_cli/cli_pack.py,sha256=U5rXVbUnHFgdEsXyhkjmWza8dfob1wU9lyl4yrYnUss,11076
 uipath/_cli/cli_publish.py,sha256=DgyfcZjvfV05Ldy0Pk5y_Le_nT9JduEE_x-VpIc_Kq0,6471
 uipath/_cli/cli_pull.py,sha256=v0iL12Z0NGE2yZ_Ff1U1jEgOnbIGJatI63KhZRIVflg,2681
 uipath/_cli/cli_push.py,sha256=cwKUr30VTvb2jhGY9LPpPpILj2URMuEIl8ven6tCRFo,3727
-uipath/_cli/cli_run.py,sha256=4XEvJQEcFafDLJHbgd94cuYxeioprNFe1qwL7JeAplg,3789
+uipath/_cli/cli_run.py,sha256=9vbmSG_FzS0x8KNNzSrST37FKjUOzhXPjl8xTm2ZEqQ,4203
 uipath/_cli/middlewares.py,sha256=tb0c4sU1SCYi0PNs956Qmk24NDk0C0mBfVQmTcyORE0,5000
 uipath/_cli/spinner.py,sha256=bS-U_HA5yne11ejUERu7CQoXmWdabUD2bm62EfEdV8M,1107
 uipath/_cli/_auth/_auth_server.py,sha256=v_b8KNwn0tAv8jxpeKdllOVzl31q9AcdwpE_koAK_w4,7235
@@ -66,7 +66,7 @@ uipath/_cli/_evals/mocks/mocker_factory.py,sha256=V5QKSTtQxztTo4-fK1TyAaXw2Z3mHf
 uipath/_cli/_evals/mocks/mockito_mocker.py,sha256=AO2BmFwA6hz3Lte-STVr7aJDPvMCqKNKa4j2jeNZ_U4,2677
 uipath/_cli/_evals/mocks/mocks.py,sha256=HY0IaSqqO8hioBB3rp5XwAjSpQE4K5hoH6oJQ-sH72I,2207
 uipath/_cli/_push/sw_file_handler.py,sha256=DrGOpX7-dodrROh7YcjHlCBUuOEdVMh8o0550TL-ZYA,22520
-uipath/_cli/_runtime/_contracts.py,sha256=WqHEMBo5jM5a-yV-KD0FeOkei4M3qq-hQwza2hCe9Rk,34318
+uipath/_cli/_runtime/_contracts.py,sha256=H7BeQ8MXB_-NsqqYDACDj5T1ra9eY7-YtHqRFVkmxjk,34355
 uipath/_cli/_runtime/_escalation.py,sha256=x3vI98qsfRA-fL_tNkRVTFXioM5Gv2w0GFcXJJ5eQtg,7981
 uipath/_cli/_runtime/_hitl.py,sha256=VKbM021nVg1HEDnTfucSLJ0LsDn83CKyUtVzofS2qTU,11369
 uipath/_cli/_runtime/_logging.py,sha256=srjAi3Cy6g7b8WNHiYNjaZT4t40F3XRqquuoGd2kh4Y,14019
@@ -98,7 +98,7 @@ uipath/_events/_event_bus.py,sha256=4-VzstyX69cr7wT1EY7ywp-Ndyz2CyemD3Wk_-QmRpo,
 uipath/_events/_events.py,sha256=eCgqEP4rzDgZShXMC9wgBVx-AcpwaJZlo2yiL7OyxdA,4441
 uipath/_resources/AGENTS.md,sha256=nRQNAVeEBaBvuMzXw8uXtMnGebLClUgwIMlgb8_qU9o,1039
 uipath/_resources/CLAUDE.md,sha256=kYsckFWTVe948z_fNWLysCHvi9_YpchBXl3s1Ek03lU,10
-uipath/_resources/CLI_REFERENCE.md,sha256=-eCe1hZSRvv9QGLltE3xl8muGWGNzmaHX8htRt3cgy8,6366
+uipath/_resources/CLI_REFERENCE.md,sha256=M_SCtSjRhj1XwfgSFLfHJJahYXEd_CSQ_EnjLQAn-2Y,6470
 uipath/_resources/REQUIRED_STRUCTURE.md,sha256=3laqGiNa3kauJ7jRI1d7w_fWKUDkqYBjcTT_6_8FAGk,1417
 uipath/_resources/SDK_REFERENCE.md,sha256=4wX8a1W5EJCta-iEHy_cDRahn0ENpJykwn-w4k_Lh6s,23245
 uipath/_services/__init__.py,sha256=_LNy4u--VlhVtTO66bULbCoBjyJBTuyh9jnzjWrv-h4,1140
@@ -182,15 +182,15 @@ 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=3RZgJtY8y28Y5rfVmC432OyRu7N3pSxPouwa82KWFso,4787
-uipath/tracing/__init__.py,sha256=GKRINyWdHVrDsI-8mrZDLdf0oey6GHGlNZTOADK-kgc,224
-uipath/tracing/_otel_exporters.py,sha256=c0GKU_oUrAwrOrqbyu64c55z1TR6xk01d3y5fLUN1lU,3215
+uipath/tracing/__init__.py,sha256=0oUuxJKOHE14iOL4SP93FOiEYRIFLTq-o0NwRcTB8Q4,317
+uipath/tracing/_otel_exporters.py,sha256=LAtaQV5QN4PSLgEbIVvlmUETNbMYqTX87R-3mRKy_S8,12438
 uipath/tracing/_traced.py,sha256=yBIY05PCCrYyx50EIHZnwJaKNdHPNx-YTR1sHQl0a98,19901
 uipath/tracing/_utils.py,sha256=X-LFsyIxDeNOGuHPvkb6T5o9Y8ElYhr_rP3CEBJSu4s,13837
 uipath/utils/__init__.py,sha256=VD-KXFpF_oWexFg6zyiWMkxl2HM4hYJMIUDZ1UEtGx0,105
 uipath/utils/_endpoints_manager.py,sha256=tnF_FiCx8qI2XaJDQgYkMN_gl9V0VqNR1uX7iawuLp8,8230
 uipath/utils/dynamic_schema.py,sha256=w0u_54MoeIAB-mf3GmwX1A_X8_HDrRy6p998PvX9evY,3839
-uipath-2.1.102.dist-info/METADATA,sha256=PHCMM28vCj3vTI7svQmDPoKJkg7J-YlGWUyLPFDFD-s,6626
-uipath-2.1.102.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.102.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.102.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.102.dist-info/RECORD,,
+uipath-2.1.103.dist-info/METADATA,sha256=lWydWnxXFj8zjUQgdUbcrWNJxfuOGM3RCqAoYPTL9oI,6626
+uipath-2.1.103.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.103.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.103.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.103.dist-info/RECORD,,