Merge branch 'dev' of https://github.com/MaiM-with-u/MaiBot into dev

src/chat/focus_chat/expressors/default_expressor.py

@@ -17,7 +17,7 @@ from src.manager.mood_manager import mood_manager
 from src.chat.heart_flow.utils_chat import get_chat_type_and_target_info
 from src.chat.message_receive.chat_stream import ChatStream
 from src.chat.focus_chat.hfc_utils import parse_thinking_id_to_timestamp
-from src.individuality.individuality import Individuality
+from src.individuality.individuality import individuality
 from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
 from src.chat.utils.chat_message_builder import build_readable_messages, get_raw_msg_before_timestamp_with_chat
 import time
@@ -281,7 +281,6 @@ class DefaultExpressor:
         in_mind_reply,
         target_message,
     ) -> str:
-        individuality = Individuality.get_instance()
         prompt_personality = individuality.get_prompt(x_person=0, level=2)
 
         # Determine if it's a group chat
@@ -294,7 +293,7 @@ class DefaultExpressor:
         message_list_before_now = get_raw_msg_before_timestamp_with_chat(
             chat_id=chat_stream.stream_id,
             timestamp=time.time(),
-            limit=global_config.chat.observation_context_size,
+            limit=global_config.focus_chat.observation_context_size,
         )
         chat_talking_prompt = await build_readable_messages(
             message_list_before_now,

src/chat/focus_chat/expressors/exprssion_learner.py

@@ -36,24 +36,6 @@ def init_prompt() -> None:
 """
     Prompt(learn_style_prompt, "learn_style_prompt")
 
-    personality_expression_prompt = """
-{personality}
-
-请从以上人设中总结出这个角色可能的语言风格
-思考回复的特殊内容和情感
-思考有没有特殊的梗，一并总结成语言风格
-总结成如下格式的规律，总结的内容要详细，但具有概括性：
-当"xxx"时，可以"xxx", xxx不超过10个字
-
-例如：
-当"表示十分惊叹"时，使用"我嘞个xxxx"
-当"表示讽刺的赞同，不想讲道理"时，使用"对对对"
-当"想说明某个观点，但懒得明说"，使用"懂的都懂"
-
-现在请你概括
-"""
-    Prompt(personality_expression_prompt, "personality_expression_prompt")
-
     learn_grammar_prompt = """
 {chat_str}
 
@@ -278,44 +260,6 @@ class ExpressionLearner:
             expressions.append((chat_id, situation, style))
         return expressions
 
-    async def extract_and_store_personality_expressions(self):
-        """
-        检查data/expression/personality目录，不存在则创建。
-        用peronality变量作为chat_str，调用LLM生成表达风格，解析后count=100，存储到expressions.json。
-        """
-        dir_path = os.path.join("data", "expression", "personality")
-        os.makedirs(dir_path, exist_ok=True)
-        file_path = os.path.join(dir_path, "expressions.json")
-
-        # 构建prompt
-        prompt = await global_prompt_manager.format_prompt(
-            "personality_expression_prompt",
-            personality=global_config.personality.expression_style,
-        )
-        # logger.info(f"个性表达方式提取prompt: {prompt}")
-
-        try:
-            response, _ = await self.express_learn_model.generate_response_async(prompt)
-        except Exception as e:
-            logger.error(f"个性表达方式提取失败: {e}")
-            return
-
-        logger.info(f"个性表达方式提取response: {response}")
-        # chat_id用personality
-        expressions = self.parse_expression_response(response, "personality")
-        # 转为dict并count=100
-        result = []
-        for _, situation, style in expressions:
-            result.append({"situation": situation, "style": style, "count": 100})
-        # 超过50条时随机删除多余的，只保留50条
-        if len(result) > 50:
-            remove_count = len(result) - 50
-            remove_indices = set(random.sample(range(len(result)), remove_count))
-            result = [item for idx, item in enumerate(result) if idx not in remove_indices]
-        with open(file_path, "w", encoding="utf-8") as f:
-            json.dump(result, f, ensure_ascii=False, indent=2)
-        logger.info(f"已写入{len(result)}条表达到{file_path}")
-
 
 init_prompt()
 

src/chat/focus_chat/heartFC_chat.py

@@ -3,7 +3,7 @@ import contextlib
 import time
 import traceback
 from collections import deque
-from typing import List, Optional, Dict, Any, Deque, Callable, Coroutine
+from typing import List, Optional, Dict, Any, Deque
 from src.chat.message_receive.chat_stream import ChatStream
 from src.chat.message_receive.chat_stream import chat_manager
 from rich.traceback import install
@@ -26,10 +26,22 @@ from src.chat.focus_chat.info_processors.self_processor import SelfProcessor
 from src.chat.focus_chat.planners.planner import ActionPlanner
 from src.chat.focus_chat.planners.action_manager import ActionManager
 from src.chat.focus_chat.working_memory.working_memory import WorkingMemory
+from src.config.config import global_config
 
 install(extra_lines=3)
 
 
+# 定义处理器映射：键是处理器名称，值是 (处理器类, 可选的配置键名)
+# 如果配置键名为 None，则该处理器默认启用且不能通过 focus_chat_processor 配置禁用
+PROCESSOR_CLASSES = {
+    "ChattingInfoProcessor": (ChattingInfoProcessor, None),
+    "MindProcessor": (MindProcessor, None),
+    "ToolProcessor": (ToolProcessor, "tool_use_processor"),
+    "WorkingMemoryProcessor": (WorkingMemoryProcessor, "working_memory_processor"),
+    "SelfProcessor": (SelfProcessor, "self_identify_processor"),
+}
+
+
 WAITING_TIME_THRESHOLD = 300  # 等待新消息时间阈值，单位秒
 
 EMOJI_SEND_PRO = 0.3  # 设置一个概率，比如 30% 才真的发
@@ -90,6 +102,21 @@ class HeartFChatting:
             observe_id=self.stream_id, working_memory=self.working_memory
         )
 
