uipath 2.1.102__tar.gz → 2.1.104__tar.gz

{uipath-2.1.102 → uipath-2.1.104}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.102"
+version = "2.1.104"
 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.102 → uipath-2.1.104}/src/uipath/_cli/__init__.py

@@ -8,7 +8,7 @@ from .cli_auth import auth as auth
 from .cli_debug import debug as debug  # type: ignore
 from .cli_deploy import deploy as deploy  # type: ignore
 from .cli_dev import dev as dev
-from .cli_eval import eval as eval  # type: ignore
+from .cli_eval import eval as eval
 from .cli_init import init as init  # type: ignore
 from .cli_invoke import invoke as invoke  # type: ignore
 from .cli_new import new as new  # type: ignore

{uipath-2.1.102 → uipath-2.1.104}/src/uipath/_cli/_debug/_bridge.py

@@ -434,7 +434,8 @@ def get_remote_debug_bridge(context: UiPathRuntimeContext) -> UiPathDebugBridge:
     if not context.trace_context:
         raise ValueError("trace_context is required for remote debugging")
 
-    signalr_url = uipath_url + "/agenthub_/wsstunnel?jobId=" + context.job_id
+    signalr_url = f"{uipath_url.rstrip('/')}/orchestrator_/signalr/robotdebug?sessionId={context.job_id}"
+
     return SignalRDebugBridge(
         hub_url=signalr_url,
         access_token=os.environ.get("UIPATH_ACCESS_TOKEN"),

uipath-2.1.104/src/uipath/_cli/_evals/_evaluate.py

@@ -0,0 +1,28 @@
+from typing import TypeVar
+
+from uipath._cli._evals._runtime import UiPathEvalContext, UiPathEvalRuntime
+from uipath._cli._runtime._contracts import (
+    UiPathBaseRuntime,
+    UiPathRuntimeContext,
+    UiPathRuntimeFactory,
+    UiPathRuntimeResult,
+)
+from uipath._events._event_bus import EventBus
+
+T = TypeVar("T", bound=UiPathBaseRuntime)
+C = TypeVar("C", bound=UiPathRuntimeContext)
+
+
+async def evaluate(
+    runtime_factory: UiPathRuntimeFactory[T, C],
+    eval_context: UiPathEvalContext,
+    event_bus: EventBus,
+) -> UiPathRuntimeResult:
+    async with UiPathEvalRuntime.from_eval_context(
+        factory=runtime_factory,
+        context=eval_context,
+        event_bus=event_bus,
+    ) as eval_runtime:
+        results = await eval_runtime.execute()
+        await event_bus.wait_for_all(timeout=10)
+        return results

{uipath-2.1.102 → uipath-2.1.104}/src/uipath/_cli/_evals/_runtime.py

@@ -176,7 +176,7 @@ class UiPathEvalRuntime(UiPathBaseRuntime, Generic[T, C]):
     ) -> "UiPathEvalRuntime[T, C]":
         return cls(context, factory, event_bus)
 
-    async def execute(self) -> Optional[UiPathRuntimeResult]:
+    async def execute(self) -> UiPathRuntimeResult:
         if self.context.eval_set is None:
             raise ValueError("eval_set must be provided for evaluation runs")
 

{uipath-2.1.102 → uipath-2.1.104}/src/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-2.1.102 → uipath-2.1.104}/src/uipath/_cli/cli_eval.py

@@ -1,4 +1,3 @@
-# type: ignore
 import ast
 import asyncio
 import os
@@ -7,10 +6,10 @@ from typing import List, Optional
 import click
 
 from uipath._cli._evals._console_progress_reporter import ConsoleProgressReporter
+from uipath._cli._evals._evaluate import evaluate
 from uipath._cli._evals._progress_reporter import StudioWebProgressReporter
 from uipath._cli._evals._runtime import (
     UiPathEvalContext,
-    UiPathEvalRuntime,
 )
 from uipath._cli._runtime._runtime_factory import generate_runtime_factory
 from uipath._cli._utils._constants import UIPATH_PROJECT_ID
@@ -46,9 +45,9 @@ def setup_reporting_prereq(no_report: bool) -> bool:
         )
         return False
     if not os.getenv("UIPATH_FOLDER_KEY"):
-        os.environ["UIPATH_FOLDER_KEY"] = asyncio.run(
-            get_personal_workspace_key_async()
-        )
+        folder_key = asyncio.run(get_personal_workspace_key_async())
+        if folder_key:
+            os.environ["UIPATH_FOLDER_KEY"] = folder_key
     return True
 
 
@@ -141,17 +140,8 @@ def eval(
             runtime_factory = generate_runtime_factory()
             if eval_context.job_id:
                 runtime_factory.add_span_exporter(LlmOpsHttpExporter())
+            asyncio.run(evaluate(runtime_factory, eval_context, event_bus))
 
-            async def execute():
-                async with UiPathEvalRuntime.from_eval_context(
-                    factory=runtime_factory,
-                    context=eval_context,
-                    event_bus=event_bus,
-                ) as eval_runtime:
-                    await eval_runtime.execute()
-                    await event_bus.wait_for_all(timeout=10)
-
-            asyncio.run(execute())
         except Exception as e:
             console.error(
                 f"Error occurred: {e or 'Execution failed'}", include_traceback=True

{uipath-2.1.102 → uipath-2.1.104}/src/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-2.1.102 → uipath-2.1.104}/src/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-2.1.104/src/uipath/tracing/__init__.py

@@ -0,0 +1,13 @@
+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",
+    "JsonLinesFileExporter",
+]

