uipath 2.1.90__py3-none-any.whl → 2.1.92__py3-none-any.whl

uipath/_cli/cli_push.py

@@ -1,7 +1,7 @@
 # type: ignore
 import asyncio
 import os
-from typing import Any
+from typing import Any, Optional
 from urllib.parse import urlparse
 
 import click
@@ -32,7 +32,7 @@ def get_org_scoped_url(base_url: str) -> str:
 
 async def upload_source_files_to_project(
     project_id: str,
-    config_data: dict[Any, str],
+    settings: Optional[dict[str, Any]],
     directory: str,
     include_uv_lock: bool = True,
 ) -> None:
@@ -50,7 +50,7 @@ async def upload_source_files_to_project(
         include_uv_lock=include_uv_lock,
     )
 
-    await sw_file_handler.upload_source_files(config_data)
+    await sw_file_handler.upload_source_files(settings)
 
 
 @click.command()
@@ -99,7 +99,7 @@ def push(root: str, nolock: bool) -> None:
             asyncio.run(
                 upload_source_files_to_project(
                     os.getenv(UIPATH_PROJECT_ID),
-                    config,
+                    config.get("settings", {}),
                     root,
                     include_uv_lock=not nolock,
                 )

uipath/_cli/models/runtime_schema.py

@@ -0,0 +1,71 @@
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+COMMON_MODEL_SCHEMA = ConfigDict(
+    validate_by_name=True,
+    validate_by_alias=True,
+    use_enum_values=True,
+    arbitrary_types_allowed=True,
+    extra="allow",
+)
+
+
+class Entrypoint(BaseModel):
+    file_path: str = Field(..., alias="filePath")
+    unique_id: str = Field(..., alias="uniqueId")
+    type: str = Field(..., alias="type")
+    input: Dict[str, Any] = Field(..., alias="input")
+    output: Dict[str, Any] = Field(..., alias="output")
+
+    model_config = COMMON_MODEL_SCHEMA
+
+
+class BindingResourceValue(BaseModel):
+    default_value: str = Field(..., alias="defaultValue")
+    is_expression: bool = Field(..., alias="isExpression")
+    display_name: str = Field(..., alias="displayName")
+
+    model_config = COMMON_MODEL_SCHEMA
+
+
+# TODO: create stronger binding resource definition with discriminator based on resource enum.
+class BindingResource(BaseModel):
+    resource: str = Field(..., alias="resource")
+    key: str = Field(..., alias="key")
+    value: dict[str, BindingResourceValue] = Field(..., alias="value")
+    metadata: Any = Field(..., alias="metadata")
+
+    model_config = COMMON_MODEL_SCHEMA
+
+
+class Bindings(BaseModel):
+    version: str = Field(..., alias="version")
+    resources: List[BindingResource] = Field(..., alias="resources")
+
+    model_config = COMMON_MODEL_SCHEMA
+
+
+class RuntimeInternalArguments(BaseModel):
+    resource_overwrites: dict[str, Any] = Field(..., alias="resourceOverwrites")
+
+    model_config = COMMON_MODEL_SCHEMA
+
+
+class RuntimeArguments(BaseModel):
+    internal_arguments: Optional[RuntimeInternalArguments] = Field(
+        default=None, alias="internalArguments"
+    )
+
+    model_config = COMMON_MODEL_SCHEMA
+
+
+class RuntimeSchema(BaseModel):
+    runtime: Optional[RuntimeArguments] = Field(default=None, alias="runtime")
+    entrypoints: List[Entrypoint] = Field(..., alias="entryPoints")
+    bindings: Bindings = Field(
+        default=Bindings(version="2.0", resources=[]), alias="bindings"
+    )
+    settings: Optional[Dict[str, Any]] = Field(default=None, alias="setting")
+
+    model_config = COMMON_MODEL_SCHEMA

uipath/_events/_events.py

@@ -1,15 +1,15 @@
-import enum
 import logging
-from typing import Any, List, Optional, Union
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
 
 from opentelemetry.sdk.trace import ReadableSpan
-from pydantic import BaseModel, ConfigDict, model_validator
+from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 from uipath._cli._evals._models._evaluation_set import EvaluationItem
 from uipath.eval.models import EvalItemResult
 
 
-class EvaluationEvents(str, enum.Enum):
+class EvaluationEvents(str, Enum):
     CREATE_EVAL_SET_RUN = "create_eval_set_run"
     CREATE_EVAL_RUN = "create_eval_run"
     UPDATE_EVAL_SET_RUN = "update_eval_set_run"
@@ -67,3 +67,81 @@ ProgressEvent = Union[
     EvalRunUpdatedEvent,
     EvalSetRunUpdatedEvent,
 ]
+
+
+class EventType(str, Enum):
+    """Types of events that can be emitted during execution."""
+
+    MESSAGE_CREATED = "message_created"
+    AGENT_STATE_UPDATED = "agent_state_updated"
+    ERROR = "error"
+
+
+class BaseEvent(BaseModel):
+    """Base class for all UiPath events."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    event_type: EventType
+    metadata: Optional[Dict[str, Any]] = Field(
+        default=None, description="Additional event context"
+    )
+
+
+class MessageCreatedEvent(BaseEvent):
+    """Event emitted when a message is created or streamed.
+
+    Wraps framework-specific message objects (e.g., LangChain BaseMessage,
+    CrewAI messages, AutoGen messages, etc.) without converting them.
+
+    Attributes:
+        payload: The framework-specific message object
+        event_type: Automatically set to MESSAGE_CREATED
+        metadata: Additional context (conversation_id, exchange_id, etc.)
+
+    Example:
+        # LangChain
+        event = MessageCreatedEvent(
+            payload=AIMessage(content="Hello"),
+            metadata={"conversation_id": "123"}
+        )
+
+        # Access the message
+        message = event.payload  # BaseMessage
+        print(message.content)
+    """
+
+    payload: Any = Field(description="Framework-specific message object")
+    event_type: EventType = Field(default=EventType.MESSAGE_CREATED, frozen=True)
+
+
+class AgentStateUpdatedEvent(BaseEvent):
+    """Event emitted when agent state is updated.
+
+    Wraps framework-specific state update objects, preserving the original
+    structure and data from the framework.
+
+    Attributes:
+        payload: The framework-specific state update (e.g., LangGraph state dict)
+        node_name: Name of the node/agent that produced this update (if available)
+        event_type: Automatically set to AGENT_STATE_UPDATED
+        metadata: Additional context
+
+    Example:
+        # LangGraph
+        event = AgentStateUpdatedEvent(
+            payload={"messages": [...], "context": "..."},
+            node_name="agent_node",
+            metadata={"conversation_id": "123"}
+        )
+
+        # Access the state
+        state = event.payload  # dict
+        messages = state.get("messages", [])
+    """
+
+    payload: Dict[str, Any] = Field(description="Framework-specific state update")
+    node_name: Optional[str] = Field(
+        default=None, description="Name of the node/agent that caused this update"
+    )
+    event_type: EventType = Field(default=EventType.AGENT_STATE_UPDATED, frozen=True)

uipath/agent/_utils.py

@@ -29,7 +29,7 @@ async def get_file(
 ) -> Response:
     resolved = resolve_path(folder, path)
     assert isinstance(resolved, ProjectFile), "Path file not found."
-    return await studio_client.download_file_async(resolved.id)
+    return await studio_client.download_project_file_async(resolved)
 
 
 async def create_agent_project(solution_id: str, project_name: str) -> str:

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[