feat: update validation and remove tool name input from event

Author: norman-le

src/uipath_langchain/agent/react/init_node.py

@@ -9,8 +9,8 @@
 from uipath_langchain.agent.tools.client_side_tool import (
     UIPATH_CLIENT_SIDE_TOOLS_INPUT_KEY,
     ClientSideToolInfo,
+    apply_tool_filter,
     available_client_side_tools,
-    validate_and_apply_tool_filter,
 )
 
 from .job_attachments import (
@@ -71,18 +71,20 @@ def graph_state_init(state: Any) -> Any:
             )
             job_attachments_dict.update(message_attachments)
 
-        # 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 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__}."
+            # Filter available client-side tools based on exchange input declarations
+            if client_side_tools:
+                client_tools_input = getattr(
+                    state, UIPATH_CLIENT_SIDE_TOOLS_INPUT_KEY, None
                 )
-            else:
-                validate_and_apply_tool_filter(client_tools_input, client_side_tools)
+                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 names, "
+                        f"got {type(client_tools_input).__name__}."
+                    )
+                else:
+                    apply_tool_filter(client_tools_input, client_side_tools)
 
         # Calculate initial message count for tracking new messages
         initial_message_count = (

src/uipath_langchain/agent/tools/client_side_tool.py

@@ -31,71 +31,29 @@ class ClientSideToolInfo(TypedDict):
     output_schema: dict[str, Any] | None
 
 
-def validate_and_apply_tool_filter(
-    declared_tools: list[dict[str, Any]],
+def apply_tool_filter(
+    declared_tools: list[str | dict[str, Any]],
     agent_tools: dict[str, ClientSideToolInfo],
 ) -> None:
-    """Validate client-side tool declarations and set the availability filter.
+    """Filter available client-side tools to the intersection of declared and agent tools.
 
-    Compares the client's declared tools against the agent's tool definitions.
-    Raises ValueError if required tools are missing or schemas don't match.
-    Sets the available_client_side_tools context variable for tool functions.
+    Extracts tool names from the client's declarations, intersects with the agent's
+    defined client-side tools, and sets the availability filter. Unknown names are
+    silently ignored.
 
     Args:
-        declared_tools: List of tool declarations from uipath__client_side_tools input.
-            Each item is a dict with 'name' and optional 'inputSchema'/'outputSchema'.
-        agent_tools: The agent's client-side tools.
-            Dict of {tool_name: ClientSideToolInfo}.
+        declared_tools: List of tool names (strings) or dicts with a 'name' field
+            from uipath__client_side_tools input.
+        agent_tools: The agent's client-side tools keyed by name.
     """
-    declared: dict[str, dict[str, Any]] = {}
-    for i, t in enumerate(declared_tools):
-        if isinstance(t, dict):
-            if "name" not in t:
-                raise ValueError(
-                    f"Client-side tool declaration at index {i} is missing required 'name' field."
-                )
-            name = t["name"]
-        elif isinstance(t, str):
-            name = t
-            t = {"name": t}
-        else:
-            raise ValueError(
-                f"Client-side tool declaration at index {i} must be a dict or string, got {type(t).__name__}."
-            )
-        if name in declared:
-            raise ValueError(
-                f"Duplicate client-side tool declaration: '{name}'."
-            )
-        declared[name] = t
-
-    required = set(agent_tools.keys())
-    missing = required - set(declared.keys())
-    if missing:
-        raise ValueError(
-            f"Missing required client-side tools: {', '.join(sorted(missing))}. "
-            f"The client must register handlers for all client-side tools defined by the agent."
-        )
-
-    for name, decl in declared.items():
-        agent_tool = agent_tools.get(name)
-        if agent_tool is None:
-            continue  # Unknown tool, runtime will ignore it
-        if decl.get("inputSchema") and agent_tool.get("input_schema"):
-            if json.dumps(decl["inputSchema"], sort_keys=True) != json.dumps(
-                agent_tool["input_schema"], sort_keys=True
-            ):
-                raise ValueError(
-                    f"Client-side tool '{name}' inputSchema does not match agent definition."
-                )
-        if decl.get("outputSchema") and agent_tool.get("output_schema"):
-            if json.dumps(decl["outputSchema"], sort_keys=True) != json.dumps(
-                agent_tool["output_schema"], sort_keys=True
-            ):
-                raise ValueError(
-                    f"Client-side tool '{name}' outputSchema does not match agent definition."
-                )
-
-    available_client_side_tools.set(set(declared.keys()))
+    declared_names: set[str] = set()
+    for t in declared_tools:
+        if isinstance(t, str):
+            declared_names.add(t)
+        elif isinstance(t, dict) and "name" in t:
+            declared_names.add(t["name"])
+
+    available_client_side_tools.set(declared_names & set(agent_tools.keys()))
 
 
 def create_client_side_tool(

src/uipath_langchain/chat/hitl.py

@@ -127,13 +127,21 @@ def request_approval(
     """
     tool_call_id: str = tool_args.pop("tool_call_id")
 
+    # For server-side tools, is_execution_phase=True so the bridge emits
+    # executingToolCall at the confirmation interrupt.
+    # For client-side tools, is_execution_phase=False here because the
+    # execution interrupt in client_side_tool.py handles it separately.
+    is_execution_trigger = not (tool.metadata or {}).get(
+        IS_CONVERSATIONAL_CLIENT_SIDE_TOOL, False
+    )
+
     @durable_interrupt
     def ask_confirmation():
         return {
             "tool_call_id": tool_call_id,
             "tool_name": tool.name,
             "input": tool_args,
-            "is_execution_phase": False,
+            "is_execution_phase": is_execution_trigger,
         }
 
     response = ask_confirmation()

src/uipath_langchain/runtime/messages.py

@@ -475,7 +475,6 @@ async def map_current_message_to_start_tool_call_events(self):
                                     tool_call=UiPathConversationToolCallEvent(
                                         tool_call_id=tool_call["id"],
                                         executing=UiPathConversationExecutingToolCallEvent(
-                                            tool_name=tool_call["name"],
                                             input=tool_call["args"],
                                         ),
                                     ),