+        # 根据配置文件和默认规则确定启用的处理器
+        self.enabled_processor_names: List[str] = []
+        config_processor_settings = global_config.focus_chat_processor
+
+        for proc_name, (_proc_class, config_key) in PROCESSOR_CLASSES.items():
+            if config_key:  # 此处理器可通过配置控制
+                if getattr(config_processor_settings, config_key, True):  # 默认启用 (如果配置中未指定该键)
+                    self.enabled_processor_names.append(proc_name)
+            else:  # 此处理器不在配置映射中 (config_key is None)，默认启用
+                self.enabled_processor_names.append(proc_name)
+
+        logger.info(f"{self.log_prefix} 将启用的处理器: {self.enabled_processor_names}")
+        self.processors: List[BaseProcessor] = []
+        self._register_default_processors()
+
         self.expressor = DefaultExpressor(chat_id=self.stream_id)
         self.action_manager = ActionManager()
         self.action_planner = ActionPlanner(log_prefix=self.log_prefix, action_manager=self.action_manager)
@@ -97,9 +124,6 @@ class HeartFChatting:
         self.hfcloop_observation.set_action_manager(self.action_manager)
 
         self.all_observations = observations
-        # --- 处理器列表 ---
-        self.processors: List[BaseProcessor] = []
-        self._register_default_processors()
 
         # 初始化状态控制
         self._initialized = False
@@ -150,13 +174,40 @@ class HeartFChatting:
         return True
 
     def _register_default_processors(self):
-        """注册默认的信息处理器"""
-        self.processors.append(ChattingInfoProcessor())
-        self.processors.append(MindProcessor(subheartflow_id=self.stream_id))
-        self.processors.append(ToolProcessor(subheartflow_id=self.stream_id))
-        self.processors.append(WorkingMemoryProcessor(subheartflow_id=self.stream_id))
-        self.processors.append(SelfProcessor(subheartflow_id=self.stream_id))
-        logger.info(f"{self.log_prefix} 已注册默认处理器: {[p.__class__.__name__ for p in self.processors]}")
+        """根据 self.enabled_processor_names 注册信息处理器"""
+        self.processors = []  # 清空已有的
+
+        for name in self.enabled_processor_names:  # 'name' is "ChattingInfoProcessor", etc.
+            processor_info = PROCESSOR_CLASSES.get(name)  # processor_info is (ProcessorClass, config_key)
+            if processor_info:
+                processor_actual_class = processor_info[0]  # 获取实际的类定义
+                # 根据处理器类名判断是否需要 subheartflow_id
+                if name in ["MindProcessor", "ToolProcessor", "WorkingMemoryProcessor", "SelfProcessor"]:
+                    self.processors.append(processor_actual_class(subheartflow_id=self.stream_id))
+                elif name == "ChattingInfoProcessor":
+                    self.processors.append(processor_actual_class())
+                else:
+                    # 对于PROCESSOR_CLASSES中定义但此处未明确处理构造的处理器
+                    # (例如, 新增了一个处理器到PROCESSOR_CLASSES, 它不需要id, 也不叫ChattingInfoProcessor)
+                    try:
+                        self.processors.append(processor_actual_class())  # 尝试无参构造
+                        logger.debug(f"{self.log_prefix} 注册处理器 {name} (尝试无参构造).")
+                    except TypeError:
+                        logger.error(
+                            f"{self.log_prefix} 处理器 {name} 构造失败。它可能需要参数（如 subheartflow_id）但未在注册逻辑中明确处理。"
+                        )
+            else:
+                # 这理论上不应该发生，因为 enabled_processor_names 是从 PROCESSOR_CLASSES 的键生成的
+                logger.warning(
+                    f"{self.log_prefix} 在 PROCESSOR_CLASSES 中未找到名为 '{name}' 的处理器定义，将跳过注册。"
+                )
+
+        if self.processors:
+            logger.info(
+                f"{self.log_prefix} 已根据配置和默认规则注册处理器: {[p.__class__.__name__ for p in self.processors]}"
+            )
+        else:
+            logger.warning(f"{self.log_prefix} 没有注册任何处理器。这可能是由于配置错误或所有处理器都被禁用了。")
 
     async def start(self):
         """
@@ -260,6 +311,8 @@ class HeartFChatting:
                     + (f"\n详情: {'; '.join(timer_strings)}" if timer_strings else "")
                 )
 
+                await asyncio.sleep(global_config.focus_chat.think_interval)
+
         except asyncio.CancelledError:
             # 设置了关闭标志位后被取消是正常流程
             if not self._shutting_down:

src/chat/focus_chat/heartflow_message_revceiver.py

@@ -5,7 +5,6 @@ from ...config.config import global_config
 from ..message_receive.message import MessageRecv
 from ..message_receive.storage import MessageStorage
 from ..utils.utils import is_mentioned_bot_in_message
-from maim_message import Seg
 from src.chat.heart_flow.heartflow import heartflow
 from src.common.logger_manager import get_logger
 from ..message_receive.chat_stream import chat_manager
@@ -79,26 +78,26 @@ async def _calculate_interest(message: MessageRecv) -> Tuple[float, bool]:
     return interested_rate, is_mentioned
 
 
-def _get_message_type(message: MessageRecv) -> str:
-    """获取消息类型
+# def _get_message_type(message: MessageRecv) -> str:
+#     """获取消息类型
 
