fix: preserve .tool attr on error-wrapped runnables for confirmation detection

Author: JoshParkSJ

src/uipath_langchain/agent/tools/tool_node.py

@@ -274,7 +274,11 @@ async def _afunc(state: AgentGraphState) -> OutputType:
                 raise
             return result
 
-    return RunnableCallable(func=_func, afunc=_afunc, name=tool_name)
+    wrapped = RunnableCallable(func=_func, afunc=_afunc, name=tool_name)
+    # Preserve .tool so _get_tool_confirmation_info can find metadata
+    if hasattr(tool_node, "tool"):
+        wrapped.tool = tool_node.tool  # type: ignore[attr-defined]
+    return wrapped
 
 
 class ToolWrapperMixin:

src/uipath_langchain/runtime/messages.py

@@ -435,9 +435,7 @@ async def map_current_message_to_start_tool_call_events(self):
                             self.map_tool_call_to_tool_call_start_event(
                                 self.current_message.id,
                                 tool_call,
-                                require_confirmation=require_confirmation
-                                if require_confirmation
-                                else None,
+                                require_confirmation=require_confirmation or None,
                                 input_schema=input_schema,
                             )
                         )
@@ -671,7 +669,7 @@ def _map_langchain_human_message_to_uipath_message_data(
             )
 
         return UiPathConversationMessageData(
-            role="user", content_parts=content_parts, tool_calls=[], interrupts=[]
+            role="user", content_parts=content_parts, tool_calls=[]
         )
 
     @staticmethod
@@ -721,7 +719,6 @@ def _map_langchain_ai_message_to_uipath_message_data(
             role="assistant",
             content_parts=content_parts,
             tool_calls=uipath_tool_calls,
-            interrupts=[],
         )
 
 

src/uipath_langchain/runtime/runtime.py

@@ -65,10 +65,9 @@ def __init__(
         self.entrypoint: str | None = entrypoint
         self.callbacks: list[BaseCallbackHandler] = callbacks or []
         self.chat = UiPathChatMessagesMapper(self.runtime_id, storage)
-        self.chat.tool_names_requiring_confirmation = (
-            self._get_tool_names_requiring_confirmation()
-        )
-        self.chat.tool_confirmation_schemas = self._get_tool_confirmation_schemas()
+        confirmation_names, confirmation_schemas = self._get_tool_confirmation_info()
+        self.chat.tool_names_requiring_confirmation = confirmation_names
+        self.chat.tool_confirmation_schemas = confirmation_schemas
         self._middleware_node_names: set[str] = self._detect_middleware_nodes()
 
     async def execute(
@@ -491,33 +490,25 @@ def _detect_middleware_nodes(self) -> set[str]:
 
         return middleware_nodes
 
-    def _get_tool_names_requiring_confirmation(self) -> set[str]:
+    def _get_tool_confirmation_info(self) -> tuple[set[str], dict[str, Any]]:
+        """Single pass over graph nodes to collect confirmation tool names and schemas."""
         names: set[str] = set()
-        for node_name, node_spec in self.graph.nodes.items():
-            # langgraph's processing node.bound -> runnable.tool -> baseTool (if tool node)
-            tool = getattr(getattr(node_spec, "bound", None), "tool", None)
-            if tool is None:
-                continue
-            metadata = getattr(tool, "metadata", None) or {}
-            if metadata.get(REQUIRE_CONVERSATIONAL_CONFIRMATION):
-                names.add(getattr(tool, "name", node_name))
-        return names
-
-    def _get_tool_confirmation_schemas(self) -> dict[str, Any]:
         schemas: dict[str, Any] = {}
         for node_name, node_spec in self.graph.nodes.items():
+            # langgraph's processing node.bound -> runnable.tool -> baseTool (if tool node)
             tool = getattr(getattr(node_spec, "bound", None), "tool", None)
             if tool is None:
                 continue
             metadata = getattr(tool, "metadata", None) or {}
             if metadata.get(REQUIRE_CONVERSATIONAL_CONFIRMATION):
                 tool_name = getattr(tool, "name", node_name)
+                names.add(tool_name)
                 tool_call_schema = getattr(tool, "tool_call_schema", None)
                 if tool_call_schema is not None:
                     schemas[tool_name] = tool_call_schema.model_json_schema()
                 else:
                     schemas[tool_name] = {}
-        return schemas
+        return names, schemas
 
     def _is_middleware_node(self, node_name: str) -> bool:
         """Check if a node name represents a middleware node."""