Update app.py

app.py

@@ -45,9 +45,22 @@ class SpyAgent(BasicAgent):
         super().__init__(name, model_name)
         self.filtered_history = []  # 存储已过滤的历史记录
         self.last_filtered_index = 0  # 记录上次过滤到的位置
+        self._name = name
+        self._model_name = model_name
+    def _ensure_memory_valid(self):
+        """确保memory对象有效，如果无效则尝试修复"""
+        if not hasattr(self, 'memory') or not isinstance(self.memory, object) or not hasattr(self.memory, 'append_history'):
+            logger.error("内存对象无效，尝试重新初始化")
+            super().__init__(self._name, self._model_name)
+            return False
+        return True
     def filter_new_messages(self):
         """只过滤新添加的消息，而不是整个历史记录"""
         try:
+            # 确认memory有效
+            if not self._ensure_memory_valid():
+                return "\n".join(self.filtered_history) if self.filtered_history else ""
+                
             raw_history = self.memory.load_history()
             
             # 如果没有新消息，直接返回现有的过滤历史
@@ -57,27 +70,27 @@ class SpyAgent(BasicAgent):
             # 获取新消息
             new_messages = raw_history[self.last_filtered_index:]
             
-            # 如果新消息很少，且都是带##标记的裁判消息，可以直接添加
-            if all(("##" in msg and "主持人:" in msg) for msg in new_messages):
+            # 如果新消息都是裁判消息，直接添加
+            if all(isinstance(msg, str) and "##" in msg and "主持人:" in msg for msg in new_messages):
                 self.filtered_history.extend(new_messages)
                 self.last_filtered_index = len(raw_history)
                 return "\n".join(self.filtered_history)
             
-            # 否则，使用LLM过滤新消息
+            # 使用LLM过滤新消息
             new_raw = "\n".join(new_messages)
             prompt = format_prompt(HISTORY_FILTER_PROMPT, {"raw_history": new_raw})
             filtered_new = self.llm_caller(prompt)
             
             # 更新过滤历史和索引
-            if filtered_new:
+            if filtered_new and isinstance(filtered_new, str):
                 self.filtered_history.extend(filtered_new.split("\n"))
             self.last_filtered_index = len(raw_history)
             
-            # 返回完整的过滤历史
             return "\n".join(self.filtered_history)
-        except AttributeError as e:
-            logger.error(f"Filter error: {e}, returning empty history")
-            return ""
+        except Exception as e:
+            logger.error(f"过滤消息时发生错误: {str(e)}")
+            return "\n".join(self.filtered_history) if self.filtered_history else ""
+
     def clear_filtered_history(self):
         """清空过滤历史（在新游戏开始时调用）"""
         self.filtered_history = []
@@ -97,78 +110,98 @@ class SpyAgent(BasicAgent):
         return filtered_history
 
     def perceive(self, req=AgentReq):
