```diff
--- test_files/407-original.txt	2025-03-07 19:06:53
+++ test_files/407-modified.txt	2025-03-07 19:06:53
@@ -5,10 +5,10 @@
 import typing_extensions as te
 
 from composio.constants import LOCAL_CACHE_DIRECTORY
-from composio.exceptions import ComposioSDKError
+from composio.exceptions import EnumStringNotFound, InvalidEnum
 from composio.storage.base import LocalStorage
 
-from .base import EnumStringNotFound, SentinalObject
+from .base import ActionData, SentinalObject
 
 
 DataT = t.TypeVar("DataT", bound=LocalStorage)
@@ -24,7 +24,11 @@
     cache: t.Dict[str, "te.Self"]
     storage: t.Type[DataT]
 
-    def __new__(cls, value: t.Union[str, te.Self, t.Type[SentinalObject]]) -> "te.Self":
+    def __new__(
+        cls,
+        value: t.Union[str, te.Self, t.Type[SentinalObject]],
+        cache: bool = True,
+    ) -> "te.Self":
         """Cache the enum singleton."""
         # No caching for runtime actions
         if hasattr(value, "sentinel"):  # TODO: get rid of SentinalObject
@@ -41,14 +45,19 @@
         value = value.upper()
 
         cached_enum = cls.cache.get(value)
-        if cached_enum is not None:
+        if cache and cached_enum is not None:
             return cached_enum  # type: ignore[return-value]
 
         enum = super().__new__(cls)
-        cls.cache[value] = enum
+        if cache:
+            cls.cache[value] = enum
         return enum
 
-    def __init__(self, value: t.Union[str, te.Self, t.Type[SentinalObject]]) -> None:
+    def __init__(
+        self,
+        value: t.Union[str, te.Self, t.Type[SentinalObject]],
+        cache: bool = True,  # pylint: disable=unused-argument
+    ) -> None:
         if hasattr(self, "_data"):
             # Object was pulled from cache and is already initialized
             return
@@ -63,7 +72,8 @@
         if hasattr(value, "sentinel"):  # TODO: get rid of SentinalObject
             slug = value.enum  # type: ignore
             if not isinstance(slug, str):
-                raise ComposioSDKError(f"Invalid enum type: {slug!r}, expected str")
+                raise InvalidEnum(f"Invalid enum type: {slug!r}, expected str")
+
         else:
             slug = str(value)
 
@@ -77,6 +87,9 @@
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}.{self.slug}"
 
+    def __str__(self) -> str:
+        return self.slug
+
     def __eq__(self, other: object) -> bool:
         if isinstance(other, Enum):
             return self.slug == other.slug
@@ -94,8 +107,16 @@
         # If we try to fetch Actions.iter() with local caching disabled
         # for example, we'd get here.
         if not path.exists():
-            return
+            # pylint: disable=import-outside-toplevel
+            from composio.client import Composio
 
+            # pylint: disable=import-outside-toplevel
+            from composio.client.utils import check_cache_refresh
+
+            check_cache_refresh(Composio.get_latest())
+            if not path.exists():
+                return
+
         yield from os.listdir(path)
 
     @classmethod
@@ -116,12 +137,16 @@
             data = self.storage.load(self.storage_path)
             # HACK: if 'replaced_by' field is not present, delete this cached file
             # as it is outdated.
-            if hasattr(data, "replaced_by"):
-                self._data = data
-                return self._data
+            if isinstance(data, ActionData):
+                if hasattr(data, "replaced_by"):
+                    self._data = data  # type: ignore
+                    return self._data  # type: ignore
 
-            self.storage_path.unlink()
+                self.storage_path.unlink()
 
+            self._data = data
+            return self._data
+
         # Try to fetch from runtime
         runtime_data = self.load_from_runtime()
         if runtime_data is not None:
```
