uipath 2.1.99__py3-none-any.whl → 2.1.100__py3-none-any.whl

uipath/_cli/cli_init.py

@@ -190,7 +190,10 @@ def init(entrypoint: str, infer_bindings: bool, no_agents_md_override: bool) ->
         result = Middlewares.next(
             "init",
             entrypoint,
-            options={"infer_bindings": infer_bindings},
+            options={
+                "infer_bindings": infer_bindings,
+                "no_agents_md_override": no_agents_md_override,
+            },
             write_config=write_config_file,
         )
 

uipath/agent/models/agent.py

@@ -6,6 +6,7 @@ from typing import Annotated, Any, Dict, List, Literal, Optional, Union
 from pydantic import BaseModel, ConfigDict, Discriminator, Field, Tag, field_validator
 
 from uipath.models import Connection
+from uipath.models.guardrails import AgentEscalationRecipient, Guardrail
 
 
 class AgentResourceType(str, Enum):
@@ -305,39 +306,6 @@ class AgentMcpResourceConfig(BaseAgentResourceConfig):
     )
 
 
-class AgentEscalationRecipientType(str, Enum):
-    """Enum for escalation recipient types."""
-
-    USER_ID = "UserId"
-    GROUP_ID = "GroupId"
-    USER_EMAIL = "UserEmail"
-
-
-class AgentEscalationRecipient(BaseModel):
-    """Recipient for escalation."""
-
-    type: Union[AgentEscalationRecipientType, str] = Field(..., alias="type")
-    value: str = Field(..., alias="value")
-    display_name: Optional[str] = Field(default=None, alias="displayName")
-
-    @field_validator("type", mode="before")
-    @classmethod
-    def normalize_type(cls, v: Any) -> str:
-        """Normalize recipient type from int (1=UserId, 2=GroupId, 3=UserEmail) or string. Unknown integers are converted to string."""
-        if isinstance(v, int):
-            mapping = {
-                1: AgentEscalationRecipientType.USER_ID,
-                2: AgentEscalationRecipientType.GROUP_ID,
-                3: AgentEscalationRecipientType.USER_EMAIL,
-            }
-            return mapping.get(v, str(v))
-        return v
-
-    model_config = ConfigDict(
-        validate_by_name=True, validate_by_alias=True, extra="allow"
-    )
-
-
 class AgentEscalationChannelProperties(BaseResourceProperties):
     """Agent escalation channel properties."""
 
@@ -508,6 +476,9 @@ class BaseAgentDefinition(BaseModel):
     output_schema: Dict[str, Any] = Field(
         ..., alias="outputSchema", description="JSON schema for output arguments"
     )
+    guardrails: Optional[List[Guardrail]] = Field(
+        None, description="List of agent guardrails"
+    )
 
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"

uipath/models/guardrails.py

