windmill-api 1.563.4__py3-none-any.whl → 1.564.0__py3-none-any.whl

windmill_api/models/ai_agent_tools_item.py

@@ -6,16 +6,8 @@ from attrs import field as _attrs_field
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
-    from ..models.ai_agent_tools_item_mock import AiAgentToolsItemMock
-    from ..models.ai_agent_tools_item_retry import AiAgentToolsItemRetry
-    from ..models.ai_agent_tools_item_skip_if import AiAgentToolsItemSkipIf
-    from ..models.ai_agent_tools_item_sleep_type_0 import AiAgentToolsItemSleepType0
-    from ..models.ai_agent_tools_item_sleep_type_1 import AiAgentToolsItemSleepType1
-    from ..models.ai_agent_tools_item_stop_after_all_iters_if import AiAgentToolsItemStopAfterAllItersIf
-    from ..models.ai_agent_tools_item_stop_after_if import AiAgentToolsItemStopAfterIf
-    from ..models.ai_agent_tools_item_suspend import AiAgentToolsItemSuspend
-    from ..models.ai_agent_tools_item_timeout_type_0 import AiAgentToolsItemTimeoutType0
-    from ..models.ai_agent_tools_item_timeout_type_1 import AiAgentToolsItemTimeoutType1
+    from ..models.ai_agent_tools_item_value_type_0 import AiAgentToolsItemValueType0
+    from ..models.ai_agent_tools_item_value_type_1 import AiAgentToolsItemValueType1
 
 
 T = TypeVar("T", bound="AiAgentToolsItem")
@@ -26,101 +18,28 @@ class AiAgentToolsItem:
     """
     Attributes:
         id (str):
-        value (Any):
-        stop_after_if (Union[Unset, AiAgentToolsItemStopAfterIf]):
-        stop_after_all_iters_if (Union[Unset, AiAgentToolsItemStopAfterAllItersIf]):
-        skip_if (Union[Unset, AiAgentToolsItemSkipIf]):
-        sleep (Union['AiAgentToolsItemSleepType0', 'AiAgentToolsItemSleepType1', Unset]):
-        cache_ttl (Union[Unset, float]):
-        timeout (Union['AiAgentToolsItemTimeoutType0', 'AiAgentToolsItemTimeoutType1', Unset]):
-        delete_after_use (Union[Unset, bool]):
+        value (Union['AiAgentToolsItemValueType0', 'AiAgentToolsItemValueType1']):
         summary (Union[Unset, str]):
-        mock (Union[Unset, AiAgentToolsItemMock]):
-        suspend (Union[Unset, AiAgentToolsItemSuspend]):
-        priority (Union[Unset, float]):
-        continue_on_error (Union[Unset, bool]):
-        retry (Union[Unset, AiAgentToolsItemRetry]):
     """
 
     id: str
-    value: Any
-    stop_after_if: Union[Unset, "AiAgentToolsItemStopAfterIf"] = UNSET
-    stop_after_all_iters_if: Union[Unset, "AiAgentToolsItemStopAfterAllItersIf"] = UNSET
-    skip_if: Union[Unset, "AiAgentToolsItemSkipIf"] = UNSET
-    sleep: Union["AiAgentToolsItemSleepType0", "AiAgentToolsItemSleepType1", Unset] = UNSET
-    cache_ttl: Union[Unset, float] = UNSET
-    timeout: Union["AiAgentToolsItemTimeoutType0", "AiAgentToolsItemTimeoutType1", Unset] = UNSET
-    delete_after_use: Union[Unset, bool] = UNSET
+    value: Union["AiAgentToolsItemValueType0", "AiAgentToolsItemValueType1"]
     summary: Union[Unset, str] = UNSET
-    mock: Union[Unset, "AiAgentToolsItemMock"] = UNSET
-    suspend: Union[Unset, "AiAgentToolsItemSuspend"] = UNSET
-    priority: Union[Unset, float] = UNSET
-    continue_on_error: Union[Unset, bool] = UNSET
-    retry: Union[Unset, "AiAgentToolsItemRetry"] = UNSET
     additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> Dict[str, Any]:
