fix: nitpicks

Author: JoshParkSJ

packages/uipath/src/uipath/_cli/_chat/_bridge.py

@@ -16,6 +16,7 @@
     UiPathConversationMessageEvent,
     UiPathConversationToolCallConfirmationEvent,
 )
+from uipath.core.triggers import UiPathResumeTrigger
 from uipath.runtime.chat import UiPathChatProtocol
 from uipath.runtime.context import UiPathRuntimeContext
 
@@ -122,7 +123,9 @@ def __init__(
         self._connected_event = asyncio.Event()
 
         self._tool_confirmation_event = asyncio.Event()
-        self._tool_confirmation_value: UiPathConversationToolCallConfirmationEvent | None = None
+        self._tool_confirmation_value: (
+            UiPathConversationToolCallConfirmationEvent | None
+        ) = None
         self._current_message_id: str | None = None
 
         # Set CAS_WEBSOCKET_DISABLED when using the debugger to prevent websocket errors from
@@ -265,6 +268,7 @@ async def emit_message_event(
             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
 
         except Exception as e:
@@ -355,15 +359,37 @@ async def emit_exchange_error_event(self, error: Exception) -> None:
             logger.error(f"Error sending exchange error event to WebSocket: {e}")
             raise RuntimeError(f"Failed to send exchange error event: {e}") from e
 
-    async def wait_for_tool_confirmation(self) -> dict[str, Any]:
+    async def emit_interrupt_event(self, resume_trigger: UiPathResumeTrigger):
+        """No-op.
+
+        Tool confirmation — the only interrupt pattern CAS uses today — is
+        handled end-to-end via ``startToolCall`` with ``requireConfirmation:
+        true`` paired with ``wait_for_resume()`` for the ``confirmToolCall``
+        response. This is deliberately simpler than the old interrupt-based
+        flow: CAS needs ``requireConfirmation`` and ``inputSchema`` on the
+        tool call event itself to render the confirmation UI, so a parallel
+        ``startInterrupt`` event would be redundant.
+
+        The only hypothetical reason to put work here is a generic,
+        non-tool-call agent interrupt (e.g. a coded agent calling
+        ``interrupt("do you want to continue?")``). Nothing uses that today
+        and it's not a near-term requirement — but the method is kept as a
+        protocol hook so the ``UiPathChatProtocol`` contract doesn't have
+        to churn if that ever becomes real.
+        """
+        return None
+
+    async def wait_for_resume(self) -> dict[str, Any]:
         """Wait for a confirmToolCall event to be received."""
         self._tool_confirmation_event.clear()
         self._tool_confirmation_value = None
 
         await self._tool_confirmation_event.wait()
 
         if self._tool_confirmation_value:
-            return self._tool_confirmation_value.model_dump(mode="python", by_alias=False)
+            return self._tool_confirmation_value.model_dump(
+                mode="python", by_alias=False
+            )
         return {}
 
     @property
@@ -395,11 +421,15 @@ async def _handle_conversation_event(
 
         try:
             parsed_event = UiPathConversationEvent(**event)
-            message = parsed_event.exchange.message if parsed_event.exchange else None
-            if message and message.tool_call and message.tool_call.confirm:
-                confirm = message.tool_call.confirm
+            tool_call = (
+                parsed_event.exchange.message.tool_call
+                if parsed_event.exchange and parsed_event.exchange.message
+                else None
+            )
+            confirm = tool_call.confirm if tool_call else None
+            if tool_call and confirm:
                 logger.info(
-                    f"Received confirmToolCall for tool_call_id: {message.tool_call.tool_call_id}, approved: {confirm.approved}"
+                    f"Received confirmToolCall for tool_call_id: {tool_call.tool_call_id}, approved: {confirm.approved}"
                 )
                 self._tool_confirmation_value = confirm
                 self._tool_confirmation_event.set()