uipath-core 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

uipath/core/chat/__init__.py

@@ -66,13 +66,23 @@ from .conversation import (
     UiPathConversationStartedEvent,
     UiPathConversationStartEvent,
 )
-from .event import UiPathConversationEvent
+from .error import (
+    UiPathConversationErrorEndEvent,
+    UiPathConversationErrorEvent,
+    UiPathConversationErrorStartEvent,
+)
+from .event import UiPathConversationEvent, UiPathConversationLabelUpdatedEvent
 from .exchange import (
     UiPathConversationExchange,
     UiPathConversationExchangeEndEvent,
     UiPathConversationExchangeEvent,
     UiPathConversationExchangeStartEvent,
 )
+from .interrupt import (
+    UiPathConversationInterruptEndEvent,
+    UiPathConversationInterruptEvent,
+    UiPathConversationInterruptStartEvent,
+)
 from .message import (
     UiPathConversationMessage,
     UiPathConversationMessageEndEvent,
@@ -91,6 +101,11 @@ from .tool import (
 __all__ = [
     # Root
     "UiPathConversationEvent",
+    "UiPathConversationLabelUpdatedEvent",
+    # Error
+    "UiPathConversationErrorStartEvent",
+    "UiPathConversationErrorEndEvent",
+    "UiPathConversationErrorEvent",
     # Conversation
     "UiPathConversationCapabilities",
     "UiPathConversationStartEvent",
@@ -106,6 +121,10 @@ __all__ = [
     "UiPathConversationMessageEndEvent",
     "UiPathConversationMessageEvent",
     "UiPathConversationMessage",
+    # Interrupt
+    "UiPathConversationInterruptStartEvent",
+    "UiPathConversationInterruptEndEvent",
+    "UiPathConversationInterruptEvent",
     # Content
     "UiPathConversationContentPartChunkEvent",
     "UiPathConversationContentPartStartEvent",

uipath/core/chat/async_stream.py

@@ -4,11 +4,12 @@ from typing import Any
 
 from pydantic import BaseModel, ConfigDict, Field
 
+from .error import UiPathConversationErrorEvent
+
 
 class UiPathConversationInputStreamChunkEvent(BaseModel):
     """Represents a single chunk of input stream data."""
 
-    input_stream_sequence: int | None = Field(None, alias="inputStreamSequence")
     data: str
 
     model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
@@ -44,9 +45,16 @@ class UiPathConversationAsyncInputStreamEvent(BaseModel):
     """Encapsulates sub-events related to an asynchronous input stream."""
 
     stream_id: str = Field(..., alias="streamId")
-    start: UiPathConversationAsyncInputStreamStartEvent | None = None
-    end: UiPathConversationAsyncInputStreamEndEvent | None = None
+    start: UiPathConversationAsyncInputStreamStartEvent | None = Field(
+        None, alias="startAsyncInputStream"
+    )
+    end: UiPathConversationAsyncInputStreamEndEvent | None = Field(
+        None, alias="endAsyncInputStream"
+    )
     chunk: UiPathConversationInputStreamChunkEvent | None = None
     meta_event: dict[str, Any] | None = Field(None, alias="metaEvent")
+    error: UiPathConversationErrorEvent | None = Field(
+        None, alias="asyncInputStreamError"
+    )
 
     model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)

uipath/core/chat/citation.py

@@ -1,9 +1,11 @@
 """Citation events for message content."""
 
-from typing import Any
+from __future__ import annotations
 
 from pydantic import BaseModel, ConfigDict, Field
 
+from .error import UiPathConversationErrorEvent
+
 
 class UiPathConversationCitationStartEvent(BaseModel):
     """Indicates the start of a citation target in a content part."""
@@ -14,7 +16,7 @@ class UiPathConversationCitationStartEvent(BaseModel):
 class UiPathConversationCitationEndEvent(BaseModel):
     """Indicates the end of a citation target in a content part."""
 
-    sources: list[dict[str, Any]]
+    sources: list[UiPathConversationCitationSource]
 
     model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
 
@@ -27,6 +29,7 @@ class UiPathConversationCitationEvent(BaseModel):
         None, alias="startCitation"
     )
     end: UiPathConversationCitationEndEvent | None = Field(None, alias="endCitation")
+    error: UiPathConversationErrorEvent | None = Field(None, alias="citationError")
 
     model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
 
@@ -52,9 +55,10 @@ class UiPathConversationCitationSourceMedia(BaseModel):
 class UiPathConversationCitationSource(BaseModel):
     """Represents a citation source, either a URL or media reference."""
 
-    title: str | None = None
+    title: str
+    number: int
 
-    # Union of Url or Media
+    # Union of Url or Media - these are optional
     url: str | None = None
     mime_type: str | None = Field(None, alias="mimeType")
     download_url: str | None = Field(None, alias="downloadUrl")

uipath/core/chat/content.py

@@ -5,6 +5,7 @@ from typing import Any
 from pydantic import BaseModel, ConfigDict, Field
 
 from .citation import UiPathConversationCitation, UiPathConversationCitationEvent
+from .error import UiPathConversationErrorEvent
 
 
 class UiPathConversationContentPartChunkEvent(BaseModel):
@@ -21,6 +22,9 @@ class UiPathConversationContentPartStartEvent(BaseModel):
 
     mime_type: str = Field(..., alias="mimeType")
     metadata: dict[str, Any] | None = Field(None, alias="metaData")
+    external_value: "UiPathExternalValue | None" = Field(None, alias="externalValue")
+    name: str | None = None
+    timestamp: str | None = None
 
     model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
 
@@ -49,6 +53,7 @@ class UiPathConversationContentPartEvent(BaseModel):
     )
     chunk: UiPathConversationContentPartChunkEvent | None = None
     meta_event: dict[str, Any] | None = Field(None, alias="metaEvent")
+    error: UiPathConversationErrorEvent | None = Field(None, alias="contentPartError")
 
     model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
 
@@ -64,7 +69,7 @@ class UiPathInlineValue(BaseModel):
 class UiPathExternalValue(BaseModel):
     """Used when a value is too large to be returned inline."""
 
-    url: str
+    uri: str
     byte_count: int | None = Field(None, alias="byteCount")
 
     model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)

