fix: pass validation when guardrail rule references missing field

When a rule references a field that doesn't exist in the data,
the evaluator should pass (nothing to validate) instead of failing.
Previously, the empty field list caused the loop to be skipped and
fall through to the "violation detected" return.

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

@@ -195,6 +195,9 @@ def evaluate_word_rule(
 ) -> tuple[bool, str]:
     """Evaluate a word rule against input and output data."""
     fields = get_fields_from_selector(rule.field_selector, input_data, output_data)
+    if not fields:
+        return True, "No fields to validate"
+
     operator = _humanize_guardrail_func(rule.detects_violation) or "violation check"
     field_paths = ", ".join({field_ref.path for _, field_ref in fields})
 
@@ -237,6 +240,9 @@ def evaluate_number_rule(
 ) -> tuple[bool, str]:
     """Evaluate a number rule against input and output data."""
     fields = get_fields_from_selector(rule.field_selector, input_data, output_data)
+    if not fields:
+        return True, "No fields to validate"
+
     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:
@@ -281,6 +287,9 @@ def evaluate_boolean_rule(
 ) -> tuple[bool, str]:
     """Evaluate a boolean rule against input and output data."""
     fields = get_fields_from_selector(rule.field_selector, input_data, output_data)
+    if not fields:
+        return True, "No fields to validate"
+
     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:

tests/guardrails/test_deterministic_guardrails_service.py

@@ -1466,3 +1466,110 @@ 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: s == "",
+                    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 < 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

tests/guardrails/test_guardrails_models.py

@@ -20,15 +20,15 @@ def test_field_reference_normalizes_capitalized_source(
     ) -> None:
         """Test that FieldReference normalizes capitalized source values to lowercase."""
         # Create FieldReference with capitalized "Input" - should normalize to FieldSource.INPUT
-        field_ref = FieldReference(path="testField", source="Input")  # type: ignore[arg-type]
+        field_ref = FieldReference(path="testField", source="Input")
         assert field_ref.source == FieldSource.INPUT
 
         # Create FieldReference with capitalized "Output" - should normalize to FieldSource.OUTPUT
-        field_ref = FieldReference(path="testField", source="Output")  # type: ignore[arg-type]
+        field_ref = FieldReference(path="testField", source="Output")
         assert field_ref.source == FieldSource.OUTPUT
 
         # Create FieldReference with lowercase "input" - should work as-is
-        field_ref = FieldReference(path="testField", source="input")  # type: ignore[arg-type]
+        field_ref = FieldReference(path="testField", source="input")
         assert field_ref.source == FieldSource.INPUT
 
     def test_all_fields_selector_normalizes_capitalized_sources(
@@ -37,17 +37,16 @@ def test_all_fields_selector_normalizes_capitalized_sources(
         """Test that AllFieldsSelector normalizes capitalized source values in the list."""
         # Create AllFieldsSelector with capitalized "Input" and "Output" - should normalize
         selector = AllFieldsSelector(
-            selector_type="all",
-            sources=["Input", "Output"],  # type: ignore[list-item]
+            selector_type="all", sources=["Input", "Output"]
         )
         assert FieldSource.INPUT in selector.sources
         assert FieldSource.OUTPUT in selector.sources
         assert len(selector.sources) == 2
 
         # Create AllFieldsSelector with mixed case - should normalize all
         selector = AllFieldsSelector(
-            selector_type="all",
-            sources=["Input", "output"],  # type: ignore[list-item]
+            selector_type="all", sources=["Input", "output"]
         )
         assert FieldSource.INPUT in selector.sources
         assert FieldSource.OUTPUT in selector.sources
+