uipath 2.1.89__py3-none-any.whl → 2.1.91__py3-none-any.whl

uipath/_resources/AGENTS.md

@@ -1,6 +1,6 @@
 # Agent Code Patterns Reference
 
-This document provides practical code patterns for building UiPath coded agents using LangGraph and the UiPath Python SDK.
+This document provides practical code patterns for building UiPath coded agents using the UiPath Python SDK.
 
 ---
 
@@ -8,32 +8,14 @@ This document provides practical code patterns for building UiPath coded agents
 
 This documentation is split into multiple files for efficient context loading. Load only the files you need:
 
-### Core Documentation Files
-
 1. **@.agent/REQUIRED_STRUCTURE.md** - Agent structure patterns and templates
    - **When to load:** Creating a new agent or understanding required patterns
-   - **Contains:** Required Pydantic models (Input, State, Output), LLM initialization patterns, standard agent template
-   - **Size:** ~90 lines
+   - **Contains:** Required Pydantic models (Input, Output), SDK initialization patterns, standard agent template
 
 2. **@.agent/SDK_REFERENCE.md** - Complete SDK API reference
    - **When to load:** Calling UiPath SDK methods, working with services (actions, assets, jobs, etc.)
    - **Contains:** All SDK services and methods with full signatures and type annotations
-   - **Size:** ~400 lines
 
 3. **@.agent/CLI_REFERENCE.md** - CLI commands documentation
    - **When to load:** Working with `uipath init`, `uipath run`, or `uipath eval` commands
    - **Contains:** Command syntax, options, usage examples, and workflows
-   - **Size:** ~200 lines
-
-### Usage Guidelines
-
-**For LLMs:**
-- Read this file (AGENTS.md) first to understand the documentation structure
-- Load .agent/REQUIRED_STRUCTURE.md when building new agents or need structure reference
-- Load .agent/SDK_REFERENCE.md only when you need to call specific SDK methods
-- Load .agent/CLI_REFERENCE.md only when working with CLI commands
-
-**Benefits:**
-- Reduced token usage by loading only relevant context
-- Faster response times
-- More focused context for specific tasks

uipath/_resources/REQUIRED_STRUCTURE.md

@@ -4,7 +4,7 @@
 
 ### Required Components
 
-Every agent implementation MUST include these three Pydantic models:
+Every agent implementation MUST include these two Pydantic models:
 
 ```python
 from pydantic import BaseModel
@@ -14,80 +14,51 @@ class Input(BaseModel):
     # Add your input fields here
     pass
 
-class State(BaseModel):
-    """Define the agent's internal state that flows between nodes"""
-    # Add your state fields here
-    pass
-
 class Output(BaseModel):
     """Define output fields that the agent returns"""
     # Add your output fields here
     pass
 ```
 
-### Required LLM Initialization
-
-Unless the user explicitly requests a different LLM provider, always use `UiPathChat`:
+### SDK Initialization
 
 ```python
-from uipath_langchain.chat import UiPathChat
+from uipath import UiPath
 
-llm = UiPathChat(model="gpt-4o-2024-08-06", temperature=0.7)
-```
+# Initialize with environment variables
+uipath = UiPath()
 
-**Alternative LLMs** (only use if explicitly requested):
-- `ChatOpenAI` from `langchain_openai`
-- `ChatAnthropic` from `langchain_anthropic`
-- Other LangChain-compatible LLMs
+# With explicit credentials
+uipath = UiPath(base_url="https://cloud.uipath.com/...", secret="your_token")
+
+# Or with client_id and client_secret
+uipath = UiPath(
+    client_id=UIPATH_CLIENT_ID,
+    client_secret=UIPATH_CLIENT_SECRET,
+    scope=UIPATH_SCOPE,
+    base_url=UIPATH_URL
+)
+```
 
 ### Standard Agent Template
 
 Every agent should follow this basic structure:
 
 ```python
