erdo 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

erdo/__init__.py

@@ -4,27 +4,21 @@
 
 # Import all condition functions from generated condition module
 from ._generated.condition import *  # noqa: F403,F401
+from ._generated.condition import __all__ as condition_all
 
 # Import all generated types automatically
 from ._generated.types import *  # noqa: F403,F401
+from ._generated.types import __all__ as generated_all
 
 # Import state object for template support
 from .state import state  # noqa: F401
 
 # Import all handwritten SDK classes automatically
 from .types import *  # noqa: F403,F401
+from .types import __all__ as handwritten_all
 
 __version__ = "0.1.0"
 
-# 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  # noqa: E402
-
 # Build __all__ dynamically by combining all available types
 __all__ = []
 __all__.extend(handwritten_all)

erdo/_generated/actions/codeexec.py

@@ -8,7 +8,7 @@ Actual execution happens in the Go backend after syncing.
 
 from typing import Any, Optional, Union
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from erdo.template import TemplateString
 
@@ -94,7 +94,9 @@ class ParseFileAsJsonResult(BaseModel):
     Result schema for codeexec.parse_file_as_json action.
     """
 
-    json: Any
+    model_config = {"populate_by_name": True}  # Allow both field names and aliases
+
+    json_data: Any = Field(alias="json")
 
 
 def execute(

erdo/_generated/condition/__init__.py

@@ -133,47 +133,72 @@ class _BaseCondition:
         return _NotCondition(self)
 
 
-class IsErrorInfoNeeded(_BaseCondition):
-    def __init__(self) -> None:
-        pass
+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."""
-        return {"type": "IsErrorInfoNeeded", "leaf": {}}
+        result: Dict[str, Any] = {}
+        result["type"] = "AndCondition"
 
+        # Add field values to leaf object (backend expects leaf format)
+        leaf: Dict[str, Any] = {}
+        if self.conditions is not None:
+            leaf["conditions"] = self.conditions
 
-class IsErrorTerminated(_BaseCondition):
-    def __init__(self) -> None:
-        pass
+        if leaf:
+            result["leaf"] = leaf
+
+        return result
+
+
+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."""
-        return {"type": "IsErrorTerminated", "leaf": {}}
+        result: Dict[str, Any] = {}
+        result["type"] = "EarlierThan"
 
+        # 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.value is not None:
+            leaf["value"] = self.value
 
-class IsFormattedError(_BaseCondition):
+        if leaf:
+            result["leaf"] = leaf
+
+        return result
+
+
+class FalseCondition(_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": "FalseCondition", "leaf": {}}
 
 
-class TextEndsWith(_BaseCondition):
-    def __init__(self, text: Any = None, value: Any = None) -> None:
-        self.text = text
+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"] = "TextEndsWith"
+        result["type"] = "GreaterThan"
 
         # 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.number is not None:
+            leaf["number"] = self.number
         if self.value is not None:
             leaf["value"] = self.value
 
@@ -206,6 +231,15 @@ class IsAny(_BaseCondition):
         return result
 
 
+class IsError(_BaseCondition):
+    def __init__(self) -> None:
+        pass
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict format expected by backend."""
+        return {"type": "IsError", "leaf": {}}
+
+
 class IsErrorActionNotFound(_BaseCondition):
     def __init__(self) -> None:
         pass
@@ -215,6 +249,15 @@ class IsErrorActionNotFound(_BaseCondition):
         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 IsErrorInternalError(_BaseCondition):
     def __init__(self) -> None:
         pass
@@ -224,45 +267,46 @@ class IsErrorInternalError(_BaseCondition):
         return {"type": "IsErrorInternalError", "leaf": {}}
 
 
