fix: RedisStorage: MemoryRecord Enum values cause JSON serialization … (#3192)

Author: Wendong-Fan

camel/memories/blocks/chat_history_block.py

@@ -96,7 +96,10 @@ def retrieve(
                 if (
                     record_dicts
                     and record_dicts[0]['role_at_backend']
-                    in {OpenAIBackendRole.SYSTEM, OpenAIBackendRole.DEVELOPER}
+                    in {
+                        OpenAIBackendRole.SYSTEM.value,
+                        OpenAIBackendRole.DEVELOPER.value,
+                    }
                 )
                 else 0
             )

camel/memories/records.py

@@ -15,8 +15,8 @@
 # Enables postponed evaluation of annotations (for string-based type hints)
 from __future__ import annotations
 
+import inspect
 import time
-from dataclasses import asdict
 from typing import Any, ClassVar, Dict
 from uuid import UUID, uuid4
 
@@ -63,37 +63,62 @@ class MemoryRecord(BaseModel):
         "FunctionCallingMessage": FunctionCallingMessage,
     }
 
+    # Cache for constructor parameters (performance optimization)
+    _constructor_params_cache: ClassVar[Dict[str, set]] = {}
+
+    @classmethod
+    def _get_constructor_params(cls, message_cls) -> set:
+        """Get constructor parameters for a message class with caching."""
+        cls_name = message_cls.__name__
+        if cls_name not in cls._constructor_params_cache:
+            sig = inspect.signature(message_cls.__init__)
+            cls._constructor_params_cache[cls_name] = set(
+                sig.parameters.keys()
+            ) - {'self'}
+        return cls._constructor_params_cache[cls_name]
+
     @classmethod
     def from_dict(cls, record_dict: Dict[str, Any]) -> "MemoryRecord":
         r"""Reconstruct a :obj:`MemoryRecord` from the input dict.
 
         Args:
             record_dict(Dict[str, Any]): A dict generated by :meth:`to_dict`.
         """
-        from camel.types import (
-            OpenAIBackendRole,
-            RoleType,
-        )
+        from camel.types import OpenAIBackendRole, RoleType
 
         message_cls = cls._MESSAGE_TYPES[record_dict["message"]["__class__"]]
-        kwargs: Dict = record_dict["message"].copy()
-        kwargs.pop("__class__")
-
-        # Convert role_type string back to RoleType enum if it's a string
-        if "role_type" in kwargs and isinstance(kwargs["role_type"], str):
-            kwargs["role_type"] = RoleType(kwargs["role_type"])
-
-        reconstructed_message = message_cls(**kwargs)
-
-        # Convert role_at_backend string back to OpenAIBackendRole enum if
-        # it's a string
+        data = record_dict["message"].copy()
+        data.pop("__class__")
+
+        # Convert role_type string to enum
+        if "role_type" in data and isinstance(data["role_type"], str):
+            data["role_type"] = RoleType(data["role_type"])
+
+        # Get valid constructor parameters (cached)
+        valid_params = cls._get_constructor_params(message_cls)
+
+        # Separate constructor args from extra fields
+        kwargs = {k: v for k, v in data.items() if k in valid_params}
+        extra_fields = {k: v for k, v in data.items() if k not in valid_params}
+
+        # Handle meta_dict properly: merge existing meta_dict with extra fields
+        existing_meta = kwargs.get("meta_dict", {}) or {}
+        if extra_fields:
+            # Extra fields take precedence, but preserve existing meta_dict
+            # structure
+            merged_meta = {**existing_meta, **extra_fields}
+            kwargs["meta_dict"] = merged_meta
+        elif not existing_meta:
+            kwargs["meta_dict"] = None
+
+        # Convert role_at_backend
         role_at_backend = record_dict["role_at_backend"]
         if isinstance(role_at_backend, str):
             role_at_backend = OpenAIBackendRole(role_at_backend)
 
         return cls(
             uuid=UUID(record_dict["uuid"]),
-            message=reconstructed_message,
+            message=message_cls(**kwargs),
             role_at_backend=role_at_backend,
             extra_info=record_dict["extra_info"],
             timestamp=record_dict["timestamp"],
@@ -108,7 +133,7 @@ def to_dict(self) -> Dict[str, Any]:
             "uuid": str(self.uuid),
             "message": {
                 "__class__": self.message.__class__.__name__,
-                **asdict(self.message),
+                **self.message.to_dict(),
             },
             "role_at_backend": self.role_at_backend.value
             if hasattr(self.role_at_backend, "value")

camel/messages/base.py

@@ -554,7 +554,7 @@ def to_dict(self) -> Dict:
         """
         return {
             "role_name": self.role_name,
-            "role_type": self.role_type.name,
+            "role_type": self.role_type.value,
             **(self.meta_dict or {}),
             "content": self.content,
         }

test/messages/test_chat_message.py

@@ -63,7 +63,7 @@ def test_chat_message(chat_message: BaseMessage) -> None:
     dictionary = chat_message.to_dict()
     reference_dict: Dict[str, Any] = {
         "role_name": role_name,
-        "role_type": role_type.name,
+        "role_type": role_type.value,
         "content": content,
     }
     assert dictionary == reference_dict
@@ -83,7 +83,7 @@ def test_assistant_chat_message(assistant_chat_message: BaseMessage) -> None:
     dictionary = assistant_chat_message.to_dict()
     reference_dict: Dict[str, Any] = {
         "role_name": role_name,
-        "role_type": role_type.name,
+        "role_type": role_type.value,
         "content": content,
     }
     assert dictionary == reference_dict
@@ -103,7 +103,7 @@ def test_user_chat_message(user_chat_message: BaseMessage) -> None:
     dictionary = user_chat_message.to_dict()
     reference_dict: Dict[str, Any] = {
         "role_name": role_name,
-        "role_type": role_type.name,
+        "role_type": role_type.value,
         "content": content,
     }
     assert dictionary == reference_dict

test/messages/test_message_base.py

@@ -88,7 +88,7 @@ def test_extract_text_and_code_prompts():
 def test_base_message_to_dict(base_message: BaseMessage) -> None:
     expected_dict = {
         "role_name": "test_user",
-        "role_type": "USER",
+        "role_type": "user",
         "key": "value",
         "content": "test content",
     }
@@ -132,7 +132,7 @@ def test_base_message():
     dictionary = message.to_dict()
     assert dictionary == {
         "role_name": role_name,
-        "role_type": role_type.name,
+        "role_type": role_type.value,
         **(meta_dict or {}),
         "content": content,
     }