-from langchain_core.messages import SystemMessage, HumanMessage
-from langgraph.graph import START, StateGraph, END
-from uipath_langchain.chat import UiPathChat
+from uipath import UiPath
 from pydantic import BaseModel
 
-# 1. Define Input, State, and Output models
+# 1. Define Input, and Output models
 class Input(BaseModel):
     field: str
 
-class State(BaseModel):
-    field: str
-    result: str = ""
-
 class Output(BaseModel):
     result: str
 
-# 2. Initialize UiPathChat LLM
-llm = UiPathChat(model="gpt-4o-2024-08-06", temperature=0.7)
-
-# 3. Define agent nodes (async functions)
-async def process_node(state: State) -> State:
-    response = await llm.ainvoke([HumanMessage(state.field)])
-    return State(field=state.field, result=response.content)
-
-async def output_node(state: State) -> Output:
-    return Output(result=state.result)
+# 2. Initialize with environment variables
+uipath = UiPath()
 
-# 4. Build the graph
-builder = StateGraph(State, input=Input, output=Output)
-builder.add_node("process", process_node)
-builder.add_node("output", output_node)
-builder.add_edge(START, "process")
-builder.add_edge("process", "output")
-builder.add_edge("output", END)
-
-# 5. Compile the graph
-graph = builder.compile()
+# 3. Define the main function (the main function can be named "main", "run" or "execute")
+def main(input_data: Input) -> Output:
+     pass
 ```
-
-**Key Rules**:
-1. Always use async/await for all node functions
-2. All nodes (except output) must accept and return `State`
-3. The final output node must return `Output`
-4. Use `StateGraph(State, input=Input, output=Output)` for initialization
-5. Always compile with `graph = builder.compile()`
-

uipath/_resources/SDK_REFERENCE.md

@@ -1,4 +1,4 @@
-## Quick API Reference
+## API Reference
 
 This section provides a comprehensive reference for all UiPath SDK services and methods. Each service is documented with complete method signatures, including parameter types and return types.
 

uipath/agent/models/agent.py

@@ -3,11 +3,8 @@
 from enum import Enum
 from typing import Annotated, Any, Dict, List, Literal, Optional, Union
 
-from pydantic import BaseModel, ConfigDict, Discriminator, Field, Tag
+from pydantic import BaseModel, ConfigDict, Discriminator, Field, Tag, field_validator
 
-from uipath._cli._evals._models._evaluation_set import EvaluationSet
-from uipath._cli._evals._models._evaluator import Evaluator
-from uipath._cli._evals._models._mocks import ExampleCall
 from uipath.models import Connection
 
 
@@ -17,6 +14,7 @@ class AgentResourceType(str, Enum):
     TOOL = "tool"
     CONTEXT = "context"
     ESCALATION = "escalation"
+    MCP = "mcp"
 
 
 class BaseAgentResourceConfig(BaseModel):
@@ -55,12 +53,14 @@ class AgentToolType(str, Enum):
     """Agent tool type."""
 
     AGENT = "agent"
-    INTEGRATION = "integration"
     PROCESS = "process"
+    API = "api"
+    PROCESS_ORCHESTRATION = "processorchestration"
+    INTEGRATION = "integration"
 
 
 class AgentToolSettings(BaseModel):
-    """Settings for tool configuration."""
+    """Settings for tool."""
 
     max_attempts: Optional[int] = Field(None, alias="maxAttempts")
     retry_delay: Optional[int] = Field(None, alias="retryDelay")
@@ -74,7 +74,9 @@ class AgentToolSettings(BaseModel):
 class BaseResourceProperties(BaseModel):
     """Base resource properties."""
 
-    example_calls: Optional[List[ExampleCall]] = Field(None, alias="exampleCalls")
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
 
 
 class AgentProcessToolProperties(BaseResourceProperties):
@@ -91,7 +93,12 @@ class AgentProcessToolProperties(BaseResourceProperties):
 class AgentProcessToolResourceConfig(BaseAgentToolResourceConfig):
     """Tool resource with tool-specific properties."""
 
-    type: Literal[AgentToolType.AGENT] = AgentToolType.AGENT
+    type: Literal[
+        AgentToolType.AGENT,
+        AgentToolType.PROCESS,
+        AgentToolType.API,
+        AgentToolType.PROCESS_ORCHESTRATION,
+    ]
     output_schema: Dict[str, Any] = Field(
         ..., alias="outputSchema", description="Output schema for the tool"
     )
@@ -101,6 +108,17 @@ class AgentProcessToolResourceConfig(BaseAgentToolResourceConfig):
     settings: AgentToolSettings = Field(
         default_factory=AgentToolSettings, description="Tool settings"
     )
+    arguments: Dict[str, Any] = Field(
+        default_factory=dict, description="Tool arguments"
+    )
+
+    @field_validator("type", mode="before")
+    @classmethod
+    def normalize_type(cls, v: Any) -> str:
+        """Normalize tool type to lowercase format."""
+        if isinstance(v, str):
+            return v.lower()
+        return v
 
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
@@ -133,7 +151,7 @@ class AgentIntegrationToolParameter(BaseModel):
 
 
 class AgentIntegrationToolProperties(BaseResourceProperties):
-    """Properties specific to tool configuration."""
+    """Properties specific to tool."""
 
     tool_path: str = Field(..., alias="toolPath")
     object_name: str = Field(..., alias="objectName")
@@ -141,7 +159,7 @@ class AgentIntegrationToolProperties(BaseResourceProperties):
     tool_description: str = Field(..., alias="toolDescription")
     method: str = Field(..., alias="method")
     connection: Connection = Field(..., alias="connection")
-    body_structure: dict[str, Any] = Field(..., alias="bodyStructure")
+    body_structure: Optional[dict[str, Any]] = Field(None, alias="bodyStructure")
     parameters: List[AgentIntegrationToolParameter] = Field([], alias="parameters")
 
     model_config = ConfigDict(
@@ -154,26 +172,93 @@ class AgentIntegrationToolResourceConfig(BaseAgentToolResourceConfig):
 
     type: Literal[AgentToolType.INTEGRATION] = AgentToolType.INTEGRATION
     properties: AgentIntegrationToolProperties
+    arguments: Optional[Dict[str, Any]] = Field(
+        default_factory=dict, description="Tool arguments"
+    )
+    is_enabled: Optional[bool] = Field(None, alias="isEnabled")
+
+    @field_validator("type", mode="before")
+    @classmethod
+    def normalize_type(cls, v: Any) -> str:
+        """Normalize tool type to lowercase format."""
+        if isinstance(v, str):
+            return v.lower()
+        return v
+
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
     )
 
 
-class AgentUnknownToolResourceConfig(BaseAgentToolResourceConfig):
+class AgentUnknownToolResourceConfig(BaseAgentResourceConfig):
     """Fallback for unknown or future tool types."""
 
     resource_type: Literal[AgentResourceType.TOOL] = AgentResourceType.TOOL
     type: str = Field(alias="$resourceType")
+    arguments: Optional[Dict[str, Any]] = Field(
+        default_factory=dict, description="Tool arguments"
+    )
+    is_enabled: Optional[bool] = Field(None, alias="isEnabled")
 
     model_config = ConfigDict(extra="allow")
 
 
+class AgentContextQuerySetting(BaseModel):
+    """Query setting for context configuration."""
+
+    description: Optional[str] = Field(None)
+    variant: Optional[str] = Field(None)
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class AgentContextValueSetting(BaseModel):
+    """Generic value setting for context configuration."""
+
+    value: Any = Field(...)
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class AgentContextOutputColumn(BaseModel):
+    """Output column configuration for Batch Transform."""
+
+    name: str = Field(...)
+    description: Optional[str] = Field(None)
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
 class AgentContextSettings(BaseModel):
-    """Settings for context configuration."""
+    """Settings for context."""
 
     result_count: int = Field(alias="resultCount")
-    retrieval_mode: Literal["Semantic", "Structured"] = Field(alias="retrievalMode")
+    retrieval_mode: Literal["Semantic", "Structured", "DeepRAG", "BatchTransform"] = (
+        Field(alias="retrievalMode")
+    )
     threshold: float = Field(default=0)
+    query: Optional[AgentContextQuerySetting] = Field(None)
+    folder_path_prefix: Optional[Union[Dict[str, Any], AgentContextValueSetting]] = (
+        Field(None, alias="folderPathPrefix")
+    )
+    file_extension: Optional[Union[Dict[str, Any], AgentContextValueSetting]] = Field(
+        None, alias="fileExtension"
+    )
+    citation_mode: Optional[AgentContextValueSetting] = Field(
+        None, alias="citationMode"
+    )
+    web_search_grounding: Optional[AgentContextValueSetting] = Field(
+        None, alias="webSearchGrounding"
+    )
+    output_columns: Optional[List[AgentContextOutputColumn]] = Field(
+        None, alias="outputColumns"
+    )
 
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
@@ -187,19 +272,67 @@ class AgentContextResourceConfig(BaseAgentResourceConfig):
     folder_path: str = Field(alias="folderPath")
     index_name: str = Field(alias="indexName")
     settings: AgentContextSettings = Field(..., description="Context settings")
+    is_enabled: Optional[bool] = Field(None, alias="isEnabled")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class AgentMcpTool(BaseModel):
+    """MCP available tool."""
+
+    name: str = Field(..., alias="name")
+    description: str = Field(..., alias="description")
+    input_schema: Dict[str, Any] = Field(..., alias="inputSchema")
 
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
     )
 
 
+class AgentMcpResourceConfig(BaseAgentResourceConfig):
+    """MCP resource configuration."""
+
+    resource_type: Literal[AgentResourceType.MCP] = Field(alias="$resourceType")
+    folder_path: str = Field(alias="folderPath")
+    slug: str = Field(..., alias="slug")
+    available_tools: List[AgentMcpTool] = Field(..., alias="availableTools")
+    is_enabled: Optional[bool] = Field(None, alias="isEnabled")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=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: int = Field(..., alias="type")
+    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"
     )
@@ -227,7 +360,7 @@ class AgentEscalationChannelProperties(BaseResourceProperties):
 class AgentEscalationChannel(BaseModel):
     """Agent escalation channel."""
 
-    id: str = Field(..., alias="id")
+    id: Optional[str] = Field(None, alias="id")
     name: str = Field(..., alias="name")
     type: str = Field(alias="type")
     description: str = Field(..., alias="description")
@@ -239,8 +372,12 @@ class AgentEscalationChannel(BaseModel):
         alias="outputSchema",
         description="Output schema for the escalation channel",
     )
+    outcome_mapping: Optional[Dict[str, str]] = Field(None, alias="outcomeMapping")
     properties: AgentEscalationChannelProperties = Field(..., alias="properties")
     recipients: List[AgentEscalationRecipient] = Field(..., alias="recipients")
+    task_title: Optional[str] = Field(default=None, alias="taskTitle")
+    priority: Optional[str] = None
+    labels: List[str] = Field(default_factory=list)
 
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
@@ -250,11 +387,11 @@ class AgentEscalationChannel(BaseModel):
 class AgentEscalationResourceConfig(BaseAgentResourceConfig):
     """Escalation resource with escalation-specific properties."""
 
+    id: Optional[str] = Field(None, alias="id")
     resource_type: Literal[AgentResourceType.ESCALATION] = Field(alias="$resourceType")
     channels: List[AgentEscalationChannel] = Field(alias="channels")
-
-    # escalation_type: int = Field(..., alias="escalationType")
-    is_agent_memory_enabled: bool = Field(alias="isAgentMemoryEnabled")
+    is_agent_memory_enabled: bool = Field(default=False, alias="isAgentMemoryEnabled")
+    escalation_type: int = Field(default=0, alias="escalationType")
 
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
@@ -269,9 +406,16 @@ def custom_discriminator(data: Any) -> str:
             return "AgentContextResourceConfig"
         elif resource_type == AgentResourceType.ESCALATION:
             return "AgentEscalationResourceConfig"
+        elif resource_type == AgentResourceType.MCP:
+            return "AgentMcpResourceConfig"
         elif resource_type == AgentResourceType.TOOL:
             tool_type = data.get("type")
-            if tool_type == AgentToolType.AGENT:
+            if tool_type in [
+                AgentToolType.AGENT,
+                AgentToolType.PROCESS,
+                AgentToolType.API,
+                AgentToolType.PROCESS_ORCHESTRATION,
+            ]:
                 return "AgentProcessToolResourceConfig"
             elif tool_type == AgentToolType.INTEGRATION:
                 return "AgentIntegrationToolResourceConfig"
@@ -296,47 +440,24 @@ AgentResourceConfig = Annotated[
         ],
         Annotated[AgentContextResourceConfig, Tag("AgentContextResourceConfig")],
         Annotated[AgentEscalationResourceConfig, Tag("AgentEscalationResourceConfig")],
+        Annotated[AgentMcpResourceConfig, Tag("AgentMcpResourceConfig")],
         Annotated[AgentUnknownResourceConfig, Tag("AgentUnknownResourceConfig")],
     ],
     Field(discriminator=Discriminator(custom_discriminator)),
 ]
 
 
-class BaseAgentDefinition(BaseModel):
-    """Main agent model."""
+class AgentMetadata(BaseModel):
+    """Metadata for agent."""
 
-    id: str = Field(..., description="Agent id or project name")
-    name: str = Field(..., description="Agent name or project name")
-    input_schema: Dict[str, Any] = Field(
-        ..., alias="inputSchema", description="JSON schema for input arguments"
-    )
-    output_schema: Dict[str, Any] = Field(
-        ..., alias="outputSchema", description="JSON schema for output arguments"
-    )
-    version: str = Field("1.0.0", description="Agent version")
-    resources: List[AgentResourceConfig] = Field(
-        ..., description="List of tools, context, and escalation resources"
-    )
-    evaluation_sets: Optional[List[EvaluationSet]] = Field(
-        None,
-        alias="evaluationSets",
-        description="List of agent evaluation sets",
-    )
-    evaluators: Optional[List[Evaluator]] = Field(
-        None, description="List of agent evaluators"
-    )
+    is_conversational: bool = Field(alias="isConversational")
+    storage_version: str = Field(alias="storageVersion")
 
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
     )
 
 
-class AgentType(str, Enum):
-    """Agent type."""
-
-    LOW_CODE = "lowCode"
-
-
 class AgentMessageRole(str, Enum):
     """Enum for message roles."""
 
@@ -345,23 +466,31 @@ class AgentMessageRole(str, Enum):
 
 
 class AgentMessage(BaseModel):
-    """Message model for agent conversations."""
+    """Message model for agent definition."""
 
-    role: AgentMessageRole
+    role: Literal[AgentMessageRole.SYSTEM, AgentMessageRole.USER]
     content: str
 
+    @field_validator("role", mode="before")
+    @classmethod
+    def normalize_role(cls, v: Any) -> str:
+        """Normalize role to lowercase format."""
+        if isinstance(v, str):
+            return v.lower()
+        return v
+
     model_config = ConfigDict(
         validate_by_name=True, validate_by_alias=True, extra="allow"
     )
 
 
 class AgentSettings(BaseModel):
-    """Settings for agent configuration."""
+    """Settings for agent."""
 
     engine: str = Field(..., description="Engine type, e.g., 'basic-v1'")
-    model: str = Field(..., description="LLM model identifier")
+    model: str = Field(..., description="LLM model")
     max_tokens: int = Field(
-        ..., alias="maxTokens", description="Maximum number of tokens"
+        ..., alias="maxTokens", description="Maximum number of tokens per completion"
     )
     temperature: float = Field(..., description="Temperature for response generation")
 
@@ -370,17 +499,60 @@ class AgentSettings(BaseModel):
     )
 
 
+class BaseAgentDefinition(BaseModel):
+    """Agent definition model."""
+
+    input_schema: Dict[str, Any] = Field(
+        ..., alias="inputSchema", description="JSON schema for input arguments"
+    )
+    output_schema: Dict[str, Any] = Field(
+        ..., alias="outputSchema", description="JSON schema for output arguments"
+    )
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class AgentType(str, Enum):
+    """Agent type."""
+
+    LOW_CODE = "lowCode"
+    CODED = "coded"
+
+
 class LowCodeAgentDefinition(BaseAgentDefinition):
     """Low code agent definition."""
 
     type: Literal[AgentType.LOW_CODE] = AgentType.LOW_CODE
+
+    id: str = Field(..., description="Agent id or project name")
+    name: str = Field(..., description="Agent name or project name")
+    metadata: Optional[AgentMetadata] = Field(None, description="Agent metadata")
     messages: List[AgentMessage] = Field(
         ..., description="List of system and user messages"
     )
-    features: List[Any] = Field(
-        default_factory=list, description="Currently empty feature list"
+
+    version: str = Field("1.0.0", description="Agent version")
+    resources: List[AgentResourceConfig] = Field(
+        ..., description="List of tools, context, mcp and escalation resources"
+    )
+    features: List[Any] = Field(default_factory=list, description="Agent feature list")
+    settings: AgentSettings = Field(..., description="Agent settings")
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
+    )
+
+
+class CodedAgentDefinition(BaseAgentDefinition):
+    """Coded agent definition."""
+
+    type: Literal[AgentType.CODED] = AgentType.CODED
+
+    model_config = ConfigDict(
+        validate_by_name=True, validate_by_alias=True, extra="allow"
     )
-    settings: AgentSettings = Field(..., description="Agent settings configuration")
 
 
 KnownAgentDefinition = Annotated[

uipath/agent/models/evals.py

@@ -0,0 +1,56 @@
+"""Agent Evaluation Models.
+
+These models extend the base agent models with evaluation and simulation-specific fields.
+"""
+
+from typing import List, Optional
+
+from pydantic import Field
+
+from uipath._cli._evals._models._evaluation_set import EvaluationSet
+from uipath._cli._evals._models._evaluator import Evaluator
+from uipath._cli._evals._models._mocks import ExampleCall
+from uipath.agent.models.agent import (
+    AgentEscalationChannelProperties,
+    AgentIntegrationToolProperties,
+    AgentProcessToolProperties,
+    BaseResourceProperties,
+    LowCodeAgentDefinition,
+)
+
+
+class AgentEvalResourceProperties(BaseResourceProperties):
+    """Resource properties with simulation support."""
+
+    example_calls: Optional[List[ExampleCall]] = Field(None, alias="exampleCalls")
+
+
+class AgentEvalProcessToolProperties(AgentProcessToolProperties):
+    """Process tool properties with simulation support."""
+
+    example_calls: Optional[List[ExampleCall]] = Field(None, alias="exampleCalls")
+
+
+class AgentEvalIntegrationToolProperties(AgentIntegrationToolProperties):
+    """Integration tool properties with simulation support."""
+
+    example_calls: Optional[List[ExampleCall]] = Field(None, alias="exampleCalls")
+
+
+class AgentEvalEscalationChannelProperties(AgentEscalationChannelProperties):
+    """Escalation channel properties with simulation support."""
+
+    example_calls: Optional[List[ExampleCall]] = Field(None, alias="exampleCalls")
+
+
+class AgentEvalsDefinition(LowCodeAgentDefinition):
+    """Agent definition with evaluation sets and evaluators support."""
+
+    evaluation_sets: Optional[List[EvaluationSet]] = Field(
+        None,
+        alias="evaluationSets",
+        description="List of agent evaluation sets",
+    )
+    evaluators: Optional[List[Evaluator]] = Field(
+        None, description="List of agent evaluators"
+    )