uipath 2.1.106__tar.gz → 2.1.108__tar.gz

{uipath-2.1.106 → uipath-2.1.108}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.106
+Version: 2.1.108
 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.106 → uipath-2.1.108}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uipath"
-version = "2.1.106"
+version = "2.1.108"
 description = "Python SDK and CLI for UiPath Platform, enabling programmatic interaction with automation services, process management, and deployment tools."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

{uipath-2.1.106 → uipath-2.1.108}/src/uipath/_cli/_runtime/_contracts.py

@@ -460,12 +460,12 @@ class UiPathRuntimeContext(BaseModel):
         return instance
 
 
-class UiPathRuntimeError(Exception):
+class UiPathBaseRuntimeError(Exception):
     """Base exception class for UiPath runtime errors with structured error information."""
 
     def __init__(
         self,
-        code: UiPathErrorCode,
+        code: str,
         title: str,
         detail: str,
         category: UiPathErrorCategory = UiPathErrorCategory.UNKNOWN,
@@ -484,10 +484,8 @@ class UiPathRuntimeError(Exception):
         if status is None:
             status = self._extract_http_status()
 
-        code_value = code.value
-
         self.error_info = UiPathErrorContract(
-            code=f"{prefix}.{code_value}",
+            code=f"{prefix}.{code}",
             title=title,
             detail=detail,
             category=category,
@@ -529,6 +527,28 @@ class UiPathRuntimeError(Exception):
         return self.error_info.model_dump()
 
 
+class UiPathRuntimeError(UiPathBaseRuntimeError):
+    """Exception class for UiPath runtime errors."""
+
+    def __init__(
+        self,
+        code: UiPathErrorCode,
+        title: str,
+        detail: str,
+        category: UiPathErrorCategory = UiPathErrorCategory.UNKNOWN,
+        prefix: str = "Python",
+        include_traceback: bool = True,
+    ):
+        super().__init__(
+            code=code.value,
+            title=title,
+            detail=detail,
+            category=category,
+            prefix=prefix,
+            include_traceback=include_traceback,
+        )
+
+
 class UiPathRuntimeStreamNotSupportedError(NotImplementedError):
     """Raised when a runtime does not support streaming."""
 

{uipath-2.1.106 → uipath-2.1.108}/src/uipath/_resources/SDK_REFERENCE.md

@@ -70,93 +70,6 @@ sdk.assets.update_async(robot_asset: uipath.models.assets.UserAsset, folder_key:
 
 ```
 
-### Attachments
-
-Attachments service
-
-```python
-# Delete an attachment.
-sdk.attachments.delete(key: uuid.UUID, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-# Delete an attachment asynchronously.
-sdk.attachments.delete_async(key: uuid.UUID, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-# Download an attachment.
-sdk.attachments.download(key: uuid.UUID, destination_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> str
-
-# Download an attachment asynchronously.
-sdk.attachments.download_async(key: uuid.UUID, destination_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> str
-
-# Upload a file or content to UiPath as an attachment.
-sdk.attachments.upload(name: str, content: Union[str, bytes, NoneType]=None, source_path: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uuid.UUID
-
-# Upload a file or content to UiPath as an attachment asynchronously.
-sdk.attachments.upload_async(name: str, content: Union[str, bytes, NoneType]=None, source_path: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uuid.UUID
-
-```
-
-### Buckets
-
-Buckets service
-
-```python
-# Download a file from a bucket.
-sdk.buckets.download(name: Optional[str]=None, key: Optional[str]=None, blob_file_path: str, destination_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-# Download a file from a bucket asynchronously.
-sdk.buckets.download_async(name: Optional[str]=None, key: Optional[str]=None, blob_file_path: str, destination_path: str, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-# Retrieve bucket information by its name.
-sdk.buckets.retrieve(name: Optional[str]=None, key: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.models.buckets.Bucket
-
-# Asynchronously retrieve bucket information by its name.
-sdk.buckets.retrieve_async(name: Optional[str]=None, key: Optional[str]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> uipath.models.buckets.Bucket
-
-# Upload a file to a bucket.
-sdk.buckets.upload(key: Optional[str]=None, name: Optional[str]=None, blob_file_path: str, content_type: Optional[str]=None, source_path: Optional[str]=None, content: Union[str, bytes, NoneType]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-# Upload a file to a bucket asynchronously.
-sdk.buckets.upload_async(key: Optional[str]=None, name: Optional[str]=None, blob_file_path: str, content_type: Optional[str]=None, source_path: Optional[str]=None, content: Union[str, bytes, NoneType]=None, folder_key: Optional[str]=None, folder_path: Optional[str]=None) -> None
-
-```
-
-### Connections
-
-Connections service
-
-```python
-# Lists all connections with optional filtering.
-sdk.connections.list(name: Optional[str]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None, connector_key: Optional[str]=None, skip: Optional[int]=None, top: Optional[int]=None) -> typing.List[uipath.models.connections.Connection]
-
-# Asynchronously lists all connections with optional filtering.
-sdk.connections.list_async(name: Optional[str]=None, folder_path: Optional[str]=None, folder_key: Optional[str]=None, connector_key: Optional[str]=None, skip: Optional[int]=None, top: Optional[int]=None) -> typing.List[uipath.models.connections.Connection]
-
-# Synchronously retrieve connection API metadata.
-sdk.connections.metadata(element_instance_id: int, tool_path: str, schema_mode: bool=True) -> uipath.models.connections.ConnectionMetadata
-
-# Asynchronously retrieve connection API metadata.
-sdk.connections.metadata_async(element_instance_id: int, tool_path: str, schema_mode: bool=True) -> uipath.models.connections.ConnectionMetadata
-
-# Retrieve connection details by its key.
-sdk.connections.retrieve(key: str) -> uipath.models.connections.Connection
-
-# Asynchronously retrieve connection details by its key.
-sdk.connections.retrieve_async(key: str) -> uipath.models.connections.Connection
-
-# Retrieve event payload from UiPath Integration Service.
-sdk.connections.retrieve_event_payload(event_args: uipath.models.connections.EventArguments) -> typing.Dict[str, typing.Any]
-
-# Retrieve event payload from UiPath Integration Service.
-sdk.connections.retrieve_event_payload_async(event_args: uipath.models.connections.EventArguments) -> typing.Dict[str, typing.Any]
-
-# Retrieve an authentication token for a connection.
-sdk.connections.retrieve_token(key: str, token_type: <enum 'ConnectionTokenType="direct") -> uipath.models.connections.ConnectionToken
-
-# Asynchronously retrieve an authentication token for a connection.
-sdk.connections.retrieve_token_async(key: str, token_type: <enum 'ConnectionTokenType="direct") -> uipath.models.connections.ConnectionToken
-
-```
-
 ### Context Grounding
 
 Context Grounding service
@@ -274,16 +187,6 @@ sdk.entities.update_records_async(entity_key: str, records: List[Any], schema: O
 
 ```
 
-### Folders
-
-Folders service
-
-```python
-# Retrieve the folder key by folder path with pagination support.
-sdk.folders.retrieve_key(folder_path: str) -> typing.Optional[str]
-
-```
-
 ### Jobs
 
 Jobs service
@@ -339,7 +242,7 @@ Llm service
 
 ```python
 # Generate chat completions using UiPath's normalized LLM Gateway API.
-sdk.llm.chat_completions(messages: List[Dict[str, str]], model: str="gpt-4o-mini-2024-07-18", max_tokens: int=4096, temperature: float=0, n: int=1, frequency_penalty: float=0, presence_penalty: float=0, top_p: Optional[float]=1, top_k: Optional[int]=None, tools: Optional[List[uipath.models.llm_gateway.ToolDefinition]]=None, tool_choice: Union[uipath.models.llm_gateway.AutoToolChoice, uipath.models.llm_gateway.RequiredToolChoice, uipath.models.llm_gateway.SpecificToolChoice, Literal['auto', 'none'], NoneType]=None, response_format: Union[Dict[str, Any], type[pydantic.main.BaseModel], NoneType]=None, api_version: str="2024-08-01-preview")
+sdk.llm.chat_completions(messages: Union[List[Dict[str, str]], List[tuple[str, str]]], model: str="gpt-4o-mini-2024-07-18", max_tokens: int=4096, temperature: float=0, n: int=1, frequency_penalty: float=0, presence_penalty: float=0, top_p: Optional[float]=1, top_k: Optional[int]=None, tools: Optional[List[uipath.models.llm_gateway.ToolDefinition]]=None, tool_choice: Union[uipath.models.llm_gateway.AutoToolChoice, uipath.models.llm_gateway.RequiredToolChoice, uipath.models.llm_gateway.SpecificToolChoice, Literal['auto', 'none'], NoneType]=None, response_format: Union[Dict[str, Any], type[pydantic.main.BaseModel], NoneType]=None, api_version: str="2024-08-01-preview")
 
 ```
 

uipath-2.1.108/src/uipath/_services/guardrails_service.py

@@ -0,0 +1,76 @@
+from typing import Any, Dict, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .._config import Config
+from .._execution_context import ExecutionContext
+from .._folder_context import FolderContext
+from .._utils import Endpoint, RequestSpec, header_folder
+from ..models.guardrails import BuiltInValidatorGuardrail, Guardrail
+from ..tracing import traced
+from ._base_service import BaseService
+
+
+class BuiltInGuardrailValidationResult(BaseModel):
+    """Result from built-in guardrail validation."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    validation_passed: bool = Field(alias="validation_passed")
+    reason: str = Field(alias="reason")
+
+
+class GuardrailViolationError(Exception):
+    """Exception raised when guardrail validation fails."""
+
+    def __init__(self, detected_issue: Any):
+        self.detected_issue = detected_issue
+        super().__init__(f"Guardrail violation detected: {detected_issue}")
+
+
+class GuardrailsService(FolderContext, BaseService):
+    """Service for validating text against UiPath Guardrails."""
+
+    def __init__(self, config: Config, execution_context: ExecutionContext) -> None:
+        super().__init__(config=config, execution_context=execution_context)
+
+    @traced("evaluate_guardrail", run_type="uipath")
+    def evaluate_guardrail(
+        self,
+        input_data: Union[str, Dict[str, Any]],
+        guardrail: Guardrail,
+        *,
+        folder_key: Optional[str] = None,
+        folder_path: Optional[str] = None,
+    ) -> BuiltInGuardrailValidationResult:
+        """Call the API to validate input_data with the given guardrail.
+
+        Only supports built-in guardrails for now.
+        """
+        if isinstance(guardrail, BuiltInValidatorGuardrail):
+            parameters = [
+                param.model_dump(by_alias=True)
+                for param in guardrail.validator_parameters
+            ]
+            payload = {
+                "validator": guardrail.validator_type,
+                "input": input_data if isinstance(input_data, str) else str(input_data),
+                "parameters": parameters,
+            }
+            spec = RequestSpec(
+                method="POST",
+                endpoint=Endpoint("/agentsruntime_/api/execution/guardrails/validate"),
+                json=payload,
+                headers={**header_folder(folder_key, folder_path)},
+            )
+            response = self.request(
+                spec.method,
+                url=spec.endpoint,
+                json=spec.json,
+                headers=spec.headers,
+            )
+            return BuiltInGuardrailValidationResult.model_validate(response.json())
+        else:
+            raise NotImplementedError(
+                "Custom guardrail validation is not yet supported by the API."
+            )

{uipath-2.1.106 → uipath-2.1.108}/src/uipath/_services/llm_gateway_service.py

@@ -344,7 +344,7 @@ class UiPathLlmChatService(BaseService):
     @traced(name="llm_chat_completions", run_type="uipath")
     async def chat_completions(
         self,
-        messages: List[Dict[str, str]],
+        messages: Union[List[Dict[str, str]], List[tuple[str, str]]],
         model: str = ChatModels.gpt_4o_mini_2024_07_18,
         max_tokens: int = 4096,
         temperature: float = 0,
@@ -475,13 +475,26 @@ class UiPathLlmChatService(BaseService):
             This service uses UiPath's normalized API format which provides consistent
             behavior across different underlying model providers and enhanced enterprise features.
         """
+        converted_messages = []
+
+        for message in messages:
+            if isinstance(message, tuple) and len(message) == 2:
+                role, content = message
+                converted_messages.append({"role": role, "content": content})
+            elif isinstance(message, dict):
+                converted_messages.append(message)
+            else:
+                raise ValueError(
+                    f"Invalid message format: {message}. Expected tuple (role, content) or dict with 'role' and 'content' keys."
+                )
+
         endpoint = EndpointManager.get_normalized_endpoint().format(
             model=model, api_version=api_version
         )
         endpoint = Endpoint("/" + endpoint)
 
         request_body = {
-            "messages": messages,
+            "messages": converted_messages,
             "max_tokens": max_tokens,
             "temperature": temperature,
             "n": n,

{uipath-2.1.106 → uipath-2.1.108}/src/uipath/_uipath.py

@@ -1,3 +1,4 @@
+from functools import cached_property
 from typing import Optional
 
 from pydantic import ValidationError
@@ -51,10 +52,6 @@ class UiPath:
                     raise BaseUrlMissingError() from e
                 elif error["loc"][0] == "secret":
                     raise SecretMissingError() from e
-        self._folders_service: Optional[FolderService] = None
-        self._buckets_service: Optional[BucketsService] = None
-        self._attachments_service: Optional[AttachmentsService] = None
-        self._connections_service: Optional[ConnectionsService] = None
         setup_logging(should_debug=debug)
         self._execution_context = ExecutionContext()
 
@@ -66,13 +63,9 @@ class UiPath:
     def assets(self) -> AssetsService:
         return AssetsService(self._config, self._execution_context)
 
-    @property
+    @cached_property
     def attachments(self) -> AttachmentsService:
-        if not self._attachments_service:
-            self._attachments_service = AttachmentsService(
-                self._config, self._execution_context
-            )
-        return self._attachments_service
+        return AttachmentsService(self._config, self._execution_context)
 
     @property
     def processes(self) -> ProcessesService:
@@ -82,39 +75,21 @@ class UiPath:
     def actions(self) -> ActionsService:
         return ActionsService(self._config, self._execution_context)
 
-    @property
+    @cached_property
     def buckets(self) -> BucketsService:
-        if not self._buckets_service:
-            self._buckets_service = BucketsService(
-                self._config, self._execution_context
-            )
         return BucketsService(self._config, self._execution_context)
 
-    @property
+    @cached_property
     def connections(self) -> ConnectionsService:
-        if not self._connections_service:
-            if not self._folders_service:
-                self._folders_service = FolderService(
-                    self._config, self._execution_context
-                )
-            self._connections_service = ConnectionsService(
-                self._config, self._execution_context, self._folders_service
-            )
-        return self._connections_service
+        return ConnectionsService(self._config, self._execution_context, self.folders)
 
     @property
     def context_grounding(self) -> ContextGroundingService:
-        if not self._folders_service:
-            self._folders_service = FolderService(self._config, self._execution_context)
-        if not self._buckets_service:
-            self._buckets_service = BucketsService(
-                self._config, self._execution_context
-            )
         return ContextGroundingService(
             self._config,
             self._execution_context,
-            self._folders_service,
-            self._buckets_service,
+            self.folders,
+            self.buckets,
         )
 
     @property
@@ -129,11 +104,9 @@ class UiPath:
     def jobs(self) -> JobsService:
         return JobsService(self._config, self._execution_context)
 
-    @property
+    @cached_property
     def folders(self) -> FolderService:
-        if not self._folders_service:
-            self._folders_service = FolderService(self._config, self._execution_context)
-        return self._folders_service
+        return FolderService(self._config, self._execution_context)
 
     @property
     def llm_openai(self) -> UiPathOpenAIService:

{uipath-2.1.106 → uipath-2.1.108}/src/uipath/agent/models/agent.py

@@ -6,7 +6,11 @@ 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
+from uipath.models.guardrails import (
+    BuiltInValidatorGuardrail,
+    CustomGuardrail,
+    FieldReference,
+)
 
 
 class AgentResourceType(str, Enum):
@@ -132,6 +136,37 @@ class AgentProcessToolResourceConfig(BaseAgentToolResourceConfig):
     )
 
 
+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 AgentIntegrationToolParameter(BaseModel):
     """Agent integration tool parameter."""
 
@@ -479,6 +514,116 @@ class AgentSettings(BaseModel):
     )
 
 
+class AgentGuardrailActionType(str, Enum):
+    """Action type enumeration."""
+
+    BLOCK = "block"
+    ESCALATE = "escalate"
+    FILTER = "filter"
+    LOG = "log"
+
+
+class AgentGuardrailBlockAction(BaseModel):
+    """Block action model."""
+
+    action_type: Literal["block"] = Field(alias="$actionType")
+    reason: str
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AgentGuardrailFilterAction(BaseModel):
+    """Filter action model."""
+
+    action_type: Literal["filter"] = Field(alias="$actionType")
+    fields: List[FieldReference]
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AgentGuardrailSeverityLevel(str, Enum):
+    """Severity level enumeration."""
+
+    ERROR = "Error"
+    INFO = "Info"
+    WARNING = "Warning"
+
+
+class AgentGuardrailLogAction(BaseModel):
+    """Log action model."""
+
+    action_type: Literal["log"] = Field(alias="$actionType")
+    message: str = Field(..., alias="message")
+    severity_level: AgentGuardrailSeverityLevel = Field(alias="severityLevel")
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AgentGuardrailEscalateActionApp(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 AgentGuardrailEscalateAction(BaseModel):
+    """Escalate action model."""
+
+    action_type: Literal["escalate"] = Field(alias="$actionType")
+    app: AgentGuardrailEscalateActionApp
+    recipient: AgentEscalationRecipient
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+GuardrailAction = Annotated[
+    Union[
+        AgentGuardrailBlockAction,
+        AgentGuardrailFilterAction,
+        AgentGuardrailLogAction,
+        AgentGuardrailEscalateAction,
+    ],
+    Field(discriminator="action_type"),
+]
+
+
+class AgentCustomGuardrail(CustomGuardrail):
+    """Agent custom guardrail with action capabilities."""
+
+    action: GuardrailAction = Field(
+        ..., description="Action to take when guardrail is triggered"
+    )
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class AgentBuiltInValidatorGuardrail(BuiltInValidatorGuardrail):
+    """Agent built-in validator guardrail with action capabilities."""
+
+    action: GuardrailAction = Field(
+        ..., description="Action to take when guardrail is triggered"
+    )
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+AgentGuardrail = Annotated[
+    Union[AgentCustomGuardrail, AgentBuiltInValidatorGuardrail],
+    Field(discriminator="guardrail_type"),
+]
+
+
 class BaseAgentDefinition(BaseModel):
     """Agent definition model."""
 
@@ -488,7 +633,7 @@ class BaseAgentDefinition(BaseModel):
     output_schema: Dict[str, Any] = Field(
         ..., alias="outputSchema", description="JSON schema for output arguments"
     )
-    guardrails: Optional[List[Guardrail]] = Field(
+    guardrails: Optional[List[AgentGuardrail]] = Field(
         None, description="List of agent guardrails"
     )