-        logger.info("spy perceive: {}".format(req))
-        if req.status == STATUS_START:  # 开始新的一局比赛
-            self.memory.clear()
-            # 清空过滤历史
-            self.clear_filtered_history()
-            
-            self.memory.set_variable("name", req.message)
-            self.memory.append_history(
-                '主持人: 女士们先生们，欢迎来到《谁是卧底》游戏！我们有一个由6名玩家组成的小组，在其中有一名卧底。让我们开始吧！每个人都会收到一张纸。其中5人的纸上拥有相同的单词，而卧底则会收到含义上相似的单词。我们将大多数人拿到的单词称为"公共词"，将卧底拿到的单词称为"卧底词"。一旦你拿到了你的单词，首先需要根据其他人的发言判断自己是否拿到了卧底词。如果判断自己拿到了卧底词，请猜测公共词是什么，然后描述公共词来混淆视听，避免被投票淘汰。如果判断自己拿到了公共词，请思考如何巧妙地描述它而不泄露它，不能让卧底察觉，也要给同伴暗示。每人每轮用一句话描述自己拿到的词语，每个人的描述禁止重复，话中不能出现所持词语。每轮描述完毕，所有在场的人投票选出怀疑是卧底的那个人，得票数最多的人出局。卧底出局则游戏结束，若卧底未出局，游戏继续。现在游戏开始。##')
-            
-        elif req.status == STATUS_DISTRIBUTION:  # 分配单词
-            self.memory.set_variable("word", req.word)
-            self.memory.append_history(
-                '主持人: 你好，{}，你分配到的单词是:{}##'.format(self.memory.load_variable("name"), req.word))
-        elif req.status == STATUS_ROUND:  # 发言环节
-            if req.name:
-                # 其他玩家发言
+        try :
+            logger.info("spy perceive: " + str(req))
+            #logger.info("spy perceive: {}".format(req))
+            # 确认memory有效
+            if not self._ensure_memory_valid():
+                # 重新初始化完成后继续
+                pass
+            if req.status == STATUS_START:  # 开始新的一局比赛
+                self.memory.clear()
+                # 清空过滤历史
+                self.clear_filtered_history()
+                
+                self.memory.set_variable("name", req.message)
+                self.memory.append_history(
+                    '主持人: 女士们先生们，欢迎来到《谁是卧底》游戏！我们有一个由6名玩家组成的小组，在其中有一名卧底。让我们开始吧！每个人都会收到一张纸。其中5人的纸上拥有相同的单词，而卧底则会收到含义上相似的单词。我们将大多数人拿到的单词称为"公共词"，将卧底拿到的单词称为"卧底词"。一旦你拿到了你的单词，首先需要根据其他人的发言判断自己是否拿到了卧底词。如果判断自己拿到了卧底词，请猜测公共词是什么，然后描述公共词来混淆视听，避免被投票淘汰。如果判断自己拿到了公共词，请思考如何巧妙地描述它而不泄露它，不能让卧底察觉，也要给同伴暗示。每人每轮用一句话描述自己拿到的词语，每个人的描述禁止重复，话中不能出现所持词语。每轮描述完毕，所有在场的人投票选出怀疑是卧底的那个人，得票数最多的人出局。卧底出局则游戏结束，若卧底未出局，游戏继续。现在游戏开始。##')
+                
+            elif req.status == STATUS_DISTRIBUTION:  # 分配单词
+                self.memory.set_variable("word", req.word)
+                self.memory.append_history(
+                    '主持人: 你好，{}，你分配到的单词是:{}##'.format(self.memory.load_variable("name"), req.word))
+            elif req.status == STATUS_ROUND:  # 发言环节
+                if req.name:
+                    # 其他玩家发言
+                    self.memory.append_history(req.name + ': ' + req.message)
+                else:
+                    # 主持人发言
+                    self.memory.append_history('主持人: 现在进入第{}轮。##'.format(str(req.round)))
+                    self.memory.append_history('主持人: 每个玩家描述自己分配到的单词。##')
+            elif req.status == STATUS_VOTE:  # 投票环节
                 self.memory.append_history(req.name + ': ' + req.message)
+            elif req.status == STATUS_VOTE_RESULT:  # 投票环节
+                out_player = req.name if req.name else req.message
+                if out_player:
+                    self.memory.append_history('主持人: 投票结果是：{}。##'.format(out_player))
+                else:
+                    self.memory.append_history('主持人: 无人出局。##')
+            elif req.status == STATUS_RESULT:
+                # 安全处理结果消息
+                try:
+                    result_message = str(req.message) if req.message else "游戏结束"
+                    self.memory.append_history(f'主持人: {result_message}##')
+                except Exception as inner_e:
+                    logger.error(f"处理游戏结果时出错: {str(inner_e)}")
             else:
