feat: resolve ArgumentEmail and ArgumentGroupName recipients at runtime (#735)

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: dushyant-uipath

pyproject.toml

@@ -5,7 +5,7 @@ description = "Python SDK that enables developers to build and deploy LangGraph
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"
 dependencies = [
-    "uipath>=2.10.29, <2.11.0",
+    "uipath>=2.10.49, <2.11.0",
     "uipath-core>=0.5.2, <0.6.0",
     "uipath-platform>=0.1.25, <0.2.0",
     "uipath-runtime>=0.10.0, <0.11.0",

src/uipath_langchain/agent/guardrails/actions/escalate_action.py

@@ -115,10 +115,20 @@ async def _create_task_node(
                 return {}
 
             # Lazy import to avoid circular dependency with escalation_tool
+            from ...react.types import AgentGraphState
             from ...tools.escalation_tool import resolve_recipient_value
+            from ...tools.utils import sanitize_dict_for_serialization
 
-            # Resolve recipient value (handles both StandardRecipient and AssetRecipient)
-            task_recipient = await resolve_recipient_value(self.recipient)
+            internal_fields = set(AgentGraphState.model_fields.keys())
+            state_dict = sanitize_dict_for_serialization(dict(state))
+            input_args = {
+                k: v for k, v in state_dict.items() if k not in internal_fields
+            }
+
+            # Resolve recipient value (handles StandardRecipient, AssetRecipient, and argument-based recipients)
+            task_recipient = await resolve_recipient_value(
+                self.recipient, input_args=input_args
+            )
 
             if isinstance(self.recipient, StandardRecipient):
                 metadata["escalation_data"]["assigned_to"] = (

src/uipath_langchain/agent/tools/escalation_tool.py

@@ -11,9 +11,12 @@
     AgentEscalationRecipient,
     AgentEscalationRecipientType,
     AgentEscalationResourceConfig,
+    ArgumentEmailRecipient,
+    ArgumentGroupNameRecipient,
     AssetRecipient,
     StandardRecipient,
 )
+from uipath.agent.utils.text_tokens import safe_get_nested
 from uipath.eval.mocks import mockable
 from uipath.platform import UiPath
 from uipath.platform.action_center.tasks import TaskRecipient, TaskRecipientType
@@ -46,6 +49,7 @@ class EscalationAction(str, Enum):
 
 async def resolve_recipient_value(
     recipient: AgentEscalationRecipient,
+    input_args: dict[str, Any] | None = None,
 ) -> TaskRecipient | None:
     """Resolve recipient value based on recipient type."""
     if isinstance(recipient, AssetRecipient):
@@ -57,6 +61,26 @@ async def resolve_recipient_value(
             type = TaskRecipientType.GROUP_NAME
         return TaskRecipient(value=value, type=type, displayName=value)
 
+    if isinstance(recipient, ArgumentEmailRecipient):
+        value = safe_get_nested(input_args or {}, recipient.argument_path)
+        if value is None:
+            raise ValueError(
+                f"Argument '{recipient.argument_path}' has no value in agent input."
+            )
+        return TaskRecipient(
+            value=value, type=TaskRecipientType.EMAIL, displayName=value
+        )
+
+    if isinstance(recipient, ArgumentGroupNameRecipient):
+        value = safe_get_nested(input_args or {}, recipient.argument_path)
+        if value is None:
+            raise ValueError(
+                f"Argument '{recipient.argument_path}' has no value in agent input."
+            )
+        return TaskRecipient(
+            value=value, type=TaskRecipientType.GROUP_NAME, displayName=value
+        )
+
     if isinstance(recipient, StandardRecipient):
         type = TaskRecipientType(recipient.type)
         if recipient.type == AgentEscalationRecipientType.USER_EMAIL:
@@ -156,8 +180,11 @@ class EscalationToolOutput(BaseModel):
     _bts_context: dict[str, Any] = {}
 
     async def escalation_tool_fn(**kwargs: Any) -> dict[str, Any]:
+        agent_input: dict[str, Any] = (
+            tool.metadata.get("agent_input") if tool.metadata else None
+        ) or {}
         recipient: TaskRecipient | None = (
-            await resolve_recipient_value(channel.recipients[0])
+            await resolve_recipient_value(channel.recipients[0], input_args=agent_input)
             if channel.recipients
             else None
         )
@@ -249,11 +276,16 @@ async def escalation_wrapper(
         if tool.metadata is None:
             raise RuntimeError("Tool metadata is required for task_title resolution")
 
+        state_dict = sanitize_dict_for_serialization(dict(state))
         tool.metadata["task_title"] = resolve_task_title(
             channel.task_title,
-            sanitize_dict_for_serialization(dict(state)),
+            state_dict,
             default_title="Escalation Task",
         )
+        internal_fields = set(AgentGraphState.model_fields.keys())
+        tool.metadata["agent_input"] = {
+            k: v for k, v in state_dict.items() if k not in internal_fields
+        }
 
         tool.metadata["_call_id"] = call.get("id")
         tool.metadata["_call_args"] = dict(call.get("args", {}))

tests/agent/guardrails/actions/test_escalate_action.py

@@ -1763,7 +1763,7 @@ async def test_create_task_resolves_recipient_correctly(
 
         await create_task_fn(state)
 
-        mock_resolve_recipient.assert_called_once_with(recipient)
+        mock_resolve_recipient.assert_called_once_with(recipient, input_args={})
         call_kwargs = mock_client.tasks.create_async.call_args[1]
         assert call_kwargs["recipient"] == expected_value