fix：调整目录结构，优化hfc prompt，移除日程，移除动态和llm判断willing模式，

src/chat/focus_chat/info_processors/base_processor.py

@@ -0,0 +1,52 @@
+from abc import ABC, abstractmethod
+from typing import List, Any, Optional, Dict
+from src.chat.focus_chat.info.info_base import InfoBase
+from src.heart_flow.observation.observation import Observation
+from src.common.logger_manager import get_logger
+
+logger = get_logger("base_processor")
+
+
+class BaseProcessor(ABC):
+    """信息处理器基类
+
+    所有具体的信息处理器都应该继承这个基类，并实现process_info方法。
+    支持处理InfoBase和Observation类型的输入。
+    """
+
+    @abstractmethod
+    def __init__(self):
+        """初始化处理器"""
+        pass
+
+    @abstractmethod
+    async def process_info(
+        self,
+        infos: List[InfoBase],
+        observations: Optional[List[Observation]] = None,
+        running_memorys: Optional[List[Dict]] = None,
+        **kwargs: Any,
+    ) -> List[InfoBase]:
+        """处理信息对象的抽象方法
+
+        Args:
+            infos: InfoBase对象列表
+            observations: 可选的Observation对象列表
+            **kwargs: 其他可选参数
+
+        Returns:
+            List[InfoBase]: 处理后的InfoBase实例列表
+        """
+        pass
+
+    def _create_processed_item(self, info_type: str, info_data: Any) -> dict:
+        """创建处理后的信息项
+
+        Args:
+            info_type: 信息类型
+            info_data: 信息数据
+
+        Returns:
+            dict: 处理后的信息项
+        """
+        return {"type": info_type, "id": f"info_{info_type}", "content": info_data, "ttl": 3}

src/chat/focus_chat/info_processors/chattinginfo_processor.py

@@ -0,0 +1,123 @@
+from typing import List, Optional, Any
+from src.chat.focus_chat.info.obs_info import ObsInfo
+from src.heart_flow.observation.observation import Observation
+from src.chat.focus_chat.info.info_base import InfoBase
+from .base_processor import BaseProcessor
+from src.common.logger_manager import get_logger
+from src.heart_flow.observation.chatting_observation import ChattingObservation
+from src.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
+
+logger = get_logger("observation")
+
+
+class ChattingInfoProcessor(BaseProcessor):
+    """观察处理器
+
+    用于处理Observation对象，将其转换为ObsInfo对象。
+    """
+
+    def __init__(self):
+        """初始化观察处理器"""
+        self.llm_summary = LLMRequest(
+            model=global_config.llm_observation, temperature=0.7, max_tokens=300, request_type="chat_observation"
+        )
+        super().__init__()
+
+    async def process_info(
+        self,
+        observations: Optional[List[Observation]] = None,
+        running_memorys: Optional[List[Dict]] = None,
+        **kwargs: Any,
+    ) -> List[InfoBase]:
+        """处理Observation对象
+
+        Args:
+            infos: InfoBase对象列表
+            observations: 可选的Observation对象列表
+            **kwargs: 其他可选参数
+
+        Returns:
+            List[InfoBase]: 处理后的ObsInfo实例列表
+        """
+        # print(f"observations: {observations}")
+        processed_infos = []
+
+        # 处理Observation对象
+        if observations:
+            for obs in observations:
+                # print(f"obs: {obs}")
+                if isinstance(obs, ChattingObservation):
+                    obs_info = ObsInfo()
+
+                    await self.chat_compress(obs)
+
+                    # 设置说话消息
+                    if hasattr(obs, "talking_message_str"):
+                        obs_info.set_talking_message(obs.talking_message_str)
+
+                    # 设置截断后的说话消息
+                    if hasattr(obs, "talking_message_str_truncate"):
+                        obs_info.set_talking_message_str_truncate(obs.talking_message_str_truncate)
+
+                    if hasattr(obs, "mid_memory_info"):
+                        obs_info.set_previous_chat_info(obs.mid_memory_info)
+
+                    # 设置聊天类型
+                    is_group_chat = obs.is_group_chat
+                    if is_group_chat:
+                        chat_type = "group"
+                    else:
+                        chat_type = "private"
+                        obs_info.set_chat_target(obs.chat_target_info.get("person_name", "某人"))
+                    obs_info.set_chat_type(chat_type)
+
+                    # logger.debug(f"聊天信息处理器处理后的信息: {obs_info}")
+
+                    processed_infos.append(obs_info)
+                if isinstance(obs, HFCloopObservation):
+                    obs_info = CycleInfo()
+                    obs_info.set_observe_info(obs.observe_info)
+                    processed_infos.append(obs_info)
+
+        return processed_infos
+
+    async def chat_compress(self, obs: ChattingObservation):
+        if obs.compressor_prompt:
+            try:
+                summary_result, _, _ = await self.llm_summary.generate_response(obs.compressor_prompt)
+                summary = "没有主题的闲聊"  # 默认值
+                if summary_result:  # 确保结果不为空
+                    summary = summary_result
+            except Exception as e:
+                logger.error(f"总结主题失败 for chat {obs.chat_id}: {e}")
+
+            mid_memory = {
+                "id": str(int(datetime.now().timestamp())),
+                "theme": summary,
+                "messages": obs.oldest_messages,  # 存储原始消息对象
+                "readable_messages": obs.oldest_messages_str,
+                # "timestamps": oldest_timestamps,
+                "chat_id": obs.chat_id,
+                "created_at": datetime.now().timestamp(),
+            }
+
+            obs.mid_memorys.append(mid_memory)
+            if len(obs.mid_memorys) > obs.max_mid_memory_len:
+                obs.mid_memorys.pop(0)  # 移除最旧的
+
+            mid_memory_str = "之前聊天的内容概述是：\n"
+            for mid_memory_item in obs.mid_memorys:  # 重命名循环变量以示区分
+                time_diff = int((datetime.now().timestamp() - mid_memory_item["created_at"]) / 60)
+                mid_memory_str += (
+                    f"距离现在{time_diff}分钟前(聊天记录id:{mid_memory_item['id']})：{mid_memory_item['theme']}\n"
+                )
+            obs.mid_memory_info = mid_memory_str
+
+            obs.compressor_prompt = ""
+            obs.oldest_messages = []
+            obs.oldest_messages_str = ""