-        from ..models.ai_agent_tools_item_sleep_type_0 import AiAgentToolsItemSleepType0
-        from ..models.ai_agent_tools_item_timeout_type_0 import AiAgentToolsItemTimeoutType0
+        from ..models.ai_agent_tools_item_value_type_0 import AiAgentToolsItemValueType0
 
         id = self.id
-        value = self.value
-        stop_after_if: Union[Unset, Dict[str, Any]] = UNSET
-        if not isinstance(self.stop_after_if, Unset):
-            stop_after_if = self.stop_after_if.to_dict()
+        value: Dict[str, Any]
 
-        stop_after_all_iters_if: Union[Unset, Dict[str, Any]] = UNSET
-        if not isinstance(self.stop_after_all_iters_if, Unset):
-            stop_after_all_iters_if = self.stop_after_all_iters_if.to_dict()
-
-        skip_if: Union[Unset, Dict[str, Any]] = UNSET
-        if not isinstance(self.skip_if, Unset):
-            skip_if = self.skip_if.to_dict()
-
-        sleep: Union[Dict[str, Any], Unset]
-        if isinstance(self.sleep, Unset):
-            sleep = UNSET
-
-        elif isinstance(self.sleep, AiAgentToolsItemSleepType0):
-            sleep = UNSET
-            if not isinstance(self.sleep, Unset):
-                sleep = self.sleep.to_dict()
-
-        else:
-            sleep = UNSET
-            if not isinstance(self.sleep, Unset):
-                sleep = self.sleep.to_dict()
-
-        cache_ttl = self.cache_ttl
-        timeout: Union[Dict[str, Any], Unset]
-        if isinstance(self.timeout, Unset):
-            timeout = UNSET
-
-        elif isinstance(self.timeout, AiAgentToolsItemTimeoutType0):
-            timeout = UNSET
-            if not isinstance(self.timeout, Unset):
-                timeout = self.timeout.to_dict()
+        if isinstance(self.value, AiAgentToolsItemValueType0):
+            value = self.value.to_dict()
 
         else:
-            timeout = UNSET
-            if not isinstance(self.timeout, Unset):
-                timeout = self.timeout.to_dict()
+            value = self.value.to_dict()
 
-        delete_after_use = self.delete_after_use
         summary = self.summary
-        mock: Union[Unset, Dict[str, Any]] = UNSET
-        if not isinstance(self.mock, Unset):
-            mock = self.mock.to_dict()
-
-        suspend: Union[Unset, Dict[str, Any]] = UNSET
-        if not isinstance(self.suspend, Unset):
-            suspend = self.suspend.to_dict()
-
-        priority = self.priority
-        continue_on_error = self.continue_on_error
-        retry: Union[Unset, Dict[str, Any]] = UNSET
-        if not isinstance(self.retry, Unset):
-            retry = self.retry.to_dict()
 
         field_dict: Dict[str, Any] = {}
         field_dict.update(self.additional_properties)
@@ -130,181 +49,42 @@ class AiAgentToolsItem:
                 "value": value,
             }
         )
-        if stop_after_if is not UNSET:
-            field_dict["stop_after_if"] = stop_after_if
-        if stop_after_all_iters_if is not UNSET:
-            field_dict["stop_after_all_iters_if"] = stop_after_all_iters_if
-        if skip_if is not UNSET:
-            field_dict["skip_if"] = skip_if
-        if sleep is not UNSET:
-            field_dict["sleep"] = sleep
-        if cache_ttl is not UNSET:
-            field_dict["cache_ttl"] = cache_ttl
-        if timeout is not UNSET:
-            field_dict["timeout"] = timeout
-        if delete_after_use is not UNSET:
-            field_dict["delete_after_use"] = delete_after_use
         if summary is not UNSET:
             field_dict["summary"] = summary
