uipath-core 0.2.4__tar.gz → 0.3.1__tar.gz

{uipath_core-0.2.4 → uipath_core-0.3.1}/PKG-INFO

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

{uipath_core-0.2.4 → uipath_core-0.3.1}/pyproject.toml

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

{uipath_core-0.2.4 → uipath_core-0.3.1}/src/uipath/core/chat/__init__.py

@@ -79,9 +79,16 @@ from .exchange import (
     UiPathConversationExchangeStartEvent,
 )
 from .interrupt import (
+    InterruptTypeEnum,
+    UiPathConversationGenericInterruptEndEvent,
+    UiPathConversationGenericInterruptStartEvent,
     UiPathConversationInterruptEndEvent,
     UiPathConversationInterruptEvent,
     UiPathConversationInterruptStartEvent,
+    UiPathConversationToolCallConfirmationEndValue,
+    UiPathConversationToolCallConfirmationInterruptEndEvent,
+    UiPathConversationToolCallConfirmationInterruptStartEvent,
+    UiPathConversationToolCallConfirmationValue,
 )
 from .message import (
     UiPathConversationMessage,
@@ -122,9 +129,16 @@ __all__ = [
     "UiPathConversationMessageEvent",
     "UiPathConversationMessage",
     # Interrupt
+    "InterruptTypeEnum",
     "UiPathConversationInterruptStartEvent",
     "UiPathConversationInterruptEndEvent",
     "UiPathConversationInterruptEvent",
+    "UiPathConversationToolCallConfirmationValue",
+    "UiPathConversationToolCallConfirmationEndValue",
+    "UiPathConversationToolCallConfirmationInterruptStartEvent",
+    "UiPathConversationToolCallConfirmationInterruptEndEvent",
+    "UiPathConversationGenericInterruptStartEvent",
+    "UiPathConversationGenericInterruptEndEvent",
     # Content
     "UiPathConversationContentPartChunkEvent",
     "UiPathConversationContentPartStartEvent",

uipath_core-0.3.1/src/uipath/core/chat/interrupt.py

@@ -0,0 +1,92 @@
+"""Interrupt events for human-in-the-loop patterns."""
+
+from enum import Enum
+from typing import Any, Literal, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class InterruptTypeEnum(str, Enum):
+    """Enum of known interrupt types."""
+
+    TOOL_CALL_CONFIRMATION = "uipath_cas_tool_call_confirmation"
+
+
+class UiPathConversationToolCallConfirmationValue(BaseModel):
+    """Schema for tool call confirmation interrupt value."""
+
+    tool_call_id: str = Field(..., alias="toolCallId")
+    tool_name: str = Field(..., alias="toolName")
+    input_schema: Any = Field(..., alias="inputSchema")
+    input_value: Any | None = Field(None, alias="inputValue")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationToolCallConfirmationInterruptStartEvent(BaseModel):
+    """Tool call confirmation interrupt start event with strong typing."""
+
+    type: Literal["uipath_cas_tool_call_confirmation"]
+    value: UiPathConversationToolCallConfirmationValue
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationGenericInterruptStartEvent(BaseModel):
+    """Generic interrupt start event for custom interrupt types."""
+
+    type: str
+    value: Any
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+UiPathConversationInterruptStartEvent = Union[
+    UiPathConversationToolCallConfirmationInterruptStartEvent,
+    UiPathConversationGenericInterruptStartEvent,
+]
+
+
+class UiPathConversationToolCallConfirmationEndValue(BaseModel):
+    """Schema for tool call confirmation end value."""
+
+    approved: bool
+    input: Any | None = None
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationToolCallConfirmationInterruptEndEvent(BaseModel):
+    """Tool call confirmation interrupt end event with strong typing."""
+
+    type: Literal["uipath_cas_tool_call_confirmation"]
+    value: UiPathConversationToolCallConfirmationEndValue
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+class UiPathConversationGenericInterruptEndEvent(BaseModel):
+    """Generic interrupt end event for custom interrupt types."""
+
+    type: str
+    value: Any
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+
+
+UiPathConversationInterruptEndEvent = Union[
+    UiPathConversationToolCallConfirmationInterruptEndEvent,
+    UiPathConversationGenericInterruptEndEvent,
+]
+
+
+class UiPathConversationInterruptEvent(BaseModel):
+    """Encapsulates interrupt-related events within a message."""
+
+    interrupt_id: str = Field(..., alias="interruptId")
+    start: UiPathConversationInterruptStartEvent | None = Field(
+        None, alias="startInterrupt"
+    )
+    end: UiPathConversationInterruptEndEvent | None = Field(None, alias="endInterrupt")
+
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)

{uipath_core-0.2.4 → uipath_core-0.3.1}/src/uipath/core/guardrails/guardrails.py

@@ -1,9 +1,18 @@
 """Guardrails models for UiPath Platform."""
 
 from enum import Enum
-from typing import Annotated, Callable, Literal
+from typing import Annotated, Any, Callable, Literal
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+def _decapitalize_first_letter(s: str) -> str:
+    """Convert first letter to lowercase (e.g., 'SimpleText' -> 'simpleText')."""
+    if not s or len(s) == 0:
+        return s
+    if len(s) == 1:
+        return s.lower()
+    return s[0].lower() + s[1:]
 
 
 class GuardrailValidationResultType(str, Enum):
@@ -56,6 +65,12 @@ class FieldReference(BaseModel):
 
     model_config = ConfigDict(populate_by_name=True, extra="allow")
 
+    @field_validator("source", mode="before")
+    @classmethod
+    def normalize_type(cls, v: Any) -> Any:
+        """Normalize type by decapitalizing first letter."""
+        return _decapitalize_first_letter(v) if isinstance(v, str) else v
+
 
 class SelectorType(str, Enum):
     """Selector type enumeration."""
@@ -72,6 +87,17 @@ class AllFieldsSelector(BaseModel):
 
     model_config = ConfigDict(populate_by_name=True, extra="allow")
 
+    @field_validator("sources", mode="before")
+    @classmethod
+    def normalize_sources(cls, v: Any) -> Any:
+        """Normalize sources by decapitalizing first letter of each item."""
+        if isinstance(v, list):
+            return [
+                _decapitalize_first_letter(item) if isinstance(item, str) else item
+                for item in v
+            ]
+        return v
+
 
 class SpecificFieldsSelector(BaseModel):
     """Specific fields selector."""
@@ -128,6 +154,12 @@ class UniversalRule(BaseModel):
 
     model_config = ConfigDict(populate_by_name=True, extra="allow")
 
+    @field_validator("apply_to", mode="before")
+    @classmethod
+    def normalize_type(cls, v: Any) -> Any:
+        """Normalize type by decapitalizing first letter."""
+        return _decapitalize_first_letter(v) if isinstance(v, str) else v
+
 
 class NumberRule(BaseModel):
     """Number rule model."""

uipath_core-0.3.1/tests/guardrails/test_guardrails_models.py

@@ -0,0 +1,53 @@
+"""Tests for guardrails models normalization validators."""
+
+from typing import TYPE_CHECKING
+
+from uipath.core.guardrails import (
+    AllFieldsSelector,
+    FieldReference,
+    FieldSource,
+)
+
+if TYPE_CHECKING:
+    pass
+
+
+class TestGuardrailsModelsNormalization:
+    """Test guardrails models field normalization."""
+
+    def test_field_reference_normalizes_capitalized_source(
+        self,
+    ) -> 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]
+        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]
+        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]
+        assert field_ref.source == FieldSource.INPUT
+
+    def test_all_fields_selector_normalizes_capitalized_sources(
+        self,
+    ) -> None:
+        """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]
+        )
+        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]
+        )
+        assert FieldSource.INPUT in selector.sources
+        assert FieldSource.OUTPUT in selector.sources

{uipath_core-0.2.4 → uipath_core-0.3.1}/uv.lock

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

uipath_core-0.2.4/src/uipath/core/chat/interrupt.py

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