update environment/message to BaseModel, update the ser&deser of roles/actions

metagpt/utils/serialize.py

@@ -5,9 +5,7 @@
 import copy
 import pickle
 
-from metagpt.actions.action_output import ActionOutput
-from metagpt.schema import Message
-from metagpt.actions.action import Action
+from metagpt.utils.utils import import_class
 
 
 def actionoutout_schema_to_mapping(schema: dict) -> dict:
@@ -59,7 +57,7 @@ def actionoutput_str_to_mapping(mapping: dict) -> dict:
     return new_mapping
 
 
-def serialize_general_message(message: Message) -> dict:
+def serialize_general_message(message: "Message") -> dict:
     """ serialize Message, not to save"""
     message_cp = copy.deepcopy(message)
     ic = message_cp.instruct_content
@@ -76,7 +74,7 @@ def serialize_general_message(message: Message) -> dict:
     return message_cp.dict()
 
 
-def serialize_message(message: Message):
+def serialize_message(message: "Message"):
     message_cp = copy.deepcopy(message)  # avoid `instruct_content` value update by reference
     ic = message_cp.instruct_content
     if ic:
@@ -90,29 +88,35 @@ def serialize_message(message: Message):
     return msg_ser
 
 
-def deserialize_general_message(message_dict: dict) -> Message:
+def deserialize_general_message(message_dict: dict) -> "Message":
     """ deserialize Message, not to load"""
     instruct_content = message_dict.pop("instruct_content")
     cause_by = message_dict.pop("cause_by")
 
-    message = Message(**message_dict)
+    message_cls = import_class("Message", "metagpt.schema")
+    message = message_cls(**message_dict)
     if instruct_content:
         ic = instruct_content
         mapping = actionoutput_str_to_mapping(ic["mapping"])
-        ic_obj = ActionOutput.create_model_class(class_name=ic["class"], mapping=mapping)
+
+        actionoutput_class = import_class("ActionOutput", "metagpt.actions.action_output")
+        ic_obj = actionoutput_class.create_model_class(class_name=ic["class"], mapping=mapping)
         ic_new = ic_obj(**ic["value"])
         message.instruct_content = ic_new
     if cause_by:
-        message.cause_by = Action.deser_class(cause_by)
+        action_class = import_class("Action", "metagpt.actions.action")
+        message.cause_by = action_class.deser_class(cause_by)
 
     return message
 
 
-def deserialize_message(message_ser: str) -> Message:
+def deserialize_message(message_ser: str) -> "Message":
     message = pickle.loads(message_ser)
     if message.instruct_content:
         ic = message.instruct_content
-        ic_obj = ActionOutput.create_model_class(class_name=ic["class"], mapping=ic["mapping"])
+
+        actionoutput_class = import_class("ActionOutput", "metagpt.actions.action_output")
+        ic_obj = actionoutput_class.create_model_class(class_name=ic["class"], mapping=ic["mapping"])
         ic_new = ic_obj(**ic["value"])
         message.instruct_content = ic_new
 

metagpt/utils/utils.py

@@ -6,6 +6,9 @@ from typing import Any
 import json
 from pathlib import Path
 import importlib
+import traceback
+
+from metagpt.logs import logger
 
 
 def read_json_file(json_file: str, encoding=None) -> list[Any]:
@@ -39,3 +42,43 @@ def import_class_inst(class_name: str, module_name: str, *args, **kwargs) -> obj
     a_class = import_class(class_name, module_name)
     class_inst = a_class(*args, **kwargs)
     return class_inst
+
+
+def format_trackback_info(limit: int = 2):
+    return traceback.format_exc(limit=limit)
+
+
+def serialize_decorator(func):
+    async def wrapper(self, *args, **kwargs):
+        try:
+            return await func(self, *args, **kwargs)
+        except KeyboardInterrupt as kbi:
+            logger.error(f"KeyboardInterrupt occurs, start to serialize the project, exp:\n{format_trackback_info()}")
+            self.serialize()  # Team.serialize
+        except Exception as exp:
+            logger.error(f"Exception occurs, start to serialize the project, exp:\n{format_trackback_info()}")
+            self.serialize()  # Team.serialize
+
+    return wrapper
+
+
+def role_raise_decorator(func):
+    async def wrapper(self, *args, **kwargs):
+        try:
+            return await func(self, *args, **kwargs)
+        except KeyboardInterrupt as kbi:
+            logger.error(f"KeyboardInterrupt: {kbi} occurs, start to serialize the project")
+            if self._rc.env:
+                newest_msgs = self._rc.env.memory.get(1)
+                if len(newest_msgs) > 0:
+                    self._rc.memory.delete(newest_msgs[0])
+        except Exception as exp:
+            if self._rc.env:
+                newest_msgs = self._rc.env.memory.get(1)
+                if len(newest_msgs) > 0:
+                    logger.warning("There is a exception in role's execution, in order to resume, "
+                                   "we delete the newest role communication message in the role's memory.")
+                    self._rc.memory.delete(newest_msgs[0])  # remove newest msg of the role to make it observed again
+            raise Exception(format_trackback_info(limit=None))  # raise again to make it captured outside
+
+    return wrapper