-    Args:
-        message: 消息对象
+#     Args:
+#         message: 消息对象
 
-    Returns:
-        str: 消息类型
-    """
-    if message.message_segment.type != "seglist":
-        return message.message_segment.type
+#     Returns:
+#         str: 消息类型
+#     """
+#     if message.message_segment.type != "seglist":
+#         return message.message_segment.type
 
-    if (
-        isinstance(message.message_segment.data, list)
-        and all(isinstance(x, Seg) for x in message.message_segment.data)
-        and len(message.message_segment.data) == 1
-    ):
-        return message.message_segment.data[0].type
+#     if (
+#         isinstance(message.message_segment.data, list)
+#         and all(isinstance(x, Seg) for x in message.message_segment.data)
+#         and len(message.message_segment.data) == 1
+#     ):
+#         return message.message_segment.data[0].type
 
-    return "seglist"
+#     return "seglist"
 
 
 def _check_ban_words(text: str, chat, userinfo) -> bool:
@@ -112,7 +111,7 @@ def _check_ban_words(text: str, chat, userinfo) -> bool:
     Returns:
         bool: 是否包含过滤词
     """
-    for word in global_config.chat.ban_words:
+    for word in global_config.message_receive.ban_words:
         if word in text:
             chat_name = chat.group_info.group_name if chat.group_info else "私聊"
             logger.info(f"[{chat_name}]{userinfo.user_nickname}:{text}")
@@ -132,7 +131,7 @@ def _check_ban_regex(text: str, chat, userinfo) -> bool:
     Returns:
         bool: 是否匹配过滤正则
     """
-    for pattern in global_config.chat.ban_msgs_regex:
+    for pattern in global_config.message_receive.ban_msgs_regex:
         if pattern.search(text):
             chat_name = chat.group_info.group_name if chat.group_info else "私聊"
             logger.info(f"[{chat_name}]{userinfo.user_nickname}:{text}")
@@ -141,7 +140,7 @@ def _check_ban_regex(text: str, chat, userinfo) -> bool:
     return False
 
 
-class HeartFCProcessor:
+class HeartFCMessageReceiver:
     """心流处理器，负责处理接收到的消息并计算兴趣度"""
 
     def __init__(self):

src/chat/focus_chat/heartflow_prompt_builder.py

@@ -1,20 +1,16 @@
 from src.config.config import global_config
 from src.common.logger_manager import get_logger
-from src.individuality.individuality import Individuality
+from src.individuality.individuality import individuality
 from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
 from src.chat.utils.chat_message_builder import build_readable_messages, get_raw_msg_before_timestamp_with_chat
 from src.chat.person_info.relationship_manager import relationship_manager
-from src.chat.utils.utils import get_embedding
 import time
-from typing import Union, Optional
+from typing import Optional
 from src.chat.utils.utils import get_recent_group_speaker
 from src.manager.mood_manager import mood_manager
 from src.chat.memory_system.Hippocampus import HippocampusManager
 from src.chat.knowledge.knowledge_lib import qa_manager
 import random
-import json
-import math
-from src.common.database.database_model import Knowledges
 
 
 logger = get_logger("prompt")
@@ -103,7 +99,6 @@ class PromptBuilder:
         return None
 
     async def _build_prompt_normal(self, chat_stream, message_txt: str, sender_name: str = "某人") -> str:
-        individuality = Individuality.get_instance()
         prompt_personality = individuality.get_prompt(x_person=2, level=2)
         is_group_chat = bool(chat_stream.group_info)
 
