uipath-core 0.1.4__tar.gz → 0.1.6__tar.gz

{uipath_core-0.1.4 → uipath_core-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath-core
-Version: 0.1.4
+Version: 0.1.6
 Summary: UiPath Core abstractions
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-core-python

{uipath_core-0.1.4 → uipath_core-0.1.6}/pyproject.toml

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

{uipath_core-0.1.4 → uipath_core-0.1.6}/src/uipath/core/guardrails/__init__.py

@@ -16,6 +16,7 @@ from .guardrails import (
     GuardrailScope,
     GuardrailSelector,
     GuardrailValidationResult,
+    GuardrailValidationResultType,
     NumberRule,
     Rule,
     SelectorType,
@@ -43,4 +44,5 @@ __all__ = [
     "GuardrailScope",
     "GuardrailSelector",
     "GuardrailValidationResult",
+    "GuardrailValidationResultType",
 ]

uipath_core-0.1.6/src/uipath/core/guardrails/_deterministic_guardrails_service.py

@@ -0,0 +1,145 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+from ..tracing.decorators import traced
+from ._evaluators import (
+    evaluate_boolean_rule,
+    evaluate_number_rule,
+    evaluate_universal_rule,
+    evaluate_word_rule,
+)
+from .guardrails import (
+    AllFieldsSelector,
+    ApplyTo,
+    BooleanRule,
+    DeterministicGuardrail,
+    FieldSource,
+    GuardrailValidationResult,
+    GuardrailValidationResultType,
+    NumberRule,
+    SpecificFieldsSelector,
+    UniversalRule,
+    WordRule,
+)
+
+
+class DeterministicGuardrailsService(BaseModel):
+    @traced("evaluate_pre_deterministic_guardrail", run_type="uipath")
+    def evaluate_pre_deterministic_guardrail(
+        self,
+        input_data: dict[str, Any],
+        guardrail: DeterministicGuardrail,
+    ) -> GuardrailValidationResult:
+        """Evaluate deterministic guardrail rules against input data (pre-execution)."""
+        # Check if guardrail contains any output-dependent rules
+        has_output_rule = self._has_output_dependent_rule(guardrail, [ApplyTo.OUTPUT])
+
+        # If guardrail has output-dependent rules, skip evaluation in pre-execution
+        # Output rules will be evaluated during post-execution
+        if has_output_rule:
+            return GuardrailValidationResult(
+                result=GuardrailValidationResultType.PASSED,
+                reason="Guardrail contains output-dependent rules that will be evaluated during post-execution",
+            )
+        return self._evaluate_deterministic_guardrail(
+            input_data=input_data,
+            output_data={},
+            guardrail=guardrail,
+        )
+
+    @traced("evaluate_post_deterministic_guardrails", run_type="uipath")
+    def evaluate_post_deterministic_guardrail(
+        self,
+        input_data: dict[str, Any],
+        output_data: dict[str, Any],
+        guardrail: DeterministicGuardrail,
+    ) -> GuardrailValidationResult:
+        """Evaluate deterministic guardrail rules against input and output data."""
+        # Check if guardrail contains any output-dependent rules
+        has_output_rule = self._has_output_dependent_rule(
+            guardrail, [ApplyTo.OUTPUT, ApplyTo.INPUT_AND_OUTPUT]
+        )
+
+        # If guardrail has no output-dependent rules, skip post-execution evaluation
+        # Only input rules exist and they should have been evaluated during pre-execution
+        if not has_output_rule:
+            return GuardrailValidationResult(
+                result=GuardrailValidationResultType.PASSED,
+                reason="Guardrail contains only input-dependent rules that were evaluated during pre-execution",
+            )
+
+        return self._evaluate_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=guardrail,
+        )
+
+    @staticmethod
+    def _has_output_dependent_rule(
+        guardrail: DeterministicGuardrail,
+        universal_rules_apply_to_values: list[ApplyTo],
+    ) -> bool:
+        """Check if at least one rule EXCLUSIVELY requires output data.
+
+        Args:
+            guardrail: The guardrail to check
+            universal_rules_apply_to_values: List of ApplyTo values to consider as output-dependent for UniversalRules.
+
+        Returns:
+            True if at least one rule exclusively depends on output data, False otherwise.
+        """
+        for rule in guardrail.rules:
+            # UniversalRule: only return True if it applies to values in universal_rules_apply_to_values
+            if isinstance(rule, UniversalRule):
+                if rule.apply_to in universal_rules_apply_to_values:
+                    return True
+            # Rules with field_selector
+            elif isinstance(rule, (WordRule, NumberRule, BooleanRule)):
+                field_selector = rule.field_selector
+                # AllFieldsSelector applies to both input and output, not exclusively output
+                # SpecificFieldsSelector: only return True if at least one field has OUTPUT source
+                if isinstance(field_selector, SpecificFieldsSelector):
+                    if field_selector.fields and any(
+                        field.source == FieldSource.OUTPUT
+                        for field in field_selector.fields
+                    ):
+                        return True
+                elif isinstance(field_selector, AllFieldsSelector):
+                    if FieldSource.OUTPUT in field_selector.sources:
+                        return True
+
+        return False
+
+    @staticmethod
+    def _evaluate_deterministic_guardrail(
+        input_data: dict[str, Any],
+        output_data: dict[str, Any],
+        guardrail: DeterministicGuardrail,
+    ) -> GuardrailValidationResult:
+        """Evaluate deterministic guardrail rules against input and output data."""
+        for rule in guardrail.rules:
+            if isinstance(rule, WordRule):
+                passed, reason = evaluate_word_rule(rule, input_data, output_data)
+            elif isinstance(rule, NumberRule):
+                passed, reason = evaluate_number_rule(rule, input_data, output_data)
+            elif isinstance(rule, BooleanRule):
+                passed, reason = evaluate_boolean_rule(rule, input_data, output_data)
+            elif isinstance(rule, UniversalRule):
+                passed, reason = evaluate_universal_rule(rule, output_data)
+            else:
+                return GuardrailValidationResult(
+                    result=GuardrailValidationResultType.VALIDATION_FAILED,
+                    reason=f"Unknown rule type: {type(rule)}",
+                )
+
+            if not passed:
+                return GuardrailValidationResult(
+                    result=GuardrailValidationResultType.VALIDATION_FAILED,
+                    reason=reason or "Rule validation failed",
+                )
+
+        return GuardrailValidationResult(
+            result=GuardrailValidationResultType.PASSED,
+            reason="All deterministic guardrail rules passed",
+        )

{uipath_core-0.1.4 → uipath_core-0.1.6}/src/uipath/core/guardrails/_evaluators.py

@@ -120,23 +120,25 @@ def get_fields_from_selector(
     fields: list[tuple[Any, FieldReference]] = []
 
     if isinstance(field_selector, AllFieldsSelector):
-        # For "all" selector, we need to collect all fields from both input and output
+        # For "all" selector, we need to collect all fields from the specified sources
         # This is a simplified implementation - in practice, you might want to
         # recursively collect all nested fields
-        for key, value in input_data.items():
-            fields.append(
-                (
-                    value,
-                    FieldReference(path=key, source=FieldSource.INPUT),
+        if FieldSource.INPUT in field_selector.sources:
+            for key, value in input_data.items():
+                fields.append(
+                    (
+                        value,
+                        FieldReference(path=key, source=FieldSource.INPUT),
+                    )
                 )
-            )
-        for key, value in output_data.items():
-            fields.append(
-                (
-                    value,
-                    FieldReference(path=key, source=FieldSource.OUTPUT),
+        if FieldSource.OUTPUT in field_selector.sources:
+            for key, value in output_data.items():
+                fields.append(
+                    (
+                        value,
+                        FieldReference(path=key, source=FieldSource.OUTPUT),
+                    )
                 )
-            )
     elif isinstance(field_selector, SpecificFieldsSelector):
         # For specific fields, extract values based on field references
         for field_ref in field_selector.fields:
@@ -286,13 +288,13 @@ def evaluate_universal_rule(
 
     Universal rules trigger based on the apply_to scope and execution phase:
     - Pre-execution (empty output_data):
-      - INPUT: triggers (validation_passed = False)
-      - OUTPUT: does not trigger (validation_passed = True)
-      - INPUT_AND_OUTPUT: triggers (validation_passed = False)
+      - INPUT: triggers (result = VALIDATION_FAILED)
+      - OUTPUT: does not trigger (result = PASSED)
+      - INPUT_AND_OUTPUT: triggers (result = VALIDATION_FAILED)
     - Post-execution (output_data has data):
-      - INPUT: does not trigger (validation_passed = True)
-      - OUTPUT: triggers (validation_passed = False)
-      - INPUT_AND_OUTPUT: triggers (validation_passed = False)
+      - INPUT: does not trigger (result = PASSED)
+      - OUTPUT: triggers (result = VALIDATION_FAILED)
+      - INPUT_AND_OUTPUT: triggers (result = VALIDATION_FAILED)
     """
     # Determine if this is pre-execution (no output data) or post-execution
     is_pre_execution = not output_data or len(output_data) == 0

{uipath_core-0.1.4 → uipath_core-0.1.6}/src/uipath/core/guardrails/guardrails.py

@@ -6,18 +6,27 @@ from typing import Annotated, Callable, Literal
 from pydantic import BaseModel, ConfigDict, Field
 
 
+class GuardrailValidationResultType(str, Enum):
+    """Guardrail validation result type enumeration."""
+
+    PASSED = "passed"
+    VALIDATION_FAILED = "validation_failed"
+    ENTITLEMENTS_MISSING = "entitlements_missing"
+    FEATURE_DISABLED = "feature_disabled"
+
+
 class GuardrailValidationResult(BaseModel):
     """Result returned from validating input with a given guardrail.
 
     Attributes:
-        validation_passed: Indicates whether the input data passed the guardrail validation.
+        result: The validation result type.
         reason: Textual explanation describing why the validation passed or failed.
     """
 
     model_config = ConfigDict(populate_by_name=True)
 
-    validation_passed: bool = Field(
-        alias="validation_passed", description="Whether the input passed validation."
+    result: GuardrailValidationResultType = Field(
+        alias="result", description="Validation result."
     )
     reason: str = Field(
         alias="reason", description="Explanation for the validation result."
@@ -59,6 +68,7 @@ class AllFieldsSelector(BaseModel):
     """All fields selector."""
 
     selector_type: Literal["all"] = Field(alias="$selectorType")
+    sources: list[FieldSource]
 
     model_config = ConfigDict(populate_by_name=True, extra="allow")
 

{uipath_core-0.1.4 → uipath_core-0.1.6}/tests/guardrails/test_deterministic_guardrails_service.py

@@ -13,6 +13,7 @@ from uipath.core.guardrails import (
     FieldSource,
     GuardrailScope,
     GuardrailSelector,
+    GuardrailValidationResultType,
     NumberRule,
     SpecificFieldsSelector,
     UniversalRule,
@@ -79,8 +80,11 @@ class TestDeterministicGuardrailsService:
             guardrail=deterministic_guardrail,
         )
 
-        assert result.validation_passed is True
-        assert result.reason == "All deterministic guardrail rules passed"
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert (
+            result.reason
+            == "Guardrail contains only input-dependent rules that were evaluated during pre-execution"
+        )
 
     def test_evaluate_post_deterministic_guardrail_validation_failed_age(
         self,
@@ -115,6 +119,16 @@ class TestDeterministicGuardrailsService:
                     ),
                     detects_violation=lambda b: b is not True,
                 ),
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
             ],
         )
 
@@ -132,7 +146,7 @@ class TestDeterministicGuardrailsService:
             guardrail=deterministic_guardrail,
         )
 
-        assert result.validation_passed is False
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
         assert (
             result.reason
             == "Input data didn't match the guardrail condition: [age] comparing function [(n): n < 21.0]"
@@ -171,6 +185,16 @@ class TestDeterministicGuardrailsService:
                     ),
                     detects_violation=lambda b: b is not True,
                 ),
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
             ],
         )
 
@@ -180,7 +204,9 @@ class TestDeterministicGuardrailsService:
             "age": 25,
             "isActive": False,
         }
-        output_data: dict[str, Any] = {}
+        output_data = {
+            "status": 200,
+        }
 
         result = service.evaluate_post_deterministic_guardrail(
             input_data=input_data,
@@ -188,7 +214,7 @@ class TestDeterministicGuardrailsService:
             guardrail=deterministic_guardrail,
         )
 
-        assert result.validation_passed is False
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
         assert (
             result.reason
             == "Input data didn't match the guardrail condition: [isActive] comparing function [(b): b is not True]"
@@ -234,8 +260,11 @@ class TestDeterministicGuardrailsService:
             guardrail=deterministic_guardrail,
         )
 
-        assert result.validation_passed is True
-        assert result.reason == "All deterministic guardrail rules passed"
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert (
+            result.reason
+            == "Guardrail contains only input-dependent rules that were evaluated during pre-execution"
+        )
 
     def test_evaluate_post_deterministic_guardrail_matches_regex_negative(
         self,
@@ -262,6 +291,16 @@ class TestDeterministicGuardrailsService:
                     ),
                     detects_violation=lambda s: not bool(re.search(".*te.*3.*", s)),
                 ),
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
             ],
         )
 
@@ -269,7 +308,9 @@ class TestDeterministicGuardrailsService:
         input_data = {
             "userName": "test",
         }
-        output_data: dict[str, Any] = {}
+        output_data = {
+            "status": 200,
+        }
 
         result = service.evaluate_post_deterministic_guardrail(
             input_data=input_data,
@@ -277,7 +318,7 @@ class TestDeterministicGuardrailsService:
             guardrail=deterministic_guardrail,
         )
 
-        assert result.validation_passed is False
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
         assert (
             result.reason
             == 'Input data didn\'t match the guardrail condition: [userName] comparing function [(s): not bool(re.search(".*te.*3.*", s))]'
@@ -323,8 +364,11 @@ class TestDeterministicGuardrailsService:
             guardrail=deterministic_guardrail,
         )
 
-        assert result.validation_passed is True
-        assert result.reason == "All deterministic guardrail rules passed"
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert (
+            result.reason
+            == "Guardrail contains only input-dependent rules that were evaluated during pre-execution"
+        )
 
     def test_evaluate_post_deterministic_guardrail_word_func_negative(
         self,
@@ -351,6 +395,16 @@ class TestDeterministicGuardrailsService:
                     ),
                     detects_violation=lambda s: len(s) <= 5,
                 ),
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
             ],
         )
 
@@ -358,7 +412,9 @@ class TestDeterministicGuardrailsService:
         input_data = {
             "userName": "test",
         }
-        output_data: dict[str, Any] = {}
+        output_data = {
+            "status": 200,
+        }
 
         result = service.evaluate_post_deterministic_guardrail(
             input_data=input_data,
@@ -366,7 +422,7 @@ class TestDeterministicGuardrailsService:
             guardrail=deterministic_guardrail,
         )
 
-        assert result.validation_passed is False
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
 
     def test_evaluate_post_deterministic_guardrail_word_contains_substring_detects_violation(
         self,
@@ -393,6 +449,16 @@ class TestDeterministicGuardrailsService:
                     ),
                     detects_violation=lambda s: "dre" in s,
                 ),
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
             ],
         )
 
@@ -400,7 +466,9 @@ class TestDeterministicGuardrailsService:
         input_data = {
             "userName": "andrei",
         }
-        output_data: dict[str, Any] = {}
+        output_data = {
+            "status": 200,
+        }
 
         result = service.evaluate_post_deterministic_guardrail(
             input_data=input_data,
@@ -408,7 +476,7 @@ class TestDeterministicGuardrailsService:
             guardrail=deterministic_guardrail,
         )
 
-        assert result.validation_passed is False
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
         assert (
             result.reason
             == 'Input data didn\'t match the guardrail condition: [userName] comparing function [(s): "dre" in s]'
@@ -452,8 +520,11 @@ class TestDeterministicGuardrailsService:
             guardrail=deterministic_guardrail,
         )
 
-        assert result.validation_passed is True
-        assert result.reason == "All deterministic guardrail rules passed"
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert (
+            result.reason
+            == "Guardrail contains only input-dependent rules that were evaluated during pre-execution"
+        )
 
     def test_evaluate_post_deterministic_guardrail_number_func_negative(
         self,
@@ -478,6 +549,16 @@ class TestDeterministicGuardrailsService:
                     ),
                     detects_violation=lambda n: n < 18 or n > 65,
                 ),
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
             ],
         )
 
@@ -485,7 +566,9 @@ class TestDeterministicGuardrailsService:
         input_data = {
             "age": 70,
         }
-        output_data: dict[str, Any] = {}
+        output_data = {
+            "status": 200,
+        }
 
         result = service.evaluate_post_deterministic_guardrail(
             input_data=input_data,
@@ -493,7 +576,7 @@ class TestDeterministicGuardrailsService:
             guardrail=deterministic_guardrail,
         )
 
-        assert result.validation_passed is False
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
 
     def test_should_trigger_policy_pre_execution_only_some_rules_not_met_returns_false(
         self,
@@ -506,7 +589,9 @@ class TestDeterministicGuardrailsService:
             "age": 18,  # Less than 21
             "isActive": True,
         }
-        output_data: dict[str, Any] = {}
+        output_data = {
+            "status": 200,
+        }
 
         result = service.evaluate_post_deterministic_guardrail(
             input_data=input_data,
@@ -514,7 +599,7 @@ class TestDeterministicGuardrailsService:
             guardrail=guardrail,
         )
 
-        assert result.validation_passed is False
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
 
     def test_should_ignore_post_execution_guardrail_for_pre_execution_returns_false(
         self,
@@ -536,7 +621,7 @@ class TestDeterministicGuardrailsService:
         )
 
         # Should fail because post-execution guardrail needs output data
-        assert result.validation_passed is True
+        assert result.result == GuardrailValidationResultType.PASSED
 
     def test_should_trigger_policy_post_execution_guardrail_for_pre_execution_returns_false(
         self,
@@ -562,7 +647,7 @@ class TestDeterministicGuardrailsService:
         )
 
         # Pre-execution guardrail should still pass in post-execution
-        assert result.validation_passed is True
+        assert result.result == GuardrailValidationResultType.PASSED
 
     def test_should_trigger_policy_post_execution_with_output_fields_all_conditions_met_returns_true(
         self,
@@ -587,7 +672,7 @@ class TestDeterministicGuardrailsService:
             guardrail=guardrail,
         )
 
-        assert result.validation_passed is True
+        assert result.result == GuardrailValidationResultType.PASSED
 
     def test_should_trigger_policy_post_execution_with_output_fields_input_conditions_not_met_returns_false(
         self,
@@ -612,7 +697,7 @@ class TestDeterministicGuardrailsService:
             guardrail=guardrail,
         )
 
-        assert result.validation_passed is False
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
 
     def test_should_trigger_policy_post_execution_with_output_fields_output_conditions_not_met_returns_false(
         self,
@@ -637,7 +722,7 @@ class TestDeterministicGuardrailsService:
             guardrail=guardrail,
         )
 
-        assert result.validation_passed is False
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
 
     def test_should_trigger_policy_post_execution_multiple_rules_all_conditions_must_be_met_returns_true(
         self,
@@ -662,7 +747,7 @@ class TestDeterministicGuardrailsService:
             guardrail=guardrail,
         )
 
-        assert result.validation_passed is True
+        assert result.result == GuardrailValidationResultType.PASSED
 
     def test_should_trigger_policy_post_execution_rule_with_multiple_conditions_all_must_be_met_returns_true(
         self,
@@ -687,7 +772,7 @@ class TestDeterministicGuardrailsService:
             guardrail=guardrail,
         )
 
-        assert result.validation_passed is True
+        assert result.result == GuardrailValidationResultType.PASSED
 
     def test_should_trigger_policy_post_execution_rule_with_multiple_conditions_one_condition_not_met_returns_false(
         self,
@@ -712,7 +797,7 @@ class TestDeterministicGuardrailsService:
             guardrail=guardrail,
         )
 
-        assert result.validation_passed is False
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
 
     def test_should_trigger_policy_post_execution_with_all_fields_selector_output_schema_has_fields_returns_true(
         self,
@@ -731,7 +816,9 @@ class TestDeterministicGuardrailsService:
             rules=[
                 NumberRule(
                     rule_type="number",
-                    field_selector=AllFieldsSelector(selector_type="all"),
+                    field_selector=AllFieldsSelector(
+                        selector_type="all", sources=[FieldSource.OUTPUT]
+                    ),
                     detects_violation=lambda n: n != 25.0,
                 ),
             ],
@@ -754,9 +841,9 @@ class TestDeterministicGuardrailsService:
             guardrail=guardrail,
         )
 
-        assert result.validation_passed is True
+        assert result.result == GuardrailValidationResultType.PASSED
 
-    def test_should_trigger_policy_post_execution_with_all_fields_selector_empty_output_schema_returns_false(
+    def test_should_trigger_policy_post_execution_with_all_fields_selector_empty_output_schema_returns_true(
         self,
         service: DeterministicGuardrailsService,
     ) -> None:
@@ -773,7 +860,9 @@ class TestDeterministicGuardrailsService:
             rules=[
                 NumberRule(
                     rule_type="number",
-                    field_selector=AllFieldsSelector(selector_type="all"),
+                    field_selector=AllFieldsSelector(
+                        selector_type="all", sources=[FieldSource.INPUT]
+                    ),
                     detects_violation=lambda n: n != 200.0,
                 ),
             ],
@@ -792,7 +881,7 @@ class TestDeterministicGuardrailsService:
             guardrail=guardrail,
         )
 
-        assert result.validation_passed is False
+        assert result.result == GuardrailValidationResultType.PASSED
 
     def test_should_trigger_policy_pre_execution_always_rule_with_input_apply_to_returns_true(
         self,
@@ -805,15 +894,15 @@ class TestDeterministicGuardrailsService:
             "age": 25,
             "isActive": True,
         }
-        output_data: dict[str, Any] = {}
 
-        result = service.evaluate_post_deterministic_guardrail(
+        result = service.evaluate_pre_deterministic_guardrail(
             input_data=input_data,
-            output_data=output_data,
             guardrail=guardrail,
         )
 
-        assert result.validation_passed is False  # Should trigger
+        assert (
+            result.result == GuardrailValidationResultType.VALIDATION_FAILED
+        )  # Should trigger
 
     def test_should_trigger_policy_pre_execution_always_rule_with_output_apply_to_returns_false(
         self,
@@ -834,7 +923,9 @@ class TestDeterministicGuardrailsService:
             guardrail=guardrail,
         )
 
-        assert result.validation_passed is True  # Should not trigger
+        assert (
+            result.result == GuardrailValidationResultType.PASSED
+        )  # Should not trigger
 
     def test_should_trigger_policy_pre_execution_always_rule_with_input_and_output_apply_to_returns_true(
         self,
@@ -855,7 +946,9 @@ class TestDeterministicGuardrailsService:
             guardrail=guardrail,
         )
 
-        assert result.validation_passed is False  # Should trigger
+        assert (
+            result.result == GuardrailValidationResultType.VALIDATION_FAILED
+        )  # Should trigger
 
     def test_should_trigger_policy_post_execution_always_rule_with_input_apply_to_returns_false(
         self,
@@ -880,7 +973,9 @@ class TestDeterministicGuardrailsService:
             guardrail=guardrail,
         )
 
-        assert result.validation_passed is True  # Should not trigger
+        assert (
+            result.result == GuardrailValidationResultType.PASSED
+        )  # Should not trigger
 
     def test_should_trigger_policy_post_execution_always_rule_with_output_apply_to_returns_true(
         self,
@@ -905,7 +1000,9 @@ class TestDeterministicGuardrailsService:
             guardrail=guardrail,
         )
 
-        assert result.validation_passed is False  # Should trigger
+        assert (
+            result.result == GuardrailValidationResultType.VALIDATION_FAILED
+        )  # Should trigger
 
     def test_should_trigger_policy_post_execution_always_rule_with_input_and_output_apply_to_returns_true(
         self,
@@ -930,7 +1027,9 @@ class TestDeterministicGuardrailsService:
             guardrail=guardrail,
         )
 
-        assert result.validation_passed is False  # Should trigger
+        assert (
+            result.result == GuardrailValidationResultType.VALIDATION_FAILED
+        )  # Should trigger
 
         # Helper methods to create guardrails
 
@@ -964,6 +1063,16 @@ class TestDeterministicGuardrailsService:
                     ),
                     detects_violation=lambda b: b is not True,
                 ),
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
             ],
         )
 
@@ -1088,6 +1197,258 @@ class TestDeterministicGuardrailsService:
             ],
         )
 
+    def test_evaluate_post_deterministic_guardrail_word_contains_operator_passes(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test deterministic guardrail with word contains operator passes for pre-execution."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="b4283bd4-5ce0-49de-a918-2604d830460c",
+            name="Before",
+            description="",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["ConverterToStringAgent"]
+            ),
+            rules=[
+                WordRule(
+                    rule_type="word",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(
+                                path="input_string", source=FieldSource.INPUT
+                            )
+                        ],
+                    ),
+                    detects_violation=lambda s: "cti" in s,
+                ),
+            ],
+        )
+
+        # Input data without "cti" in input_string - should pass
+        input_data = {
+            "input_string": "test value",
+        }
+        output_data: dict[str, Any] = {}
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert (
+            result.reason
+            == "Guardrail contains only input-dependent rules that were evaluated during pre-execution"
+        )
+
+    def test_evaluate_post_deterministic_guardrail_only_output_rules_passes(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test post guardrail with only output rules passes when conditions are met."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-only-output-id",
+            name="Output Only Guardrail",
+            description="Test guardrail with only output rules",
+            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="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
+                WordRule(
+                    rule_type="word",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="result", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda s: s != "Success",
+                ),
+            ],
+        )
+
+        input_data = {
+            "userName": "John",
+        }
+        output_data = {
+            "status": 200,
+            "result": "Success",
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert result.reason == "All deterministic guardrail rules passed"
+
+    def test_evaluate_post_deterministic_guardrail_only_always_rule_fails(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test post guardrail with only UniversalRule always fails."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-only-always-id",
+            name="Always Rule Only Guardrail",
+            description="Test guardrail with only always rule",
+            enabled_for_evals=True,
+            guardrail_type="custom",
+            selector=GuardrailSelector(
+                scopes=[GuardrailScope.TOOL], match_names=["test"]
+            ),
+            rules=[
+                UniversalRule(
+                    rule_type="always",
+                    apply_to=ApplyTo.OUTPUT,
+                ),
+            ],
+        )
+
+        input_data = {
+            "userName": "John",
+        }
+        output_data = {
+            "status": 200,
+        }
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.VALIDATION_FAILED
+
+    def test_evaluate_post_deterministic_guardrail_only_input_rules_passes(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test post guardrail passes when only input rules exist (no output data required)."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-only-input-id",
+            name="Input Only Guardrail",
+            description="Test guardrail with only input rules",
+            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 < 18,
+                ),
+                WordRule(
+                    rule_type="word",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[FieldReference(path="name", source=FieldSource.INPUT)],
+                    ),
+                    detects_violation=lambda s: len(s) < 2,
+                ),
+            ],
+        )
+
+        input_data = {
+            "age": 25,
+            "name": "John",
+        }
+        output_data: dict[str, Any] = {}
+
+        result = service.evaluate_post_deterministic_guardrail(
+            input_data=input_data,
+            output_data=output_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+        assert (
+            result.reason
+            == "Guardrail contains only input-dependent rules that were evaluated during pre-execution"
+        )
+
+    def test_evaluate_pre_deterministic_guardrail_with_input_and_output_rules_input_true(
+        self,
+        service: DeterministicGuardrailsService,
+    ) -> None:
+        """Test pre-execution guardrail with input rule and output rules, should pass because is ignored."""
+        deterministic_guardrail = DeterministicGuardrail(
+            id="test-pre-mixed-rules-id",
+            name="Pre Execution Mixed Rules Guardrail",
+            description="Test pre-execution with both input and output rules",
+            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 < 21.0,
+                ),
+                BooleanRule(
+                    rule_type="boolean",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="isActive", source=FieldSource.INPUT)
+                        ],
+                    ),
+                    detects_violation=lambda b: b is not True,
+                ),
+                # Output rule - should be ignored in pre-execution
+                NumberRule(
+                    rule_type="number",
+                    field_selector=SpecificFieldsSelector(
+                        selector_type="specific",
+                        fields=[
+                            FieldReference(path="status", source=FieldSource.OUTPUT)
+                        ],
+                    ),
+                    detects_violation=lambda n: n != 200.0,
+                ),
+            ],
+        )
+
+        input_data = {
+            "userName": "John",
+            "age": 18,
+            "isActive": True,
+        }
+
+        result = service.evaluate_pre_deterministic_guardrail(
+            input_data=input_data,
+            guardrail=deterministic_guardrail,
+        )
+
+        assert result.result == GuardrailValidationResultType.PASSED
+
     def _create_guardrail_with_always_rule(
         self, apply_to: ApplyTo
     ) -> DeterministicGuardrail:

{uipath_core-0.1.4 → uipath_core-0.1.6}/uv.lock

@@ -991,7 +991,7 @@ wheels = [
 
 [[package]]
 name = "uipath-core"
-version = "0.1.4"
+version = "0.1.6"
 source = { editable = "." }
 dependencies = [
     { name = "opentelemetry-instrumentation" },

uipath_core-0.1.4/src/uipath/core/guardrails/_deterministic_guardrails_service.py

@@ -1,79 +0,0 @@
-from typing import Any
-
-from pydantic import BaseModel
-
-from ..tracing.decorators import traced
-from ._evaluators import (
-    evaluate_boolean_rule,
-    evaluate_number_rule,
-    evaluate_universal_rule,
-    evaluate_word_rule,
-)
-from .guardrails import (
-    BooleanRule,
-    DeterministicGuardrail,
-    GuardrailValidationResult,
-    NumberRule,
-    UniversalRule,
-    WordRule,
-)
-
-
-class DeterministicGuardrailsService(BaseModel):
-    @traced("evaluate_pre_deterministic_guardrail", run_type="uipath")
-    def evaluate_pre_deterministic_guardrail(
-        self,
-        input_data: dict[str, Any],
-        guardrail: DeterministicGuardrail,
-    ) -> GuardrailValidationResult:
-        """Evaluate deterministic guardrail rules against input data (pre-execution)."""
-        return self._evaluate_deterministic_guardrail(
-            input_data=input_data,
-            output_data={},
-            guardrail=guardrail,
-        )
-
-    @traced("evaluate_post_deterministic_guardrails", run_type="uipath")
-    def evaluate_post_deterministic_guardrail(
-        self,
-        input_data: dict[str, Any],
-        output_data: dict[str, Any],
-        guardrail: DeterministicGuardrail,
-    ) -> GuardrailValidationResult:
-        """Evaluate deterministic guardrail rules against input and output data."""
-        return self._evaluate_deterministic_guardrail(
-            input_data=input_data,
-            output_data=output_data,
-            guardrail=guardrail,
-        )
-
-    @staticmethod
-    def _evaluate_deterministic_guardrail(
-        input_data: dict[str, Any],
-        output_data: dict[str, Any],
-        guardrail: DeterministicGuardrail,
-    ) -> GuardrailValidationResult:
-        """Evaluate deterministic guardrail rules against input and output data."""
-        for rule in guardrail.rules:
-            if isinstance(rule, WordRule):
-                passed, reason = evaluate_word_rule(rule, input_data, output_data)
-            elif isinstance(rule, NumberRule):
-                passed, reason = evaluate_number_rule(rule, input_data, output_data)
-            elif isinstance(rule, BooleanRule):
-                passed, reason = evaluate_boolean_rule(rule, input_data, output_data)
-            elif isinstance(rule, UniversalRule):
-                passed, reason = evaluate_universal_rule(rule, output_data)
-            else:
-                return GuardrailValidationResult(
-                    validation_passed=False,
-                    reason=f"Unknown rule type: {type(rule)}",
-                )
-
-            if not passed:
-                return GuardrailValidationResult(
-                    validation_passed=False, reason=reason or "Rule validation failed"
-                )
-
-        return GuardrailValidationResult(
-            validation_passed=True, reason="All deterministic guardrail rules passed"
-        )