uipath 2.1.105__py3-none-any.whl → 2.1.107__py3-none-any.whl

uipath/_cli/_debug/_bridge.py

@@ -3,7 +3,8 @@ import json
 import logging
 import os
 from abc import ABC, abstractmethod
-from typing import Any, Dict, Optional
+from enum import Enum
+from typing import Any, Dict, List, Optional, Set
 
 from pydantic import BaseModel
 from pysignalr.client import SignalRClient
@@ -22,6 +23,50 @@ from uipath._events._events import UiPathAgentStateEvent
 logger = logging.getLogger(__name__)
 
 
+class DebuggerQuitException(Exception):
+    """Raised when user quits the debugger."""
+
+    pass
+
+
+class DebugCommand(str, Enum):
+    """Available debug commands."""
+
+    CONTINUE = "continue"
+    STEP = "step"
+    BREAKPOINT = "breakpoint"
+    LIST_BREAKPOINTS = "list"
+    CLEAR_BREAKPOINT = "clear"
+    HELP = "help"
+    QUIT = "quit"
+
+
+class DebuggerState:
+    """Maintains debugger state across execution."""
+
+    def __init__(self):
+        self.breakpoints: Set[str] = set()
+        self.step_mode: bool = False
+
+    def add_breakpoint(self, node_name: str) -> None:
+        """Add a breakpoint at a node."""
+        self.breakpoints.add(node_name)
+
+    def remove_breakpoint(self, node_name: str) -> None:
+        """Remove a breakpoint from a node."""
+        self.breakpoints.discard(node_name)
+
+    def clear_all_breakpoints(self) -> None:
+        """Clear all breakpoints."""
+        self.breakpoints.clear()
+
+    def should_break(self, node_name: str) -> bool:
+        """Check if execution should break at this node."""
+        if self.step_mode:
+            return True
+        return node_name in self.breakpoints
+
+
 class UiPathDebugBridge(ABC):
     """Abstract interface for debug communication.
 
@@ -77,6 +122,15 @@ class UiPathDebugBridge(ABC):
         """Wait for resume command from debugger."""
         pass
 
+    @abstractmethod
+    def get_breakpoints(self) -> List[str]:
+        """Get nodes to suspend execution at.
+
+        Returns:
+            List of node names to suspend at, or ["*"] for all nodes (step mode)
+        """
+        pass
+
 
 class ConsoleDebugBridge(UiPathDebugBridge):
     """Console-based debug bridge for local development."""
@@ -89,15 +143,12 @@ class ConsoleDebugBridge(UiPathDebugBridge):
         """
         self.console = Console()
         self.verbose = verbose
+        self.state = DebuggerState()
 
     async def connect(self) -> None:
         """Connect to console debugger."""
         self.console.print()
-        self.console.print("[bold cyan]─" * 40)
-        self.console.print("[bold cyan]Debug Mode")
-        self.console.print("[dim]Press ENTER to continue | Type 'quit' to exit")
-        self.console.print("[bold cyan]─" * 40)
-        self.console.print()
+        self._print_help()
 
     async def disconnect(self) -> None:
         """Cleanup."""
@@ -182,18 +233,128 @@ class ConsoleDebugBridge(UiPathDebugBridge):
 
     async def wait_for_resume(self) -> Any:
         """Wait for user to press Enter or type commands."""
-        self.console.print()
-        self.console.print("[cyan]> [/cyan]", end="")
+        while True:  # Keep looping until we get a resume command
+            self.console.print()
 
-        # Run input() in executor to not block async loop
-        loop = asyncio.get_running_loop()
-        user_input = await loop.run_in_executor(None, input)
+            # Run input() in executor to not block async loop
+            loop = asyncio.get_running_loop()
+            user_input = await loop.run_in_executor(None, lambda: input("> "))
 