@@ -112,7 +107,7 @@ class PromptBuilder:
             who_chat_in_group = get_recent_group_speaker(
                 chat_stream.stream_id,
                 (chat_stream.user_info.platform, chat_stream.user_info.user_id) if chat_stream.user_info else None,
-                limit=global_config.chat.observation_context_size,
+                limit=global_config.focus_chat.observation_context_size,
             )
         elif chat_stream.user_info:
             who_chat_in_group.append(
@@ -161,7 +156,7 @@ class PromptBuilder:
         message_list_before_now = get_raw_msg_before_timestamp_with_chat(
             chat_id=chat_stream.stream_id,
             timestamp=time.time(),
-            limit=global_config.chat.observation_context_size,
+            limit=global_config.focus_chat.observation_context_size,
         )
         chat_talking_prompt = await build_readable_messages(
             message_list_before_now,
@@ -265,129 +260,6 @@ class PromptBuilder:
 
         return prompt
 
-    async def get_prompt_info_old(self, message: str, threshold: float):
-        start_time = time.time()
-        related_info = ""
-        logger.debug(f"获取知识库内容，元消息：{message[:30]}...，消息长度: {len(message)}")
-        # 1. 先从LLM获取主题，类似于记忆系统的做法
-        topics = []
-
-        # 如果无法提取到主题，直接使用整个消息
-        if not topics:
-            logger.info("未能提取到任何主题，使用整个消息进行查询")
-            embedding = await get_embedding(message, request_type="prompt_build")
-            if not embedding:
-                logger.error("获取消息嵌入向量失败")
-                return ""
-
-            related_info = self.get_info_from_db(embedding, limit=3, threshold=threshold)
-            logger.info(f"知识库检索完成，总耗时: {time.time() - start_time:.3f}秒")
-            return related_info
-
-        # 2. 对每个主题进行知识库查询
-        logger.info(f"开始处理{len(topics)}个主题的知识库查询")
-
-        # 优化：批量获取嵌入向量，减少API调用
-        embeddings = {}
-        topics_batch = [topic for topic in topics if len(topic) > 0]
-        if message:  # 确保消息非空
-            topics_batch.append(message)
-
-        # 批量获取嵌入向量
-        embed_start_time = time.time()
-        for text in topics_batch:
-            if not text or len(text.strip()) == 0:
-                continue
-
-            try:
-                embedding = await get_embedding(text, request_type="prompt_build")
-                if embedding:
-                    embeddings[text] = embedding
-                else:
-                    logger.warning(f"获取'{text}'的嵌入向量失败")
-            except Exception as e:
-                logger.error(f"获取'{text}'的嵌入向量时发生错误: {str(e)}")
-
-        logger.info(f"批量获取嵌入向量完成，耗时: {time.time() - embed_start_time:.3f}秒")
-
-        if not embeddings:
-            logger.error("所有嵌入向量获取失败")
-            return ""
-
-        # 3. 对每个主题进行知识库查询
-        all_results = []
-        query_start_time = time.time()
-
-        # 首先添加原始消息的查询结果
-        if message in embeddings:
-            original_results = self.get_info_from_db(embeddings[message], limit=3, threshold=threshold, return_raw=True)
-            if original_results:
-                for result in original_results:
-                    result["topic"] = "原始消息"
-                all_results.extend(original_results)
-                logger.info(f"原始消息查询到{len(original_results)}条结果")
-
-        # 然后添加每个主题的查询结果
-        for topic in topics:
-            if not topic or topic not in embeddings:
-                continue
-
-            try:
-                topic_results = self.get_info_from_db(embeddings[topic], limit=3, threshold=threshold, return_raw=True)
-                if topic_results:
-                    # 添加主题标记
-                    for result in topic_results:
-                        result["topic"] = topic
-                    all_results.extend(topic_results)
-                    logger.info(f"主题'{topic}'查询到{len(topic_results)}条结果")
-            except Exception as e:
-                logger.error(f"查询主题'{topic}'时发生错误: {str(e)}")
-
-        logger.info(f"知识库查询完成，耗时: {time.time() - query_start_time:.3f}秒，共获取{len(all_results)}条结果")
-
-        # 4. 去重和过滤
-        process_start_time = time.time()
-        unique_contents = set()
-        filtered_results = []
-        for result in all_results:
-            content = result["content"]
-            if content not in unique_contents:
-                unique_contents.add(content)
-                filtered_results.append(result)
-
-        # 5. 按相似度排序
-        filtered_results.sort(key=lambda x: x["similarity"], reverse=True)
-
-        # 6. 限制总数量（最多10条）
-        filtered_results = filtered_results[:10]
-        logger.info(
-            f"结果处理完成，耗时: {time.time() - process_start_time:.3f}秒，过滤后剩余{len(filtered_results)}条结果"
-        )
-
-        # 7. 格式化输出
-        if filtered_results:
-            format_start_time = time.time()
-            grouped_results = {}
-            for result in filtered_results:
-                topic = result["topic"]
-                if topic not in grouped_results:
-                    grouped_results[topic] = []
-                grouped_results[topic].append(result)
-
-            # 按主题组织输出
-            for topic, results in grouped_results.items():
-                related_info += f"【主题: {topic}】\n"
-                for _i, result in enumerate(results, 1):
-                    _similarity = result["similarity"]
-                    content = result["content"].strip()
-                    related_info += f"{content}\n"
-                related_info += "\n"
-
-            logger.info(f"格式化输出完成，耗时: {time.time() - format_start_time:.3f}秒")
-
-        logger.info(f"知识库检索总耗时: {time.time() - start_time:.3f}秒")
-        return related_info
-
     async def get_prompt_info(self, message: str, threshold: float):
         related_info = ""
         start_time = time.time()
@@ -407,93 +279,11 @@ class PromptBuilder:
                 logger.debug(f"获取知识库内容，相关信息：{related_info[:100]}...，信息长度: {len(related_info)}")
                 return related_info
             else:
-                logger.debug("从LPMM知识库获取知识失败，使用旧版数据库进行检索")
-                knowledge_from_old = await self.get_prompt_info_old(message, threshold=threshold)
-                related_info += knowledge_from_old
-                logger.debug(f"获取知识库内容，相关信息：{related_info[:100]}...，信息长度: {len(related_info)}")
-                return related_info
+                logger.debug("从LPMM知识库获取知识失败，可能是从未导入过知识，返回空知识...")
+                return "未检索到知识"
         except Exception as e:
             logger.error(f"获取知识库内容时发生异常: {str(e)}")
-            try:
-                knowledge_from_old = await self.get_prompt_info_old(message, threshold=threshold)
-                related_info += knowledge_from_old
-                logger.debug(
-                    f"异常后使用旧版数据库获取知识，相关信息：{related_info[:100]}...，信息长度: {len(related_info)}"
-                )
-                return related_info
-            except Exception as e2:
-                logger.error(f"使用旧版数据库获取知识时也发生异常: {str(e2)}")
-                return ""
-
-    @staticmethod
-    def get_info_from_db(
-        query_embedding: list, limit: int = 1, threshold: float = 0.5, return_raw: bool = False
-    ) -> Union[str, list]:
-        if not query_embedding:
-            return "" if not return_raw else []
-
-        results_with_similarity = []
-        try:
-            # Fetch all knowledge entries
-            # This might be inefficient for very large databases.
-            # Consider strategies like FAISS or other vector search libraries if performance becomes an issue.
-            all_knowledges = Knowledges.select()
-
-            if not all_knowledges:
-                return [] if return_raw else ""
-
-            query_embedding_magnitude = math.sqrt(sum(x * x for x in query_embedding))
-            if query_embedding_magnitude == 0:  # Avoid division by zero
-                return "" if not return_raw else []
-
-            for knowledge_item in all_knowledges:
-                try:
-                    db_embedding_str = knowledge_item.embedding
-                    db_embedding = json.loads(db_embedding_str)
-
-                    if len(db_embedding) != len(query_embedding):
-                        logger.warning(
-                            f"Embedding length mismatch for knowledge ID {knowledge_item.id if hasattr(knowledge_item, 'id') else 'N/A'}. Skipping."
-                        )
-                        continue
-
-                    # Calculate Cosine Similarity
-                    dot_product = sum(q * d for q, d in zip(query_embedding, db_embedding))
-                    db_embedding_magnitude = math.sqrt(sum(x * x for x in db_embedding))
-
-                    if db_embedding_magnitude == 0:  # Avoid division by zero
-                        similarity = 0.0
-                    else:
-                        similarity = dot_product / (query_embedding_magnitude * db_embedding_magnitude)
-
-                    if similarity >= threshold:
-                        results_with_similarity.append({"content": knowledge_item.content, "similarity": similarity})
-                except json.JSONDecodeError:
-                    logger.error(
-                        f"Failed to parse embedding for knowledge ID {knowledge_item.id if hasattr(knowledge_item, 'id') else 'N/A'}"
-                    )
-                except Exception as e:
-                    logger.error(f"Error processing knowledge item: {e}")
-
-            # Sort by similarity in descending order
-            results_with_similarity.sort(key=lambda x: x["similarity"], reverse=True)
-
-            # Limit results
-            limited_results = results_with_similarity[:limit]
-
-            logger.debug(f"知识库查询结果数量 (after Peewee processing): {len(limited_results)}")
-
-            if not limited_results:
-                return "" if not return_raw else []
-
-            if return_raw:
-                return limited_results
-            else:
-                return "\n".join(str(result["content"]) for result in limited_results)
-
-        except Exception as e:
-            logger.error(f"Error querying Knowledges with Peewee: {e}")
-            return "" if not return_raw else []
+            return "未检索到知识"
 
 
 init_prompt()

src/chat/focus_chat/info/action_info.py

@@ -80,4 +80,4 @@ class ActionInfo(InfoBase):
         Returns:
             bool: 如果有任何动作需要添加或移除则返回True
         """
-        return bool(self.get_add_actions() or self.get_remove_actions()) 
+        return bool(self.get_add_actions() or self.get_remove_actions())

src/chat/focus_chat/info_processors/action_processor.py

@@ -1,14 +1,10 @@
 from typing import List, Optional, Any
-from src.chat.focus_chat.info.obs_info import ObsInfo
 from src.chat.heart_flow.observation.observation import Observation
 from src.chat.focus_chat.info.info_base import InfoBase
 from src.chat.focus_chat.info.action_info import ActionInfo
 from .base_processor import BaseProcessor
 from src.common.logger_manager import get_logger
-from src.chat.heart_flow.observation.chatting_observation import ChattingObservation
 from src.chat.heart_flow.observation.hfcloop_observation import HFCloopObservation
-from src.chat.focus_chat.info.cycle_info import CycleInfo
-from datetime import datetime
 from typing import Dict
 from src.chat.models.utils_model import LLMRequest
 from src.config.config import global_config
@@ -55,10 +51,7 @@ class ActionProcessor(BaseProcessor):
         # 处理Observation对象
         if observations:
             for obs in observations:
-
                 if isinstance(obs, HFCloopObservation):
-
-
                     # 创建动作信息
                     action_info = ActionInfo()
                     action_changes = await self.analyze_loop_actions(obs)
@@ -75,7 +68,6 @@ class ActionProcessor(BaseProcessor):
 
         return processed_infos
 
-
     async def analyze_loop_actions(self, obs: HFCloopObservation) -> Dict[str, List[str]]:
         """分析最近的循环内容并决定动作的增减
 
@@ -87,29 +79,29 @@ class ActionProcessor(BaseProcessor):
                 }
         """
         result = {"add": [], "remove": []}
-        
+
         # 获取最近10次循环
         recent_cycles = obs.history_loop[-10:] if len(obs.history_loop) > 10 else obs.history_loop
         if not recent_cycles:
             return result
-            
+
         # 统计no_reply的数量
         no_reply_count = 0
         reply_sequence = []  # 记录最近的动作序列
-        
+
         for cycle in recent_cycles:
             action_type = cycle.loop_plan_info["action_result"]["action_type"]
             if action_type == "no_reply":
                 no_reply_count += 1
             reply_sequence.append(action_type == "reply")
-            
+
         # 检查no_reply比例
         if len(recent_cycles) >= 5 and (no_reply_count / len(recent_cycles)) >= 0.8:
             result["add"].append("exit_focus_chat")
-            
+
         # 获取最近三次的reply状态
         last_three = reply_sequence[-3:] if len(reply_sequence) >= 3 else reply_sequence
-        
+
         # 根据最近的reply情况决定是否移除reply动作
         if len(last_three) >= 3 and all(last_three):
             # 如果最近三次都是reply，直接移除
@@ -122,5 +114,5 @@ class ActionProcessor(BaseProcessor):
             # 如果最近一次是reply，20%概率移除
             if random.random() < 0.2:
                 result["remove"].append("reply")
-                
+
         return result

src/chat/focus_chat/info_processors/mind_processor.py

@@ -5,7 +5,7 @@ from src.config.config import global_config
 import time
 import traceback
 from src.common.logger_manager import get_logger
-from src.individuality.individuality import Individuality
+from src.individuality.individuality import individuality
 from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
 from src.chat.utils.json_utils import safe_json_dumps
 from src.chat.message_receive.chat_stream import chat_manager
@@ -194,7 +194,6 @@ class MindProcessor(BaseProcessor):
 
         # ---------- 3. 准备个性化数据 ----------
         # 获取个性化信息
-        individuality = Individuality.get_instance()
 
         relation_prompt = ""
         for person in person_list:

src/chat/focus_chat/info_processors/self_processor.py

@@ -5,7 +5,7 @@ from src.config.config import global_config
 import time
 import traceback
 from src.common.logger_manager import get_logger
-from src.individuality.individuality import Individuality
+from src.individuality.individuality import individuality
 from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
 from src.chat.message_receive.chat_stream import chat_manager
 from src.chat.person_info.relationship_manager import relationship_manager
@@ -21,8 +21,9 @@ logger = get_logger("processor")
 
 def init_prompt():
     indentify_prompt = """
-你的名字是{bot_name},你是一个AI，但是你伪装成了一个人类，你的人格是，{prompt_personality}。
-你的头像形象是一只橙色的鱼，头上有绿色的树叶。
+{name_block}
+你是一个AI，但是你伪装成了一个人类，你的人格是，{prompt_personality}。
+{indentify_block}
 
 {relation_prompt}
 {memory_str}
@@ -36,8 +37,8 @@ def init_prompt():
 3. 你的自我认同是否有助于你的回答，如果你需要自我相关的信息来帮你参与聊天，请输出，否则请输出十个字以内的简短自我认同
 4. 一般情况下不用输出自我认同，只需要输出十几个字的简短自我认同就好，除非有明显需要自我认同的场景
 
-请回复的平淡一些，简短一些，说中文，不要浮夸，平淡一些。
-请注意不要输出多余内容(包括前后缀，冒号和引号，括号()，表情包，at或 @等 )。只输出内容。
+请思考的平淡一些，简短一些，说中文，不要浮夸，平淡一些。
+请注意不要输出多余内容(包括前后缀，冒号和引号，括号()，表情包，at或 @等 )。只输出自我认同内容。
 
 """
     Prompt(indentify_prompt, "indentify_prompt")
@@ -125,16 +126,22 @@ class SelfProcessor(BaseProcessor):
                 # hfcloop_observe_info = observation.get_observe_info()
                 pass
 
-        individuality = Individuality.get_instance()
-        personality_block = individuality.get_prompt(x_person=2, level=2)
+        nickname_str = ""
+        for nicknames in global_config.bot.alias_names:
+            nickname_str += f"{nicknames},"
+        name_block = f"你的名字是{global_config.bot.nickname},你的昵称有{nickname_str}，有人也会用这些昵称称呼你。"
+
+        personality_block = individuality.get_personality_prompt(x_person=2, level=2)
+        identity_block = individuality.get_identity_prompt(x_person=2, level=2)
 
         relation_prompt = ""
         for person in person_list:
             relation_prompt += await relationship_manager.build_relationship_info(person, is_id=True)
 
         prompt = (await global_prompt_manager.get_prompt_async("indentify_prompt")).format(
-            bot_name=individuality.name,
+            name_block=name_block,
             prompt_personality=personality_block,
+            indentify_block=identity_block,
             memory_str=memory_str,
             relation_prompt=relation_prompt,
             time_now=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),

src/chat/focus_chat/info_processors/tool_processor.py

@@ -3,7 +3,7 @@ from src.chat.models.utils_model import LLMRequest
 from src.config.config import global_config
 import time
 from src.common.logger_manager import get_logger
-from src.individuality.individuality import Individuality
+from src.individuality.individuality import individuality
 from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
 from src.tools.tool_use import ToolUser
 from src.chat.utils.json_utils import process_llm_tool_calls
@@ -133,7 +133,7 @@ class ToolProcessor(BaseProcessor):
             relation_prompt += await relationship_manager.build_relationship_info(person, is_id=True)
 
         # 获取个性信息
-        individuality = Individuality.get_instance()
+
         # prompt_personality = individuality.get_prompt(x_person=2, level=2)
 
         # 获取时间信息

src/chat/focus_chat/planners/action_manager.py

@@ -1,9 +1,8 @@
-from typing import Dict, List, Optional, Callable, Coroutine, Type, Any
+from typing import Dict, List, Optional, Type, Any
 from src.chat.focus_chat.planners.actions.base_action import BaseAction, _ACTION_REGISTRY
 from src.chat.heart_flow.observation.observation import Observation
 from src.chat.focus_chat.expressors.default_expressor import DefaultExpressor
 from src.chat.message_receive.chat_stream import ChatStream
-from src.chat.focus_chat.heartFC_Cycleinfo import CycleDetail
 from src.common.logger_manager import get_logger
 import importlib
 import pkgutil

src/chat/focus_chat/planners/actions/exit_focus_chat_action.py

@@ -1,12 +1,9 @@
 import asyncio
 import traceback
 from src.common.logger_manager import get_logger
-from src.chat.utils.timer_calculator import Timer
 from src.chat.focus_chat.planners.actions.base_action import BaseAction, register_action
-from typing import Tuple, List, Callable, Coroutine
+from typing import Tuple, List
 from src.chat.heart_flow.observation.observation import Observation
-from src.chat.heart_flow.observation.chatting_observation import ChattingObservation
-from src.chat.heart_flow.sub_heartflow import SubHeartFlow
 from src.chat.message_receive.chat_stream import ChatStream
 from src.chat.heart_flow.heartflow import heartflow
 from src.chat.heart_flow.sub_heartflow import ChatState
@@ -61,8 +58,6 @@ class ExitFocusChatAction(BaseAction):
         self._shutting_down = shutting_down
         self.chat_id = chat_stream.stream_id
 
-        
-
     async def handle_action(self) -> Tuple[bool, str]:
         """
         处理退出专注聊天的情况
@@ -83,7 +78,7 @@ class ExitFocusChatAction(BaseAction):
             if self.sub_heartflow:
                 try:
                     # 转换为normal_chat状态
-                    await self.sub_heartflow.change_chat_state(ChatState.NORMAL_CHAT)
+                    await self.sub_heartflow.change_chat_state(ChatState.CHAT)
                     status_message = "已成功切换到普通聊天模式"
                     logger.info(f"{self.log_prefix} {status_message}")
                 except Exception as e:
@@ -95,7 +90,6 @@ class ExitFocusChatAction(BaseAction):
                 logger.warning(f"{self.log_prefix} {warning_msg}")
                 return False, warning_msg
 
-
             return True, status_message
 
         except asyncio.CancelledError:
@@ -105,4 +99,4 @@ class ExitFocusChatAction(BaseAction):
             error_msg = f"处理 'exit_focus_chat' 时发生错误: {str(e)}"
             logger.error(f"{self.log_prefix} {error_msg}")
             logger.error(traceback.format_exc())
-            return False, error_msg
+            return False, error_msg

src/chat/focus_chat/planners/actions/no_reply_action.py

@@ -3,7 +3,7 @@ import traceback
 from src.common.logger_manager import get_logger
 from src.chat.utils.timer_calculator import Timer
 from src.chat.focus_chat.planners.actions.base_action import BaseAction, register_action
-from typing import Tuple, List, Callable, Coroutine
+from typing import Tuple, List
 from src.chat.heart_flow.observation.observation import Observation
 from src.chat.heart_flow.observation.chatting_observation import ChattingObservation
 from src.chat.focus_chat.hfc_utils import parse_thinking_id_to_timestamp

src/chat/focus_chat/planners/actions/plugin_action.py

@@ -41,7 +41,7 @@ class PluginAction(BaseAction):
         return platform, user_id
 
     # 提供简化的API方法
-    async def send_message(self, text: str, target: Optional[str] = None) -> bool:
+    async def send_message(self, type: str, data: str, target: Optional[str] = "") -> bool:
         """发送消息的简化方法
 
         Args:
@@ -60,7 +60,7 @@ class PluginAction(BaseAction):
                 return False
 
             # 构造简化的动作数据
-            reply_data = {"text": text, "target": target or "", "emojis": []}
+            # reply_data = {"text": text, "target": target or "", "emojis": []}
 
             # 获取锚定消息（如果有）
             observations = self._services.get("observations", [])
@@ -68,7 +68,8 @@ class PluginAction(BaseAction):
             chatting_observation: ChattingObservation = next(
                 obs for obs in observations if isinstance(obs, ChattingObservation)
             )
-            anchor_message = chatting_observation.search_message_by_text(reply_data["target"])
+
+            anchor_message = chatting_observation.search_message_by_text(target)
 
             # 如果没有找到锚点消息，创建一个占位符
             if not anchor_message:
@@ -80,7 +81,7 @@ class PluginAction(BaseAction):
                 anchor_message.update_chat_stream(chat_stream)
 
             response_set = [
-                ("text", text),
+                (type, data),
             ]
 
             # 调用内部方法发送消息

src/chat/focus_chat/planners/planner.py

@@ -12,7 +12,7 @@ from src.chat.focus_chat.info.action_info import ActionInfo
 from src.chat.focus_chat.info.structured_info import StructuredInfo
 from src.common.logger_manager import get_logger
 from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
-from src.individuality.individuality import Individuality
+from src.individuality.individuality import individuality
 from src.chat.focus_chat.planners.action_manager import ActionManager
 
 logger = get_logger("planner")
@@ -92,37 +92,37 @@ class ActionPlanner:
         try:
             # 获取观察信息
             extra_info: list[str] = []
-            
+
             # 首先处理动作变更
             for info in all_plan_info:
                 if isinstance(info, ActionInfo) and info.has_changes():
                     add_actions = info.get_add_actions()
                     remove_actions = info.get_remove_actions()
                     reason = info.get_reason()
-                    
+
                     # 处理动作的增加
                     for action_name in add_actions:
                         if action_name in self.action_manager.get_registered_actions():
                             self.action_manager.add_action_to_using(action_name)
                             logger.debug(f"{self.log_prefix}添加动作: {action_name}, 原因: {reason}")
-                            
+
                     # 处理动作的移除
                     for action_name in remove_actions:
                         self.action_manager.remove_action_from_using(action_name)
                         logger.debug(f"{self.log_prefix}移除动作: {action_name}, 原因: {reason}")
-                        
+
                     # 如果当前选择的动作被移除了，更新为no_reply
                     if action in remove_actions:
                         action = "no_reply"
                         reasoning = f"之前选择的动作{action}已被移除，原因: {reason}"
-            
+
             # 继续处理其他信息
             for info in all_plan_info:
                 if isinstance(info, ObsInfo):
                     observed_messages = info.get_talking_message()
                     observed_messages_str = info.get_talking_message_str_truncate()
                     chat_type = info.get_chat_type()
-                    is_group_chat = (chat_type == "group")
+                    is_group_chat = chat_type == "group"
                 elif isinstance(info, MindInfo):
                     current_mind = info.get_current_mind()
                 elif isinstance(info, CycleInfo):
@@ -134,20 +134,16 @@ class ActionPlanner:
 
             # 获取当前可用的动作
             current_available_actions = self.action_manager.get_using_actions()
-            
+
             # 如果没有可用动作，直接返回no_reply
             if not current_available_actions:
                 logger.warning(f"{self.log_prefix}没有可用的动作，将使用no_reply")
                 action = "no_reply"
                 reasoning = "没有可用的动作"
                 return {
-                    "action_result": {
-                        "action_type": action,
-                        "action_data": action_data,
-                        "reasoning": reasoning
-                    },
+                    "action_result": {"action_type": action, "action_data": action_data, "reasoning": reasoning},
                     "current_mind": current_mind,
-                    "observed_messages": observed_messages
+                    "observed_messages": observed_messages,
                 }
 
             # --- 构建提示词 (调用修改后的 PromptBuilder 方法) ---
@@ -271,7 +267,6 @@ class ActionPlanner:
             else:
                 mind_info_block = "你刚参与聊天"
 
-            individuality = Individuality.get_instance()
             personality_block = individuality.get_prompt(x_person=2, level=2)
 
             action_options_block = ""