-                # 主持人发言
-                self.memory.append_history('主持人: 现在进入第{}轮。##'.format(str(req.round)))
-                self.memory.append_history('主持人: 每个玩家描述自己分配到的单词。##')
-        elif req.status == STATUS_VOTE:  # 投票环节
-            self.memory.append_history(req.name + ': ' + req.message)
-        elif req.status == STATUS_VOTE_RESULT:  # 投票环节
-            out_player = req.name if req.name else req.message
-            if out_player:
-                self.memory.append_history('主持人: 投票结果是：{}。##'.format(out_player))
-            else:
-                self.memory.append_history('主持人: 无人出局。##')
-        elif req.status == STATUS_RESULT:
-                # 修复问题：确保message是字符串
-                result_message = str(req.message) if req.message else "游戏结束"
-                self.memory.append_history(f'主持人: {result_message}##')
-        else:
-            raise NotImplementedError
-
+                raise NotImplementedError
+        except Exception as e:
+            # 修正日志格式问题
+            logger.error("perceive错误: " + str(e))
     
     def interact(self, req=AgentReq) -> AgentResp:
-        logger.info("spy interact: {}".format(req))
-        if req.status == STATUS_ROUND:
-            # 使用增量过滤
-            filtered_history = self.filter_new_messages()
-            
-            prompt = format_prompt(DESC_PROMPT,
-                                  {"name": self.memory.load_variable("name"),
-                                   "word": self.memory.load_variable("word"),
-                                   "history": filtered_history
-                                  })
-            logger.info("prompt:" + prompt)
-            result = self.llm_caller(prompt)
-            logger.info("spy interact result: {}".format(result))
-            return AgentResp(success=True, result=result, errMsg=None)
-
-        elif req.status == STATUS_VOTE:
-            self.memory.append_history('主持人: 到了投票的时候了。每个人，请指向你认为可能是卧底的人。##')
-            choices = [name for name in req.message.split(",") if name != self.memory.load_variable("name")]  # 排除自己
-            self.memory.set_variable("choices", choices)
-            
-            # 先过滤历史记录
-            filtered_history = self.filter_new_messages()
-            prompt = format_prompt(VOTE_PROMPT, {"name": self.memory.load_variable("name"),
-                                                "word": self.memory.load_variable("word"),
-                                                "choices": choices,
-                                                "history": filtered_history
-                                                })
-            logger.info("prompt:" + prompt)
-            result = self.llm_caller(prompt)
-            logger.info("spy interact result: {}".format(result))
-            return AgentResp(success=True, result=result, errMsg=None)
-        else:
-            raise NotImplementedError
+        try :
+             # 确认memory有效
+            if not self._ensure_memory_valid():
+                return AgentResp(success=False, result="系统错误", errMsg="内存对象无效")
+                
+            logger.info("spy interact: " + str(req))
+            #logger.info("spy interact: {}".format(req))
+            if req.status == STATUS_ROUND:
+                # 使用增量过滤
+                filtered_history = self.filter_new_messages()
+                
+                prompt = format_prompt(DESC_PROMPT,
+                                    {"name": self.memory.load_variable("name"),
+                                    "word": self.memory.load_variable("word"),
+                                    "history": filtered_history
+                                    })
+                logger.info("prompt:" + prompt)
+                result = self.llm_caller(prompt)
+                logger.info("spy interact result: {}".format(result))
+                return AgentResp(success=True, result=result, errMsg=None)
+
+            elif req.status == STATUS_VOTE:
+                self.memory.append_history('主持人: 到了投票的时候了。每个人，请指向你认为可能是卧底的人。##')
+                choices = [name for name in req.message.split(",") if name != self.memory.load_variable("name")]  # 排除自己
+                self.memory.set_variable("choices", choices)
+                
+                # 先过滤历史记录
+                filtered_history = self.filter_new_messages()
+                prompt = format_prompt(VOTE_PROMPT, {"name": self.memory.load_variable("name"),
+                                                    "word": self.memory.load_variable("word"),
+                                                    "choices": choices,
+                                                    "history": filtered_history
+                                                    })
+                logger.info("prompt:" + prompt)
+                result = self.llm_caller(prompt)
+                logger.info("spy interact result: {}".format(result))
+                return AgentResp(success=True, result=result, errMsg=None)
+            else:
+                raise NotImplementedError
+        except Exception as e:
+            logger.error("interact错误: " + str(e))
+            return AgentResp(success=False, result="处理错误", errMsg=str(e))
 
     def llm_caller(self, prompt):
         client = OpenAI(