-        if user_input.strip().lower() == "quit":
+            command_result = self._parse_command(user_input.strip())
+
+            # Handle commands that need another prompt
+            if command_result["command"] in [
+                DebugCommand.BREAKPOINT,
+                DebugCommand.LIST_BREAKPOINTS,
+                DebugCommand.CLEAR_BREAKPOINT,
+                DebugCommand.HELP,
+            ]:
+                # These commands don't resume execution, loop again
+                continue
+
+            # Reset step modes if continuing
+            if command_result["command"] == DebugCommand.CONTINUE:
+                self.state.step_mode = False
+
+            if command_result["command"] == DebugCommand.QUIT:
+                raise DebuggerQuitException("User requested exit")
+
+            # Commands that resume execution: CONTINUE, STEP
+            self.console.print()
+            return command_result
+
+    def get_breakpoints(self) -> List[str]:
+        """Get nodes to suspend execution at."""
+        if self.state.step_mode:
+            return ["*"]  # Suspend at all nodes
+        return list(self.state.breakpoints)  # Only suspend at breakpoints
+
+    def _parse_command(self, user_input: str) -> Dict[str, Any]:
+        """Parse user command input.
+
+        Returns:
+            Dict with 'command' and optional 'args'
+        """
+        if not user_input:
+            return {"command": DebugCommand.CONTINUE, "args": None}
+
+        parts = user_input.lower().split()
+        cmd = parts[0]
+        args = parts[1:] if len(parts) > 1 else []
+
+        if cmd in ["c", "continue"]:
+            return {"command": DebugCommand.CONTINUE, "args": None}
+
+        elif cmd in ["s", "step"]:
+            self.state.step_mode = True
+            return {"command": DebugCommand.STEP, "args": None}
+
+        elif cmd in ["b", "break", "breakpoint"]:
+            if not args:
+                self.console.print(
+                    "[red]Error: breakpoint command requires a node name[/red]"
+                )
+                return {"command": DebugCommand.HELP, "args": None}
+            node_name = " ".join(args)
+            self.state.add_breakpoint(node_name)
+            self.console.print(f"[green]✓ Breakpoint set at: {node_name}[/green]")
+            return {"command": DebugCommand.BREAKPOINT, "args": {"node": node_name}}
+
+        elif cmd in ["l", "list"]:
+            self._list_breakpoints()
+            return {"command": DebugCommand.LIST_BREAKPOINTS, "args": None}
+
+        elif cmd in ["r", "remove", "delete"]:
+            if not args:
+                self.console.print("[yellow]Removing all breakpoints[/yellow]")
+                self.state.clear_all_breakpoints()
+            else:
+                node_name = " ".join(args)
+                self.state.remove_breakpoint(node_name)
+                self.console.print(f"[green]✓ Breakpoint removed: {node_name}[/green]")
+            return {
+                "command": DebugCommand.CLEAR_BREAKPOINT,
+                "args": {"node": " ".join(args) if args else None},
+            }
+
+        elif cmd in ["q", "quit", "exit"]:
             raise KeyboardInterrupt("User requested exit")
 
+        elif cmd in ["h", "help", "?"]:
+            self._print_help()
+            return {"command": DebugCommand.HELP, "args": None}
+
+        else:
+            self.console.print(f"[red]Unknown command: {cmd}[/red]")
+            self.console.print("[dim]Type 'help' for available commands[/dim]")
+            return {"command": DebugCommand.HELP, "args": None}
+
+    def _list_breakpoints(self) -> None:
+        """List all active breakpoints."""
+        if not self.state.breakpoints:
+            self.console.print("[dim]No breakpoints set[/dim]")
+        else:
+            self.console.print("[yellow]Active breakpoints:[/yellow]")
+            for i, bp in enumerate(sorted(self.state.breakpoints), 1):
+                self.console.print(f"  {i}. [cyan]{bp}[/cyan]")
+
+    def _print_help(self) -> None:
+        """Print available commands."""
+        self.console.print("[bold cyan]Debug Mode Commands[/bold cyan]")
+        self.console.print(
+            "  [yellow]c, continue[/yellow]     Continue until next breakpoint"
+        )
+        self.console.print("  [yellow]s, step[/yellow]         Step to next node")
+        self.console.print(
+            "  [yellow]b  <node>[/yellow]       Set breakpoint at <node>"
+        )
+        self.console.print("  [yellow]l, list[/yellow]         List all breakpoints")
+        self.console.print(
+            "  [yellow]r  <node>[/yellow]       Remove breakpoint at <node>"
+        )
+        self.console.print("  [yellow]h, help[/yellow]         Show help")
+        self.console.print("  [yellow]q, quit[/yellow]         Exit debugger")
         self.console.print()
-        return user_input
 
     def _print_json(self, data: Dict[str, Any], label: str = "data") -> None:
         """Print JSON data with enhanced hierarchy."""