uipath-2.1.104/src/uipath/tracing/_otel_exporters.py

@@ -0,0 +1,339 @@
+import json
+import logging
+import os
+import time
+from typing import Any, Dict, List, Optional, Sequence
+
+import httpx
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import (
+    SpanExporter,
+    SpanExportResult,
+)
+
+from uipath._utils._ssl_context import get_httpx_client_kwargs
+
+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."""
+
+    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__(**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()
+
+        self.http_client = httpx.Client(**client_kwargs, headers=self.headers)
+        self.trace_id = trace_id
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        """Export spans to UiPath LLM Ops."""
+        logger.debug(
+            f"Exporting {len(spans)} spans to {self.base_url}/llmopstenant_/api/Traces/spans"
+        )
+
+        span_list = [
+            _SpanUtils.otel_span_to_uipath_span(
+                span, custom_trace_id=self.trace_id
+            ).to_dict()
+            for span in spans
+        ]
+        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)
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        """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"])
+        return f"{self.base_url}/llmopstenant_/api/Traces/spans?traceId={trace_id}&source=Robots"
+
+    def _send_with_retries(
+        self, url: str, payload: list[Dict[str, Any]], max_retries: int = 4
+    ) -> SpanExportResult:
+        """Send the HTTP request with retry logic."""
+        for attempt in range(max_retries):
+            try:
+                response = self.http_client.post(url, json=payload)
+                if response.status_code == 200:
+                    return SpanExportResult.SUCCESS
+                else:
+                    logger.warning(
+                        f"Attempt {attempt + 1} failed with status code {response.status_code}: {response.text}"
+                    )
+            except Exception as e:
+                logger.error(f"Attempt {attempt + 1} failed with exception: {e}")
+
+            if attempt < max_retries - 1:
+                time.sleep(1.5**attempt)  # Exponential backoff
+
+        return SpanExportResult.FAILURE
+
+    def _get_base_url(self) -> str:
+        uipath_url = (
+            os.environ.get("UIPATH_URL")
+            or "https://cloud.uipath.com/dummyOrg/dummyTennant/"
+        )
+
+        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.104/tests/cli/eval/evals/eval-sets/default.json

@@ -0,0 +1,24 @@
+{
+  "fileName": "default.json",
+  "id": "default-eval-set-id",
+  "name": "Basic Calculator Evaluation Set",
+  "batchSize": 10,
+  "evaluatorRefs": [
+    "equality"
+  ],
+  "evaluations": [
+    {
+      "id": "test-addition",
+      "name": "Test Addition",
+      "inputs": {"foo":  "bar"},
+      "expectedOutput": {"foo":  "bar"},
+      "expectedAgentBehavior": "",
+      "evalSetId": "default-eval-set-id",
+      "createdAt": "2025-09-04T18:54:58.378Z",
+      "updatedAt": "2025-09-04T18:55:55.416Z"
+    }
+  ],
+  "modelSettings": [],
+  "createdAt": "2025-09-04T18:54:58.379Z",
+  "updatedAt": "2025-09-04T18:55:55.416Z"
+}

uipath-2.1.104/tests/cli/eval/evals/evaluators/equality.json

@@ -0,0 +1,11 @@
+{
+    "fileName": "equality.json",
+    "id": "equality",
+    "name": "Equality Evaluator",
+    "description": "An evaluator that judges the agent based on expected output.",
+    "category": 0,
+    "type": 1,
+    "targetOutputKey": "*",
+    "createdAt": "2025-06-26T17:45:39.651Z",
+    "updatedAt": "2025-06-26T17:45:39.651Z"
+}

uipath-2.1.104/tests/cli/eval/test_evaluate.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+from typing import Any
+
+from uipath._cli._evals._evaluate import evaluate
+from uipath._cli._evals._runtime import UiPathEvalContext
+from uipath._cli._runtime._contracts import UiPathRuntimeContext, UiPathRuntimeFactory
+from uipath._cli._runtime._runtime import UiPathRuntime
+from uipath._events._event_bus import EventBus
+
+
+async def test_evaluate():
+    # Arrange
+    event_bus = EventBus()
+    context = UiPathEvalContext(
+        eval_set=str(Path(__file__).parent / "evals" / "eval-sets" / "default.json")
+    )
+
+    async def identity(input: Any) -> Any:
+        return input
+
+    class MyFactory(UiPathRuntimeFactory[UiPathRuntime, UiPathRuntimeContext]):
+        def __init__(self):
+            super().__init__(
+                UiPathRuntime,
+                UiPathRuntimeContext,
+                runtime_generator=lambda context: UiPathRuntime(
+                    context, executor=identity
+                ),
+            )
+
+    # Act
+    result = await evaluate(MyFactory(), context, event_bus)
+
+    # Assert
+    assert result.output
+    assert (
+        result.output["evaluationSetResults"][0]["evaluationRunResults"][0]["result"][
+            "score"
+        ]
+        == 100.0
+    )

{uipath-2.1.102 → uipath-2.1.104}/tests/cli/test_run.py

@@ -120,6 +120,7 @@ class TestRun:
                         debug=False,
                         debug_port=5678,
                         execution_output_file=None,
+                        trace_file=None,
                     )
 
     class TestMiddleware: