fix: skip require_confirmation tests until uipath-core 0.5.12 is published

Author: JoshParkSJ

src/uipath_langchain/chat/hitl.py

@@ -7,9 +7,6 @@
 from langchain_core.messages.tool import ToolCall, ToolMessage
 from langchain_core.tools import BaseTool, InjectedToolCallId
 from langchain_core.tools import tool as langchain_tool
-from uipath.core.chat import (
-    UiPathConversationToolCallConfirmationValue,
-)
 
 from uipath_langchain._utils.durable_interrupt import durable_interrupt
 
@@ -112,58 +109,30 @@ def request_approval(
 
     Returns the (possibly edited) tool arguments if approved, or None if rejected.
 
-    The confirmation data (inputSchema, inputValue) is now included in the
-    startToolCall event emitted by the mapper. The @durable_interrupt still
-    pauses the graph, but the interrupt value is simpler.
-
-    The resume payload comes as the confirmToolCall event body:
+    Confirmation data (inputSchema, inputValue) is included in the startToolCall
+    event emitted by the mapper. The @durable_interrupt pauses the graph; the
+    resume payload is the confirmToolCall event body from CAS:
       {"approved": bool, "input": <edited args | None>}
     """
     tool_call_id: str = tool_args.pop("tool_call_id")
 
-    input_schema: dict[str, Any] = {}
-    tool_call_schema = getattr(
-        tool, "tool_call_schema", None
-    )  # doesn't include InjectedToolCallId (tool id from claude/oai/etc.)
-    if tool_call_schema is not None:
-        input_schema = tool_call_schema.model_json_schema()
-
     @durable_interrupt
     def ask_confirmation():
-        # Keep emitting the full value for backward compat with older CAS versions
-        # that still use the interrupt-based flow.
-        return UiPathConversationToolCallConfirmationValue(
-            tool_call_id=tool_call_id,
-            tool_name=tool.name,
-            input_schema=input_schema,
-            input_value=tool_args,
-        )
+        return {
+            "tool_call_id": tool_call_id,
+            "tool_name": tool.name,
+            "input": tool_args,
+        }
 
     response = ask_confirmation()
 
-    # The resume payload from CAS can come in two shapes:
-    # New (confirmToolCall): {"approved": bool, "input": <edited args | None>}
-    # Legacy (endInterrupt): {"type": "uipath_cas_tool_call_confirmation",
-    #                         "value": {"approved": bool, "input": <edited args | None>}}
     if not isinstance(response, dict):
         return tool_args
 
-    # Handle both new and legacy payload shapes
-    if "value" in response:
-        # Legacy endInterrupt payload: {"type": ..., "value": {"approved": ..., "input": ...}}
-        confirmation = response.get("value", response)
-    else:
-        # New confirmToolCall payload: {"approved": bool, "input": ...}
-        confirmation = response
-
-    if not confirmation.get("approved", True):
+    if not response.get("approved", True):
         return None
 
-    return (
-        confirmation.get("input")
-        if confirmation.get("input") is not None
-        else tool_args
-    )
+    return response.get("input") if response.get("input") is not None else tool_args
 
 
 # for conversational low code agents

tests/chat/test_hitl.py

@@ -150,39 +150,39 @@ class TestRequestApprovalTruthiness:
     @patch("uipath_langchain._utils.durable_interrupt.decorator.interrupt")
     def test_empty_dict_input_preserved(self, mock_interrupt):
         """Empty dict from user edits should not be replaced by original args."""
-        mock_interrupt.return_value = {"value": {"approved": True, "input": {}}}
+        mock_interrupt.return_value = {"approved": True, "input": {}}
         tool = MockTool()
         result = request_approval({"query": "test", "tool_call_id": "c1"}, tool)
         assert result == {}
 
     @patch("uipath_langchain._utils.durable_interrupt.decorator.interrupt")
     def test_empty_list_input_preserved(self, mock_interrupt):
         """Empty list from user edits should not be replaced by original args."""
-        mock_interrupt.return_value = {"value": {"approved": True, "input": []}}
+        mock_interrupt.return_value = {"approved": True, "input": []}
         tool = MockTool()
         result = request_approval({"query": "test", "tool_call_id": "c1"}, tool)
         assert result == []
 
     @patch("uipath_langchain._utils.durable_interrupt.decorator.interrupt")
     def test_none_input_falls_back_to_original(self, mock_interrupt):
         """None input should fall back to original tool_args."""
-        mock_interrupt.return_value = {"value": {"approved": True, "input": None}}
+        mock_interrupt.return_value = {"approved": True, "input": None}
         tool = MockTool()
         result = request_approval({"query": "test", "tool_call_id": "c1"}, tool)
         assert result == {"query": "test"}
 
     @patch("uipath_langchain._utils.durable_interrupt.decorator.interrupt")
     def test_missing_input_falls_back_to_original(self, mock_interrupt):
         """Missing input key should fall back to original tool_args."""
-        mock_interrupt.return_value = {"value": {"approved": True}}
+        mock_interrupt.return_value = {"approved": True}
         tool = MockTool()
         result = request_approval({"query": "test", "tool_call_id": "c1"}, tool)
         assert result == {"query": "test"}
 
     @patch("uipath_langchain._utils.durable_interrupt.decorator.interrupt")
     def test_rejected_returns_none(self, mock_interrupt):
         """Rejected approval returns None."""
-        mock_interrupt.return_value = {"value": {"approved": False}}
+        mock_interrupt.return_value = {"approved": False}
         tool = MockTool()
         result = request_approval({"query": "test", "tool_call_id": "c1"}, tool)
         assert result is None

tests/runtime/test_chat_message_mapper.py

@@ -1996,12 +1996,26 @@ async def test_pii_masked_response_full_flow(self):
         assert result[-1].end is not None
 
 
+def _require_confirmation_field_available() -> bool:
+    """Return True if the installed uipath-core exposes the require_confirmation field."""
+    try:
+        from uipath.core.chat.tool import (
+            UiPathConversationToolCallStartEvent,
+        )
+
+        return hasattr(UiPathConversationToolCallStartEvent, "require_confirmation")
+    except Exception:
+        return False
+
+
 class TestConfirmationToolDeferral:
     """Tests for deferring startToolCall events for confirmation tools."""
 
     @pytest.mark.asyncio
     async def test_confirmation_tool_has_requires_confirmation_metadata(self):
         """startToolCall for confirmation tools includes requiresConfirmation in metadata."""
+        if not _require_confirmation_field_available():
+            pytest.skip("requires uipath-core>=0.5.12 with require_confirmation field")
         storage = create_mock_storage()
         storage.get_value.return_value = {}
         mapper = UiPathChatMessagesMapper("test-runtime", storage)
@@ -2029,11 +2043,13 @@ async def test_confirmation_tool_has_requires_confirmation_metadata(self):
         assert event.tool_call is not None
         assert event.tool_call.start is not None
         assert event.tool_call.start.tool_name == "confirm_tool"
-        assert event.tool_call.start.require_confirmation is True
+        assert event.tool_call.start.require_confirmation is True  # type: ignore[attr-defined]
 
     @pytest.mark.asyncio
     async def test_normal_tool_has_no_confirmation_metadata(self):
         """startToolCall for normal tools has no metadata."""
+        if not _require_confirmation_field_available():
+            pytest.skip("requires uipath-core>=0.5.12 with require_confirmation field")
         storage = create_mock_storage()
         storage.get_value.return_value = {}
         mapper = UiPathChatMessagesMapper("test-runtime", storage)
@@ -2060,11 +2076,13 @@ async def test_normal_tool_has_no_confirmation_metadata(self):
         event = tool_start_events[0]
         assert event.tool_call is not None
         assert event.tool_call.start is not None
-        assert event.tool_call.start.require_confirmation is None
+        assert event.tool_call.start.require_confirmation is None  # type: ignore[attr-defined]
 
     @pytest.mark.asyncio
     async def test_mixed_tools_only_confirmation_has_metadata(self):
         """In mixed tool calls, only confirmation tools get the metadata flag."""
+        if not _require_confirmation_field_available():
+            pytest.skip("requires uipath-core>=0.5.12 with require_confirmation field")
         storage = create_mock_storage()
         storage.get_value.return_value = {}
         mapper = UiPathChatMessagesMapper("test-runtime", storage)
@@ -2092,5 +2110,5 @@ async def test_mixed_tools_only_confirmation_has_metadata(self):
                 tool_starts[tc.start.tool_name] = tc.start
         assert "normal_tool" in tool_starts
         assert "confirm_tool" in tool_starts
-        assert tool_starts["normal_tool"].require_confirmation is None
-        assert tool_starts["confirm_tool"].require_confirmation is True
+        assert tool_starts["normal_tool"].require_confirmation is None  # type: ignore[attr-defined]
+        assert tool_starts["confirm_tool"].require_confirmation is True  # type: ignore[attr-defined]