@@ -289,6 +450,7 @@ class SignalRDebugBridge(UiPathDebugBridge):
         self.hub_url = hub_url
         self.access_token = access_token
         self.headers = headers or {}
+        self.state = DebuggerState()
         self._client: Optional[SignalRClient] = None
         self._connected_event = asyncio.Event()
         self._resume_event: Optional[asyncio.Event] = None
@@ -396,6 +558,12 @@ class SignalRDebugBridge(UiPathDebugBridge):
         logger.info("Resume command received")
         return self._resume_data
 
+    def get_breakpoints(self) -> List[str]:
+        """Get nodes to suspend execution at."""
+        if self.state.step_mode:
+            return ["*"]  # Suspend at all nodes
+        return list(self.state.breakpoints)  # Only suspend at breakpoints
+
     async def _send(self, method: str, data: Dict[str, Any]) -> None:
         """Send message to SignalR hub."""
         if not self._client:

uipath/_cli/_debug/_runtime.py

@@ -11,9 +11,10 @@ from .._runtime._contracts import (
     UiPathRuntimeContext,
     UiPathRuntimeFactory,
     UiPathRuntimeResult,
+    UiPathRuntimeStatus,
     UiPathRuntimeStreamNotSupportedError,
 )
-from ._bridge import UiPathDebugBridge
+from ._bridge import DebuggerQuitException, UiPathDebugBridge
 
 logger = logging.getLogger(__name__)
 
@@ -91,8 +92,15 @@ class UiPathDebugRuntime(UiPathBaseRuntime, Generic[T, C]):
         final_result: Optional[UiPathRuntimeResult] = None
         execution_completed = False
 
+        # Starting in paused state - wait for breakpoints and resume
+        await self.debug_bridge.wait_for_resume()
+
         # Keep streaming until execution completes (not just paused at breakpoint)
         while not execution_completed:
+            # Update breakpoints from debug bridge
+            self._inner_runtime.context.breakpoints = (
+                self.debug_bridge.get_breakpoints()
+            )
             # Stream events from inner runtime
             async for event in self._inner_runtime.stream():
                 # Handle final result
@@ -101,10 +109,18 @@ class UiPathDebugRuntime(UiPathBaseRuntime, Generic[T, C]):
 
                     # Check if it's a breakpoint result
                     if isinstance(event, UiPathBreakpointResult):
-                        # Hit a breakpoint - wait for resume and continue
-                        await self.debug_bridge.emit_breakpoint_hit(event)
-                        await self.debug_bridge.wait_for_resume()
-                        self._inner_runtime.context.resume = True
+                        try:
+                            # Hit a breakpoint - wait for resume and continue
+                            await self.debug_bridge.emit_breakpoint_hit(event)
+                            await self.debug_bridge.wait_for_resume()
+
+                            self._inner_runtime.context.resume = True
+
+                        except DebuggerQuitException:
+                            final_result = UiPathRuntimeResult(
+                                status=UiPathRuntimeStatus.SUCCESSFUL,
+                            )
+                            execution_completed = True
                     else:
                         # Normal completion or suspension with dynamic interrupt
                         execution_completed = True

uipath/_cli/_runtime/_contracts.py

@@ -382,6 +382,7 @@ class UiPathRuntimeContext(BaseModel):
     log_handler: Optional[logging.Handler] = None
     chat_handler: Optional[UiPathConversationHandler] = None
     is_conversational: Optional[bool] = None
+    breakpoints: Optional[List[str]] = None
 
     model_config = {"arbitrary_types_allowed": True, "extra": "allow"}
 

uipath/_resources/SDK_REFERENCE.md

@@ -339,7 +339,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/_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/_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/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"
     )
 

uipath/models/guardrails.py

@@ -1,7 +1,7 @@
 from enum import Enum
-from typing import Annotated, Any, Dict, List, Literal, Optional, Union
+from typing import Annotated, Dict, List, Literal, Optional, Union
 
-from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class FieldSource(str, Enum):
@@ -183,112 +183,6 @@ Rule = Annotated[
 ]
 
 