uipath/core/chat/error.py

@@ -0,0 +1,34 @@
+"""Common error event models used across all conversation event types."""
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class UiPathConversationErrorStartEvent(BaseModel):
+    """Represents the start of an error condition."""
+
+    message: str
+    details: Any | None = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationErrorEndEvent(BaseModel):
+    """Represents the end of an error condition."""
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationErrorEvent(BaseModel):
+    """Encapsulates sub-events that represent the start and end of an error condition.
+
+    This is a common error event model used across all event types (conversation, exchange,
+    message, content part, citation, tool call, async input stream).
+    """
+
+    error_id: str = Field(..., alias="errorId")
+    start: UiPathConversationErrorStartEvent | None = Field(None, alias="startError")
+    end: UiPathConversationErrorEndEvent | None = Field(None, alias="endError")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)

uipath/core/chat/event.py

@@ -12,11 +12,21 @@ from .conversation import (
     UiPathConversationStartedEvent,
     UiPathConversationStartEvent,
 )
+from .error import UiPathConversationErrorEvent
 from .exchange import UiPathConversationExchangeEvent
 from .meta import UiPathConversationMetaEvent
 from .tool import UiPathConversationToolCallEvent
 
 
+class UiPathConversationLabelUpdatedEvent(BaseModel):
+    """Indicates the update of the conversation label."""
+
+    label: str
+    autogenerated: bool
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
 class UiPathConversationEvent(BaseModel):
     """The top-level event type representing an event in a conversation.
 
@@ -31,13 +41,17 @@ class UiPathConversationEvent(BaseModel):
     )
     start: UiPathConversationStartEvent | None = Field(
         None,
+        alias="startSession",
         description="Signals the start of an event stream concerning a conversation. This event does NOT necessarily mean this is a brand new conversation. It may be a continuation of an existing conversation.",
     )
     started: UiPathConversationStartedEvent | None = Field(
-        None, description="Signals the acceptance of the start of a conversation."
+        None,
+        alias="sessionStarted",
+        description="Signals the acceptance of the start of a conversation.",
     )
     end: UiPathConversationEndEvent | None = Field(
         None,
+        alias="endSession",
         description="Signals the end of a conversation event stream. This does NOT mean the conversation is over. A new event stream for the conversation could be started in the future.",
     )
     exchange: UiPathConversationExchangeEvent | None = Field(
@@ -54,10 +68,20 @@ class UiPathConversationEvent(BaseModel):
         alias="asyncToolCall",
         description="Optional async tool call sub-event. This feature is not supported by all LLMs. Most tool calls are scoped to a message, and use the toolCall and toolResult properties defined by the ConversationMessage type.",
     )
+    label_updated: "UiPathConversationLabelUpdatedEvent | None" = Field(
+        None,
+        alias="labelUpdated",
+        description="Indicates that the conversation's label has been updated. Useful for UIs to update the display name of live conversations.",
+    )
     meta_event: UiPathConversationMetaEvent | None = Field(
         None,
         alias="metaEvent",
         description="Allows additional events to be sent in the context of the enclosing event stream.",
     )
+    error: UiPathConversationErrorEvent | None = Field(
+        None,
+        alias="conversationError",
+        description="Sent by the service to indicate the start and end of an error condition impacting a conversation. The client should not send any events for this conversation while the error condition is present.",
+    )
 
     model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)

uipath/core/chat/exchange.py

@@ -20,6 +20,7 @@ from typing import Any
 
 from pydantic import BaseModel, ConfigDict, Field
 
+from .error import UiPathConversationErrorEvent
 from .message import UiPathConversationMessage, UiPathConversationMessageEvent
 
 
@@ -28,6 +29,7 @@ class UiPathConversationExchangeStartEvent(BaseModel):
 
     conversation_sequence: int | None = Field(None, alias="conversationSequence")
     metadata: dict[str, Any] | None = Field(None, alias="metaData")
+    timestamp: str | None = None
 
     model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
 
@@ -50,6 +52,7 @@ class UiPathConversationExchangeEvent(BaseModel):
     end: UiPathConversationExchangeEndEvent | None = Field(None, alias="endExchange")
     message: UiPathConversationMessageEvent | None = None
     meta_event: dict[str, Any] | None = Field(None, alias="metaEvent")
+    error: UiPathConversationErrorEvent | None = Field(None, alias="exchangeError")
 
     model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
 

uipath/core/chat/interrupt.py

@@ -0,0 +1,35 @@
+"""Interrupt events for human-in-the-loop patterns."""
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class UiPathConversationInterruptStartEvent(BaseModel):
+    """Signals the start of an interrupt - a pause point where the agent needs external input."""
+
+    type: str
+    value: Any
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationInterruptEndEvent(BaseModel):
+    """Signals the interrupt end event with the provided value."""
+
+    # Can be any type
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class UiPathConversationInterruptEvent(BaseModel):
+    """Encapsulates interrupt-related events within a message."""
+
+    interrupt_id: str = Field(..., alias="interruptId")
+    start: UiPathConversationInterruptStartEvent | None = Field(
+        None, alias="startInterrupt"
+    )
+    end: Any | None = Field(None, alias="endInterrupt")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)

uipath/core/chat/message.py

@@ -5,6 +5,8 @@ from typing import Any
 from pydantic import BaseModel, ConfigDict, Field
 
 from .content import UiPathConversationContentPart, UiPathConversationContentPartEvent
+from .error import UiPathConversationErrorEvent
+from .interrupt import UiPathConversationInterruptEvent
 from .tool import UiPathConversationToolCall, UiPathConversationToolCallEvent
 
 
@@ -39,7 +41,9 @@ class UiPathConversationMessageEvent(BaseModel):
         None, alias="contentPart"
     )
     tool_call: UiPathConversationToolCallEvent | None = Field(None, alias="toolCall")
+    interrupt: UiPathConversationInterruptEvent | None = None
     meta_event: dict[str, Any] | None = Field(None, alias="metaEvent")
+    error: UiPathConversationErrorEvent | None = Field(None, alias="messageError")
 
     model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
 

uipath/core/chat/tool.py

@@ -5,6 +5,7 @@ from typing import Any
 from pydantic import BaseModel, ConfigDict, Field
 
 from .content import InlineOrExternal
+from .error import UiPathConversationErrorEvent
 
 
 class UiPathConversationToolCallResult(BaseModel):
@@ -23,7 +24,7 @@ class UiPathConversationToolCall(BaseModel):
 
     tool_call_id: str = Field(..., alias="toolCallId")
     name: str
-    arguments: InlineOrExternal | None = None
+    input: InlineOrExternal | None = None
     timestamp: str | None = None
     result: UiPathConversationToolCallResult | None = None
 
@@ -62,5 +63,6 @@ class UiPathConversationToolCallEvent(BaseModel):
     )
     end: UiPathConversationToolCallEndEvent | None = Field(None, alias="endToolCall")
     meta_event: dict[str, Any] | None = Field(None, alias="metaEvent")
+    error: UiPathConversationErrorEvent | None = Field(None, alias="toolCallError")
 
     model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)

uipath/core/guardrails/__init__.py

@@ -0,0 +1,44 @@
+"""UiPath Guardrails Models.
+
+This module contains models related to UiPath Guardrails.
+"""
+
+from ._deterministic_guardrails_service import DeterministicGuardrailsService
+from .guardrails import (
+    AllFieldsSelector,
+    ApplyTo,
+    BaseGuardrail,
+    BooleanRule,
+    DeterministicGuardrail,
+    FieldReference,
+    FieldSelector,
+    FieldSource,
+    GuardrailScope,
+    GuardrailSelector,
+    NumberRule,
+    Rule,
+    SelectorType,
+    SpecificFieldsSelector,
+    UniversalRule,
+    WordRule,
+)
+
+__all__ = [
+    "DeterministicGuardrailsService",
+    "FieldSource",
+    "ApplyTo",
+    "FieldReference",
+    "SelectorType",
+    "AllFieldsSelector",
+    "SpecificFieldsSelector",
+    "FieldSelector",
+    "BaseGuardrail",
+    "DeterministicGuardrail",
+    "WordRule",
+    "NumberRule",
+    "BooleanRule",
+    "UniversalRule",
+    "Rule",
+    "GuardrailScope",
+    "GuardrailSelector",
+]

uipath/core/guardrails/_deterministic_guardrails_service.py

@@ -0,0 +1,79 @@
+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"
+        )

uipath/core/guardrails/_evaluators.py

@@ -0,0 +1,309 @@
+"""Guardrail rule evaluators.
+
+This module provides functions for evaluating different types of guardrail rules
+against input and output data.
+"""
+
+from enum import IntEnum
+from typing import Any
+
+from .guardrails import (
+    AllFieldsSelector,
+    ApplyTo,
+    BooleanRule,
+    FieldReference,
+    FieldSource,
+    NumberRule,
+    SpecificFieldsSelector,
+    UniversalRule,
+    WordRule,
+)
+
+
+class ArrayDepth(IntEnum):
+    """Array depth enumeration for path parsing."""
+
+    NONE = 0  # Not an array
+    SINGLE = 1  # Single array [*]
+    MATRIX = 2  # Matrix [*][*]
+
+
+def extract_field_value(path: str, data: dict[str, Any]) -> list[Any]:
+    """Extract field values from data using dot-notation path.
+
+    Supports array notation with [*] and [*][*] for arrays and matrices.
+    If an array is encountered at any point in the path, all elements are checked.
+    """
+    if not isinstance(data, dict):
+        return []
+
+    results: list[Any] = []
+
+    def _parse_path_segment(segment: str) -> tuple[str, ArrayDepth]:
+        """Parse a path segment to extract field name and array depth."""
+        if "[*][*]" in segment:
+            field_name = segment.replace("[*][*]", "")
+            return field_name, ArrayDepth.MATRIX
+        elif "[*]" in segment:
+            field_name = segment.replace("[*]", "")
+            return field_name, ArrayDepth.SINGLE
+        else:
+            return segment, ArrayDepth.NONE
+
+    def _traverse(current: Any, remaining_parts: list[str]) -> None:
+        """Recursively traverse the path, handling arrays and matrices."""
+        if not remaining_parts:
+            # End of path, add current value
+            if current is not None:
+                if isinstance(current, list):
+                    # If current is a list, add all elements
+                    results.extend(current)
+                else:
+                    results.append(current)
+            return
+
+        part = remaining_parts[0]
+        next_parts = remaining_parts[1:]
+        field_name, array_depth = _parse_path_segment(part)
+
+        if isinstance(current, dict):
+            if field_name not in current:
+                return
+            next_value = current.get(field_name)
+
+            if array_depth == ArrayDepth.MATRIX:
+                # Matrix [*][*] - expect 2D array
+                if isinstance(next_value, list):
+                    for row in next_value:
+                        if isinstance(row, list):
+                            for item in row:
+                                _traverse(item, next_parts)
+                        else:
+                            # Not a 2D array, treat as 1D
+                            _traverse(row, next_parts)
+            elif array_depth == ArrayDepth.SINGLE:
+                # Array [*] - expect 1D array
+                if isinstance(next_value, list):
+                    for item in next_value:
+                        _traverse(item, next_parts)
+                else:
+                    # Not an array, but path expects one - continue traversal
+                    _traverse(next_value, next_parts)
+            else:
+                # No array notation, continue traversal
+                if isinstance(next_value, list):
+                    # Array encountered without notation - check all elements
+                    for item in next_value:
+                        _traverse(item, next_parts)
+                else:
+                    _traverse(next_value, next_parts)
+        elif isinstance(current, list):
+            # Current is an array - check all elements
+            for item in current:
+                _traverse(item, remaining_parts)
+        else:
+            # Cannot traverse further
+            return
+
+    path_parts = path.split(".")
+    _traverse(data, path_parts)
+    return results
+
+
+def get_fields_from_selector(
+    field_selector: AllFieldsSelector | SpecificFieldsSelector,
+    input_data: dict[str, Any],
+    output_data: dict[str, Any],
+) -> list[tuple[Any, FieldReference]]:
+    """Get field values and their references based on the field 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
+        # 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),
+                )
+            )
+        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:
+            # Use FieldSource to determine whether to use input_data or output_data
+            if field_ref.source == FieldSource.INPUT:
+                data = input_data
+            elif field_ref.source == FieldSource.OUTPUT:
+                data = output_data
+            else:
+                # Unknown source, skip this field
+                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))
+
+    return fields
+
+
+def format_guardrail_error_message(
+    field_ref: FieldReference,
+    operator: str,
+    expected_value: str | None = None,
+) -> str:
+    """Format a guardrail error message following the standard pattern."""
+    source = "Input" if field_ref.source == FieldSource.INPUT else "Output"
+    message = f"{source} data didn't match the guardrail condition: [{field_ref.path}] {operator}"
+    if expected_value and expected_value.strip():
+        message += f" [{expected_value.strip()}]"
+    return message
+
+
+def evaluate_word_rule(
+    rule: WordRule, input_data: dict[str, Any], output_data: dict[str, Any]
+) -> tuple[bool, str | None]:
+    """Evaluate a word rule against input and output data."""
+    fields = get_fields_from_selector(rule.field_selector, input_data, output_data)
+
+    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):
+            continue
+
+        field_str = field_value
+
+        # Use the custom function to evaluate the rule
+        try:
+            passed = rule.func(field_str)
+        except Exception:
+            # If function raises an exception, treat as failure
+            passed = False
+
+        if not passed:
+            reason = format_guardrail_error_message(
+                field_ref, "comparing function", None
+            )
+            return False, reason
+
+    return True, "All word rule validations passed"
+
+
+def evaluate_number_rule(
+    rule: NumberRule, input_data: dict[str, Any], output_data: dict[str, Any]
+) -> tuple[bool, str | None]:
+    """Evaluate a number rule against input and output data."""
+    fields = get_fields_from_selector(rule.field_selector, input_data, output_data)
+
+    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.)
+        # 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)):
+            continue
+
+        field_num = float(field_value)
+
+        # Use the custom function to evaluate the rule
+        try:
+            passed = rule.func(field_num)
+        except Exception:
+            # If function raises an exception, treat as failure
+            passed = False
+
+        if not passed:
+            reason = format_guardrail_error_message(
+                field_ref, "comparing function", None
+            )
+            return False, reason
+
+    return True, "All number rule validations passed"
+
+
+def evaluate_boolean_rule(
+    rule: BooleanRule,
+    input_data: dict[str, Any],
+    output_data: dict[str, Any],
+) -> tuple[bool, str | None]:
+    """Evaluate a boolean rule against input and output data."""
+    fields = get_fields_from_selector(rule.field_selector, input_data, output_data)
+
+    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):
+            continue
+
+        field_bool = field_value
+
+        # Use the custom function to evaluate the rule
+        try:
+            passed = rule.func(field_bool)
+        except Exception:
+            # If function raises an exception, treat as failure
+            passed = False
+
+        if not passed:
+            reason = format_guardrail_error_message(
+                field_ref, "comparing function", None
+            )
+            return False, reason
+
+    return True, "All boolean rule validations passed"
+
+
+def evaluate_universal_rule(
+    rule: UniversalRule,
+    output_data: dict[str, Any],
+) -> tuple[bool, str | None]:
+    """Evaluate a universal rule against input and output data.
+
+    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)
+    - 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)
+    """
+    # Determine if this is pre-execution (no output data) or post-execution
+    is_pre_execution = not output_data or len(output_data) == 0
+
+    if rule.apply_to == ApplyTo.INPUT:
+        # INPUT: triggers in pre-execution, does not trigger in post-execution
+        if is_pre_execution:
+            return False, "Universal rule validation triggered (pre-execution, input)"
+        else:
+            return True, "Universal rule validation passed (post-execution, input)"
+    elif rule.apply_to == ApplyTo.OUTPUT:
+        # OUTPUT: does not trigger in pre-execution, triggers in post-execution
+        if is_pre_execution:
+            return True, "Universal rule validation passed (pre-execution, output)"
+        else:
+            return False, "Universal rule validation triggered (post-execution, output)"
+    elif rule.apply_to == ApplyTo.INPUT_AND_OUTPUT:
+        # INPUT_AND_OUTPUT: triggers in both phases
+        return False, "Universal rule validation triggered (input and output)"
+    else:
+        return False, f"Unknown apply_to value: {rule.apply_to}"