-        if mock is not UNSET:
-            field_dict["mock"] = mock
-        if suspend is not UNSET:
-            field_dict["suspend"] = suspend
-        if priority is not UNSET:
-            field_dict["priority"] = priority
-        if continue_on_error is not UNSET:
-            field_dict["continue_on_error"] = continue_on_error
-        if retry is not UNSET:
-            field_dict["retry"] = retry
 
         return field_dict
 
     @classmethod
     def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
-        from ..models.ai_agent_tools_item_mock import AiAgentToolsItemMock
-        from ..models.ai_agent_tools_item_retry import AiAgentToolsItemRetry
-        from ..models.ai_agent_tools_item_skip_if import AiAgentToolsItemSkipIf
-        from ..models.ai_agent_tools_item_sleep_type_0 import AiAgentToolsItemSleepType0
-        from ..models.ai_agent_tools_item_sleep_type_1 import AiAgentToolsItemSleepType1
-        from ..models.ai_agent_tools_item_stop_after_all_iters_if import AiAgentToolsItemStopAfterAllItersIf
-        from ..models.ai_agent_tools_item_stop_after_if import AiAgentToolsItemStopAfterIf
-        from ..models.ai_agent_tools_item_suspend import AiAgentToolsItemSuspend
-        from ..models.ai_agent_tools_item_timeout_type_0 import AiAgentToolsItemTimeoutType0
-        from ..models.ai_agent_tools_item_timeout_type_1 import AiAgentToolsItemTimeoutType1
+        from ..models.ai_agent_tools_item_value_type_0 import AiAgentToolsItemValueType0
+        from ..models.ai_agent_tools_item_value_type_1 import AiAgentToolsItemValueType1
 
         d = src_dict.copy()
         id = d.pop("id")
 
-        value = d.pop("value")
-
-        _stop_after_if = d.pop("stop_after_if", UNSET)
-        stop_after_if: Union[Unset, AiAgentToolsItemStopAfterIf]
-        if isinstance(_stop_after_if, Unset):
-            stop_after_if = UNSET
-        else:
-            stop_after_if = AiAgentToolsItemStopAfterIf.from_dict(_stop_after_if)
-
-        _stop_after_all_iters_if = d.pop("stop_after_all_iters_if", UNSET)
-        stop_after_all_iters_if: Union[Unset, AiAgentToolsItemStopAfterAllItersIf]
-        if isinstance(_stop_after_all_iters_if, Unset):
-            stop_after_all_iters_if = UNSET
-        else:
-            stop_after_all_iters_if = AiAgentToolsItemStopAfterAllItersIf.from_dict(_stop_after_all_iters_if)
-
-        _skip_if = d.pop("skip_if", UNSET)
-        skip_if: Union[Unset, AiAgentToolsItemSkipIf]
-        if isinstance(_skip_if, Unset):
-            skip_if = UNSET
-        else:
-            skip_if = AiAgentToolsItemSkipIf.from_dict(_skip_if)
-
-        def _parse_sleep(data: object) -> Union["AiAgentToolsItemSleepType0", "AiAgentToolsItemSleepType1", Unset]:
-            if isinstance(data, Unset):
-                return data
+        def _parse_value(data: object) -> Union["AiAgentToolsItemValueType0", "AiAgentToolsItemValueType1"]:
             try:
                 if not isinstance(data, dict):
                     raise TypeError()
-                _sleep_type_0 = data
-                sleep_type_0: Union[Unset, AiAgentToolsItemSleepType0]
-                if isinstance(_sleep_type_0, Unset):
-                    sleep_type_0 = UNSET
-                else:
-                    sleep_type_0 = AiAgentToolsItemSleepType0.from_dict(_sleep_type_0)
+                value_type_0 = AiAgentToolsItemValueType0.from_dict(data)
 
