erdo 0.1.5__tar.gz → 0.1.6__tar.gz

{erdo-0.1.5 → erdo-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: erdo
-Version: 0.1.5
+Version: 0.1.6
 Summary: Python SDK for building workflow automation agents with Erdo
 Project-URL: Homepage, https://erdo.ai
 Project-URL: Documentation, https://docs.erdo.ai
@@ -32,6 +32,8 @@ Requires-Dist: isort>=5.0.0; extra == 'dev'
 Requires-Dist: mypy>=1.0.0; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
 Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: types-pyyaml>=6.0.0; extra == 'dev'
+Requires-Dist: types-requests>=2.31.0; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # Erdo Agent SDK

erdo-0.1.6/VERSION

@@ -0,0 +1 @@
+0.1.6

{erdo-0.1.5 → erdo-0.1.6}/erdo/__init__.py

@@ -16,22 +16,19 @@ from .types import *  # noqa: F403,F401
 
 __version__ = "0.1.0"
 
-# Build __all__ dynamically by combining all available types
-__all__ = []
+# Add all condition functions automatically
+from ._generated.condition import __all__ as condition_all  # noqa: E402
+
+# Add all generated types automatically
+from ._generated.types import __all__ as generated_all  # noqa: E402
 
 # Add handwritten SDK classes
-from .types import __all__ as handwritten_all
+from .types import __all__ as handwritten_all  # noqa: E402
 
+# Build __all__ dynamically by combining all available types
+__all__ = []
 __all__.extend(handwritten_all)
-
-# Add all generated types automatically
-from ._generated.types import __all__ as generated_all
-
 __all__.extend(generated_all)
-
-# Add all condition functions automatically
-from ._generated.condition import __all__ as condition_all
-
 __all__.extend(condition_all)
 
 # Add state to __all__ for explicit import

{erdo-0.1.5 → erdo-0.1.6}/erdo/_generated/actions/bot.py

@@ -42,7 +42,19 @@ class AskResult(BaseModel):
     error: Optional[str] = None  # Error message if ask failed
 
 
-class InvokeParams(BaseModel):
+class BaseActionParams(BaseModel):
+    """Base class for all action parameter classes.
+
+    Provides common fields that all actions support:
+    - name: The action type identifier
+    - step_metadata: Optional configuration for the step created from this action
+    """
+
+    name: str
+    step_metadata: Optional[Any] = None
+
+
+class InvokeParams(BaseActionParams):
     """Invoke a bot with specified parameters and return the result parameters"""
 
     name: str = "bot.invoke"  # Action type for roundtrip compatibility
@@ -66,7 +78,7 @@ class InvokeParams(BaseModel):
     )
 
 
-class AskParams(BaseModel):
+class AskParams(BaseActionParams):
     """Ask a bot a question and get a response parameters"""
 
     name: str = "bot.ask"  # Action type for roundtrip compatibility
