test: validation and tests

norman-le · norman-le · commit 050977d718c6 · 2026-05-29T13:17:59.000-04:00
diff --git a/src/uipath_langchain/agent/react/agent.py b/src/uipath_langchain/agent/react/agent.py
@@ -1,4 +1,4 @@
-from typing import Any, Callable, Sequence, Type, TypeVar
+from typing import Callable, Sequence, Type, TypeVar
 
 from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import HumanMessage, SystemMessage
diff --git a/src/uipath_langchain/agent/react/init_node.py b/src/uipath_langchain/agent/react/init_node.py
@@ -74,10 +74,15 @@ def graph_state_init(state: Any) -> Any:
         # Validate client-side tool declarations from the exchange input
         if client_side_tools:
             client_tools_input = getattr(state, UIPATH_CLIENT_SIDE_TOOLS_INPUT_KEY, None)
-            if client_tools_input is not None and isinstance(client_tools_input, list):
-                validate_and_apply_tool_filter(client_tools_input, client_side_tools)
-            else:
+            if client_tools_input is None:
                 available_client_side_tools.set(None)
+            elif not isinstance(client_tools_input, list):
+                raise ValueError(
+                    f"'{UIPATH_CLIENT_SIDE_TOOLS_INPUT_KEY}' must be a list of tool declarations, "
+                    f"got {type(client_tools_input).__name__}."
+                )
+            else:
+                validate_and_apply_tool_filter(client_tools_input, client_side_tools)
 
         # Calculate initial message count for tracking new messages
         initial_message_count = (
diff --git a/src/uipath_langchain/runtime/messages.py b/src/uipath_langchain/runtime/messages.py
@@ -40,6 +40,7 @@
 )
 from uipath.runtime import UiPathRuntimeStorageProtocol
 