-class LessThan(_BaseCondition):
-    def __init__(self, number: Any = None, value: Any = None) -> None:
-        self.number = number
-        self.value = value
+class IsErrorTerminated(_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"] = "LessThan"
+        return {"type": "IsErrorTerminated", "leaf": {}}
 
-        # 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
+class IsErrorTimeout(_BaseCondition):
+    def __init__(self) -> None:
+        pass
 
-        return result
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict format expected by backend."""
+        return {"type": "IsErrorTimeout", "leaf": {}}
 
 
-class EarlierThan(_BaseCondition):
-    def __init__(self, time: Any = None, value: Any = None) -> None:
-        self.time = time
-        self.value = value
+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 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"] = "EarlierThan"
+        result["type"] = "IsNull"
 
         # 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.value is not None:
-            leaf["value"] = self.value
+        if self.key is not None:
+            leaf["key"] = self.key
 
         if leaf:
             result["leaf"] = leaf
@@ -270,16 +314,16 @@ class EarlierThan(_BaseCondition):
         return result
 
 
-class FalseCondition(_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": "FalseCondition", "leaf": {}}
+        return {"type": "IsSuccess", "leaf": {}}
 
 
-class GreaterThan(_BaseCondition):
+class LessThan(_BaseCondition):
     def __init__(self, number: Any = None, value: Any = None) -> None:
         self.number = number
         self.value = value
@@ -287,7 +331,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] = {}
@@ -302,31 +346,19 @@ class GreaterThan(_BaseCondition):
         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": "IsErrorTimeout", "leaf": {}}
-
-
-class TextContains(_BaseCondition):
-    def __init__(self, text: Any = None, value: Any = None) -> None:
-        self.text = text
-        self.value = value
+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"] = "TextContains"
+        result["type"] = "NotCondition"
 
         # 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 self.condition is not None:
+            leaf["condition"] = self.condition
 
         if leaf:
             result["leaf"] = leaf
@@ -334,22 +366,19 @@ class TextContains(_BaseCondition):
         return result
 
 
-class TextEquals(_BaseCondition):
-    def __init__(self, text: Any = None, value: Any = None) -> None:
-        self.text = text
-        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"] = "TextEquals"
+        result["type"] = "OrCondition"
 
         # 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 self.conditions is not None:
+            leaf["conditions"] = self.conditions
 
         if leaf:
             result["leaf"] = leaf
@@ -357,7 +386,7 @@ class TextEquals(_BaseCondition):
         return result
 
 
-class TextStartsWith(_BaseCondition):
+class TextContains(_BaseCondition):
     def __init__(self, text: Any = None, value: Any = None) -> None:
         self.text = text
         self.value = value
@@ -365,7 +394,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"] = "TextContains"
 
         # Add field values to leaf object (backend expects leaf format)
         leaf: Dict[str, Any] = {}
@@ -380,37 +409,22 @@ class TextStartsWith(_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 IsError(_BaseCondition):
-    def __init__(self) -> None:
-        pass
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        return {"type": "IsError", "leaf": {}}
-
-
-class IsNull(_BaseCondition):
-    def __init__(self, key: Any = None) -> None:
-        self.key = key
+class TextEndsWith(_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"] = "IsNull"
+        result["type"] = "TextEndsWith"
 
         # 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.text is not None:
+            leaf["text"] = self.text
+        if self.value is not None:
+            leaf["value"] = self.value
 
         if leaf:
             result["leaf"] = leaf
@@ -418,28 +432,22 @@ class IsNull(_BaseCondition):
         return result
 
 
-class IsSuccess(_BaseCondition):
-    def __init__(self) -> None:
-        pass
-
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert to dict format expected by backend."""
-        return {"type": "IsSuccess", "leaf": {}}
-
-
-class AndCondition(_BaseCondition):
-    def __init__(self, conditions: Any = None) -> None:
-        self.conditions = conditions
+class TextEquals(_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"] = "AndCondition"
+        result["type"] = "TextEquals"
 
         # 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.text is not None:
+            leaf["text"] = self.text
+        if self.value is not None:
+            leaf["value"] = self.value
 
         if leaf:
             result["leaf"] = leaf
@@ -447,19 +455,22 @@ class AndCondition(_BaseCondition):
         return result
 
 
-class OrCondition(_BaseCondition):
-    def __init__(self, conditions: Any = None) -> None:
-        self.conditions = conditions
+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"] = "OrCondition"
+        result["type"] = "TextStartsWith"
 
         # 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.text is not None:
+            leaf["text"] = self.text
+        if self.value is not None:
+            leaf["value"] = self.value
 
         if leaf:
             result["leaf"] = leaf
@@ -467,48 +478,37 @@ class OrCondition(_BaseCondition):
         return result
 
 
-class NotCondition(_BaseCondition):
-    def __init__(self, condition: Any = None) -> None:
-        self.condition = condition
+class TrueCondition(_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"] = "NotCondition"
-
-        # 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 leaf:
-            result["leaf"] = leaf
-
-        return result
+        return {"type": "TrueCondition", "leaf": {}}
 
 
 # Auto-generated __all__ list for import *
 __all__ = [
     "And",
-    "Or",
     "Not",
+    "Or",
     "EarlierThan",
     "FalseCondition",
     "GreaterThan",
-    "IsErrorTimeout",
-    "TextContains",
-    "TextEquals",
-    "TextStartsWith",
-    "TrueCondition",
+    "IsAny",
     "IsError",
-    "IsNull",
-    "IsSuccess",
+    "IsErrorActionNotFound",
     "IsErrorInfoNeeded",
+    "IsErrorInternalError",
     "IsErrorTerminated",
+    "IsErrorTimeout",
     "IsFormattedError",
-    "TextEndsWith",
-    "IsAny",
-    "IsErrorActionNotFound",
-    "IsErrorInternalError",
+    "IsNull",
+    "IsSuccess",
     "LessThan",
+    "TextContains",
+    "TextEndsWith",
+    "TextEquals",
+    "TextStartsWith",
+    "TrueCondition",
 ]

erdo/_generated/types.py

@@ -2375,91 +2375,91 @@ class ExportIntegrationsResponse:
 
 # Auto-generated __all__ list for import *
 __all__ = [
-    "ParameterType",
-    "ParameterHydrationBehaviour",
-    "OutputVisibility",
-    "OutputContentType",
-    "HandlerType",
-    "ExecutionModeType",
-    "LlmModel",
-    "OutputBehaviorType",
-    "CredentialSource",
-    "SensitivityLevel",
-    "JSONSchemaType",
-    "InvocationEventType",
-    "Status",
-    "Error",
-    "DatasetType",
-    "IntegrationType",
+    "APIConditionDefinition",
+    "APIExecutionMode",
+    "APIParameterDefinition",
+    "APIParameterInterpreter",
+    "APIParameterValueSource",
+    "APIParameterValueSourceHandler",
+    "APIResultHandler",
+    "APIStep",
+    "APIStepWithHandlers",
+    "APITool",
+    "ActionDefinition",
+    "AgentDiscovery",
+    "AnalysisDetails",
     "AuthType",
-    "IntegrationStatus",
-    "SegmentSelectionType",
-    "ExpiryType",
-    "ResourceType",
-    "ResourceState",
-    "ResourceRelationshipType",
-    "ResourceAttachType",
     "Bot",
-    "ParameterDefinition",
-    "ParameterValueSource",
-    "ParameterValueSourceHandler",
-    "ParameterInterpreter",
-    "AgentDiscovery",
-    "ExecutionModeConfig",
-    "UpsertBotRequest",
+    "BotResource",
     "BotsResponse",
-    "StepsResponse",
-    "ServiceDefinition",
-    "ActionDefinition",
-    "ResultSchema",
-    "PropertySchema",
-    "IntegrationSchema",
     "CodegenDetails",
-    "AnalysisDetails",
-    "CredentialSchema",
-    "ExportActionsResponse",
     "ConditionDefinition",
-    "TempCondition",
-    "StepWithHandlers",
-    "ResultHandler",
-    "JSONSchemaProperty",
-    "JSONSchema",
-    "Tool",
-    "Message",
-    "SystemParameters",
-    "Result",
-    "APIStep",
-    "APIParameterValueSource",
-    "APIParameterValueSourceHandler",
-    "APIParameterInterpreter",
-    "APIExecutionMode",
-    "APIConditionDefinition",
-    "APITool",
-    "APIResultHandler",
-    "APIParameterDefinition",
-    "APIStepWithHandlers",
+    "CredentialSchema",
+    "CredentialSource",
     "Dataset",
-    "BotResource",
-    "UIConfigIcon",
-    "UIConfig",
-    "ErrorHandlingConfig",
-    "SegmentLevel",
-    "SegmentConfig",
-    "ResourceTypeConfig",
     "DatasetResourceDiscoveryConfig",
+    "DatasetType",
+    "Error",
+    "ErrorHandlingConfig",
+    "ExecutionModeConfig",
+    "ExecutionModeType",
     "ExpiryConfig",
-    "SegmentOption",
-    "IntegrationDefinition",
+    "ExpiryType",
+    "ExportActionsResponse",
+    "ExportIntegrationsResponse",
+    "HandlerType",
     "IntegrationConfig",
-    "PythonIntegrationInstance",
+    "IntegrationDefinition",
     "IntegrationDiscovery",
-    "UpsertIntegrationRequest",
-    "UpsertIntegrationResponse",
+    "IntegrationSchema",
+    "IntegrationStatus",
+    "IntegrationType",
+    "InvocationEventType",
+    "JSONSchema",
+    "JSONSchemaProperty",
+    "JSONSchemaType",
     "ListIntegrationsResponse",
-    "ExportIntegrationsResponse",
+    "LlmModel",
     "Memory",
-    "ResourceAnalysis",
+    "Message",
+    "OutputBehaviorType",
+    "OutputContentType",
+    "OutputVisibility",
+    "ParameterDefinition",
+    "ParameterHydrationBehaviour",
+    "ParameterInterpreter",
+    "ParameterType",
+    "ParameterValueSource",
+    "ParameterValueSourceHandler",
+    "PropertySchema",
+    "PythonIntegrationInstance",
     "Resource",
+    "ResourceAnalysis",
+    "ResourceAttachType",
+    "ResourceRelationshipType",
+    "ResourceState",
+    "ResourceType",
+    "ResourceTypeConfig",
+    "Result",
+    "ResultHandler",
+    "ResultSchema",
+    "SegmentConfig",
+    "SegmentLevel",
+    "SegmentOption",
+    "SegmentSelectionType",
+    "SensitivityLevel",
+    "ServiceDefinition",
+    "Status",
+    "StepWithHandlers",
+    "StepsResponse",
+    "SystemParameters",
+    "TempCondition",
+    "Tool",
+    "UIConfig",
+    "UIConfigIcon",
+    "UpsertBotRequest",
+    "UpsertIntegrationRequest",
+    "UpsertIntegrationResponse",
 ]
 
 

erdo/actions/__init__.py

@@ -25,16 +25,16 @@ from .._generated.internal_actions import refresh_resource  # noqa: F401
 
 # Make all services available for import
 __all__ = [
-    "checkpoint_attempt",
-    "refresh_resource",
     "analysis",
     "bot",
-    "webparser",
-    "websearch",
+    "checkpoint_attempt",
     "codeexec",
     "llm",
     "memory",
+    "refresh_resource",
     "resource_definitions",
     "sqlexec",
     "utils",
+    "webparser",
+    "websearch",
 ]

erdo/sync/extractor.py

@@ -70,6 +70,12 @@ def transform_dict_recursively(obj: Any) -> Any:
         return [transform_dict_recursively(item) for item in obj]
     elif isinstance(obj, str):
         return transform_string_value(obj)
+    elif hasattr(obj, "__class__") and hasattr(obj.__class__, "__mro__"):
+        # Handle enums by converting to their value
+        for base in obj.__class__.__mro__:
+            if "Enum" in str(base):
+                return obj.value if hasattr(obj, "value") else str(obj)
+        return obj
     else:
         return obj
 

{erdo-0.1.6.dist-info → erdo-0.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: erdo
-Version: 0.1.6
+Version: 0.1.8
 Summary: Python SDK for building workflow automation agents with Erdo
 Project-URL: Homepage, https://erdo.ai
 Project-URL: Documentation, https://docs.erdo.ai

{erdo-0.1.6.dist-info → erdo-0.1.8.dist-info}/RECORD

@@ -1,4 +1,4 @@
-erdo/__init__.py,sha256=DhDXlZHGo9UoWZtjHzHILk8kK_DfMy9bjLHpNuj16Wg,1111
+erdo/__init__.py,sha256=gg-frEZXTdpawdIdEOpSJuHDG6w7OM-Fu-QhHmcSK7Y,952
 erdo/bot_permissions.py,sha256=NZSjjGURORpq3hRqv0tA0YvkxcTZ9MQqtmzrlmof29c,8261
 erdo/cli_entry.py,sha256=jz18bWz-D09rmkEvwLTAbcK1shHUqFCpiU7U7czEltY,2057
 erdo/install_cli.py,sha256=jgRoSm-MIbLHW0Sr5m78q3htRwIh7JXo_wNmpVsiAcM,4454
@@ -13,11 +13,11 @@ erdo/_generated/internal_actions.py,sha256=dbZgHNF5RQhjyB8VAJ-4eaV2XUlqHKv99m-Dt
 erdo/_generated/parameters.py,sha256=QC-_75fQg_iFu-dvI9ce4yHP9UnFItDWe6sBfzfXaig,472
 erdo/_generated/secrets.py,sha256=F2xBkFsiYXOJnZ5Tcrc9uiaakyirHlKFkYCFxZKANtw,454
 erdo/_generated/template_functions.py,sha256=mgFqsXxL36dMNptzDaGvNEjoA76nFf4k9ZRz-J4Ozdc,1174
-erdo/_generated/types.py,sha256=XPG0hBqo1kUg75b5XI8pq8RtIuz2TkgbBp69tcKq3fM,81094
+erdo/_generated/types.py,sha256=heiWWVNnCDqO8a99emh1XTtqRHIQEHKugWUoJUKq5Og,81094
 erdo/_generated/actions/__init__.py,sha256=L5YKDEe1RikpvtkWxmTAThVLa-HxGfur3kcO-S7RB_w,1223
 erdo/_generated/actions/analysis.py,sha256=xuDxpd4NiS4bW_JAAQEhQa4Impmq_sBfSaUt3SYhf0g,5483
 erdo/_generated/actions/bot.py,sha256=5rQxG2GgU8V_sjLN6QIMTPZN5e5omURRLUppuNQegXM,6291
-erdo/_generated/actions/codeexec.py,sha256=XDbBG66ozPrav-HMHif1walqbuOMD3CA-1BUp8CkEAw,6579
+erdo/_generated/actions/codeexec.py,sha256=31cZWnFHSAsYeu_y_gLlhcoKVpSl-C701OvilKb_qo4,6698
 erdo/_generated/actions/llm.py,sha256=HvCXnnUadJnM4P3zrcQ2KIWyhqACAX4x0zw6VO6N3XI,5142
 erdo/_generated/actions/memory.py,sha256=cSzlVrR2tMobaO4VBGtRPmBv5NGpUHq36nAG3yQQFVg,16321
 erdo/_generated/actions/pdfextractor.py,sha256=UQ10OQ3K3FNKkqx18aG67Xbqd3GjB0nNh7DA6mpNs2g,3535
@@ -26,8 +26,8 @@ erdo/_generated/actions/sqlexec.py,sha256=z6SzgryI19wLhg-t_INqdG7n82lFGM4rfWvXEB
 erdo/_generated/actions/utils.py,sha256=rLvks2e3FJT5IjaV3hQygC-jijS8yBkL37QPgsyopik,16135
 erdo/_generated/actions/webparser.py,sha256=TonVmfVvnUPthvAT2rC_l8hvO25rCPhtYVR36pNPNQI,4184
 erdo/_generated/actions/websearch.py,sha256=KGKeJwZDBUXg-fPkq8oe7vw1zsspSNJ_Ei-BhSLi3zg,2715
-erdo/_generated/condition/__init__.py,sha256=ONWEhJu6CxQM2RTpsGq5w-5i4mzwujZoR1ErAqn7NBo,14808
-erdo/actions/__init__.py,sha256=9vn7-8u9xifdlExyeu4Rc0DAH_J6grhZc6AZNrW-IYs,1311
+erdo/_generated/condition/__init__.py,sha256=tWS9LUWbMy8Q4yYG2ZHJuQibNbmACAEupe1f9PPQ11c,14808
+erdo/actions/__init__.py,sha256=kb9vGSmhSGwxKNGacUCquu6z3d8u972uIw9x13aCrp0,1311
 erdo/conditions/__init__.py,sha256=xN7MS1aj4lh65CrE-94yFQXnQV8v8VjdEXMzPLTK0CU,394
 erdo/config/__init__.py,sha256=qUkApXToTQC88f5n6FDIuAfDM6na7ydOiKT1M5enbNo,121
 erdo/config/config.py,sha256=BSerQVQdbbp1KuARpIuKp6bM1M4Cqr-Bsf0nQJJTND8,4279
@@ -36,10 +36,10 @@ erdo/invoke/client.py,sha256=h88WB5OQukt9KKQzGavmp_-A9o5R4ZvA49TffG1Xa2w,7582
 erdo/invoke/invoke.py,sha256=yMD65tQiBzrYw_Z_lKdxW2C0lyut9N4n_OmKDp0c6k8,8166
 erdo/sync/__init__.py,sha256=f-7-9cYngOiLrTDAng3JxMC86JIE6jFk6-Vjz_dMybs,311
 erdo/sync/client.py,sha256=LrcyrsapuyrqmuPh-UwbocL7WUhHZ9zkDItXzon_AUs,3022
-erdo/sync/extractor.py,sha256=rhZlGLYAUvc04Liso05GjODC_lXbKw0nmx2o-z2cHXc,16921
+erdo/sync/extractor.py,sha256=iAIlRJqHr4e69XYnir2mZ6F6cUjnXp0P_EKsG1jdDLc,17217
 erdo/sync/sync.py,sha256=KzuChW5ramY8rX6QM3emRda928A09CQzFLmLJ5PLztg,10421
-erdo-0.1.6.dist-info/METADATA,sha256=WXb7ngMPEOV5mexjyPw9Wgr4YJzULDEFe_aMHGhu7yk,9127
-erdo-0.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-erdo-0.1.6.dist-info/entry_points.txt,sha256=KFGSp8-6IE3-8dSr-3Djqye3IdEY65Y4E8fABoFUCHg,45
-erdo-0.1.6.dist-info/licenses/LICENSE,sha256=9pdgUAuBAumY5tewMdJnx2Ozj8dS6gGKsSiY-SVInu4,1034
-erdo-0.1.6.dist-info/RECORD,,
+erdo-0.1.8.dist-info/METADATA,sha256=2gBPUH8bkBcY_RB9ohlnPWAdRqIr7WgSMyHsxgy0KJE,9127
+erdo-0.1.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+erdo-0.1.8.dist-info/entry_points.txt,sha256=KFGSp8-6IE3-8dSr-3Djqye3IdEY65Y4E8fABoFUCHg,45
+erdo-0.1.8.dist-info/licenses/LICENSE,sha256=9pdgUAuBAumY5tewMdJnx2Ozj8dS6gGKsSiY-SVInu4,1034
+erdo-0.1.8.dist-info/RECORD,,