-                return sleep_type_0
+                return value_type_0
             except:  # noqa: E722
                 pass
             if not isinstance(data, dict):
                 raise TypeError()
-            _sleep_type_1 = data
-            sleep_type_1: Union[Unset, AiAgentToolsItemSleepType1]
-            if isinstance(_sleep_type_1, Unset):
-                sleep_type_1 = UNSET
-            else:
-                sleep_type_1 = AiAgentToolsItemSleepType1.from_dict(_sleep_type_1)
-
-            return sleep_type_1
+            value_type_1 = AiAgentToolsItemValueType1.from_dict(data)
 
-        sleep = _parse_sleep(d.pop("sleep", UNSET))
+            return value_type_1
 
-        cache_ttl = d.pop("cache_ttl", UNSET)
-
-        def _parse_timeout(
-            data: object,
-        ) -> Union["AiAgentToolsItemTimeoutType0", "AiAgentToolsItemTimeoutType1", Unset]:
-            if isinstance(data, Unset):
-                return data
-            try:
-                if not isinstance(data, dict):
-                    raise TypeError()
-                _timeout_type_0 = data
-                timeout_type_0: Union[Unset, AiAgentToolsItemTimeoutType0]
-                if isinstance(_timeout_type_0, Unset):
-                    timeout_type_0 = UNSET
-                else:
-                    timeout_type_0 = AiAgentToolsItemTimeoutType0.from_dict(_timeout_type_0)
-
-                return timeout_type_0
-            except:  # noqa: E722
-                pass
-            if not isinstance(data, dict):
-                raise TypeError()
-            _timeout_type_1 = data
-            timeout_type_1: Union[Unset, AiAgentToolsItemTimeoutType1]
-            if isinstance(_timeout_type_1, Unset):
-                timeout_type_1 = UNSET
-            else:
-                timeout_type_1 = AiAgentToolsItemTimeoutType1.from_dict(_timeout_type_1)
-
-            return timeout_type_1
-
-        timeout = _parse_timeout(d.pop("timeout", UNSET))
-
-        delete_after_use = d.pop("delete_after_use", UNSET)
+        value = _parse_value(d.pop("value"))
 
         summary = d.pop("summary", UNSET)
 
-        _mock = d.pop("mock", UNSET)
-        mock: Union[Unset, AiAgentToolsItemMock]
-        if isinstance(_mock, Unset):
-            mock = UNSET
-        else:
-            mock = AiAgentToolsItemMock.from_dict(_mock)
-
-        _suspend = d.pop("suspend", UNSET)
-        suspend: Union[Unset, AiAgentToolsItemSuspend]
-        if isinstance(_suspend, Unset):
-            suspend = UNSET
-        else:
-            suspend = AiAgentToolsItemSuspend.from_dict(_suspend)
-
-        priority = d.pop("priority", UNSET)
-
-        continue_on_error = d.pop("continue_on_error", UNSET)
-
-        _retry = d.pop("retry", UNSET)
-        retry: Union[Unset, AiAgentToolsItemRetry]
-        if isinstance(_retry, Unset):
-            retry = UNSET
-        else:
-            retry = AiAgentToolsItemRetry.from_dict(_retry)
-
         ai_agent_tools_item = cls(
             id=id,
             value=value,
-            stop_after_if=stop_after_if,
-            stop_after_all_iters_if=stop_after_all_iters_if,
-            skip_if=skip_if,
-            sleep=sleep,
-            cache_ttl=cache_ttl,
-            timeout=timeout,
-            delete_after_use=delete_after_use,
             summary=summary,
-            mock=mock,
-            suspend=suspend,
-            priority=priority,
-            continue_on_error=continue_on_error,
-            retry=retry,
         )
 
         ai_agent_tools_item.additional_properties = d

windmill_api/models/ai_agent_tools_item_value_type_0.py

