fix: add guardrail rule_description

Author: Valentina Bojan

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.5.15,<2.6.0",
+    "uipath>=2.5.17,<2.6.0",
     "uipath-runtime>=0.5.1,<0.6.0",
     "langgraph>=1.0.0, <2.0.0",
     "langchain-core>=1.2.5, <2.0.0",

src/uipath_langchain/agent/guardrails/guardrail_nodes.py

@@ -108,7 +108,7 @@ def _create_validation_command(
     if guardrail_result.result == GuardrailValidationResultType.PASSED:
         return Command(
             goto=success_node,
-            update={"inner_state": {"guardrail_validation_result": None}},
+            update={"inner_state": {"guardrail_validation_result": guardrail_result.reason}},
         )
 
     if guardrail_result.result == GuardrailValidationResultType.VALIDATION_FAILED:

src/uipath_langchain/agent/guardrails/guardrails_factory.py

@@ -155,6 +155,72 @@ def _create_word_rule_func(
             raise ValueError(f"Unsupported word operator: {operator}")
 
 
+def _build_field_selector_description(field_selector: AgentFieldSelector) -> str:
+    """Build a human-readable selector description for field selector.
+
+    Args:
+        field_selector: The field selector describing which fields this rule applies to.
+
+    Returns:
+        A string describing the selector, using:
+        - \"All\" for `AgentAllFieldsSelector`
+        - Comma-separated field paths for `SpecificFieldsSelector`
+        - ``str(field_selector)`` as a fallback.
+    """
+    if isinstance(field_selector, AgentAllFieldsSelector):
+        return "All fields"
+    if isinstance(field_selector, SpecificFieldsSelector):
+        field_paths = [field.path for field in field_selector.fields]
+        return ", ".join(field_paths)
+    return str(field_selector)
+
+
+def _build_rule_description(
+    operator: AgentWordOperator | AgentNumberOperator | AgentBooleanOperator,
+    value: str | float | bool | None,
+    field_selector: AgentFieldSelector,
+) -> str:
+    """Build the full human-readable description for a word rule.
+
+    Args:
+        operator: The word operator to describe.
+        value: The comparison value, if applicable for the operator.
+        field_selector: The field selector describing which fields this rule applies to.
+
+    Returns:
+        A string describing the rule, combining selector, operator, and value.
+    """
+    selector_description = _build_field_selector_description(field_selector)
+
+    if operator in {
+        AgentWordOperator.CONTAINS,
+        AgentWordOperator.DOES_NOT_CONTAIN,
+        AgentWordOperator.EQUALS,
+        AgentWordOperator.DOES_NOT_EQUAL,
+        AgentWordOperator.STARTS_WITH,
+        AgentWordOperator.DOES_NOT_START_WITH,
+        AgentWordOperator.ENDS_WITH,
+        AgentWordOperator.DOES_NOT_END_WITH,
+        AgentWordOperator.MATCHES_REGEX,
+        AgentNumberOperator.EQUALS,
+        AgentNumberOperator.DOES_NOT_EQUAL,
+        AgentNumberOperator.GREATER_THAN,
+        AgentNumberOperator.GREATER_THAN_OR_EQUAL,
+        AgentNumberOperator.LESS_THAN,
+        AgentNumberOperator.LESS_THAN_OR_EQUAL,
+        AgentBooleanOperator.EQUALS,
+    }:
+        return f"{selector_description} {operator.value} {value!r}"
+
+    if operator in {
+        AgentWordOperator.IS_EMPTY,
+        AgentWordOperator.IS_NOT_EMPTY,
+    }:
+        return f"{selector_description} {operator.value}"
+
+    raise ValueError(f"Unsupported word operator: {operator}")
+
+
 def _create_number_rule_func(
     operator: AgentNumberOperator, value: float
 ) -> Callable[[float], bool]:
@@ -314,6 +380,9 @@ def _convert_agent_rule_to_deterministic(
             detects_violation=_create_word_rule_func(
                 agent_rule.operator, agent_rule.value
             ),
+            rule_description=_build_rule_description(
+                agent_rule.operator, agent_rule.value, agent_rule.field_selector
+            ),
         )
 
     if isinstance(agent_rule, AgentNumberRule):
@@ -325,6 +394,9 @@ def _convert_agent_rule_to_deterministic(
             detects_violation=_create_number_rule_func(
                 agent_rule.operator, agent_rule.value
             ),
+            rule_description=_build_rule_description(
+                agent_rule.operator, agent_rule.value, agent_rule.field_selector
+            ),
         )
 
     if isinstance(agent_rule, AgentBooleanRule):
@@ -336,6 +408,9 @@ def _convert_agent_rule_to_deterministic(
             detects_violation=_create_boolean_rule_func(
                 agent_rule.operator, agent_rule.value
             ),
+            rule_description=_build_rule_description(
+                agent_rule.operator, agent_rule.value, agent_rule.field_selector
+            ),
         )
 
     raise ValueError(f"Unsupported agent rule type: {type(agent_rule)}")

tests/agent/guardrails/test_guardrails_factory.py

@@ -44,6 +44,7 @@
 from uipath_langchain.agent.guardrails.actions.filter_action import FilterAction
 from uipath_langchain.agent.guardrails.actions.log_action import LogAction
 from uipath_langchain.agent.guardrails.guardrails_factory import (
+    _build_rule_description,
     _convert_agent_custom_guardrail_to_deterministic,
     _convert_agent_rule_to_deterministic,
     _create_boolean_rule_func,
@@ -562,6 +563,117 @@ def test_unsupported_operator_raises_value_error(self) -> None:
             _create_boolean_rule_func(cast(AgentBooleanOperator, "INVALID"), True)
 
 
+class TestBuildRuleDescription:
+    """Tests for _build_rule_description."""
+
+    def test_word_rule_with_specific_field_selector(self) -> None:
+        """Description for word rule with specific selector includes field path, operator, and value."""
+        word_rule = AgentWordRule.model_validate(
+            {
+                "$ruleType": "word",
+                "fieldSelector": {
+                    "$selectorType": "specific",
+                    "fields": [{"path": "message.content", "source": "input"}],
+                },
+                "operator": "contains",
+                "value": "forbidden",
+            }
+        )
+
+        description = _build_rule_description(
+            word_rule.operator,
+            word_rule.value,
+            word_rule.field_selector,
+        )
+
+        assert description == "message.content contains 'forbidden'"
+
+    def test_word_rule_with_all_field_selector(self) -> None:
+        """Description for word rule with all selector uses 'All' as selector description."""
+        word_rule = AgentWordRule.model_validate(
+            {
+                "$ruleType": "word",
+                "fieldSelector": {"$selectorType": "all"},
+                "operator": "equals",
+                "value": "test",
+            }
+        )
+
+        description = _build_rule_description(
+            word_rule.operator,
+            word_rule.value,
+            word_rule.field_selector,
+        )
+
+        assert description == "All fields equals 'test'"
+
+    def test_word_rule_without_value_operator(self) -> None:
+        """Description for word rule without value omits the value portion."""
+        word_rule = AgentWordRule.model_validate(
+            {
+                "$ruleType": "word",
+                "fieldSelector": {
+                    "$selectorType": "specific",
+                    "fields": [{"path": "message.content", "source": "input"}],
+                },
+                "operator": "isEmpty",
+                "value": None,
+            }
+        )
+
+        description = _build_rule_description(
+            word_rule.operator,
+            word_rule.value,
+            word_rule.field_selector,
+        )
+
+        assert description == "message.content isEmpty"
+
+    def test_number_rule_description(self) -> None:
+        """Description for number rule includes numeric comparison operator and value."""
+        number_rule = AgentNumberRule.model_validate(
+            {
+                "$ruleType": "number",
+                "fieldSelector": {
+                    "$selectorType": "specific",
+                    "fields": [{"path": "data.count", "source": "input"}],
+                },
+                "operator": "greaterThan",
+                "value": 10.0,
+            }
+        )
+
+        description = _build_rule_description(
+            number_rule.operator,
+            number_rule.value,
+            number_rule.field_selector,
+        )
+
+        assert description == "data.count greaterThan 10.0"
+
+    def test_boolean_rule_description(self) -> None:
+        """Description for boolean rule includes field path, equals operator, and boolean value."""
+        boolean_rule = AgentBooleanRule.model_validate(
+            {
+                "$ruleType": "boolean",
+                "fieldSelector": {
+                    "$selectorType": "specific",
+                    "fields": [{"path": "data.is_active", "source": "input"}],
+                },
+                "operator": "equals",
+                "value": True,
+            }
+        )
+
+        description = _build_rule_description(
+            boolean_rule.operator,
+            boolean_rule.value,
+            boolean_rule.field_selector,
+        )
+
+        assert description == "data.is_active equals True"
+
+
 class TestConvertAgentRuleToDeterministic:
     """Tests for _convert_agent_rule_to_deterministic."""