src/chat/focus_chat/info_processors/mind_processor.py

@@ -0,0 +1,410 @@
+from src.heart_flow.observation.chatting_observation import ChattingObservation
+from src.heart_flow.observation.observation import Observation
+from src.chat.models.utils_model import LLMRequest
+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
+import random
+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
+import difflib
+from src.chat.person_info.relationship_manager import relationship_manager
+from .base_processor import BaseProcessor
+from src.chat.focus_chat.info.mind_info import MindInfo
+from typing import List, Optional
+from src.heart_flow.observation.hfcloop_observation import HFCloopObservation
+from src.chat.focus_chat.info_processors.processor_utils import (
+    calculate_similarity,
+    calculate_replacement_probability,
+    get_spark,
+)
+from typing import Dict
+from src.chat.focus_chat.info.info_base import InfoBase
+
+logger = get_logger("sub_heartflow")
+
+
+def init_prompt():
+    # --- Group Chat Prompt ---
+    group_prompt = """
+{memory_str}
+{extra_info}
+{relation_prompt}
+你的名字是{bot_name}
+{mood_info}
+{cycle_info_block}
+现在是{time_now}，你正在上网，和qq群里的网友们聊天，以下是正在进行的聊天内容：
+{chat_observe_info}
+
+以下是你之前对聊天的观察和规划，你的名字是{bot_name}：
+{last_mind}
+
+现在请你继续输出观察和规划，输出要求：
+1. 先关注未读新消息的内容和近期回复历史
+2. 根据新信息，修改和删除之前的观察和规划
+3. 根据聊天内容继续输出观察和规划，{hf_do_next}
+4. 注意群聊的时间线索，话题由谁发起，进展状况如何，思考聊天的时间线。
+6. 语言简洁自然，不要分点，不要浮夸，不要修辞，仅输出思考内容就好"""
+    Prompt(group_prompt, "sub_heartflow_prompt_before")
+
+    # --- Private Chat Prompt ---
+    private_prompt = """
+{memory_str}
+{extra_info}
+{relation_prompt}
+你的名字是{bot_name},{prompt_personality},你现在{mood_info}
+{cycle_info_block}
+现在是{time_now}，你正在上网，和 {chat_target_name} 私聊，以下是你们的聊天内容：
+{chat_observe_info}
+以下是你之前对聊天的观察和规划：
+{last_mind}
+请仔细阅读聊天内容，想想你和 {chat_target_name} 的关系，回顾你们刚刚的交流,你刚刚发言和对方的反应，思考聊天的主题。
+请思考你要不要回复以及如何回复对方。
+思考并输出你的内心想法
+输出要求：
+1. 根据聊天内容生成你的想法，{hf_do_next}
+2. 不要分点、不要使用表情符号
+3. 避免多余符号(冒号、引号、括号等)
+4. 语言简洁自然，不要浮夸
+5. 如果你刚发言，对方没有回复你，请谨慎回复"""
+    Prompt(private_prompt, "sub_heartflow_prompt_private_before")
+
+
+class MindProcessor(BaseProcessor):
+    def __init__(self, subheartflow_id: str):
+        super().__init__()
+        self.subheartflow_id = subheartflow_id
+
+        self.llm_model = LLMRequest(
+            model=global_config.llm_sub_heartflow,
+            temperature=global_config.llm_sub_heartflow["temp"],
+            max_tokens=800,
+            request_type="sub_heart_flow",
+        )
+
+        self.current_mind = ""
+        self.past_mind = []
+        self.structured_info = []
+        self.structured_info_str = ""
+
+        name = chat_manager.get_stream_name(self.subheartflow_id)
+        self.log_prefix = f"[{name}] "
+        self._update_structured_info_str()
+
+    def _update_structured_info_str(self):
+        """根据 structured_info 更新 structured_info_str"""
+        if not self.structured_info:
+            self.structured_info_str = ""
+            return
+
+        lines = ["【信息】"]
+        for item in self.structured_info:
+            # 简化展示，突出内容和类型，包含TTL供调试
+            type_str = item.get("type", "未知类型")
+            content_str = item.get("content", "")
+
+            if type_str == "info":
+                lines.append(f"刚刚: {content_str}")
+            elif type_str == "memory":
+                lines.append(f"{content_str}")
+            elif type_str == "comparison_result":
+                lines.append(f"数字大小比较结果: {content_str}")
+            elif type_str == "time_info":
+                lines.append(f"{content_str}")
+            elif type_str == "lpmm_knowledge":
+                lines.append(f"你知道：{content_str}")
+            else:
+                lines.append(f"{type_str}的信息: {content_str}")
+
+        self.structured_info_str = "\n".join(lines)
+        logger.debug(f"{self.log_prefix} 更新 structured_info_str: \n{self.structured_info_str}")
+
+    async def process_info(
+        self, observations: Optional[List[Observation]] = None, running_memorys: Optional[List[Dict]] = None, *infos
+    ) -> List[InfoBase]:
+        """处理信息对象
+
+        Args:
+            *infos: 可变数量的InfoBase类型的信息对象
+
+        Returns:
+            List[InfoBase]: 处理后的结构化信息列表
+        """
+        current_mind = await self.do_thinking_before_reply(observations, running_memorys)
+
+        mind_info = MindInfo()
+        mind_info.set_current_mind(current_mind)
+
+        return [mind_info]
+
+    async def do_thinking_before_reply(
+        self, observations: Optional[List[Observation]] = None, running_memorys: Optional[List[Dict]] = None
+    ):
+        """
+        在回复前进行思考，生成内心想法并收集工具调用结果
+
+        参数:
+            observations: 观察信息
+
+        返回:
+            如果return_prompt为False:
+                tuple: (current_mind, past_mind) 当前想法和过去的想法列表
+            如果return_prompt为True:
+                tuple: (current_mind, past_mind, prompt) 当前想法、过去的想法列表和使用的prompt
+        """
+
+        # ---------- 0. 更新和清理 structured_info ----------
+        if self.structured_info:
+            updated_info = []
+            for item in self.structured_info:
+                item["ttl"] -= 1
+                if item["ttl"] > 0:
+                    updated_info.append(item)
+                else:
+                    logger.debug(f"{self.log_prefix} 移除过期的 structured_info 项: {item['id']}")
+            self.structured_info = updated_info
+            self._update_structured_info_str()
+        logger.debug(
+            f"{self.log_prefix} 当前完整的 structured_info: {safe_json_dumps(self.structured_info, ensure_ascii=False)}"
+        )
+
+        memory_str = ""
+        if running_memorys:
+            memory_str = "以下是当前在聊天中，你回忆起的记忆：\n"
+            for running_memory in running_memorys:
+                memory_str += f"{running_memory['topic']}: {running_memory['content']}\n"
+
+        # ---------- 1. 准备基础数据 ----------
+        # 获取现有想法和情绪状态
+        previous_mind = self.current_mind if self.current_mind else ""
+
+        if observations is None:
+            observations = []
+        for observation in observations:
+            if isinstance(observation, ChattingObservation):
+                # 获取聊天元信息
+                is_group_chat = observation.is_group_chat
+                chat_target_info = observation.chat_target_info
+                chat_target_name = "对方"  # 私聊默认名称
+                if not is_group_chat and chat_target_info:
+                    # 优先使用person_name，其次user_nickname，最后回退到默认值
+                    chat_target_name = (
+                        chat_target_info.get("person_name") or chat_target_info.get("user_nickname") or chat_target_name
+                    )
+                # 获取聊天内容
+                chat_observe_info = observation.get_observe_info()
+                person_list = observation.person_list
+            if isinstance(observation, HFCloopObservation):
+                hfcloop_observe_info = observation.get_observe_info()
+
+        # ---------- 3. 准备个性化数据 ----------
+        # 获取个性化信息
+        individuality = Individuality.get_instance()
+
+        relation_prompt = ""
+        for person in person_list:
+            relation_prompt += await relationship_manager.build_relationship_info(person, is_id=True)
+
+        # 构建个性部分
+        # prompt_personality = individuality.get_prompt(x_person=2, level=2)
+
+        # 获取当前时间
+        time_now = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+
+        spark_prompt = get_spark()
+
+        # ---------- 5. 构建最终提示词 ----------
+        template_name = "sub_heartflow_prompt_before" if is_group_chat else "sub_heartflow_prompt_private_before"
+        logger.debug(f"{self.log_prefix} 使用{'群聊' if is_group_chat else '私聊'}思考模板")
+
+        prompt = (await global_prompt_manager.get_prompt_async(template_name)).format(
+            memory_str=memory_str,
+            extra_info=self.structured_info_str,
+            # prompt_personality=prompt_personality,
+            relation_prompt=relation_prompt,
+            bot_name=individuality.name,
+            time_now=time_now,
+            chat_observe_info=chat_observe_info,
+            mood_info="mood_info",
+            hf_do_next=spark_prompt,
+            last_mind=previous_mind,
+            cycle_info_block=hfcloop_observe_info,
+            chat_target_name=chat_target_name,
+        )
+
+        # 在构建完提示词后，生成最终的prompt字符串
+        final_prompt = prompt
+
+        content = ""  # 初始化内容变量
+
+        try:
+            # 调用LLM生成响应
+            response, _ = await self.llm_model.generate_response_async(prompt=final_prompt)
+
+            # 直接使用LLM返回的文本响应作为 content
+            content = response if response else ""
+
+        except Exception as e:
+            # 处理总体异常
+            logger.error(f"{self.log_prefix} 执行LLM请求或处理响应时出错: {e}")
+            logger.error(traceback.format_exc())
+            content = "思考过程中出现错误"
+
+        # 记录初步思考结果
+        logger.debug(f"{self.log_prefix} 思考prompt: \n{final_prompt}\n")
+
+        # 处理空响应情况
+        if not content:
+            content = "(不知道该想些什么...)"
+            logger.warning(f"{self.log_prefix} LLM返回空结果，思考失败。")
+
+        # ---------- 8. 更新思考状态并返回结果 ----------
+        logger.info(f"{self.log_prefix} 思考结果: {content}")
+        # 更新当前思考内容
+        self.update_current_mind(content)
+
+        return content
+
+    def update_current_mind(self, response):
+        if self.current_mind:  # 只有当 current_mind 非空时才添加到 past_mind
+            self.past_mind.append(self.current_mind)
+        self.current_mind = response
+
+    def de_similar(self, previous_mind, new_content):
+        try:
+            similarity = calculate_similarity(previous_mind, new_content)
+            replacement_prob = calculate_replacement_probability(similarity)
+            logger.debug(f"{self.log_prefix} 新旧想法相似度: {similarity:.2f}, 替换概率: {replacement_prob:.2f}")
+
+            # 定义词语列表 (移到判断之前)
+            yu_qi_ci_liebiao = ["嗯", "哦", "啊", "唉", "哈", "唔"]
+            zhuan_zhe_liebiao = ["但是", "不过", "然而", "可是", "只是"]
+            cheng_jie_liebiao = ["然后", "接着", "此外", "而且", "另外"]
+            zhuan_jie_ci_liebiao = zhuan_zhe_liebiao + cheng_jie_liebiao
+
+            if random.random() < replacement_prob:
+                # 相似度非常高时，尝试去重或特殊处理
+                if similarity == 1.0:
+                    logger.debug(f"{self.log_prefix} 想法完全重复 (相似度 1.0)，执行特殊处理...")
+                    # 随机截取大约一半内容
+                    if len(new_content) > 1:  # 避免内容过短无法截取
+                        split_point = max(
+                            1, len(new_content) // 2 + random.randint(-len(new_content) // 4, len(new_content) // 4)
+                        )
+                        truncated_content = new_content[:split_point]
+                    else:
+                        truncated_content = new_content  # 如果只有一个字符或者为空，就不截取了
+
+                    # 添加语气词和转折/承接词
+                    yu_qi_ci = random.choice(yu_qi_ci_liebiao)
+                    zhuan_jie_ci = random.choice(zhuan_jie_ci_liebiao)
+                    content = f"{yu_qi_ci}{zhuan_jie_ci}，{truncated_content}"
+                    logger.debug(f"{self.log_prefix} 想法重复，特殊处理后: {content}")
+
+                else:
+                    # 相似度较高但非100%，执行标准去重逻辑
+                    logger.debug(f"{self.log_prefix} 执行概率性去重 (概率: {replacement_prob:.2f})...")
+                    logger.debug(
+                        f"{self.log_prefix} previous_mind类型: {type(previous_mind)}, new_content类型: {type(new_content)}"
+                    )
+
+                    matcher = difflib.SequenceMatcher(None, previous_mind, new_content)
+                    logger.debug(f"{self.log_prefix} matcher类型: {type(matcher)}")
+
+                    deduplicated_parts = []
+                    last_match_end_in_b = 0
+
+                    # 获取并记录所有匹配块
+                    matching_blocks = matcher.get_matching_blocks()
+                    logger.debug(f"{self.log_prefix} 匹配块数量: {len(matching_blocks)}")
+                    logger.debug(
+                        f"{self.log_prefix} 匹配块示例(前3个): {matching_blocks[:3] if len(matching_blocks) > 3 else matching_blocks}"
+                    )
+
+                    # get_matching_blocks()返回形如[(i, j, n), ...]的列表，其中i是a中的索引，j是b中的索引，n是匹配的长度
+                    for idx, match in enumerate(matching_blocks):
+                        if not isinstance(match, tuple):
+                            logger.error(f"{self.log_prefix} 匹配块 {idx} 不是元组类型，而是 {type(match)}: {match}")
+                            continue
+
+                        try:
+                            _i, j, n = match  # 解包元组为三个变量
+                            logger.debug(f"{self.log_prefix} 匹配块 {idx}: i={_i}, j={j}, n={n}")
+
+                            if last_match_end_in_b < j:
+                                # 确保添加的是字符串，而不是元组
+                                try:
+                                    non_matching_part = new_content[last_match_end_in_b:j]
+                                    logger.debug(
+                                        f"{self.log_prefix} 添加非匹配部分: '{non_matching_part}', 类型: {type(non_matching_part)}"
+                                    )
+                                    if not isinstance(non_matching_part, str):
+                                        logger.warning(
+                                            f"{self.log_prefix} 非匹配部分不是字符串类型: {type(non_matching_part)}"
+                                        )
+                                        non_matching_part = str(non_matching_part)
+                                    deduplicated_parts.append(non_matching_part)
+                                except Exception as e:
+                                    logger.error(f"{self.log_prefix} 处理非匹配部分时出错: {e}")
+                                    logger.error(traceback.format_exc())
+                            last_match_end_in_b = j + n
+                        except Exception as e:
+                            logger.error(f"{self.log_prefix} 处理匹配块时出错: {e}")
+                            logger.error(traceback.format_exc())
+
+                    logger.debug(f"{self.log_prefix} 去重前部分列表: {deduplicated_parts}")
+                    logger.debug(f"{self.log_prefix} 列表元素类型: {[type(part) for part in deduplicated_parts]}")
+
+                    # 确保所有元素都是字符串
+                    deduplicated_parts = [str(part) for part in deduplicated_parts]
+
+                    # 防止列表为空
+                    if not deduplicated_parts:
+                        logger.warning(f"{self.log_prefix} 去重后列表为空，添加空字符串")
+                        deduplicated_parts = [""]
+
+                    logger.debug(f"{self.log_prefix} 处理后的部分列表: {deduplicated_parts}")
+
+                    try:
+                        deduplicated_content = "".join(deduplicated_parts).strip()
+                        logger.debug(f"{self.log_prefix} 拼接后的去重内容: '{deduplicated_content}'")
+                    except Exception as e:
+                        logger.error(f"{self.log_prefix} 拼接去重内容时出错: {e}")
+                        logger.error(traceback.format_exc())
+                        deduplicated_content = ""
+
+                    if deduplicated_content:
+                        # 根据概率决定是否添加词语
+                        prefix_str = ""
+                        if random.random() < 0.3:  # 30% 概率添加语气词
+                            prefix_str += random.choice(yu_qi_ci_liebiao)
+                        if random.random() < 0.7:  # 70% 概率添加转折/承接词
+                            prefix_str += random.choice(zhuan_jie_ci_liebiao)
+
+                        # 组合最终结果
+                        if prefix_str:
+                            content = f"{prefix_str}，{deduplicated_content}"  # 更新 content
+                            logger.debug(f"{self.log_prefix} 去重并添加引导词后: {content}")
+                        else:
+                            content = deduplicated_content  # 更新 content
+                            logger.debug(f"{self.log_prefix} 去重后 (未添加引导词): {content}")
+                    else:
+                        logger.warning(f"{self.log_prefix} 去重后内容为空，保留原始LLM输出: {new_content}")
+                        content = new_content  # 保留原始 content
+            else:
+                logger.debug(f"{self.log_prefix} 未执行概率性去重 (概率: {replacement_prob:.2f})")
+                # content 保持 new_content 不变
+
+        except Exception as e:
+            logger.error(f"{self.log_prefix} 应用概率性去重或特殊处理时出错: {e}")
+            logger.error(traceback.format_exc())
+            # 出错时保留原始 content
+            content = new_content
+
+        return content
+
+
+init_prompt()