@@ -0,0 +1,60 @@
+from typing import Any, Dict, List, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.ai_agent_tools_item_value_type_0_tool_type import AiAgentToolsItemValueType0ToolType
+
+T = TypeVar("T", bound="AiAgentToolsItemValueType0")
+
+
+@_attrs_define
+class AiAgentToolsItemValueType0:
+    """
+    Attributes:
+        tool_type (AiAgentToolsItemValueType0ToolType):
+    """
+
+    tool_type: AiAgentToolsItemValueType0ToolType
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        tool_type = self.tool_type.value
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "tool_type": tool_type,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        tool_type = AiAgentToolsItemValueType0ToolType(d.pop("tool_type"))
+
+        ai_agent_tools_item_value_type_0 = cls(
+            tool_type=tool_type,
+        )
+
+        ai_agent_tools_item_value_type_0.additional_properties = d
+        return ai_agent_tools_item_value_type_0
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

windmill_api/models/ai_agent_tools_item_value_type_0_tool_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class AiAgentToolsItemValueType0ToolType(str, Enum):
+    FLOWMODULE = "flowmodule"
+
+    def __str__(self) -> str:
+        return str(self.value)

windmill_api/models/ai_agent_tools_item_value_type_1.py

@@ -0,0 +1,90 @@
+from typing import Any, Dict, List, Type, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.ai_agent_tools_item_value_type_1_tool_type import AiAgentToolsItemValueType1ToolType
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="AiAgentToolsItemValueType1")
+
+
+@_attrs_define
+class AiAgentToolsItemValueType1:
+    """
+    Attributes:
+        tool_type (AiAgentToolsItemValueType1ToolType):
+        resource_path (str):
+        include_tools (Union[Unset, List[str]]):
+        exclude_tools (Union[Unset, List[str]]):
+    """
+
+    tool_type: AiAgentToolsItemValueType1ToolType
+    resource_path: str
+    include_tools: Union[Unset, List[str]] = UNSET
+    exclude_tools: Union[Unset, List[str]] = UNSET
+    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        tool_type = self.tool_type.value
+
+        resource_path = self.resource_path
+        include_tools: Union[Unset, List[str]] = UNSET
+        if not isinstance(self.include_tools, Unset):
+            include_tools = self.include_tools
+
+        exclude_tools: Union[Unset, List[str]] = UNSET
+        if not isinstance(self.exclude_tools, Unset):
+            exclude_tools = self.exclude_tools
+
+        field_dict: Dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "tool_type": tool_type,
+                "resource_path": resource_path,
+            }
+        )
+        if include_tools is not UNSET:
+            field_dict["include_tools"] = include_tools
+        if exclude_tools is not UNSET:
+            field_dict["exclude_tools"] = exclude_tools
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        d = src_dict.copy()
+        tool_type = AiAgentToolsItemValueType1ToolType(d.pop("tool_type"))
+
+        resource_path = d.pop("resource_path")
+
+        include_tools = cast(List[str], d.pop("include_tools", UNSET))
+
+        exclude_tools = cast(List[str], d.pop("exclude_tools", UNSET))
+
+        ai_agent_tools_item_value_type_1 = cls(
+            tool_type=tool_type,
+            resource_path=resource_path,
+            include_tools=include_tools,
+            exclude_tools=exclude_tools,
+        )
+
+        ai_agent_tools_item_value_type_1.additional_properties = d
+        return ai_agent_tools_item_value_type_1
+
+    @property
+    def additional_keys(self) -> List[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

windmill_api/models/{ai_agent_tools_item_timeout_type_0_type.py → ai_agent_tools_item_value_type_1_tool_type.py}

@@ -1,8 +1,8 @@
 from enum import Enum
 
 
-class AiAgentToolsItemTimeoutType0Type(str, Enum):
-    STATIC = "static"
+class AiAgentToolsItemValueType1ToolType(str, Enum):
+    MCP = "mcp"
 
     def __str__(self) -> str:
         return str(self.value)

windmill_api/models/completed_job_flow_status_failure_module.py

@@ -13,6 +13,9 @@ if TYPE_CHECKING:
     from ..models.completed_job_flow_status_failure_module_agent_actions_item_type_1 import (
         CompletedJobFlowStatusFailureModuleAgentActionsItemType1,
     )
+    from ..models.completed_job_flow_status_failure_module_agent_actions_item_type_2 import (
+        CompletedJobFlowStatusFailureModuleAgentActionsItemType2,
+    )
     from ..models.completed_job_flow_status_failure_module_approvers_item import (
         CompletedJobFlowStatusFailureModuleApproversItem,
     )
@@ -48,7 +51,8 @@ class CompletedJobFlowStatusFailureModule:
         failed_retries (Union[Unset, List[str]]):
         skipped (Union[Unset, bool]):
         agent_actions (Union[Unset, List[Union['CompletedJobFlowStatusFailureModuleAgentActionsItemType0',
-            'CompletedJobFlowStatusFailureModuleAgentActionsItemType1']]]):
+            'CompletedJobFlowStatusFailureModuleAgentActionsItemType1',
+            'CompletedJobFlowStatusFailureModuleAgentActionsItemType2']]]):
         agent_actions_success (Union[Unset, List[bool]]):
         parent_module (Union[Unset, str]):
     """
@@ -73,6 +77,7 @@ class CompletedJobFlowStatusFailureModule:
             Union[
                 "CompletedJobFlowStatusFailureModuleAgentActionsItemType0",
                 "CompletedJobFlowStatusFailureModuleAgentActionsItemType1",
+                "CompletedJobFlowStatusFailureModuleAgentActionsItemType2",
             ]
         ],
     ] = UNSET
@@ -84,6 +89,9 @@ class CompletedJobFlowStatusFailureModule:
         from ..models.completed_job_flow_status_failure_module_agent_actions_item_type_0 import (
             CompletedJobFlowStatusFailureModuleAgentActionsItemType0,
         )
+        from ..models.completed_job_flow_status_failure_module_agent_actions_item_type_1 import (
+            CompletedJobFlowStatusFailureModuleAgentActionsItemType1,
+        )
 
         type = self.type.value
 
@@ -137,6 +145,9 @@ class CompletedJobFlowStatusFailureModule:
                 if isinstance(agent_actions_item_data, CompletedJobFlowStatusFailureModuleAgentActionsItemType0):
                     agent_actions_item = agent_actions_item_data.to_dict()
 
+                elif isinstance(agent_actions_item_data, CompletedJobFlowStatusFailureModuleAgentActionsItemType1):
+                    agent_actions_item = agent_actions_item_data.to_dict()
+
                 else:
                     agent_actions_item = agent_actions_item_data.to_dict()
 
@@ -198,6 +209,9 @@ class CompletedJobFlowStatusFailureModule:
         from ..models.completed_job_flow_status_failure_module_agent_actions_item_type_1 import (
             CompletedJobFlowStatusFailureModuleAgentActionsItemType1,
         )
+        from ..models.completed_job_flow_status_failure_module_agent_actions_item_type_2 import (
+            CompletedJobFlowStatusFailureModuleAgentActionsItemType2,
+        )
         from ..models.completed_job_flow_status_failure_module_approvers_item import (
             CompletedJobFlowStatusFailureModuleApproversItem,
         )
@@ -277,6 +291,7 @@ class CompletedJobFlowStatusFailureModule:
             ) -> Union[
                 "CompletedJobFlowStatusFailureModuleAgentActionsItemType0",
                 "CompletedJobFlowStatusFailureModuleAgentActionsItemType1",
+                "CompletedJobFlowStatusFailureModuleAgentActionsItemType2",
             ]:
                 try:
                     if not isinstance(data, dict):
@@ -286,11 +301,19 @@ class CompletedJobFlowStatusFailureModule:
                     return agent_actions_item_type_0
                 except:  # noqa: E722
                     pass
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    agent_actions_item_type_1 = CompletedJobFlowStatusFailureModuleAgentActionsItemType1.from_dict(data)
+
+                    return agent_actions_item_type_1
+                except:  # noqa: E722
+                    pass
                 if not isinstance(data, dict):
                     raise TypeError()
-                agent_actions_item_type_1 = CompletedJobFlowStatusFailureModuleAgentActionsItemType1.from_dict(data)
+                agent_actions_item_type_2 = CompletedJobFlowStatusFailureModuleAgentActionsItemType2.from_dict(data)
 
-                return agent_actions_item_type_1
+                return agent_actions_item_type_2
 
             agent_actions_item = _parse_agent_actions_item(agent_actions_item_data)
 

windmill_api/models/completed_job_flow_status_failure_module_agent_actions_item_type_1.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Type, TypeVar
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -6,6 +6,13 @@ from attrs import field as _attrs_field
 from ..models.completed_job_flow_status_failure_module_agent_actions_item_type_1_type import (
     CompletedJobFlowStatusFailureModuleAgentActionsItemType1Type,
 )
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.completed_job_flow_status_failure_module_agent_actions_item_type_1_arguments import (
+        CompletedJobFlowStatusFailureModuleAgentActionsItemType1Arguments,
+    )
+
 
 T = TypeVar("T", bound="CompletedJobFlowStatusFailureModuleAgentActionsItemType1")
 
@@ -14,32 +21,73 @@ T = TypeVar("T", bound="CompletedJobFlowStatusFailureModuleAgentActionsItemType1
 class CompletedJobFlowStatusFailureModuleAgentActionsItemType1:
     """
     Attributes:
+        call_id (str):
+        function_name (str):
+        resource_path (str):
         type (CompletedJobFlowStatusFailureModuleAgentActionsItemType1Type):
+        arguments (Union[Unset, CompletedJobFlowStatusFailureModuleAgentActionsItemType1Arguments]):
     """
 
+    call_id: str
+    function_name: str
+    resource_path: str
     type: CompletedJobFlowStatusFailureModuleAgentActionsItemType1Type
+    arguments: Union[Unset, "CompletedJobFlowStatusFailureModuleAgentActionsItemType1Arguments"] = UNSET
     additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> Dict[str, Any]:
+        call_id = self.call_id
+        function_name = self.function_name
+        resource_path = self.resource_path
         type = self.type.value
 
+        arguments: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.arguments, Unset):
+            arguments = self.arguments.to_dict()
+
         field_dict: Dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
             {
+                "call_id": call_id,
+                "function_name": function_name,
+                "resource_path": resource_path,
                 "type": type,
             }
         )
+        if arguments is not UNSET:
+            field_dict["arguments"] = arguments
 
         return field_dict
 
     @classmethod
     def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
+        from ..models.completed_job_flow_status_failure_module_agent_actions_item_type_1_arguments import (
+            CompletedJobFlowStatusFailureModuleAgentActionsItemType1Arguments,
+        )
+
         d = src_dict.copy()
+        call_id = d.pop("call_id")
+
+        function_name = d.pop("function_name")
+
+        resource_path = d.pop("resource_path")
+
         type = CompletedJobFlowStatusFailureModuleAgentActionsItemType1Type(d.pop("type"))
 
+        _arguments = d.pop("arguments", UNSET)
+        arguments: Union[Unset, CompletedJobFlowStatusFailureModuleAgentActionsItemType1Arguments]
+        if isinstance(_arguments, Unset):
+            arguments = UNSET
+        else:
+            arguments = CompletedJobFlowStatusFailureModuleAgentActionsItemType1Arguments.from_dict(_arguments)
+
         completed_job_flow_status_failure_module_agent_actions_item_type_1 = cls(
+            call_id=call_id,
+            function_name=function_name,
+            resource_path=resource_path,
             type=type,
+            arguments=arguments,
         )
 
         completed_job_flow_status_failure_module_agent_actions_item_type_1.additional_properties = d