Merge branch 'main' into feat/model_settings_id

Author: mathurk

CONTRIBUTING.md

@@ -104,3 +104,5 @@ For additional commands related to linting, formatting, and building, run `just
 ### General Rules
 - Please write informative description to the PRs for the reviewers to understand the context.
 - If you want to publish a `dev` build, please add a `build:dev` label to your PR.
+  - You can then use the published `dev` version from the PR description/comments to use as needed <img width="880" height="433" alt="image" src="https://github.com/user-attachments/assets/b670bb08-a469-454f-a5f6-10d60477c033" />
+

pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "uipath"
-version = "2.2.37"
+version = "2.3.0"
 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.11"
 dependencies = [
-  "uipath-runtime>=0.2.7, <0.3.0",
   "uipath-core>=0.1.4, <0.2.0",
+  "uipath-runtime>=0.3.1, <0.4.0",
   "click>=8.3.1",
   "httpx>=0.28.1",
   "pyjwt>=2.10.1",

src/uipath/_cli/_chat/_bridge.py

@@ -3,6 +3,7 @@
 import asyncio
 import logging
 import os
+import uuid
 from typing import Any
 from urllib.parse import urlparse
 
@@ -12,7 +13,11 @@
     UiPathConversationEvent,
     UiPathConversationExchangeEndEvent,
     UiPathConversationExchangeEvent,
+    UiPathConversationInterruptEvent,
+    UiPathConversationInterruptStartEvent,
+    UiPathConversationMessageEvent,
 )
+from uipath.runtime import UiPathRuntimeResult
 from uipath.runtime.chat import UiPathChatProtocol
 from uipath.runtime.context import UiPathRuntimeContext
 
@@ -82,7 +87,6 @@ async def connect(self, timeout: float = 10.0) -> None:
         self._client.on("disconnect", self._handle_disconnect)
         self._client.on("connect_error", self._handle_connect_error)
 
-        # Clear connection event
         self._connected_event.clear()
 
         try:
@@ -98,11 +102,8 @@ async def connect(self, timeout: float = 10.0) -> None:
                 timeout=timeout,
             )
 
-            # Wait for connection confirmation
             await asyncio.wait_for(self._connected_event.wait(), timeout=timeout)
 
-            logger.info("WebSocket connection established successfully")
-
         except asyncio.TimeoutError as e:
             error_message = (
                 f"Failed to connect to WebSocket server within {timeout}s timeout"
@@ -127,34 +128,16 @@ async def disconnect(self) -> None:
             logger.warning("WebSocket client not connected")
             return
 
-        # Send exchange end event using stored IDs
-        if self._client and self._connected_event.is_set():
-            try:
-                end_event = UiPathConversationEvent(
-                    conversation_id=self.conversation_id,
-                    exchange=UiPathConversationExchangeEvent(
-                        exchange_id=self.exchange_id,
-                        end=UiPathConversationExchangeEndEvent(),
-                    ),
-                )
-                event_data = end_event.model_dump(
-                    mode="json", exclude_none=True, by_alias=True
-                )
-                await self._client.emit("ConversationEvent", event_data)
-                logger.info("Exchange end event sent")
-            except Exception as e:
-                logger.warning(f"Error sending exchange end event: {e}")
-
         try:
-            logger.info("Disconnecting from WebSocket server")
             await self._client.disconnect()
-            logger.info("WebSocket disconnected successfully")
         except Exception as e:
             logger.error(f"Error during WebSocket disconnect: {e}")
         finally:
             await self._cleanup_client()
 
-    async def emit_message_event(self, message_event: Any) -> None:
+    async def emit_message_event(
+        self, message_event: UiPathConversationMessageEvent
+    ) -> None:
         """Wrap and send a message event to the WebSocket server.
 
         Args:
@@ -183,14 +166,82 @@ async def emit_message_event(self, message_event: Any) -> None:
                 mode="json", exclude_none=True, by_alias=True
             )
 
-            logger.debug("Sending conversation event to WebSocket")
             await self._client.emit("ConversationEvent", event_data)
-            logger.debug("Conversation event sent successfully")
+
+            # Store the current message ID, used for emitting interrupt events.
+            self._current_message_id = message_event.message_id
+
+        except Exception as e:
+            logger.error(f"Error sending conversation event to WebSocket: {e}")
+            raise RuntimeError(f"Failed to send conversation event: {e}") from e
+
+    async def emit_exchange_end_event(self) -> None:
+        """Send an exchange end event.
+
+        Raises:
+           RuntimeError: If client is not connected
+        """
+        if self._client is None:
+            raise RuntimeError("WebSocket client not connected. Call connect() first.")
+
+        if not self._connected_event.is_set():
+            raise RuntimeError("WebSocket client not in connected state")
+
+        try:
+            exchange_end_event = UiPathConversationEvent(
+                conversation_id=self.conversation_id,
+                exchange=UiPathConversationExchangeEvent(
+                    exchange_id=self.exchange_id,
+                    end=UiPathConversationExchangeEndEvent(),
+                ),
+            )
+
+            event_data = exchange_end_event.model_dump(
+                mode="json", exclude_none=True, by_alias=True
+            )
+
+            await self._client.emit("ConversationEvent", event_data)
 
         except Exception as e:
             logger.error(f"Error sending conversation event to WebSocket: {e}")
             raise RuntimeError(f"Failed to send conversation event: {e}") from e
 
+    async def emit_interrupt_event(self, runtime_result: UiPathRuntimeResult):
+        if self._client and self._connected_event.is_set():
+            try:
+                self._interrupt_id = str(uuid.uuid4())
+
+                interrupt_event = UiPathConversationEvent(
+                    conversation_id=self.conversation_id,
+                    exchange=UiPathConversationExchangeEvent(
+                        exchange_id=self.exchange_id,
+                        message=UiPathConversationMessageEvent(
+                            message_id=self._current_message_id,
+                            interrupt=UiPathConversationInterruptEvent(
+                                interrupt_id=self._interrupt_id,
+                                start=UiPathConversationInterruptStartEvent(
+                                    type="coded-agent-interrupt",
+                                    value=runtime_result.output,
+                                ),
+                            ),
+                        ),
+                    ),
+                )
+                event_data = interrupt_event.model_dump(
+                    mode="json", exclude_none=True, by_alias=True
+                )
+                await self._client.emit("ConversationEvent", event_data)
+            except Exception as e:
+                logger.warning(f"Error sending interrupt event: {e}")
+
+    async def wait_for_resume(self) -> dict[str, Any]:
+        """Wait for the interrupt_end event to be received.
+
+        Returns:
+            Resume data from the interrupt end event
+        """
+        return {}
+
     @property
     def is_connected(self) -> bool:
         """Check if the WebSocket is currently connected.

src/uipath/_cli/_debug/_bridge.py

@@ -18,7 +18,7 @@
     UiPathRuntimeResult,
     UiPathRuntimeStatus,
 )
-from uipath.runtime.debug import UiPathDebugBridgeProtocol, UiPathDebugQuitError
+from uipath.runtime.debug import UiPathDebugProtocol, UiPathDebugQuitError
 from uipath.runtime.events import UiPathRuntimeStateEvent
 from uipath.runtime.resumable import UiPathResumeTriggerType
 
@@ -846,7 +846,7 @@ async def _handle_error(self, error: Any) -> None:
         logger.error(f"SignalR error: {error}")
 
 
-def get_remote_debug_bridge(context: UiPathRuntimeContext) -> UiPathDebugBridgeProtocol:
+def get_remote_debug_bridge(context: UiPathRuntimeContext) -> UiPathDebugProtocol:
     """Factory to get SignalR debug bridge for remote debugging."""
     uipath_url = os.environ.get("UIPATH_URL")
     if not uipath_url or not context.job_id:
@@ -869,7 +869,7 @@ def get_remote_debug_bridge(context: UiPathRuntimeContext) -> UiPathDebugBridgeP
 
 def get_debug_bridge(
     context: UiPathRuntimeContext, verbose: bool = True
-) -> UiPathDebugBridgeProtocol:
+) -> UiPathDebugProtocol:
     """Factory to get appropriate debug bridge based on context.
 
     Args:

src/uipath/_cli/_evals/_models/_mocks.py

@@ -1,9 +1,3 @@
-from pydantic import BaseModel, Field
+from uipath.agent.models.agent import ExampleCall
 
-
-class ExampleCall(BaseModel):
-    """Example invocation for a resource."""
-
-    id: str = Field(..., alias="id")
-    input: str = Field(..., alias="input")
-    output: str = Field(..., alias="output")
+__all__ = ["ExampleCall"]

src/uipath/_cli/_evals/_progress_reporter.py

@@ -537,12 +537,57 @@ def _serialize_justification(
 
         return justification
 
-    def _extract_agent_snapshot(self, entrypoint: str) -> StudioWebAgentSnapshot:
+    def _extract_agent_snapshot(self, entrypoint: str | None) -> StudioWebAgentSnapshot:
+        """Extract agent snapshot from entry points configuration or low-code agent file.
+
+        For coded agents, reads from entry-points.json configuration file.
+        For low-code agents (*.json files like agent.json), reads inputSchema
+        and outputSchema directly from the agent file.
+
+        Args:
+            entrypoint: The entrypoint file path to look up
+
+        Returns:
+            StudioWebAgentSnapshot with input and output schemas
+        """
+        if not entrypoint:
+            logger.warning(
+                "Entrypoint not provided - falling back to empty inputSchema "
+                "and outputSchema"
+            )
+            return StudioWebAgentSnapshot(input_schema={}, output_schema={})
+
         try:
+            # Check if entrypoint is a low-code agent JSON file (e.g., agent.json)
+            if entrypoint.endswith(".json"):
+                agent_file_path = os.path.join(os.getcwd(), entrypoint)
+                if os.path.exists(agent_file_path):
+                    with open(agent_file_path, "r") as f:
+                        agent_data = json.load(f)
+
+                    # Low-code agent files have inputSchema and outputSchema at root
+                    input_schema = agent_data.get("inputSchema", {})
+                    output_schema = agent_data.get("outputSchema", {})
+
+                    logger.debug(
+                        f"Extracted agent snapshot from low-code agent '{entrypoint}': "
+                        f"inputSchema={json.dumps(input_schema)}, "
+                        f"outputSchema={json.dumps(output_schema)}"
+                    )
+
+                    return StudioWebAgentSnapshot(
+                        input_schema=input_schema, output_schema=output_schema
+                    )
+
+            # Fall back to entry-points.json for coded agents
             entry_points_file_path = os.path.join(
                 os.getcwd(), str(UiPathConfig.entry_points_file_path)
             )
             if not os.path.exists(entry_points_file_path):
+                logger.debug(
+                    f"Entry points file not found at {entry_points_file_path}, "
+                    "using empty schemas"
+                )
                 return StudioWebAgentSnapshot(input_schema={}, output_schema={})
 
             with open(entry_points_file_path, "r") as f:
@@ -563,6 +608,12 @@ def _extract_agent_snapshot(self, entrypoint: str) -> StudioWebAgentSnapshot:
             input_schema = ep.get("input", {})
             output_schema = ep.get("output", {})
 
+            logger.debug(
+                f"Extracted agent snapshot for entrypoint '{entrypoint}': "
+                f"inputSchema={json.dumps(input_schema)}, "
+                f"outputSchema={json.dumps(output_schema)}"
+            )
+
             return StudioWebAgentSnapshot(
                 input_schema=input_schema, output_schema=output_schema
             )
@@ -724,6 +775,14 @@ def _update_eval_run_spec(
         # Both coded and legacy send payload directly at root level
         payload = inner_payload
 
+        # Log the payload for debugging eval run updates
+        agent_type = "coded" if is_coded else "low-code"
+        logger.debug(
+            f"Updating eval run (type={agent_type}): "
+            f"evalRunId={eval_run_id}, success={success}"
+        )
+        logger.debug(f"Full eval run update payload: {json.dumps(payload, indent=2)}")
+
         return RequestSpec(
             method="PUT",
             endpoint=Endpoint(
@@ -762,6 +821,16 @@ def _update_coded_eval_run_spec(
             "evaluatorRuns": evaluator_runs,
         }
 
+        # Log the payload for debugging coded eval run updates
+        agent_type = "coded" if is_coded else "low-code"
+        logger.debug(
+            f"Updating coded eval run (type={agent_type}): "
+            f"evalRunId={eval_run_id}, success={success}"
+        )
+        logger.debug(
+            f"Full coded eval run update payload: {json.dumps(payload, indent=2)}"
+        )
+
         return RequestSpec(
             method="PUT",
             endpoint=Endpoint(
@@ -826,6 +895,14 @@ def _create_eval_run_spec(
         # Both coded and legacy send payload directly at root level
         payload = inner_payload
 
+        # Log the payload for debugging eval run reporting
+        agent_type = "coded" if is_coded else "low-code"
+        logger.debug(
+            f"Creating eval run (type={agent_type}): "
+            f"evalSetRunId={eval_set_run_id}, evalItemId={eval_item.id}"
+        )
+        logger.debug(f"Full eval run payload: {json.dumps(payload, indent=2)}")
+
         return RequestSpec(
             method="POST",
             endpoint=Endpoint(
@@ -872,6 +949,16 @@ def _create_eval_set_run_spec(
         # Both coded and legacy send payload directly at root level
         payload = inner_payload
 
+        # Log the payload for debugging eval set run reporting
+        agent_type = "coded" if is_coded else "low-code"
+        logger.info(
+            f"Creating eval set run (type={agent_type}): "
+            f"evalSetId={eval_set_id}, "
+            f"inputSchema={json.dumps(payload.get('agentSnapshot', {}).get('inputSchema', {}))}, "
+            f"outputSchema={json.dumps(payload.get('agentSnapshot', {}).get('outputSchema', {}))}"
+        )
+        logger.debug(f"Full eval set run payload: {json.dumps(payload, indent=2)}")
+
         return RequestSpec(
             method="POST",
             endpoint=Endpoint(
@@ -926,6 +1013,17 @@ def _update_eval_set_run_spec(
         # Both coded and legacy send payload directly at root level
         payload = inner_payload
 
+        # Log the payload for debugging eval set run updates
+        agent_type = "coded" if is_coded else "low-code"
+        logger.info(
+            f"Updating eval set run (type={agent_type}): "
+            f"evalSetRunId={eval_set_run_id}, success={success}, "
+            f"evaluatorScores={json.dumps(payload.get('evaluatorScores', []))}"
+        )
+        logger.debug(
+            f"Full eval set run update payload: {json.dumps(payload, indent=2)}"
+        )
+
         return RequestSpec(
             method="PUT",
             endpoint=Endpoint(

src/uipath/_cli/cli_debug.py

@@ -10,7 +10,7 @@
     UiPathRuntimeProtocol,
 )
 from uipath.runtime.chat import UiPathChatProtocol, UiPathChatRuntime
-from uipath.runtime.debug import UiPathDebugBridgeProtocol, UiPathDebugRuntime
+from uipath.runtime.debug import UiPathDebugProtocol, UiPathDebugRuntime
 
 from uipath._cli._chat._bridge import get_chat_bridge
 from uipath._cli._debug._bridge import get_debug_bridge
@@ -136,7 +136,7 @@ async def execute_debug_runtime():
                                     delegate=runtime, chat_bridge=chat_bridge
                                 )
 
-                        debug_bridge: UiPathDebugBridgeProtocol = get_debug_bridge(ctx)
+                        debug_bridge: UiPathDebugProtocol = get_debug_bridge(ctx)
 
                         debug_runtime = UiPathDebugRuntime(
                             delegate=chat_runtime or runtime,