src/chat/focus_chat/info_processors/processor_utils.py

@@ -0,0 +1,56 @@
+import difflib
+import random
+import time
+
+
+def calculate_similarity(text_a: str, text_b: str) -> float:
+    """
+    计算两个文本字符串的相似度。
+    """
+    if not text_a or not text_b:
+        return 0.0
+    matcher = difflib.SequenceMatcher(None, text_a, text_b)
+    return matcher.ratio()
+
+
+def calculate_replacement_probability(similarity: float) -> float:
+    """
+    根据相似度计算替换的概率。
+    规则：
+    - 相似度 <= 0.4: 概率 = 0
+    - 相似度 >= 0.9: 概率 = 1
+    - 相似度 == 0.6: 概率 = 0.7
+    - 0.4 < 相似度 <= 0.6: 线性插值 (0.4, 0) 到 (0.6, 0.7)
+    - 0.6 < 相似度 < 0.9: 线性插值 (0.6, 0.7) 到 (0.9, 1.0)
+    """
+    if similarity <= 0.4:
+        return 0.0
+    elif similarity >= 0.9:
+        return 1.0
+    elif 0.4 < similarity <= 0.6:
+        # p = 3.5 * s - 1.4
+        probability = 3.5 * similarity - 1.4
+        return max(0.0, probability)
+    else:  # 0.6 < similarity < 0.9
+        # p = s + 0.1
+        probability = similarity + 0.1
+        return min(1.0, max(0.0, probability))
+
+
+def get_spark():
+    local_random = random.Random()
+    current_minute = int(time.strftime("%M"))
+    local_random.seed(current_minute)
+
+    hf_options = [
+        ("可以参考之前的想法，在原来想法的基础上继续思考", 0.2),
+        ("可以参考之前的想法，在原来的想法上尝试新的话题", 0.4),
+        ("不要太深入", 0.2),
+        ("进行深入思考", 0.2),
+    ]
+    # 加权随机选择思考指导
+    hf_do_next = local_random.choices(
+        [option[0] for option in hf_options], weights=[option[1] for option in hf_options], k=1
+    )[0]
+
+    return hf_do_next