-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."""
 
@@ -312,7 +206,6 @@ class BaseGuardrail(BaseModel):
     id: str
     name: str
     description: Optional[str] = None
-    action: GuardrailAction
     enabled_for_evals: bool = Field(True, alias="enabledForEvals")
     selector: GuardrailSelector
 
@@ -351,119 +244,3 @@ class GuardrailType(str, Enum):
 
     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/tracing/_utils.py

@@ -13,16 +13,26 @@ from zoneinfo import ZoneInfo
 
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.trace import StatusCode
+from pydantic import BaseModel
 
 logger = logging.getLogger(__name__)
 
 
 def _simple_serialize_defaults(obj):
-    if hasattr(obj, "model_dump"):
+    # Handle Pydantic BaseModel instances
+    if hasattr(obj, "model_dump") and not isinstance(obj, type):
         return obj.model_dump(exclude_none=True, mode="json")
-    if hasattr(obj, "dict"):
+
+    # Handle classes - convert to schema representation
+    if isinstance(obj, type) and issubclass(obj, BaseModel):
+        return {
+            "__class__": obj.__name__,
+            "__module__": obj.__module__,
+            "schema": obj.model_json_schema(),
+        }
+    if hasattr(obj, "dict") and not isinstance(obj, type):
         return obj.dict()
-    if hasattr(obj, "to_dict"):
+    if hasattr(obj, "to_dict") and not isinstance(obj, type):
         return obj.to_dict()
 
     # Handle dataclasses
@@ -31,7 +41,7 @@ def _simple_serialize_defaults(obj):
 
     # Handle enums
     if isinstance(obj, Enum):
-        return obj.value
+        return _simple_serialize_defaults(obj.value)
 
     if isinstance(obj, (set, tuple)):
         if hasattr(obj, "_asdict") and callable(obj._asdict):
@@ -44,6 +54,10 @@ def _simple_serialize_defaults(obj):
     if isinstance(obj, (timezone, ZoneInfo)):
         return obj.tzname(None)
 
+    # Allow JSON-serializable primitives to pass through unchanged
+    if obj is None or isinstance(obj, (bool, int, float, str)):
+        return obj
+
     return str(obj)
 
 

{uipath-2.1.105.dist-info → uipath-2.1.107.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uipath
-Version: 2.1.105
+Version: 2.1.107
 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.105.dist-info → uipath-2.1.107.dist-info}/RECORD

@@ -32,8 +32,8 @@ uipath/_cli/_auth/auth_config.json,sha256=o8J5BBFwiEtjZLHpJ_64lvnTeYeRIHaJ-Bhg0Q
 uipath/_cli/_auth/index.html,sha256=uGK0CDTP8Rys_p4O_Pbd2x4tz0frKNVcumjrXnal5Nc,22814
 uipath/_cli/_auth/localhost.crt,sha256=oGl9oLLOiouHubAt39B4zEfylFvKEtbtr_43SIliXJc,1226
 uipath/_cli/_auth/localhost.key,sha256=X31VYXD8scZtmGA837dGX5l6G-LXHLo5ItWJhZXaz3c,1679
-uipath/_cli/_debug/_bridge.py,sha256=3TORu0ArTJoNFzolx80RgTv3z_84G_SZOKnYa7sOC0s,16161
-uipath/_cli/_debug/_runtime.py,sha256=h4WRBJn46dorTVXNZ32KIqg_-Z0mcLq5BvXGXqHAT_o,4934
+uipath/_cli/_debug/_bridge.py,sha256=_CArFkZlwBYUkmpfqehcXyPNVDXv00vPNFfKJiOVJoA,22269
+uipath/_cli/_debug/_runtime.py,sha256=iQ0L7WVvh0eF85D6sckZTTjE5wc_KQjCncT23hEdC6k,5596
 uipath/_cli/_dev/_terminal/__init__.py,sha256=di_RiN9Mcp9wqyKRRqXag28vbSw8_78mCnQZNn9H-Ss,14027
 uipath/_cli/_dev/_terminal/_components/_chat.py,sha256=NLRoy49QScHiI-q0FGykkaU8ajv1d23fx7issSALcFA,4119
 uipath/_cli/_dev/_terminal/_components/_details.py,sha256=FbLYtJ56gqHV6CIrpzO_n9Sk_YNg4nzRKTSsbj-DBPQ,17257
@@ -68,7 +68,7 @@ uipath/_cli/_evals/mocks/mocker_factory.py,sha256=V5QKSTtQxztTo4-fK1TyAaXw2Z3mHf
 uipath/_cli/_evals/mocks/mockito_mocker.py,sha256=AO2BmFwA6hz3Lte-STVr7aJDPvMCqKNKa4j2jeNZ_U4,2677
 uipath/_cli/_evals/mocks/mocks.py,sha256=HY0IaSqqO8hioBB3rp5XwAjSpQE4K5hoH6oJQ-sH72I,2207
 uipath/_cli/_push/sw_file_handler.py,sha256=DrGOpX7-dodrROh7YcjHlCBUuOEdVMh8o0550TL-ZYA,22520
-uipath/_cli/_runtime/_contracts.py,sha256=tlL67y7YtbbdNpNz5ZmRBxHsaZ59fefcPgHnmZA0Drw,35653
+uipath/_cli/_runtime/_contracts.py,sha256=DvpDLkmCESMID2S_ryUu7Y1N26-QIRrDNgk-pPGoOSU,35697
 uipath/_cli/_runtime/_escalation.py,sha256=x3vI98qsfRA-fL_tNkRVTFXioM5Gv2w0GFcXJJ5eQtg,7981
 uipath/_cli/_runtime/_hitl.py,sha256=JAwTUKvxO4HpnZMwE4E0AegAPw_uYOwgt0OYcu6EvTg,11474
 uipath/_cli/_runtime/_logging.py,sha256=srjAi3Cy6g7b8WNHiYNjaZT4t40F3XRqquuoGd2kh4Y,14019
@@ -102,7 +102,7 @@ uipath/_resources/AGENTS.md,sha256=nRQNAVeEBaBvuMzXw8uXtMnGebLClUgwIMlgb8_qU9o,1
 uipath/_resources/CLAUDE.md,sha256=kYsckFWTVe948z_fNWLysCHvi9_YpchBXl3s1Ek03lU,10
 uipath/_resources/CLI_REFERENCE.md,sha256=M_SCtSjRhj1XwfgSFLfHJJahYXEd_CSQ_EnjLQAn-2Y,6470
 uipath/_resources/REQUIRED_STRUCTURE.md,sha256=3laqGiNa3kauJ7jRI1d7w_fWKUDkqYBjcTT_6_8FAGk,1417
-uipath/_resources/SDK_REFERENCE.md,sha256=4wX8a1W5EJCta-iEHy_cDRahn0ENpJykwn-w4k_Lh6s,23245
+uipath/_resources/SDK_REFERENCE.md,sha256=1i2S2219HSTVrMHoMPcUxTC4nGqeLKfzeD_JSuIB3ec,23275
 uipath/_services/__init__.py,sha256=_LNy4u--VlhVtTO66bULbCoBjyJBTuyh9jnzjWrv-h4,1140
 uipath/_services/_base_service.py,sha256=x9-9jhPzn9Z16KRdFHhJNvV-FZHvTniMsDfxlS4Cutk,5782
 uipath/_services/actions_service.py,sha256=2RPMR-hFMsOlqEyjIf3aF7-lrf57jdrSD0pBjj0Kyko,16040
@@ -116,8 +116,9 @@ uipath/_services/documents_service.py,sha256=dVv7kYT2wm4gbtqulSAQhtn418xgzV2yt7g
 uipath/_services/entities_service.py,sha256=QKCLE6wRgq3HZraF-M2mljy-8il4vsNHrQhUgkewVVk,14028
 uipath/_services/external_application_service.py,sha256=gZhnGgLn7ZYUZzZF7AumB14QEPanVY-D_02FqEcAFtw,5478
 uipath/_services/folder_service.py,sha256=9JqgjKhWD-G_KUnfUTP2BADxL6OK9QNZsBsWZHAULdE,2749
+uipath/_services/guardrails_service.py,sha256=Uch_3Ph3Obg7vG--iemqJUB7I7vSHmQMYtESAyIzqFI,2796
 uipath/_services/jobs_service.py,sha256=tTZNsdZKN3uP7bWPQyBCpJeQxTfuOWbKYOR4L-_yJo4,32736
-uipath/_services/llm_gateway_service.py,sha256=oFBKSYbZqujGHDuM3A72S3J7mHn9kWjNTgcE3U0c24Y,24411
+uipath/_services/llm_gateway_service.py,sha256=vRnx5MSSkxxR0Xw4_km0_aDBrWgkZmyJ1QRBp_anfog,24995
 uipath/_services/processes_service.py,sha256=O_uHgQ1rnwiV5quG0OQqabAnE6Rf6cWrMENYY2jKWt8,8585
 uipath/_services/queues_service.py,sha256=VaG3dWL2QK6AJBOLoW2NQTpkPfZjsqsYPl9-kfXPFzA,13534
 uipath/_utils/__init__.py,sha256=VdcpnENJIa0R6Y26NoxY64-wUVyvb4pKfTh1wXDQeMk,526
@@ -143,7 +144,7 @@ uipath/agent/conversation/exchange.py,sha256=nuk1tEMBHc_skrraT17d8U6AtyJ3h07ExGQ
 uipath/agent/conversation/message.py,sha256=1ZkEs146s79TrOAWCQwzBAEJvjAu4lQBpJ64tKXDgGE,2142
 uipath/agent/conversation/meta.py,sha256=3t0eS9UHoAPHre97QTUeVbjDhnMX4zj4-qG6ju0B8wY,315
 uipath/agent/conversation/tool.py,sha256=ol8XI8AVd-QNn5auXNBPcCzOkh9PPFtL7hTK3kqInkU,2191
-uipath/agent/models/agent.py,sha256=lCSXE2ctZOSQfK27dk7y5cl0VARE7iGb0UredBIigTM,18613
+uipath/agent/models/agent.py,sha256=kAdNWpyzggIYB4ye7vs-hPrHGxYPgTp48DcmQXw-Bcw,22630
 uipath/agent/models/evals.py,sha256=QMIqwCuwabD_vYF0KgJpip5BV0pFLf9ZKUd9AL5eU2w,1843
 uipath/agent/react/__init__.py,sha256=0Ci-uf0gSOReoHQyx3QImY-om3q_SgLT-bJUSlzS3B8,527
 uipath/agent/react/prompts.py,sha256=0a06TJz2XqZuLK-yC_bvZV9ULXpY6UGtybjjbyVzXII,3375
@@ -175,7 +176,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=f71VsUyonK2uuH1Cs0tpP6f9dec6v6cffL1Z9EjTxm0,1870
-uipath/models/guardrails.py,sha256=3LQf8CJj1ipnUqdUJuDenC4MS8o9GlWj_AsS2naP_tM,12976
+uipath/models/guardrails.py,sha256=tyrJ0WTYX0Ds7VtFyX87k7T9mQaGv-u1maQpnO0IPXM,6034
 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
@@ -187,12 +188,12 @@ uipath/telemetry/_track.py,sha256=3RZgJtY8y28Y5rfVmC432OyRu7N3pSxPouwa82KWFso,47
 uipath/tracing/__init__.py,sha256=0oUuxJKOHE14iOL4SP93FOiEYRIFLTq-o0NwRcTB8Q4,317
 uipath/tracing/_otel_exporters.py,sha256=LAtaQV5QN4PSLgEbIVvlmUETNbMYqTX87R-3mRKy_S8,12438
 uipath/tracing/_traced.py,sha256=yBIY05PCCrYyx50EIHZnwJaKNdHPNx-YTR1sHQl0a98,19901
-uipath/tracing/_utils.py,sha256=X-LFsyIxDeNOGuHPvkb6T5o9Y8ElYhr_rP3CEBJSu4s,13837
+uipath/tracing/_utils.py,sha256=zMjiKjNpSN3YQNEU4-u5AAvPtUsi8QuEqNLya89jfAU,14466
 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.105.dist-info/METADATA,sha256=K5hQtwyATXioIYlwjouky0NiHWH8OcFpClL9bjEXSWc,6626
-uipath-2.1.105.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-uipath-2.1.105.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
-uipath-2.1.105.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
-uipath-2.1.105.dist-info/RECORD,,
+uipath-2.1.107.dist-info/METADATA,sha256=fHXbkUqpyNJ9NMJB1vkME8fMivyaqb4HAZhIB0hPrJc,6626
+uipath-2.1.107.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+uipath-2.1.107.dist-info/entry_points.txt,sha256=9C2_29U6Oq1ExFu7usihR-dnfIVNSKc-0EFbh0rskB4,43
+uipath-2.1.107.dist-info/licenses/LICENSE,sha256=-KBavWXepyDjimmzH5fVAsi-6jNVpIKFc2kZs0Ri4ng,1058
+uipath-2.1.107.dist-info/RECORD,,