uipath/core/guardrails/guardrails.py

@@ -0,0 +1,170 @@
+"""Guardrails models for UiPath Platform."""
+
+from enum import Enum
+from typing import Annotated, Callable, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class GuardrailValidationResult(BaseModel):
+    """Result returned from validating input with a given guardrail.
+
+    Attributes:
+        validation_passed: Indicates whether the input data passed the guardrail validation.
+        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."
+    )
+    reason: str = Field(
+        alias="reason", description="Explanation for the validation result."
+    )
+
+
+class FieldSource(str, Enum):
+    """Field source enumeration."""
+
+    INPUT = "input"
+    OUTPUT = "output"
+
+
+class ApplyTo(str, Enum):
+    """Apply to enumeration."""
+
+    INPUT = "input"
+    INPUT_AND_OUTPUT = "inputAndOutput"
+    OUTPUT = "output"
+
+
+class FieldReference(BaseModel):
+    """Field reference model."""
+
+    path: str
+    source: FieldSource
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class SelectorType(str, Enum):
+    """Selector type enumeration."""
+
+    ALL = "all"
+    SPECIFIC = "specific"
+
+
+class AllFieldsSelector(BaseModel):
+    """All fields selector."""
+
+    selector_type: Literal["all"] = Field(alias="$selectorType")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class SpecificFieldsSelector(BaseModel):
+    """Specific fields selector."""
+
+    selector_type: Literal["specific"] = Field(alias="$selectorType")
+    fields: list[FieldReference]
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+FieldSelector = Annotated[
+    AllFieldsSelector | SpecificFieldsSelector,
+    Field(discriminator="selector_type"),
+]
+
+
+class RuleType(str, Enum):
+    """Rule type enumeration."""
+
+    BOOLEAN = "boolean"
+    NUMBER = "number"
+    UNIVERSAL = "always"
+    WORD = "word"
+
+
+class WordRule(BaseModel):
+    """Word rule model."""
+
+    rule_type: Literal["word"] = Field(alias="$ruleType")
+    field_selector: FieldSelector = Field(alias="fieldSelector")
+    func: Callable[[str], bool] = Field(exclude=True)
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class UniversalRule(BaseModel):
+    """Universal rule model."""
+
+    rule_type: Literal["always"] = Field(alias="$ruleType")
+    apply_to: ApplyTo = Field(alias="applyTo")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class NumberRule(BaseModel):
+    """Number rule model."""
+
+    rule_type: Literal["number"] = Field(alias="$ruleType")
+    field_selector: FieldSelector = Field(alias="fieldSelector")
+    func: Callable[[float], bool] = Field(exclude=True)
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class BooleanRule(BaseModel):
+    """Boolean rule model."""
+
+    rule_type: Literal["boolean"] = Field(alias="$ruleType")
+    field_selector: FieldSelector = Field(alias="fieldSelector")
+    func: Callable[[bool], bool] = Field(exclude=True)
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+Rule = Annotated[
+    WordRule | NumberRule | BooleanRule | UniversalRule,
+    Field(discriminator="rule_type"),
+]
+
+
+class GuardrailScope(str, Enum):
+    """Guardrail scope enumeration."""
+
+    AGENT = "Agent"
+    LLM = "Llm"
+    TOOL = "Tool"
+
+
+class GuardrailSelector(BaseModel):
+    """Guardrail selector model."""
+
+    scopes: list[GuardrailScope] = Field(default=[GuardrailScope.TOOL])
+    match_names: list[str] | None = Field(None, alias="matchNames")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class BaseGuardrail(BaseModel):
+    """Base guardrail model."""
+
+    id: str
+    name: str
+    description: str | None = None
+    enabled_for_evals: bool = Field(True, alias="enabledForEvals")
+    selector: GuardrailSelector
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class DeterministicGuardrail(BaseGuardrail):
+    """Deterministic guardrail model."""
+
+    guardrail_type: Literal["custom"] = Field(alias="custom")
+    rules: list[Rule]
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")

{uipath_core-0.1.0.dist-info → uipath_core-0.1.2.dist-info}/METADATA

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

uipath_core-0.1.2.dist-info/RECORD

@@ -0,0 +1,31 @@
+uipath/core/__init__.py,sha256=KaOxKswriK_zGul3KzILhqnR3G0E5otuXny0IuuwTqA,280
+uipath/core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+uipath/core/chat/__init__.py,sha256=1qwg2n6EhRS_u3vkXN1D40q_5bYNxj5BeQXUp7VtyQw,6013
+uipath/core/chat/async_stream.py,sha256=XbfSAu67TKYzzHoeh-WkolP3WXqEGJ2fTtCX5XqfUKY,2163
+uipath/core/chat/citation.py,sha256=UBZ51wk3PyaXr7uljicEH_8Q2dthBMxYvPR6j2dEhA4,2608
+uipath/core/chat/content.py,sha256=fSbXwSusMuqWF9WQhr1fRQCP5aUMITrBRJ-WJ2jH1vc,3135
+uipath/core/chat/conversation.py,sha256=CVCj4z0DYQsodciCpmiefMjvn8NmJsLTaZU49QiseUw,1723
+uipath/core/chat/error.py,sha256=uXaI0jHYsRhOq8LRHVN5fwODX-uJX68PqJU26oe-4c4,1165
+uipath/core/chat/event.py,sha256=SRif5ZQGEKQBmzcSl2fx0O_--zlKZ7lOVh15hRjLxP4,3832
+uipath/core/chat/exchange.py,sha256=pkYt_pPDyzaJQAfDdqqUM36QLnz4rgBDR0DkBl03r90,2463
+uipath/core/chat/interrupt.py,sha256=-3Fl1_6_7cS8ZV64AaFwDnlNglGBfACwaDAPxI3dTa0,1064
+uipath/core/chat/message.py,sha256=nJJ1xc--b7Nnj5hXwoH4T4pYkZSoiSHzSXlaiPqac4g,2390
+uipath/core/chat/meta.py,sha256=3t0eS9UHoAPHre97QTUeVbjDhnMX4zj4-qG6ju0B8wY,315
+uipath/core/chat/tool.py,sha256=6e5pyX3hOWM5fIzr_fdG49Mbzz6XzJD3nsmha-yGa2k,2308
+uipath/core/errors/__init__.py,sha256=gjxdLibZ0fjwgzPuLJY04P8dIX9rbSM2wQ97jP34ucE,278
+uipath/core/errors/errors.py,sha256=5LajjuTfNW82ju07wT5mD3tXk0S-Ju7OqJqQpPN0F6g,486
+uipath/core/guardrails/__init__.py,sha256=oPJnSJmeDlXNpN6XfnnZUGCDg_BkaG3Tk-chLM743C0,892
+uipath/core/guardrails/_deterministic_guardrails_service.py,sha256=3WGcgpyUIvTXBvheEXjX-XguytxquWJkBevrVeM2tcc,2841
+uipath/core/guardrails/_evaluators.py,sha256=nIODDFu0IjrgVcf0pshmXV0BNAEU-16-liwJv50Lcy4,11343
+uipath/core/guardrails/guardrails.py,sha256=jM_In6kxttkuFoH5KiiE5iREcFAMY2wTxNQkg35ZQqw,4286
+uipath/core/tracing/__init__.py,sha256=1XNLYZ4J76XkRrizGO486mS6yxzVXUbrldpvxTyJe3E,483
+uipath/core/tracing/_utils.py,sha256=FiCFGOFa4czruhlSF87Q5Q4jX9KKPHZiw8k14K7W5v4,6636
+uipath/core/tracing/decorators.py,sha256=ag_MFwZ0TywrhbpLKqQwF1guvRA9sYiItxao5LN9_Iw,10942
+uipath/core/tracing/exporters.py,sha256=FClouEEQfk3F8J7G_NFoarDJM3R0-gA5jUxA5xRHx5s,1562
+uipath/core/tracing/processors.py,sha256=R_652rtjPmfpUtaXoIcmfZrRZylVXFRNwjOmJUUxOQw,1408
+uipath/core/tracing/span_utils.py,sha256=WYBrd6ZbawAs7r1Js-Zvo9_8GzkD9LhHNOls00bK_xI,12235
+uipath/core/tracing/trace_manager.py,sha256=51rscJcepkTK4bWoCZdE-DFc9wt2F-aSuFBaSXmkHl0,3130
+uipath_core-0.1.2.dist-info/METADATA,sha256=rRT3V6Rlvi1KVNC128ie__-tZ1ymkt1ZFZbbGGJ07m4,938
+uipath_core-0.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+uipath_core-0.1.2.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath_core-0.1.2.dist-info/RECORD,,

uipath_core-0.1.0.dist-info/RECORD

@@ -1,25 +0,0 @@
-uipath/core/__init__.py,sha256=KaOxKswriK_zGul3KzILhqnR3G0E5otuXny0IuuwTqA,280
-uipath/core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-uipath/core/chat/__init__.py,sha256=rjJd-tzN0U1_ATHqneW1rMQv_ye3O_CngSY6h7COYaY,5379
-uipath/core/chat/async_stream.py,sha256=5KbqDh1NTuKyWilFwq-5ueJ1Mle0rNveLlAoIKJIvUo,1987
-uipath/core/chat/citation.py,sha256=qxJTl6wmp0wr49Ug4u2TLKkN582c1MpsDcirwD3JXGo,2422
-uipath/core/chat/content.py,sha256=-Con3JhrFR9mxgZerNVe2DYjFYjQY5zknyJvfsyeJrc,2853
-uipath/core/chat/conversation.py,sha256=CVCj4z0DYQsodciCpmiefMjvn8NmJsLTaZU49QiseUw,1723
-uipath/core/chat/event.py,sha256=mXE6cQzqHU27UW_PgXqpjH4hNRGeOlvXxZtF64fmjDA,2854
-uipath/core/chat/exchange.py,sha256=wwkTO09S5-QhyzAAgWArhJ_1KXI8EMdZTEasnXUH-lI,2298
-uipath/core/chat/message.py,sha256=ofTahX97xOzoUFU1ig3S2AKkHwS7xXqzi66N1m93NlQ,2141
-uipath/core/chat/meta.py,sha256=3t0eS9UHoAPHre97QTUeVbjDhnMX4zj4-qG6ju0B8wY,315
-uipath/core/chat/tool.py,sha256=uXeP6psjwNGqt5ZLEQHF83LH8ApvjSCwI5ouoDo0Jk0,2180
-uipath/core/errors/__init__.py,sha256=gjxdLibZ0fjwgzPuLJY04P8dIX9rbSM2wQ97jP34ucE,278
-uipath/core/errors/errors.py,sha256=5LajjuTfNW82ju07wT5mD3tXk0S-Ju7OqJqQpPN0F6g,486
-uipath/core/tracing/__init__.py,sha256=1XNLYZ4J76XkRrizGO486mS6yxzVXUbrldpvxTyJe3E,483
-uipath/core/tracing/_utils.py,sha256=FiCFGOFa4czruhlSF87Q5Q4jX9KKPHZiw8k14K7W5v4,6636
-uipath/core/tracing/decorators.py,sha256=ag_MFwZ0TywrhbpLKqQwF1guvRA9sYiItxao5LN9_Iw,10942
-uipath/core/tracing/exporters.py,sha256=FClouEEQfk3F8J7G_NFoarDJM3R0-gA5jUxA5xRHx5s,1562
-uipath/core/tracing/processors.py,sha256=R_652rtjPmfpUtaXoIcmfZrRZylVXFRNwjOmJUUxOQw,1408
-uipath/core/tracing/span_utils.py,sha256=WYBrd6ZbawAs7r1Js-Zvo9_8GzkD9LhHNOls00bK_xI,12235
-uipath/core/tracing/trace_manager.py,sha256=51rscJcepkTK4bWoCZdE-DFc9wt2F-aSuFBaSXmkHl0,3130
-uipath_core-0.1.0.dist-info/METADATA,sha256=sgs7Gqbu5d1UWPhfg8n5vQjbM5RFB43J2rYfSViy3QI,938
-uipath_core-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-uipath_core-0.1.0.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath_core-0.1.0.dist-info/RECORD,,