src/chat/focus_chat/info_processors/tool_processor.py

@@ -0,0 +1,193 @@
+from src.heart_flow.observation.chatting_observation import ChattingObservation
+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.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
+from src.chat.person_info.relationship_manager import relationship_manager
+from .base_processor import BaseProcessor
+from typing import List, Optional, Dict
+from src.heart_flow.observation.observation import Observation
+from src.heart_flow.observation.working_observation import WorkingObservation
+from src.chat.focus_chat.info.structured_info import StructuredInfo
+
+logger = get_logger("tool_use")
+
+
+def init_prompt():
+    # ... 原有代码 ...
+
+    # 添加工具执行器提示词
+    tool_executor_prompt = """
+你是一个专门执行工具的助手。你的名字是{bot_name}。现在是{time_now}。
+
+你要在群聊中扮演以下角色：
+{prompt_personality}
+
+你当前的额外信息：
+{memory_str}
+
+群里正在进行的聊天内容：
+{chat_observe_info}
+
+请仔细分析聊天内容，考虑以下几点：
+1. 内容中是否包含需要查询信息的问题
+2. 是否需要执行特定操作
+3. 是否有明确的工具使用指令
+4. 考虑用户与你的关系以及当前的对话氛围
+
+如果需要使用工具，请直接调用相应的工具函数。如果不需要使用工具，请简单输出"无需使用工具"。
+"""
+    Prompt(tool_executor_prompt, "tool_executor_prompt")
+
+
+class ToolProcessor(BaseProcessor):
+    def __init__(self, subheartflow_id: str):
+        super().__init__()
+        self.subheartflow_id = subheartflow_id
+        self.log_prefix = f"[{subheartflow_id}:ToolExecutor] "
+        self.llm_model = LLMRequest(
+            model=global_config.llm_tool_use,
+            max_tokens=500,
+            request_type="tool_execution",
+        )
+        self.structured_info = []
+
+    async def process_info(
+        self, observations: Optional[List[Observation]] = None, running_memorys: Optional[List[Dict]] = None, *infos
+    ) -> List[dict]:
+        """处理信息对象
+
+        Args:
+            *infos: 可变数量的InfoBase类型的信息对象
+
+        Returns:
+            list: 处理后的结构化信息列表
+        """
+
+        if observations:
+            for observation in observations:
+                if isinstance(observation, ChattingObservation):
+                    result, used_tools, prompt = await self.execute_tools(observation, running_memorys)
+
+            # 更新WorkingObservation中的结构化信息
+            for observation in observations:
+                if isinstance(observation, WorkingObservation):
+                    for structured_info in result:
+                        logger.debug(f"{self.log_prefix} 更新WorkingObservation中的结构化信息: {structured_info}")
+                        observation.add_structured_info(structured_info)
+
+                    working_infos = observation.get_observe_info()
+                    logger.debug(f"{self.log_prefix} 获取更新后WorkingObservation中的结构化信息: {working_infos}")
+
+        structured_info = StructuredInfo()
+        for working_info in working_infos:
+            structured_info.set_info(working_info.get("type"), working_info.get("content"))
+
+        return [structured_info]
+
+    async def execute_tools(self, observation: ChattingObservation, running_memorys: Optional[List[Dict]] = None):
+        """
+        并行执行工具，返回结构化信息
+
+        参数:
+            sub_mind: 子思维对象
+            chat_target_name: 聊天目标名称，默认为"对方"
+            is_group_chat: 是否为群聊，默认为False
+            return_details: 是否返回详细信息，默认为False
+            cycle_info: 循环信息对象，可用于记录详细执行信息
+
+        返回:
+            如果return_details为False:
+                List[Dict]: 工具执行结果的结构化信息列表
+            如果return_details为True:
+                Tuple[List[Dict], List[str], str]: (工具执行结果列表, 使用的工具列表, 工具执行提示词)
+        """
+        tool_instance = ToolUser()
+        tools = tool_instance._define_tools()
+
+        # logger.debug(f"observation: {observation}")
+        # logger.debug(f"observation.chat_target_info: {observation.chat_target_info}")
+        # logger.debug(f"observation.is_group_chat: {observation.is_group_chat}")
+        # logger.debug(f"observation.person_list: {observation.person_list}")
+
+        is_group_chat = observation.is_group_chat
+
+        chat_observe_info = observation.get_observe_info()
+        person_list = observation.person_list
+
+        memory_str = ""
+        if running_memorys:
+            memory_str = "以下是当前在聊天中，你回忆起的记忆：\n"
+            for running_memory in running_memorys:
+                memory_str += f"{running_memory['topic']}: {running_memory['content']}\n"
+
+        # 构建关系信息
+        relation_prompt = "【关系信息】\n"
+        for person in person_list:
+            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)
+
+        # 获取时间信息
+        time_now = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
+
+        # 构建专用于工具调用的提示词
+        prompt = await global_prompt_manager.format_prompt(
+            "tool_executor_prompt",
+            memory_str=memory_str,
+            # extra_info="extra_structured_info",
+            chat_observe_info=chat_observe_info,
+            # chat_target_name=chat_target_name,
+            is_group_chat=is_group_chat,
+            # relation_prompt=relation_prompt,
+            prompt_personality=prompt_personality,
+            # mood_info=mood_info,
+            bot_name=individuality.name,
+            time_now=time_now,
+        )
+
+        # 调用LLM，专注于工具使用
+        logger.debug(f"开始执行工具调用{prompt}")
+        response, _, tool_calls = await self.llm_model.generate_response_tool_async(prompt=prompt, tools=tools)
+
+        logger.debug(f"获取到工具原始输出:\n{tool_calls}")
+        # 处理工具调用和结果收集，类似于SubMind中的逻辑
+        new_structured_items = []
+        used_tools = []  # 记录使用了哪些工具
+
+        if tool_calls:
+            success, valid_tool_calls, error_msg = process_llm_tool_calls(tool_calls)
+            if success and valid_tool_calls:
+                for tool_call in valid_tool_calls:
+                    try:
+                        # 记录使用的工具名称
+                        tool_name = tool_call.get("name", "unknown_tool")
+                        used_tools.append(tool_name)
+
+                        result = await tool_instance._execute_tool_call(tool_call)
+
+                        name = result.get("type", "unknown_type")
+                        content = result.get("content", "")
+
+                        logger.info(f"工具{name}，获得信息:{content}")
+                        if result:
+                            new_item = {
+                                "type": result.get("type", "unknown_type"),
+                                "id": result.get("id", f"tool_exec_{time.time()}"),
+                                "content": result.get("content", ""),
+                                "ttl": 3,
+                            }
+                            new_structured_items.append(new_item)
+                    except Exception as e:
+                        logger.error(f"{self.log_prefix}工具执行失败: {e}")
+
+        return new_structured_items, used_tools, prompt
+
+
+init_prompt()