feat: conversational agent support

Author: mike-deem-uipath

src/uipath/_cli/_chat/_bridge.py

@@ -1,10 +1,11 @@
 """Chat bridge implementations for conversational agents."""
 
 import asyncio
+import json
 import logging
 import os
 import uuid
-from typing import Any
+from typing import Any, Dict
 from urllib.parse import urlparse
 
 import socketio  # type: ignore[import-untyped]
@@ -57,6 +58,10 @@ def __init__(
         self._client: AsyncClient | None = None
         self._connected_event = asyncio.Event()
 
+        # Set CAS_WEBSOCKET_DISABLED when using the debugger to prevent websocket errors from
+        # interrupting the debugging session. Events will be logged instead of being sent.
+        self._websocket_disabled = os.environ.get("CAS_WEBSOCKET_DISABLED") == "true"
+
     async def connect(self, timeout: float = 10.0) -> None:
         """Establish WebSocket connection to the server.
 
@@ -86,37 +91,43 @@ async def connect(self, timeout: float = 10.0) -> None:
         self._client.on("connect", self._handle_connect)
         self._client.on("disconnect", self._handle_disconnect)
         self._client.on("connect_error", self._handle_connect_error)
+        self._client.on("ConversationEvent", self._handle_conversation_event)
 
         self._connected_event.clear()
 
-        try:
-            # Attempt to connect with timeout
-            await asyncio.wait_for(
-                self._client.connect(
-                    url=self.websocket_url,
-                    socketio_path=self.websocket_path,
-                    headers=self.headers,
-                    auth=self.auth,
-                    transports=["websocket"],
-                ),
-                timeout=timeout,
+        if self._websocket_disabled:
+            logger.warning(
+                "SocketIOChatBridge is in debug mode. Not connecting websocket."
             )
+        else:
+            try:
+                # Attempt to connect with timeout
+                await asyncio.wait_for(
+                    self._client.connect(
+                        url=self.websocket_url,
+                        socketio_path=self.websocket_path,
+                        headers=self.headers,
+                        auth=self.auth,
+                        transports=["websocket"],
+                    ),
+                    timeout=timeout,
+                )
 
-            await asyncio.wait_for(self._connected_event.wait(), timeout=timeout)
+                await asyncio.wait_for(self._connected_event.wait(), timeout=timeout)
 
-        except asyncio.TimeoutError as e:
-            error_message = (
-                f"Failed to connect to WebSocket server within {timeout}s timeout"
-            )
-            logger.error(error_message)
-            await self._cleanup_client()
-            raise RuntimeError(error_message) from e
+            except asyncio.TimeoutError as e:
+                error_message = (
+                    f"Failed to connect to WebSocket server within {timeout}s timeout"
+                )
+                logger.error(error_message)
+                await self._cleanup_client()
+                raise RuntimeError(error_message) from e
 
-        except Exception as e:
-            error_message = f"Failed to connect to WebSocket server: {e}"
-            logger.error(error_message)
-            await self._cleanup_client()
-            raise RuntimeError(error_message) from e
+            except Exception as e:
+                error_message = f"Failed to connect to WebSocket server: {e}"
+                logger.error(error_message)
+                await self._cleanup_client()
+                raise RuntimeError(error_message) from e
 
     async def disconnect(self) -> None:
         """Close the WebSocket connection gracefully.
@@ -149,7 +160,7 @@ async def emit_message_event(
         if self._client is None:
             raise RuntimeError("WebSocket client not connected. Call connect() first.")
 
-        if not self._connected_event.is_set():
+        if not self._connected_event.is_set() and not self._websocket_disabled:
             raise RuntimeError("WebSocket client not in connected state")
 
         try:
@@ -166,7 +177,12 @@ async def emit_message_event(
                 mode="json", exclude_none=True, by_alias=True
             )
 
-            await self._client.emit("ConversationEvent", event_data)
+            if self._websocket_disabled:
+                logger.info(
+                    f"SocketIOChatBridge is in debug mode. Not sending event: {json.dumps(event_data)}"
+                )
+            else:
+                await self._client.emit("ConversationEvent", event_data)
 
             # Store the current message ID, used for emitting interrupt events.
             self._current_message_id = message_event.message_id
@@ -184,7 +200,7 @@ async def emit_exchange_end_event(self) -> None:
         if self._client is None:
             raise RuntimeError("WebSocket client not connected. Call connect() first.")
 
-        if not self._connected_event.is_set():
+        if not self._connected_event.is_set() and not self._websocket_disabled:
             raise RuntimeError("WebSocket client not in connected state")
 
         try:
@@ -200,7 +216,12 @@ async def emit_exchange_end_event(self) -> None:
                 mode="json", exclude_none=True, by_alias=True
             )
 
-            await self._client.emit("ConversationEvent", event_data)
+            if self._websocket_disabled:
+                logger.info(
+                    f"SocketIOChatBridge is in debug mode. Not sending event: {json.dumps(event_data)}"
+                )
+            else:
+                await self._client.emit("ConversationEvent", event_data)
 
         except Exception as e:
             logger.error(f"Error sending conversation event to WebSocket: {e}")
@@ -230,7 +251,12 @@ async def emit_interrupt_event(self, runtime_result: UiPathRuntimeResult):
                 event_data = interrupt_event.model_dump(
                     mode="json", exclude_none=True, by_alias=True
                 )
-                await self._client.emit("ConversationEvent", event_data)
+                if self._websocket_disabled:
+                    logger.info(
+                        f"SocketIOChatBridge is in debug mode. Not sending event: {json.dumps(event_data)}"
+                    )
+                else:
+                    await self._client.emit("ConversationEvent", event_data)
             except Exception as e:
                 logger.warning(f"Error sending interrupt event: {e}")
 
@@ -265,6 +291,14 @@ async def _handle_connect_error(self, data: Any) -> None:
         """Handle connection error event."""
         logger.error(f"WebSocket connection error: {data}")
 
+    async def _handle_conversation_event(
+        self, event: Dict[str, Any], _sid: str
+    ) -> None:
+        """Handle received ConversationEvent events."""
+        error_event = event.get("conversationError")
+        if error_event:
+            logger.error(f"Conversation error: {json.dumps(error_event)}")
+
     async def _cleanup_client(self) -> None:
         """Clean up client resources."""
         self._connected_event.clear()
@@ -315,6 +349,13 @@ def get_chat_bridge(
     websocket_url = f"wss://{host}?conversationId={context.conversation_id}"
     websocket_path = "autopilotforeveryone_/websocket_/socket.io"
 
+    if os.environ.get("CAS_WEBSOCKET_HOST"):
+        websocket_url = f"ws://{os.environ.get('CAS_WEBSOCKET_HOST')}?conversationId={context.conversation_id}"
+        websocket_path = "/socket.io"
+        logger.warning(
+            f"CAS_WEBSOCKET_HOST is set. Using websocket_url '{websocket_url}{websocket_path}'."
+        )
+
     # Build headers from context
     headers = {
         "Authorization": f"Bearer {os.environ.get('UIPATH_ACCESS_TOKEN', '')}",

src/uipath/_cli/cli_run.py

@@ -69,6 +69,11 @@
     default=5678,
     help="Port for the debug server (default: 5678)",
 )
+@click.option(
+    "--keep-state-file",
+    is_flag=True,
+    help="Keep the state file even when not resuming and no job id is provided",
+)
 def run(
     entrypoint: str | None,
     input: str | None,
@@ -79,6 +84,7 @@ def run(
     trace_file: str | None,
     debug: bool,
     debug_port: int,
+    keep_state_file: bool,
 ) -> None:
     """Execute the project."""
     input_file = file or input_file
@@ -147,6 +153,7 @@ async def execute() -> None:
                     resume=resume,
                     command="run",
                     trace_manager=trace_manager,
+                    keep_state_file=keep_state_file,
                 )
 
                 if ctx.trace_file:

src/uipath/agent/models/agent.py

@@ -803,6 +803,15 @@ class AgentDefinition(BaseModel):
         validate_by_name=True, validate_by_alias=True, extra="allow"
     )
 
+    @property
+    def is_conversational(self) -> bool:
+        """Checks the settings.engine property to determine if the agent is conversational."""
+        if hasattr(self, "metadata") and self.metadata:
+            metadata = self.metadata
+            if hasattr(metadata, "is_conversational"):
+                return metadata.is_conversational
+        return False
+
     @staticmethod
     def _normalize_guardrails(v: Dict[str, Any]) -> None:
         guards = v.get("guardrails")

src/uipath/agent/react/__init__.py

@@ -3,6 +3,10 @@
 This module includes UiPath ReAct Agent Loop constructs such as prompts, tools
 """
 
+from .conversational_prompts import (
+    PromptUserSettings,
+    generate_conversational_agent_system_prompt,
+)
 from .prompts import AGENT_SYSTEM_PROMPT_TEMPLATE
 from .tools import (
     END_EXECUTION_TOOL,
@@ -19,4 +23,6 @@
     "RAISE_ERROR_TOOL",
     "EndExecutionToolSchemaModel",
     "RaiseErrorToolSchemaModel",
+    "PromptUserSettings",
+    "generate_conversational_agent_system_prompt",
 ]