fix: pass None to rule evaluation when guardrail references missing field

When a rule references a field that doesn't exist in the data,
pass None as the value to detects_violation so the rule lambda
can decide the outcome. Previously, missing fields caused the
evaluator loop to be skipped entirely, incorrectly treating
the rule as violated.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Valentina Bojan

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath-core"
-version = "0.5.4"
+version = "0.5.5"
 description = "UiPath Core abstractions"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"

src/uipath/core/guardrails/_evaluators.py

@@ -152,9 +152,12 @@ def get_fields_from_selector(
                 continue
             # Extract values (may return multiple if arrays are in the path)
             values = extract_field_value(field_ref.path, data)
-            # Add each value as a separate field reference
-            for value in values:
-                fields.append((value, field_ref))
+            if not values:
+                # Field is missing from data — pass None so the rule can decide
+                fields.append((None, field_ref))
+            else:
+                for value in values:
+                    fields.append((value, field_ref))
 
     return fields
 
@@ -199,20 +202,15 @@ def evaluate_word_rule(
     field_paths = ", ".join({field_ref.path for _, field_ref in fields})
 
     for field_value, field_ref in fields:
-        if field_value is None:
-            continue
-
-        # Word rules should only be applied to string values
-        # Skip non-string values (numbers, booleans, objects, arrays, etc.)
-        if not isinstance(field_value, str):
+        # Word rules should only be applied to string values or None (missing field)
+        # Skip non-string, non-None values (numbers, booleans, objects, arrays, etc.)
+        if field_value is not None and not isinstance(field_value, str):
             continue
 
-        field_str = field_value
-
         # Use the custom function to evaluate the rule
         # If detects_violation returns True, it means the rule was violated (validation fails)
         try:
-            violation_detected = rule.detects_violation(field_str)
+            violation_detected = rule.detects_violation(field_value)
         except Exception:
             # If function raises an exception, treat as failure
             violation_detected = True
@@ -240,16 +238,15 @@ def evaluate_number_rule(
     operator = _humanize_guardrail_func(rule.detects_violation) or "violation check"
     field_paths = ", ".join({field_ref.path for _, field_ref in fields})
     for field_value, field_ref in fields:
-        if field_value is None:
-            continue
-
-        # Number rules should only be applied to numeric values
-        # Skip non-numeric values (strings, booleans, objects, arrays, etc.)
+        # Number rules should only be applied to numeric values or None (missing field)
+        # Skip non-numeric, non-None values (strings, booleans, objects, arrays, etc.)
         # Note: bool is a subclass of int in Python, so we must check for bool first
-        if isinstance(field_value, bool) or not isinstance(field_value, (int, float)):
+        if field_value is not None and (
+            isinstance(field_value, bool) or not isinstance(field_value, (int, float))
+        ):
             continue
 
-        field_num = float(field_value)
+        field_num = float(field_value) if field_value is not None else None
 
         # Use the custom function to evaluate the rule
         # If detects_violation returns True, it means the rule was violated (validation fails)
@@ -284,20 +281,15 @@ def evaluate_boolean_rule(
     operator = _humanize_guardrail_func(rule.detects_violation) or "violation check"
     field_paths = ", ".join({field_ref.path for _, field_ref in fields})
     for field_value, field_ref in fields:
-        if field_value is None:
-            continue
-
-        # Boolean rules should only be applied to boolean values
-        # Skip non-boolean values (strings, numbers, objects, arrays, etc.)
-        if not isinstance(field_value, bool):
+        # Boolean rules should only be applied to boolean values or None (missing field)
+        # Skip non-boolean, non-None values (strings, numbers, objects, arrays, etc.)
+        if field_value is not None and not isinstance(field_value, bool):
             continue
 
-        field_bool = field_value
-
         # Use the custom function to evaluate the rule
         # If detects_violation returns True, it means the rule was violated (validation fails)
         try:
-            violation_detected = rule.detects_violation(field_bool)
+            violation_detected = rule.detects_violation(field_value)
         except Exception:
             # If function raises an exception, treat as failure
             violation_detected = True

tests/guardrails/test_deterministic_guardrails_service.py

@@ -1466,3 +1466,104 @@ def _create_guardrail_with_always_rule(
                 ),
             ],
         )
+
+
+class TestMissingFieldPassesValidation:
+    """Test that rules referencing missing fields pass validation."""
+
+    def test_word_rule_missing_field_passes(
+        self, service: DeterministicGuardrailsService
+    ) -> None:
+        guardrail = DeterministicGuardrail(
+            id="test-missing-field",
+            name="Missing Field Guardrail",
+            description="Test missing field",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                WordRule(
+                    rule_type="word",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="sentence2", source=FieldSource.INPUT)
+                        ],
+                    ),
+                    detects_violation=lambda s: len(s or "") > 0,
+                    rule_description="sentence2 is not empty",
+                ),
+            ],
+        )
+        result = service._evaluate_deterministic_guardrail(
+            input_data={"sentence1": "hello"},
+            output_data={},
+            guardrail=guardrail,
+        )
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def test_number_rule_missing_field_passes(
+        self, service: DeterministicGuardrailsService
+    ) -> None:
+        guardrail = DeterministicGuardrail(
+            id="test-missing-field",
+            name="Missing Field Guardrail",
+            description="Test missing field",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[FieldReference(path="age", source=FieldSource.INPUT)],
+                    ),
+                    detects_violation=lambda n: n is not None and n < 0,
+                    rule_description="age is negative",
+                ),
+            ],
+        )
+        result = service._evaluate_deterministic_guardrail(
+            input_data={"name": "test"},
+            output_data={},
+            guardrail=guardrail,
+        )
+        assert result.result == GuardrailValidationResultType.PASSED
+
+    def test_boolean_rule_missing_field_passes(
+        self, service: DeterministicGuardrailsService
+    ) -> None:
+        guardrail = DeterministicGuardrail(
+            id="test-missing-field",
+            name="Missing Field Guardrail",
+            description="Test missing field",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                BooleanRule(
+                    rule_type="boolean",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="is_active", source=FieldSource.INPUT)
+                        ],
+                    ),
+                    detects_violation=lambda b: b is False,
+                    rule_description="is_active is false",
+                ),
+            ],
+        )
+        result = service._evaluate_deterministic_guardrail(
+            input_data={"name": "test"},
+            output_data={},
+            guardrail=guardrail,
+        )
+        assert result.result == GuardrailValidationResultType.PASSED