@@ -117,6 +129,10 @@ def invoke(
     params_dict = {k: v for k, v in params_dict.items() if v is not None}
     params_dict.update(params)
 
+    # Include step_metadata in params_dict since it's a field on BaseActionParams
+    if step_metadata is not None:
+        params_dict["step_metadata"] = step_metadata
+
     # Use normal constructor for proper validation
     return InvokeParams(**params_dict)
 
@@ -151,6 +167,10 @@ def ask(
     params_dict = {k: v for k, v in params_dict.items() if v is not None}
     params_dict.update(params)
 
+    # Include step_metadata in params_dict since it's a field on BaseActionParams
+    if step_metadata is not None:
+        params_dict["step_metadata"] = step_metadata
+
     # Use normal constructor for proper validation
     return AskParams(**params_dict)
 

{erdo-0.1.5 → erdo-0.1.6}/erdo/_generated/actions/llm.py

@@ -30,7 +30,19 @@ class MessageResult(BaseModel):
     finish_reason: Optional[str] = None  # Reason the generation finished
 
 
-class MessageParams(BaseModel):
+class BaseActionParams(BaseModel):
+    """Base class for all action parameter classes.
+
+    Provides common fields that all actions support:
+    - name: The action type identifier
+    - step_metadata: Optional configuration for the step created from this action
+    """
+
+    name: str
+    step_metadata: Optional[StepMetadata] = None
+
+
+class MessageParams(BaseActionParams):
     """LLM message parameters (bot-compatible)"""
 
     name: str = "llm.message"  # Action type for roundtrip compatibility
@@ -78,6 +90,7 @@ def message(
     disable_tools: Optional[Union[bool, TemplateString]] = None,
     reasoning: Optional[Union[Dict[str, Any], TemplateString]] = None,
     step_metadata: Optional[StepMetadata] = None,
+    **params: Any,
 ) -> MessageParams:
     """Generate LLM message with bot-compatible parameters
 
@@ -100,7 +113,7 @@ def message(
     Returns:
         MessageParams: Type-safe parameter object
     """
-    params = {
+    params_dict = {
         "system_prompt": system_prompt,
         "message_history": message_history,
         "query": query,
@@ -115,10 +128,15 @@ def message(
     }
 
     # Remove None values for optional parameters
-    params = {k: v for k, v in params.items() if v is not None}
+    params_dict = {k: v for k, v in params_dict.items() if v is not None}
+    params_dict.update(params)
+
+    # Include step_metadata in params_dict since it's a field on BaseActionParams
+    if step_metadata is not None:
+        params_dict["step_metadata"] = step_metadata
 
     # Use normal constructor for proper validation
-    return MessageParams(**params)
+    return MessageParams(**params_dict)
 
 
 # Associate parameter classes with their result types

{erdo-0.1.5 → erdo-0.1.6}/erdo/_generated/internal_actions.py

@@ -14,7 +14,19 @@ from pydantic import BaseModel
 from erdo.template import TemplateString
 
 
-class CheckpointAttemptParams(BaseModel):
+class BaseActionParams(BaseModel):
+    """Base class for all action parameter classes.
+
+    Provides common fields that all actions support:
+    - name: The action type identifier
+    - step_metadata: Optional configuration for the step created from this action
+    """
+
+    name: str
+    step_metadata: Optional[Any] = None
+
+
+class CheckpointAttemptParams(BaseActionParams):
     """checkpoint_attempt parameters"""
 
     name: str = "checkpoint_attempt"  # Action type for roundtrip compatibility
@@ -22,7 +34,7 @@ class CheckpointAttemptParams(BaseModel):
     loops: Optional[Union[Any, TemplateString]] = None  # Loop data
 
 
-class RefreshResourceParams(BaseModel):
+class RefreshResourceParams(BaseActionParams):
     """refresh_resource parameters"""
 
     name: str = "refresh_resource"  # Action type for roundtrip compatibility

{erdo-0.1.5 → erdo-0.1.6}/erdo/actions/__init__.py

@@ -19,21 +19,22 @@ from .._generated.actions import utils  # noqa: F401
 from .._generated.actions import webparser  # noqa: F401
 from .._generated.actions import websearch  # noqa: F401
 
-# Import internal actions first
-from .._generated.internal_actions import *  # noqa: F403,F401
+# Import internal actions explicitly
+from .._generated.internal_actions import checkpoint_attempt  # noqa: F401
+from .._generated.internal_actions import refresh_resource  # noqa: F401
 
 # Make all services available for import
 __all__ = [
     "checkpoint_attempt",
     "refresh_resource",
-    "resource_definitions",
+    "analysis",
+    "bot",
     "webparser",
     "websearch",
-    "analysis",
     "codeexec",
     "llm",
+    "memory",
+    "resource_definitions",
     "sqlexec",
     "utils",
-    "bot",
-    "memory",
 ]

{erdo-0.1.5 → erdo-0.1.6}/erdo/config/config.py

@@ -72,7 +72,7 @@ class Config:
 
                 with open(self._config_yaml, "r") as f:
                     return yaml.safe_load(f)
-            except:
+            except Exception:
                 try:
                     # Fallback to simple parsing if yaml not available
                     with open(self._config_yaml, "r") as f:
@@ -82,7 +82,7 @@ class Config:
                                 key, value = line.strip().split(": ", 1)
                                 config[key] = value
                         return config
-                except:
+                except Exception:
                     pass
 
         # Try JSON as fallback

{erdo-0.1.5 → erdo-0.1.6}/erdo/invoke/client.py

@@ -76,7 +76,7 @@ class InvokeClient:
         }
 
         # Build invoke parameters
-        invoke_params = {
+        invoke_params: Dict[str, Any] = {
             "parameters": parameters or {},
         }
 
@@ -91,7 +91,7 @@ class InvokeClient:
             try:
                 error_details = response.text
                 error_msg = f"{error_msg}: {error_details}"
-            except:
+            except Exception:
                 pass
             raise requests.RequestException(error_msg)
 
@@ -102,8 +102,8 @@ class InvokeClient:
             return sse_client
         else:
             # Consume all events and return final result
-            events = []
-            final_result = {}
+            events: list[Dict[str, Any]] = []
+            final_result: Dict[str, Any] = {}
 
             for event in sse_client.events():
                 events.append(event)
@@ -173,7 +173,7 @@ class InvokeClient:
             try:
                 error_details = response.text
                 error_msg = f"{error_msg}: {error_details}"
-            except:
+            except Exception:
                 pass
             raise requests.RequestException(error_msg)
 
@@ -184,8 +184,8 @@ class InvokeClient:
             return sse_client
         else:
             # Consume all events and return final result
-            events = []
-            final_result = {}
+            events: list[Dict[str, Any]] = []
+            final_result: Dict[str, Any] = {}
 
             for event in sse_client.events():
                 events.append(event)

{erdo-0.1.5 → erdo-0.1.6}/erdo/invoke/invoke.py

@@ -124,21 +124,23 @@ class Invoke:
                 final_result = None
                 invocation_id = None
 
-                for event in response.events():
-                    events.append(event)
+                # Type guard: response should be SSEClient when stream=True
+                if not isinstance(response, dict):
+                    for event in response.events():
+                        events.append(event)
 
-                    if self.print_events:
-                        self._print_event(event)
+                        if self.print_events:
+                            self._print_event(event)
 
-                    # Extract invocation ID from events
-                    if "invocation_id" in event:
-                        invocation_id = event["invocation_id"]
+                        # Extract invocation ID from events
+                        if "invocation_id" in event:
+                            invocation_id = event["invocation_id"]
 
-                    # Check for final result
-                    if event.get("type") == "invocation_completed":
-                        final_result = event.get("result")
-                    elif event.get("type") == "result":
-                        final_result = event.get("data")
+                        # Check for final result
+                        if event.get("type") == "invocation_completed":
+                            final_result = event.get("result")
+                        elif event.get("type") == "result":
+                            final_result = event.get("data")
 
                 return InvokeResult(
                     success=True,
@@ -148,9 +150,13 @@ class Invoke:
                     events=events,
                 )
             else:
-                # Non-streaming response
+                # Non-streaming response - response is a dict
+                response_dict = response if isinstance(response, dict) else {}
                 return InvokeResult(
-                    success=True, bot_id=bot_key, result=response, events=[response]
+                    success=True,
+                    bot_id=bot_key,
+                    result=response_dict,
+                    events=[response_dict],
                 )
 
         except Exception as e:
@@ -170,7 +176,7 @@ class Invoke:
             content = event.get("content", "")
             print(content, end="", flush=True)
         elif event_type == "invocation_completed":
-            print(f"\n✨ Invocation completed")
+            print("\n✨ Invocation completed")
         elif event_type == "error":
             error = event.get("error", "Unknown error")
             print(f"❌ Error: {error}")

{erdo-0.1.5 → erdo-0.1.6}/erdo/sync/client.py

@@ -53,7 +53,7 @@ class SyncClient:
             try:
                 error_details = response.text
                 error_msg = f"{error_msg}: {error_details}"
-            except:
+            except Exception:
                 pass
             raise requests.RequestException(error_msg)
 
@@ -88,7 +88,7 @@ class SyncClient:
             try:
                 error_details = response.text
                 error_msg = f"{error_msg}: {error_details}"
-            except:
+            except Exception:
                 pass
             raise requests.RequestException(error_msg)
 

{erdo-0.1.5 → erdo-0.1.6}/erdo/sync/extractor.py

@@ -218,7 +218,7 @@ if __name__ == "__main__":
     secrets_json = os.environ.get('STEP_SECRETS', '{{}}')
     secrets = json.loads(secrets_json)
     context = StepContext(parameters=parameters, secrets=secrets)
-    
+
     try:
         result = {func_name}(context)
         if result:
@@ -298,7 +298,7 @@ def extract_action_result_schemas(module: Any) -> Dict:
                     action_name = name_field.default.split(".")[-1]
 
             if action_name and result_class:
-                schema = {
+                schema: Dict[str, Any] = {
                     "class_name": result_class.__name__,
                     "description": result_class.__doc__ or "",
                     "required_fields": [],
@@ -413,9 +413,12 @@ def extract_agent_from_instance(
             spec = importlib.util.spec_from_file_location(
                 "agent_module", source_file_path
             )
+            if not spec or not spec.loader:
+                raise ValueError(f"Could not load module spec from {source_file_path}")
+
             module = importlib.util.module_from_spec(spec)
             spec.loader.exec_module(module)
-        except:
+        except Exception:
             module = None
     else:
         module = None
@@ -451,6 +454,9 @@ def extract_agents_from_file(file_path: str) -> Union[Dict, List[Dict]]:
         sys.path.insert(0, file_dir)
 
     spec = importlib.util.spec_from_file_location("target_module", file_path)
+    if not spec or not spec.loader:
+        raise ValueError(f"Could not load module from {file_path}")
+
     module = importlib.util.module_from_spec(spec)
 
     with warnings.catch_warnings():

{erdo-0.1.5 → erdo-0.1.6}/erdo/sync/sync.py

@@ -137,7 +137,6 @@ class Sync:
         Returns:
             List of SyncResult objects for each agent found
         """
-        sync = cls(endpoint=endpoint, auth_token=auth_token)
         results = []
 
         directory = Path(directory_path)
@@ -151,7 +150,7 @@ class Sync:
                 )
                 if init_results:
                     return init_results
-            except:
+            except Exception:
                 pass  # Fall back to directory scan
 
         # Scan directory for agent files

{erdo-0.1.5 → erdo-0.1.6}/erdo/types.py

@@ -947,8 +947,11 @@ class Agent(BaseModel):
         Returns:
             Step: The created step with sensible defaults
         """
-        # Auto-generate key if not provided
-        if key is None:
+        # Extract step_metadata from the action if present
+        extracted_config = _extract_step_config_from_action(action)
+
+        # Auto-generate key if not provided (either via param or step_metadata)
+        if key is None and "key" not in extracted_config:
             key = f"step_{len(self.steps) + 1}"
 
         # Set sensible defaults
@@ -966,7 +969,9 @@ class Agent(BaseModel):
             "output_content_type": OutputContentType.TEXT,
         }
 
-        # Override with any provided kwargs
+        # First merge extracted_config (from step_metadata), then kwargs
+        # This allows kwargs to override step_metadata if needed
+        step_config.update(extracted_config)
         step_config.update(kwargs)
 
         step = Step(**step_config)

{erdo-0.1.5 → erdo-0.1.6}/pyproject.toml

@@ -43,6 +43,8 @@ dev = [
     "isort>=5.0.0",
     "mypy>=1.0.0",
     "flake8>=6.0.0",
+    "types-requests>=2.31.0",
+    "types-PyYAML>=6.0.0",
 ]
 
 [project.urls]

erdo-0.1.5/VERSION

@@ -1 +0,0 @@
-0.1.5

{erdo-0.1.5 → erdo-0.1.6}/erdo/_generated/condition/__init__.py

@@ -133,30 +133,34 @@ class _BaseCondition:
         return _NotCondition(self)
 
 
-class TextEquals(_BaseCondition):
-    def __init__(self, text: Any = None, value: Any = None) -> None:
-        self.text = text
-        self.value = value
+class IsErrorInfoNeeded(_BaseCondition):
+    def __init__(self) -> None:
+        pass
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
-        result: Dict[str, Any] = {}
-        result["type"] = "TextEquals"
+        return {"type": "IsErrorInfoNeeded", "leaf": {}}
 
-        # Add field values to leaf object (backend expects leaf format)
-        leaf: Dict[str, Any] = {}
-        if self.text is not None:
-            leaf["text"] = self.text
-        if self.value is not None:
-            leaf["value"] = self.value
 
-        if leaf:
-            result["leaf"] = leaf
+class IsErrorTerminated(_BaseCondition):
+    def __init__(self) -> None:
+        pass
 
-        return result
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict format expected by backend."""
+        return {"type": "IsErrorTerminated", "leaf": {}}
 
 
-class TextStartsWith(_BaseCondition):
+class IsFormattedError(_BaseCondition):
+    def __init__(self) -> None:
+        pass
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict format expected by backend."""
+        return {"type": "IsFormattedError", "leaf": {}}
+
+
+class TextEndsWith(_BaseCondition):
     def __init__(self, text: Any = None, value: Any = None) -> None:
         self.text = text
         self.value = value
@@ -164,7 +168,7 @@ class TextStartsWith(_BaseCondition):
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "TextStartsWith"
+        result["type"] = "TextEndsWith"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
@@ -179,19 +183,22 @@ class TextStartsWith(_BaseCondition):
         return result
 
 
-class NotCondition(_BaseCondition):
-    def __init__(self, condition: Any = None) -> None:
-        self.condition = condition
+class IsAny(_BaseCondition):
+    def __init__(self, key: Any = None, value: Any = None) -> None:
+        self.key = key
+        self.value = value
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "NotCondition"
+        result["type"] = "IsAny"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
-        if self.condition is not None:
-            leaf["condition"] = self.condition
+        if self.key is not None:
+            leaf["key"] = self.key
+        if self.value is not None:
+            leaf["value"] = self.value
 
         if leaf:
             result["leaf"] = leaf
@@ -199,16 +206,25 @@ class NotCondition(_BaseCondition):
         return result
 
 
-class FalseCondition(_BaseCondition):
+class IsErrorActionNotFound(_BaseCondition):
     def __init__(self) -> None:
         pass
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
-        return {"type": "FalseCondition", "leaf": {}}
+        return {"type": "IsErrorActionNotFound", "leaf": {}}
 
 
-class GreaterThan(_BaseCondition):
+class IsErrorInternalError(_BaseCondition):
+    def __init__(self) -> None:
+        pass
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict format expected by backend."""
+        return {"type": "IsErrorInternalError", "leaf": {}}
+
+
+class LessThan(_BaseCondition):
     def __init__(self, number: Any = None, value: Any = None) -> None:
         self.number = number
         self.value = value
@@ -216,7 +232,7 @@ class GreaterThan(_BaseCondition):
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "GreaterThan"
+        result["type"] = "LessThan"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
@@ -231,20 +247,20 @@ class GreaterThan(_BaseCondition):
         return result
 
 
-class IsAny(_BaseCondition):
-    def __init__(self, key: Any = None, value: Any = None) -> None:
-        self.key = key
+class EarlierThan(_BaseCondition):
+    def __init__(self, time: Any = None, value: Any = None) -> None:
+        self.time = time
         self.value = value
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "IsAny"
+        result["type"] = "EarlierThan"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
-        if self.key is not None:
-            leaf["key"] = self.key
+        if self.time is not None:
+            leaf["time"] = self.time
         if self.value is not None:
             leaf["value"] = self.value
 
@@ -254,22 +270,45 @@ class IsAny(_BaseCondition):
         return result
 
 
-class IsError(_BaseCondition):
+class FalseCondition(_BaseCondition):
     def __init__(self) -> None:
         pass
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
-        return {"type": "IsError", "leaf": {}}
+        return {"type": "FalseCondition", "leaf": {}}
 
 
-class IsErrorInternalError(_BaseCondition):
+class GreaterThan(_BaseCondition):
+    def __init__(self, number: Any = None, value: Any = None) -> None:
+        self.number = number
+        self.value = value
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict format expected by backend."""
+        result: Dict[str, Any] = {}
+        result["type"] = "GreaterThan"
+
+        # Add field values to leaf object (backend expects leaf format)
+        leaf: Dict[str, Any] = {}
+        if self.number is not None:
+            leaf["number"] = self.number
+        if self.value is not None:
+            leaf["value"] = self.value
+
+        if leaf:
+            result["leaf"] = leaf
+
+        return result
+
+
+class IsErrorTimeout(_BaseCondition):
     def __init__(self) -> None:
         pass
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
-        return {"type": "IsErrorInternalError", "leaf": {}}
+        return {"type": "IsErrorTimeout", "leaf": {}}
 
 
 class TextContains(_BaseCondition):
@@ -295,7 +334,7 @@ class TextContains(_BaseCondition):
         return result
 
 
-class TextEndsWith(_BaseCondition):
+class TextEquals(_BaseCondition):
     def __init__(self, text: Any = None, value: Any = None) -> None:
         self.text = text
         self.value = value
@@ -303,7 +342,7 @@ class TextEndsWith(_BaseCondition):
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "TextEndsWith"
+        result["type"] = "TextEquals"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
@@ -318,29 +357,20 @@ class TextEndsWith(_BaseCondition):
         return result
 
 
-class TrueCondition(_BaseCondition):
-    def __init__(self) -> None:
-        pass
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        return {"type": "TrueCondition", "leaf": {}}
-
-
-class EarlierThan(_BaseCondition):
-    def __init__(self, time: Any = None, value: Any = None) -> None:
-        self.time = time
+class TextStartsWith(_BaseCondition):
+    def __init__(self, text: Any = None, value: Any = None) -> None:
+        self.text = text
         self.value = value
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "EarlierThan"
+        result["type"] = "TextStartsWith"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
-        if self.time is not None:
-            leaf["time"] = self.time
+        if self.text is not None:
+            leaf["text"] = self.text
         if self.value is not None:
             leaf["value"] = self.value
 
@@ -350,64 +380,37 @@ class EarlierThan(_BaseCondition):
         return result
 
 
-class IsErrorActionNotFound(_BaseCondition):
-    def __init__(self) -> None:
-        pass
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        return {"type": "IsErrorActionNotFound", "leaf": {}}
-
-
-class IsErrorInfoNeeded(_BaseCondition):
-    def __init__(self) -> None:
-        pass
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        return {"type": "IsErrorInfoNeeded", "leaf": {}}
-
-
-class IsErrorTerminated(_BaseCondition):
-    def __init__(self) -> None:
-        pass
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        return {"type": "IsErrorTerminated", "leaf": {}}
-
-
-class IsErrorTimeout(_BaseCondition):
+class TrueCondition(_BaseCondition):
     def __init__(self) -> None:
         pass
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
-        return {"type": "IsErrorTimeout", "leaf": {}}
+        return {"type": "TrueCondition", "leaf": {}}
 
 
-class IsSuccess(_BaseCondition):
+class IsError(_BaseCondition):
     def __init__(self) -> None:
         pass
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
-        return {"type": "IsSuccess", "leaf": {}}
+        return {"type": "IsError", "leaf": {}}
 
 
-class OrCondition(_BaseCondition):
-    def __init__(self, conditions: Any = None) -> None:
-        self.conditions = conditions
+class IsNull(_BaseCondition):
+    def __init__(self, key: Any = None) -> None:
+        self.key = key
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "OrCondition"
+        result["type"] = "IsNull"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
-        if self.conditions is not None:
-            leaf["conditions"] = self.conditions
+        if self.key is not None:
+            leaf["key"] = self.key
 
         if leaf:
             result["leaf"] = leaf
@@ -415,28 +418,28 @@ class OrCondition(_BaseCondition):
         return result
 
 
-class IsFormattedError(_BaseCondition):
+class IsSuccess(_BaseCondition):
     def __init__(self) -> None:
         pass
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
-        return {"type": "IsFormattedError", "leaf": {}}
+        return {"type": "IsSuccess", "leaf": {}}
 
 
-class IsNull(_BaseCondition):
-    def __init__(self, key: Any = None) -> None:
-        self.key = key
+class AndCondition(_BaseCondition):
+    def __init__(self, conditions: Any = None) -> None:
+        self.conditions = conditions
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "IsNull"
+        result["type"] = "AndCondition"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
-        if self.key is not None:
-            leaf["key"] = self.key
+        if self.conditions is not None:
+            leaf["conditions"] = self.conditions
 
         if leaf:
             result["leaf"] = leaf
@@ -444,22 +447,19 @@ class IsNull(_BaseCondition):
         return result
 
 
-class LessThan(_BaseCondition):
-    def __init__(self, number: Any = None, value: Any = None) -> None:
-        self.number = number
-        self.value = value
+class OrCondition(_BaseCondition):
+    def __init__(self, conditions: Any = None) -> None:
+        self.conditions = conditions
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "LessThan"
+        result["type"] = "OrCondition"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
-        if self.number is not None:
-            leaf["number"] = self.number
-        if self.value is not None:
-            leaf["value"] = self.value
+        if self.conditions is not None:
+            leaf["conditions"] = self.conditions
 
         if leaf:
             result["leaf"] = leaf
@@ -467,19 +467,19 @@ class LessThan(_BaseCondition):
         return result
 
 
-class AndCondition(_BaseCondition):
-    def __init__(self, conditions: Any = None) -> None:
-        self.conditions = conditions
+class NotCondition(_BaseCondition):
+    def __init__(self, condition: Any = None) -> None:
+        self.condition = condition
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dict format expected by backend."""
         result: Dict[str, Any] = {}
-        result["type"] = "AndCondition"
+        result["type"] = "NotCondition"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
-        if self.conditions is not None:
-            leaf["conditions"] = self.conditions
+        if self.condition is not None:
+            leaf["condition"] = self.condition
 
         if leaf:
             result["leaf"] = leaf
@@ -492,23 +492,23 @@ __all__ = [
     "And",
     "Or",
     "Not",
+    "EarlierThan",
     "FalseCondition",
     "GreaterThan",
-    "IsAny",
-    "IsError",
-    "IsErrorInternalError",
+    "IsErrorTimeout",
     "TextContains",
-    "TextEndsWith",
+    "TextEquals",
+    "TextStartsWith",
     "TrueCondition",
-    "EarlierThan",
-    "IsErrorActionNotFound",
+    "IsError",
+    "IsNull",
+    "IsSuccess",
     "IsErrorInfoNeeded",
     "IsErrorTerminated",
-    "IsErrorTimeout",
-    "IsSuccess",
     "IsFormattedError",
-    "IsNull",
+    "TextEndsWith",
+    "IsAny",
+    "IsErrorActionNotFound",
+    "IsErrorInternalError",
     "LessThan",
-    "TextEquals",
-    "TextStartsWith",
 ]