@@ -0,0 +1,469 @@
+from enum import Enum
+from typing import Annotated, Any, Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+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[
+    Union[AllFieldsSelector, SpecificFieldsSelector],
+    Field(discriminator="selector_type"),
+]
+
+
+class RuleType(str, Enum):
+    """Rule type enumeration."""
+
+    BOOLEAN = "boolean"
+    NUMBER = "number"
+    UNIVERSAL = "always"
+    WORD = "word"
+
+
+class WordOperator(str, Enum):
+    """Word operator enumeration."""
+
+    CONTAINS = "contains"
+    DOES_NOT_CONTAIN = "doesNotContain"
+    DOES_NOT_END_WITH = "doesNotEndWith"
+    DOES_NOT_EQUAL = "doesNotEqual"
+    DOES_NOT_START_WITH = "doesNotStartWith"
+    ENDS_WITH = "endsWith"
+    EQUALS = "equals"
+    IS_EMPTY = "isEmpty"
+    IS_NOT_EMPTY = "isNotEmpty"
+    STARTS_WITH = "startsWith"
+
+
+class WordRule(BaseModel):
+    """Word rule model."""
+
+    rule_type: Literal["word"] = Field(alias="$ruleType")
+    field_selector: FieldSelector = Field(alias="fieldSelector")
+    operator: WordOperator
+    value: Optional[str] = None
+
+    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 NumberOperator(str, Enum):
+    """Number operator enumeration."""
+
+    DOES_NOT_EQUAL = "doesNotEqual"
+    EQUALS = "equals"
+    GREATER_THAN = "greaterThan"
+    GREATER_THAN_OR_EQUAL = "greaterThanOrEqual"
+    LESS_THAN = "lessThan"
+    LESS_THAN_OR_EQUAL = "lessThanOrEqual"
+
+
+class NumberRule(BaseModel):
+    """Number rule model."""
+
+    rule_type: Literal["number"] = Field(alias="$ruleType")
+    field_selector: FieldSelector = Field(alias="fieldSelector")
+    operator: NumberOperator
+    value: float
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class BooleanOperator(str, Enum):
+    """Boolean operator enumeration."""
+
+    EQUALS = "equals"
+
+
+class BooleanRule(BaseModel):
+    """Boolean rule model."""
+
+    rule_type: Literal["boolean"] = Field(alias="$ruleType")
+    field_selector: FieldSelector = Field(alias="fieldSelector")
+    operator: BooleanOperator
+    value: bool
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class EnumListParameterValue(BaseModel):
+    """Enum list parameter value."""
+
+    parameter_type: Literal["enum-list"] = Field(alias="$parameterType")
+    id: str
+    value: List[str]
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class MapEnumParameterValue(BaseModel):
+    """Map enum parameter value."""
+
+    parameter_type: Literal["map-enum"] = Field(alias="$parameterType")
+    id: str
+    value: Dict[str, float]
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class NumberParameterValue(BaseModel):
+    """Number parameter value."""
+
+    parameter_type: Literal["number"] = Field(alias="$parameterType")
+    id: str
+    value: float
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+ValidatorParameter = Annotated[
+    Union[EnumListParameterValue, MapEnumParameterValue, NumberParameterValue],
+    Field(discriminator="parameter_type"),
+]
+
+
+Rule = Annotated[
+    Union[WordRule, NumberRule, BooleanRule, UniversalRule],
+    Field(discriminator="rule_type"),
+]
+
+
+class ActionType(str, Enum):
+    """Action type enumeration."""
+
+    BLOCK = "block"
+    ESCALATE = "escalate"
+    FILTER = "filter"
+    LOG = "log"
+
+
+class BlockAction(BaseModel):
+    """Block action model."""
+
+    action_type: Literal["block"] = Field(alias="$actionType")
+    reason: str
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class FilterAction(BaseModel):
+    """Filter action model."""
+
+    action_type: Literal["filter"] = Field(alias="$actionType")
+    fields: List[FieldReference]
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class SeverityLevel(str, Enum):
+    """Severity level enumeration."""
+
+    ERROR = "Error"
+    INFO = "Info"
+    WARNING = "Warning"
+
+
+class LogAction(BaseModel):
+    """Log action model."""
+
+    action_type: Literal["log"] = Field(alias="$actionType")
+    message: str = Field(..., alias="message")
+    severity_level: SeverityLevel = Field(alias="severityLevel")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class EscalateActionApp(BaseModel):
+    """Escalate action app model."""
+
+    id: Optional[str] = None
+    version: int
+    name: str
+    folder_id: Optional[str] = Field(None, alias="folderId")
+    folder_name: str = Field(alias="folderName")
+    app_process_key: Optional[str] = Field(None, alias="appProcessKey")
+    runtime: Optional[str] = None
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AgentEscalationRecipientType(str, Enum):
+    """Enum for escalation recipient types."""
+
+    USER_ID = "UserId"
+    GROUP_ID = "GroupId"
+    USER_EMAIL = "UserEmail"
+
+
+class AgentEscalationRecipient(BaseModel):
+    """Recipient for escalation."""
+
+    type: Union[AgentEscalationRecipientType, str] = Field(..., alias="type")
+    value: str = Field(..., alias="value")
+    display_name: Optional[str] = Field(default=None, alias="displayName")
+
+    @field_validator("type", mode="before")
+    @classmethod
+    def normalize_type(cls, v: Any) -> str:
+        """Normalize recipient type from int (1=UserId, 2=GroupId, 3=UserEmail) or string. Unknown integers are converted to string."""
+        if isinstance(v, int):
+            mapping = {
+                1: AgentEscalationRecipientType.USER_ID,
+                2: AgentEscalationRecipientType.GROUP_ID,
+                3: AgentEscalationRecipientType.USER_EMAIL,
+            }
+            return mapping.get(v, str(v))
+        return v
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class EscalateAction(BaseModel):
+    """Escalate action model."""
+
+    action_type: Literal["escalate"] = Field(alias="$actionType")
+    app: EscalateActionApp
+    recipient: AgentEscalationRecipient
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+GuardrailAction = Annotated[
+    Union[BlockAction, FilterAction, LogAction, EscalateAction],
+    Field(discriminator="action_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: Optional[List[str]] = Field(None, alias="matchNames")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class BaseGuardrail(BaseModel):
+    """Base guardrail model."""
+
+    id: str
+    name: str
+    description: Optional[str] = None
+    action: GuardrailAction
+    enabled_for_evals: bool = Field(True, alias="enabledForEvals")
+    selector: GuardrailSelector
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class CustomGuardrail(BaseGuardrail):
+    """Custom guardrail model."""
+
+    guardrail_type: Literal["custom"] = Field(alias="$guardrailType")
+    rules: List[Rule]
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class BuiltInValidatorGuardrail(BaseGuardrail):
+    """Built-in validator guardrail model."""
+
+    guardrail_type: Literal["builtInValidator"] = Field(alias="$guardrailType")
+    validator_type: str = Field(alias="validatorType")
+    validator_parameters: List[ValidatorParameter] = Field(
+        default_factory=list, alias="validatorParameters"
+    )
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+Guardrail = Annotated[
+    Union[CustomGuardrail, BuiltInValidatorGuardrail],
+    Field(discriminator="guardrail_type"),
+]
+
+
+class GuardrailType(str, Enum):
+    """Guardrail type enumeration."""
+
+    BUILT_IN_VALIDATOR = "builtInValidator"
+    CUSTOM = "custom"
+
+
+# Helper functions for type checking
+def is_boolean_rule(rule: Rule) -> bool:
+    """Check if rule is a BooleanRule."""
+    return hasattr(rule, "rule_type") and rule.rule_type == RuleType.BOOLEAN
+
+
+def is_number_rule(rule: Rule) -> bool:
+    """Check if rule is a NumberRule."""
+    return hasattr(rule, "rule_type") and rule.rule_type == RuleType.NUMBER
+
+
+def is_universal_rule(rule: Rule) -> bool:
+    """Check if rule is a UniversalRule."""
+    return hasattr(rule, "rule_type") and rule.rule_type == RuleType.UNIVERSAL
+
+
+def is_word_rule(rule: Rule) -> bool:
+    """Check if rule is a WordRule."""
+    return hasattr(rule, "rule_type") and rule.rule_type == RuleType.WORD
+
+
+def is_custom_guardrail(guardrail: Guardrail) -> bool:
+    """Check if guardrail is a CustomGuardrail."""
+    return (
+        hasattr(guardrail, "guardrail_type")
+        and guardrail.guardrail_type == GuardrailType.CUSTOM
+    )
+
+
+def is_built_in_validator_guardrail(guardrail: Guardrail) -> bool:
+    """Check if guardrail is a BuiltInValidatorGuardrail."""
+    return (
+        hasattr(guardrail, "guardrail_type")
+        and guardrail.guardrail_type == GuardrailType.BUILT_IN_VALIDATOR
+    )
+
+
+def is_valid_action_type(value: Any) -> bool:
+    """Check if value is a valid ActionType."""
+    return isinstance(value, str) and value.lower() in [
+        at.value.lower() for at in ActionType
+    ]
+
+
+def is_valid_severity_level(value: Any) -> bool:
+    """Check if value is a valid SeverityLevel."""
+    return isinstance(value, str) and value in [sl.value for sl in SeverityLevel]
+
+
+# Guardrail Models
+class AgentGuardrailRuleParameter(BaseModel):
+    """Parameter for guardrail rules."""
+
+    parameter_type: str = Field(..., alias="$parameterType")
+    parameter_type_alt: Optional[str] = Field(None, alias="parameterType")
+    value: Any = Field(..., description="Parameter value")
+    id: str = Field(..., description="Parameter identifier")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AgentGuardrailRule(BaseModel):
+    """Guardrail validation rule."""
+
+    rule_type: str = Field(..., alias="$ruleType")
+    rule_type_alt: Optional[str] = Field(None, alias="ruleType")
+    validator: str = Field(..., description="Validator type")
+    parameters: List[AgentGuardrailRuleParameter] = Field(
+        default_factory=list, description="Rule parameters"
+    )
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AgentGuardrailActionApp(BaseModel):
+    """App configuration for guardrail actions."""
+
+    name: str = Field(..., description="App name")
+    version: str = Field(..., description="App version")
+    folder_name: str = Field(..., alias="folderName", description="Folder name")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AgentGuardrailActionRecipient(BaseModel):
+    """Recipient for guardrail actions."""
+
+    type: int = Field(..., description="Recipient type")
+    value: str = Field(..., description="Recipient identifier")
+    display_name: str = Field(..., alias="displayName", description="Display name")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AgentGuardrailAction(BaseModel):
+    """Action configuration for guardrails."""
+
+    action_type: str = Field(..., alias="$actionType")
+    action_type_alt: Optional[str] = Field(None, alias="actionType")
+    app: AgentGuardrailActionApp = Field(..., description="App configuration")
+    recipient: AgentGuardrailActionRecipient = Field(..., description="Recipient")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AgentGuardrailSelector(BaseModel):
+    """Selector for guardrail application scope."""
+
+    scopes: List[str] = Field(..., description="Scopes where guardrail applies")
+    match_names: List[str] = Field(
+        ..., alias="matchNames", description="Names to match"
+    )
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")

{uipath-2.1.99.dist-info → uipath-2.1.100.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.99
+Version: 2.1.100
 Summary: Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools.
 Project-URL: Homepage, https://uipath.com
 Project-URL: Repository, https://github.com/UiPath/uipath-python

{uipath-2.1.99.dist-info → uipath-2.1.100.dist-info}/RECORD

@@ -11,7 +11,7 @@ uipath/_cli/cli_debug.py,sha256=-s6Nmy0DnDyITjZAf6f71hZ1YDDt0Yl57XklEkuL0FU,4068
 uipath/_cli/cli_deploy.py,sha256=KPCmQ0c_NYD5JofSDao5r6QYxHshVCRxlWDVnQvlp5w,645
 uipath/_cli/cli_dev.py,sha256=nEfpjw1PZ72O6jmufYWVrueVwihFxDPOeJakdvNHdOA,2146
 uipath/_cli/cli_eval.py,sha256=6evrUtaHnQ1NTEQKZKltgH7mpYOy6YP88L2LZcnnnfs,5139
-uipath/_cli/cli_init.py,sha256=kCwAHzrTrerptInGx8-eWbh3SdwYdFqlmIsKNPhhnjA,7392
+uipath/_cli/cli_init.py,sha256=hAPMV_0HGZD0cDh7KqHDwMRlUfLoJl2NCp4T3Ilw8y0,7487
 uipath/_cli/cli_invoke.py,sha256=m-te-EjhDpk_fhFDkt-yQFzmjEHGo5lQDGEQWxSXisQ,4395
 uipath/_cli/cli_new.py,sha256=9378NYUBc9j-qKVXV7oja-jahfJhXBg8zKVyaon7ctY,2102
 uipath/_cli/cli_pack.py,sha256=U5rXVbUnHFgdEsXyhkjmWza8dfob1wU9lyl4yrYnUss,11076
@@ -144,7 +144,7 @@ uipath/agent/conversation/tool.py,sha256=ol8XI8AVd-QNn5auXNBPcCzOkh9PPFtL7hTK3kq
 uipath/agent/loop/__init__.py,sha256=EZlNqrh8xod0VtTJqc-1pyUofaeS6PKjbsDfWoveVtI,424
 uipath/agent/loop/prompts.py,sha256=qPwyd6Ple2m-Kt0m2foa6ZEmxD3kyCXOmGfXvzHi8Rc,3372
 uipath/agent/loop/tools.py,sha256=OsT3x431KqOEzLi2jLxy2B9xXbcFq16xMfmyAqFaqZQ,1351
-uipath/agent/models/agent.py,sha256=dEUWZIzvTnxhdCQlMad6Pf6EphLP_W5ukHtczbXKYL0,18712
+uipath/agent/models/agent.py,sha256=o_nkrFtZFQdSNMK5NH9rCo346ABZcQLfW5h2Wv9yUhg,17791
 uipath/agent/models/evals.py,sha256=QMIqwCuwabD_vYF0KgJpip5BV0pFLf9ZKUd9AL5eU2w,1843
 uipath/eval/_helpers/__init__.py,sha256=GSmZMryjuO3Wo_zdxZdrHCRRsgOxsVFYkYgJ15YNC3E,86
 uipath/eval/_helpers/helpers.py,sha256=iE2HHdMiAdAMLqxHkPKHpfecEtAuN5BTBqvKFTI8ciE,1315
@@ -173,6 +173,7 @@ uipath/models/documents.py,sha256=g3xAhZlGcLuD6a_DHcUQWoLdzh5dENulouYAwrjGHEw,39
 uipath/models/entities.py,sha256=x6jbq4o_QhgL_pCgvHFsp9O8l333kQhn8e9ZCBs72UM,9823
 uipath/models/errors.py,sha256=WCxxHBlLzLF17YxjqsFkkyBLwEQM_dc6fFU5qmBjD4A,597
 uipath/models/exceptions.py,sha256=F0ITAhJsl6Agvmnv4nxvgY5oC_lrYIlxWTLs0yx859M,1636
+uipath/models/guardrails.py,sha256=3LQf8CJj1ipnUqdUJuDenC4MS8o9GlWj_AsS2naP_tM,12976
 uipath/models/interrupt_models.py,sha256=UzuVTMVesI204YQ4qFQFaN-gN3kksddkrujofcaC7zQ,881
 uipath/models/job.py,sha256=h1S-ErUk4-oIdrxo4nEBEJdSv1NTTF4AF8LfXx5Exak,3063
 uipath/models/llm_gateway.py,sha256=rUIus7BrUuuRriXqSJUE9FnjOyQ7pYpaX6hWEYvA6AA,1923
@@ -188,8 +189,8 @@ uipath/tracing/_utils.py,sha256=X-LFsyIxDeNOGuHPvkb6T5o9Y8ElYhr_rP3CEBJSu4s,1383
 uipath/utils/__init__.py,sha256=VD-KXFpF_oWexFg6zyiWMkxl2HM4hYJMIUDZ1UEtGx0,105
 uipath/utils/_endpoints_manager.py,sha256=tnF_FiCx8qI2XaJDQgYkMN_gl9V0VqNR1uX7iawuLp8,8230
 uipath/utils/dynamic_schema.py,sha256=w0u_54MoeIAB-mf3GmwX1A_X8_HDrRy6p998PvX9evY,3839
-uipath-2.1.99.dist-info/METADATA,sha256=uzQOaz08OQ0caJ37TK1DW-SC2oGIk-BHNnOMVVe1hVE,6625
-uipath-2.1.99.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.99.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.99.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.99.dist-info/RECORD,,
+uipath-2.1.100.dist-info/METADATA,sha256=K8dpdNDLy0rwzQon8JSyQJLutfnTIuVLDBBlav901UE,6626
+uipath-2.1.100.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.100.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.100.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.100.dist-info/RECORD,,