+from uipath_langchain.agent.tools.client_side_tool import ClientSideToolInfo
 from uipath_langchain.chat.hitl import IS_CONVERSATIONAL_CLIENT_SIDE_TOOL
 
 from ._citations import (
@@ -67,7 +68,7 @@ def __init__(self, runtime_id: str, storage: UiPathRuntimeStorageProtocol | None
         self.storage = storage
         self.current_message: AIMessageChunk | AIMessage
         self.tools_requiring_confirmation: dict[str, Any] = {}
-        self.client_side_tools: dict[str, Any] = {}
+        self.client_side_tools: dict[str, ClientSideToolInfo] = {}
         self.seen_message_ids: set[str] = set()
         self._storage_lock = asyncio.Lock()
         self._citation_stream_processor = CitationStreamProcessor()
@@ -448,13 +449,8 @@ async def map_current_message_to_start_tool_call_events(self):
                         )
                         input_schema = self.tools_requiring_confirmation.get(tool_name)
                         is_client_side = tool_name in self.client_side_tools
-                        client_tool_info = self.client_side_tools.get(tool_name)
                         output_schema = (
-                            (
-                                client_tool_info.get("output_schema")
-                                if isinstance(client_tool_info, dict)
-                                else client_tool_info
-                            )
+                            self.client_side_tools[tool_name].get("output_schema")
                             if is_client_side
                             else None
                         )
diff --git a/tests/agent/tools/test_client_side_tool_validation.py b/tests/agent/tools/test_client_side_tool_validation.py
@@ -0,0 +1,273 @@
+"""Tests for client-side tool validation and filtering logic."""
+
+import pytest
+
+from uipath_langchain.agent.tools.client_side_tool import (
+    ClientSideToolInfo,
+    available_client_side_tools,
+    validate_and_apply_tool_filter,
+)
+
+AGENT_TOOLS: dict[str, ClientSideToolInfo] = {
+    "get_weather": {
+        "input_schema": {
+            "type": "object",
+            "properties": {"city": {"type": "string"}},
+        },
+        "output_schema": {
+            "type": "object",
+            "properties": {"temp": {"type": "number"}},
+        },
+    },
+    "show_map": {
+        "input_schema": None,
+        "output_schema": None,
+    },
+}
+
+
+class TestValidateAndApplyToolFilter:
+    """Tests for validate_and_apply_tool_filter."""
+
+    def test_valid_declarations_set_filter(self):
+        declared = [
+            {"name": "get_weather"},
+            {"name": "show_map"},
+        ]
+        validate_and_apply_tool_filter(declared, AGENT_TOOLS)
+
+        allowed = available_client_side_tools.get()
+        assert allowed == {"get_weather", "show_map"}
+
+    def test_missing_required_tool_raises(self):
+        declared = [{"name": "get_weather"}]  # missing show_map
+
+        with pytest.raises(ValueError, match="Missing required client-side tools"):
+            validate_and_apply_tool_filter(declared, AGENT_TOOLS)
+
+    def test_input_schema_mismatch_raises(self):
+        declared = [
+            {
+                "name": "get_weather",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {"location": {"type": "string"}},
+                },
+            },
+            {"name": "show_map"},
+        ]
+
+        with pytest.raises(ValueError, match="inputSchema does not match"):
+            validate_and_apply_tool_filter(declared, AGENT_TOOLS)
+
+    def test_output_schema_mismatch_raises(self):
+        declared = [
+            {
+                "name": "get_weather",
+                "outputSchema": {
+                    "type": "object",
+                    "properties": {"temperature": {"type": "string"}},
+                },
+            },
+            {"name": "show_map"},
+        ]
+
+        with pytest.raises(ValueError, match="outputSchema does not match"):
+            validate_and_apply_tool_filter(declared, AGENT_TOOLS)
+
+    def test_unknown_extra_tools_are_ignored(self):
+        declared = [
+            {"name": "get_weather"},
+            {"name": "show_map"},
+            {"name": "unknown_tool"},
+        ]
+        validate_and_apply_tool_filter(declared, AGENT_TOOLS)
+
+        allowed = available_client_side_tools.get()
+        assert allowed is not None
+        assert "unknown_tool" in allowed
+        assert "get_weather" in allowed
+
+    def test_string_declarations_accepted(self):
+        declared = ["get_weather", "show_map"]
+        validate_and_apply_tool_filter(declared, AGENT_TOOLS)
+
+        allowed = available_client_side_tools.get()
+        assert allowed == {"get_weather", "show_map"}
+
+    def test_missing_name_field_raises(self):
+        declared = [{"inputSchema": {}}]
+
+        with pytest.raises(ValueError, match="missing required 'name' field"):
+            validate_and_apply_tool_filter(declared, AGENT_TOOLS)
+
+    def test_invalid_type_raises(self):
+        declared = [123]
+
+        with pytest.raises(ValueError, match="must be a dict or string"):
+            validate_and_apply_tool_filter(declared, AGENT_TOOLS)
+
+    def test_duplicate_name_raises(self):
+        declared = [
+            {"name": "get_weather"},
+            {"name": "get_weather"},
+            {"name": "show_map"},
+        ]
+
+        with pytest.raises(ValueError, match="Duplicate client-side tool"):
+            validate_and_apply_tool_filter(declared, AGENT_TOOLS)
+
+    def test_matching_schemas_pass(self):
+        declared = [
+            {
+                "name": "get_weather",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {"city": {"type": "string"}},
+                },
+                "outputSchema": {
+                    "type": "object",
+                    "properties": {"temp": {"type": "number"}},
+                },
+            },
+            {"name": "show_map"},
+        ]
+        validate_and_apply_tool_filter(declared, AGENT_TOOLS)
+
+        allowed = available_client_side_tools.get()
+        assert allowed is not None
+        assert "get_weather" in allowed
+
+
+class TestToolNotAvailableEnforcement:
+    """Tests that client_side_tool_fn returns error ToolMessage when tool is filtered out."""
+
+    def test_tool_not_in_allowed_set_returns_error(self):
+        token = available_client_side_tools.set({"other_tool"})
+        try:
+            from unittest.mock import AsyncMock, patch
+
+            from uipath.agent.models.agent import AgentClientSideToolResourceConfig
+
+            resource = AgentClientSideToolResourceConfig(
+                name="my_tool",
+                description="A test tool",
+                input_schema={
+                    "type": "object",
+                    "properties": {"query": {"type": "string"}},
+                },
+                output_schema=None,
+            )
+
+            from uipath_langchain.agent.tools.client_side_tool import (
+                create_client_side_tool,
+            )
+
+            tool = create_client_side_tool(resource)
+
+            import asyncio
+
+            result = asyncio.get_event_loop().run_until_complete(
+                tool.coroutine(tool_call_id="tc-1", query="test")
+            )
+
+            assert result.status == "error"
+            assert "not available" in result.content
+        finally:
+            available_client_side_tools.reset(token)
+
+    def test_tool_in_allowed_set_proceeds(self):
+        """When tool IS in the allowed set, it should NOT return an error.
+
+        We can't fully test execution (it would hit durable_interrupt),
+        but we verify the availability check passes by patching the interrupt.
+        """
+        token = available_client_side_tools.set({"my_tool"})
+        try:
+            from unittest.mock import AsyncMock, patch
+
+            from uipath.agent.models.agent import AgentClientSideToolResourceConfig
+
+            resource = AgentClientSideToolResourceConfig(
+                name="my_tool",
+                description="A test tool",
+                input_schema={
+                    "type": "object",
+                    "properties": {"query": {"type": "string"}},
+                },
+                output_schema=None,
+            )
+
+            from uipath_langchain.agent.tools.client_side_tool import (
+                create_client_side_tool,
+            )
+
+            tool = create_client_side_tool(resource)
+
+            import asyncio
+
+            # Patch durable_interrupt to avoid GraphInterrupt
+            with (
+                patch(
+                    "uipath_langchain.agent.tools.client_side_tool.durable_interrupt",
+                    side_effect=lambda fn: fn,
+                ),
+                patch(
+                    "uipath_langchain.agent.tools.client_side_tool.mockable",
+                    side_effect=lambda **kw: lambda fn: fn,
+                ),
+            ):
+                # Re-create tool after patching
+                tool = create_client_side_tool(resource)
+                result = asyncio.get_event_loop().run_until_complete(
+                    tool.coroutine(tool_call_id="tc-1", query="test")
+                )
+                # Should NOT be an error ToolMessage — it proceeded past the availability check
+                if hasattr(result, "status"):
+                    assert result.status != "error"
+        finally:
+            available_client_side_tools.reset(token)
+
+    def test_none_allowed_set_permits_all(self):
+        """When available_client_side_tools is None (CAS default), all tools proceed."""
+        token = available_client_side_tools.set(None)
+        try:
+            from uipath.agent.models.agent import AgentClientSideToolResourceConfig
+
+            resource = AgentClientSideToolResourceConfig(
+                name="any_tool",
+                description="A test tool",
+                input_schema={
+                    "type": "object",
+                    "properties": {"q": {"type": "string"}},
+                },
+                output_schema=None,
+            )
+
+            from unittest.mock import patch
+
+            from uipath_langchain.agent.tools.client_side_tool import (
+                create_client_side_tool,
+            )
+
+            with (
+                patch(
+                    "uipath_langchain.agent.tools.client_side_tool.durable_interrupt",
+                    side_effect=lambda fn: fn,
+                ),
+                patch(
+                    "uipath_langchain.agent.tools.client_side_tool.mockable",
+                    side_effect=lambda **kw: lambda fn: fn,
+                ),
+            ):
+                tool = create_client_side_tool(resource)
+
+                import asyncio
+
+                result = asyncio.get_event_loop().run_until_complete(
+                    tool.coroutine(tool_call_id="tc-1", q="test")
+                )
+                if hasattr(result, "status"):
+                    assert result.status != "error"
+        finally:
+            available_client_side_tools.reset(token)

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-from typing import Any, Callable, Sequence, Type, TypeVar`
	`1`	`+from typing import Callable, Sequence, Type, TypeVar`
`2`	`2`
`3`	`3`	`from langchain_core.language_models import BaseChatModel`
`4`	`4`	`from langchain_core.messages import HumanMessage, SystemMessage`