Merge branch 'dev' into HFC-para

src/plugins/__init__.py

@@ -6,7 +6,6 @@ MaiMBot插件系统
 from .chat.chat_stream import chat_manager
 from .emoji_system.emoji_manager import emoji_manager
 from .person_info.relationship_manager import relationship_manager
-from .moods.moods import MoodManager
 from .willing.willing_manager import willing_manager
 from .schedule.schedule_generator import bot_schedule
 
@@ -15,7 +14,6 @@ __all__ = [
     "chat_manager",
     "emoji_manager",
     "relationship_manager",
-    "MoodManager",
     "willing_manager",
     "bot_schedule",
 ]

src/plugins/chat/bot.py

@@ -1,16 +1,15 @@
+import traceback
 from typing import Dict, Any
 
-from ..moods.moods import MoodManager  # 导入情绪管理器
-from ...config.config import global_config
-from .message import MessageRecv
-from ..PFC.pfc_manager import PFCManager
-from .chat_stream import chat_manager
-from .only_message_process import MessageProcessor
-
 from src.common.logger_manager import get_logger
+from src.manager.mood_manager import mood_manager  # 导入情绪管理器
+from .chat_stream import chat_manager
+from .message import MessageRecv
+from .only_message_process import MessageProcessor
+from ..PFC.pfc_manager import PFCManager
 from ..heartFC_chat.heartflow_processor import HeartFCProcessor
 from ..utils.prompt_builder import Prompt, global_prompt_manager
-import traceback
+from ...config.config import global_config
 
 # 定义日志配置
 
@@ -23,7 +22,7 @@ class ChatBot:
     def __init__(self):
         self.bot = None  # bot 实例引用
         self._started = False
-        self.mood_manager = MoodManager.get_instance()  # 获取情绪管理器单例
+        self.mood_manager = mood_manager  # 获取情绪管理器单例
         self.heartflow_processor = HeartFCProcessor()  # 新增
 
         # 创建初始化PFC管理器的任务，会在_ensure_started时执行

src/plugins/chat/utils.py

@@ -1,21 +1,20 @@
 import random
-import time
 import re
+import time
 from collections import Counter
 
 import jieba
 import numpy as np
-from src.common.logger import get_module_logger
+from maim_message import UserInfo
 from pymongo.errors import PyMongoError
 
+from src.common.logger import get_module_logger
+from src.manager.mood_manager import mood_manager
+from .message import MessageRecv
 from ..models.utils_model import LLMRequest
 from ..utils.typo_generator import ChineseTypoGenerator
-from ...config.config import global_config
-from .message import MessageRecv
-from maim_message import UserInfo
-from ..moods.moods import MoodManager
 from ...common.database import db
-
+from ...config.config import global_config
 
 logger = get_module_logger("chat_utils")
 
@@ -405,7 +404,6 @@ def calculate_typing_time(
     - 在所有输入结束后，额外加上回车时间0.3秒
     - 如果is_emoji为True，将使用固定1秒的输入时间
     """
-    mood_manager = MoodManager.get_instance()
     # 将0-1的唤醒度映射到-1到1
     mood_arousal = mood_manager.current_mood.arousal
     # 映射到0.5到2倍的速度系数

src/plugins/heartFC_chat/heartFC_chat.py

@@ -1,37 +1,35 @@
 import asyncio
+import contextlib
+import json  # <--- 确保导入 json
+import random  # <--- 添加导入
 import time
 import traceback
-import random  # <--- 添加导入
-import json  # <--- 确保导入 json
-from typing import List, Optional, Dict, Any, Deque, Callable, Coroutine
 from collections import deque
+from typing import List, Optional, Dict, Any, Deque, Callable, Coroutine
+
+from rich.traceback import install
+
+from src.common.logger_manager import get_logger
+from src.config.config import global_config
+from src.heart_flow.observation import Observation
+from src.heart_flow.sub_mind import SubMind
+from src.heart_flow.utils_chat import get_chat_type_and_target_info
+from src.manager.mood_manager import mood_manager
 from src.plugins.chat.chat_stream import ChatStream
 from src.plugins.chat.chat_stream import chat_manager
-from src.common.logger_manager import get_logger
+from src.plugins.chat.message import MessageRecv, BaseMessageInfo, MessageThinking, MessageSending
+from src.plugins.chat.message import Seg  # Local import needed after move
+from src.plugins.chat.message import UserInfo
+from src.plugins.chat.utils import process_llm_response
+from src.plugins.chat.utils_image import image_path_to_base64  # Local import needed after move
+from src.plugins.emoji_system.emoji_manager import emoji_manager
+from src.plugins.heartFC_chat.heartFC_Cycleinfo import CycleInfo
+from src.plugins.heartFC_chat.heartflow_prompt_builder import global_prompt_manager, prompt_builder
 from src.plugins.models.utils_model import LLMRequest
-from src.config.config import global_config
-from src.plugins.utils.timer_calculator import Timer
-from src.heart_flow.observation.observation import Observation
-from src.plugins.heartFC_chat.heartflow_prompt_builder import prompt_builder
-import contextlib
-from src.plugins.heartFC_chat.heartFC_Cycleinfo import CycleDetail
-from src.heart_flow.observation.chatting_observation import ChattingObservation
-from src.heart_flow.utils_chat import get_chat_type_and_target_info
-from rich.traceback import install
-from src.heart_flow.info.info_base import InfoBase
-from src.heart_flow.info.obs_info import ObsInfo
-from src.heart_flow.info.cycle_info import CycleInfo
-from src.heart_flow.info.mind_info import MindInfo
-from src.heart_flow.info.structured_info import StructuredInfo
-from src.plugins.heartFC_chat.info_processors.chattinginfo_processor import ChattingInfoProcessor
-from src.plugins.heartFC_chat.info_processors.mind_processor import MindProcessor
-from src.heart_flow.observation.memory_observation import MemoryObservation
-from src.heart_flow.observation.hfcloop_observation import HFCloopObservation
-from src.heart_flow.observation.working_observation import WorkingObservation
-from src.plugins.heartFC_chat.info_processors.tool_processor import ToolProcessor
-from src.plugins.heartFC_chat.expressors.default_expressor import DefaultExpressor
-from src.plugins.heartFC_chat.hfc_utils import _create_empty_anchor_message
-from src.plugins.heartFC_chat.memory_activator import MemoryActivator
+from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager
+from src.plugins.utils.chat_message_builder import num_new_messages_since
+from src.plugins.utils.timer_calculator import Timer  # <--- Import Timer
+from .heartFC_sender import HeartFCSender
 
 install(extra_lines=3)
 

src/plugins/heartFC_chat/heartflow_prompt_builder.py

@@ -10,7 +10,7 @@ import time
 from typing import Union, Optional, Dict, Any
 from ...common.database import db
 from ..chat.utils import get_recent_group_speaker
-from ..moods.moods import MoodManager
+from src.manager.mood_manager import mood_manager
 from ..memory_system.Hippocampus import HippocampusManager
 from ..schedule.schedule_generator import bot_schedule
 from ..knowledge.knowledge_lib import qa_manager
@@ -383,8 +383,7 @@ class PromptBuilder:
             else:
                 logger.warning(f"Invalid person tuple encountered for relationship prompt: {person}")
 
-        mood_manager = MoodManager.get_instance()
-        mood_prompt = mood_manager.get_prompt()
+        mood_prompt = mood_manager.get_mood_prompt()
         reply_styles1 = [
             ("然后给出日常且口语化的回复，平淡一些", 0.4),
             ("给出非常简短的回复", 0.4),

src/plugins/heartFC_chat/normal_chat.py

@@ -1,26 +1,26 @@
-import time
 import asyncio
-import traceback
 import statistics  # 导入 statistics 模块
+import time
+import traceback
 from random import random
 from typing import List, Optional  # 导入 Optional
 
-from ..moods.moods import MoodManager
-from ...config.config import global_config
-from ..emoji_system.emoji_manager import emoji_manager
-from .normal_chat_generator import NormalChatGenerator
-from ..chat.message import MessageSending, MessageRecv, MessageThinking, MessageSet
-from ..chat.message_sender import message_manager
-from ..chat.utils_image import image_path_to_base64
-from ..willing.willing_manager import willing_manager
 from maim_message import UserInfo, Seg
+
 from src.common.logger_manager import get_logger
+from src.heart_flow.utils_chat import get_chat_type_and_target_info
+from src.manager.mood_manager import mood_manager
 from src.plugins.chat.chat_stream import ChatStream, chat_manager
 from src.plugins.person_info.relationship_manager import relationship_manager
 from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager
 from src.plugins.utils.timer_calculator import Timer
-from src.heart_flow.utils_chat import get_chat_type_and_target_info
-
+from .normal_chat_generator import NormalChatGenerator
+from ..chat.message import MessageSending, MessageRecv, MessageThinking, MessageSet
+from ..chat.message_sender import message_manager
+from ..chat.utils_image import image_path_to_base64
+from ..emoji_system.emoji_manager import emoji_manager
+from ..willing.willing_manager import willing_manager
+from ...config.config import global_config
 
 logger = get_logger("chat")
 
@@ -45,7 +45,7 @@ class NormalChat:
 
         # Other sync initializations
         self.gpt = NormalChatGenerator()
-        self.mood_manager = MoodManager.get_instance()
+        self.mood_manager = mood_manager
         self.start_time = time.time()
         self.last_speak_time = 0
         self._chat_task: Optional[asyncio.Task] = None

src/plugins/moods/moods.py

@@ -1,293 +0,0 @@
-import math
-import threading
-import time
-from dataclasses import dataclass
-
-from ...config.config import global_config
-from src.common.logger_manager import get_logger
-from ..person_info.relationship_manager import relationship_manager
-from src.individuality.individuality import Individuality
-
-
-logger = get_logger("mood")
-
-
-@dataclass
-class MoodState:
-    valence: float  # 愉悦度 (-1.0 到 1.0)，-1表示极度负面，1表示极度正面
-    arousal: float  # 唤醒度 (-1.0 到 1.0)，-1表示抑制，1表示兴奋
-    text: str  # 心情文本描述
-
-
-class MoodManager:
-    _instance = None
-    _lock = threading.Lock()
-
-    def __new__(cls):
-        with cls._lock:
-            if cls._instance is None:
-                cls._instance = super().__new__(cls)
-                cls._instance._initialized = False
-            return cls._instance
-
-    def __init__(self):
-        # 确保初始化代码只运行一次
-        if self._initialized:
-            return
-
-        self._initialized = True
-
-        # 初始化心情状态
-        self.current_mood = MoodState(valence=0.0, arousal=0.0, text="平静")
-
-        # 从配置文件获取衰减率
-        self.decay_rate_valence = 1 - global_config.mood_decay_rate  # 愉悦度衰减率
-        self.decay_rate_arousal = 1 - global_config.mood_decay_rate  # 唤醒度衰减率
-
-        # 上次更新时间
-        self.last_update = time.time()
-
-        # 线程控制
-        self._running = False
-        self._update_thread = None
-
-        # 情绪词映射表 (valence, arousal)
-        self.emotion_map = {
-            "开心": (0.21, 0.6),
-            "害羞": (0.15, 0.2),
-            "愤怒": (-0.24, 0.8),
-            "恐惧": (-0.21, 0.7),
-            "悲伤": (-0.21, 0.3),
-            "厌恶": (-0.12, 0.4),
-            "惊讶": (0.06, 0.7),
-            "困惑": (0.0, 0.6),
-            "平静": (0.03, 0.5),
-        }
-
-        # 情绪文本映射表
-        self.mood_text_map = {
-            # 第一象限：高唤醒，正愉悦
-            (0.5, 0.4): "兴奋",
-            (0.3, 0.6): "快乐",
-            (0.2, 0.3): "满足",
-            # 第二象限：高唤醒，负愉悦
-            (-0.5, 0.4): "愤怒",
-            (-0.3, 0.6): "焦虑",
-            (-0.2, 0.3): "烦躁",
-            # 第三象限：低唤醒，负愉悦
-            (-0.5, -0.4): "悲伤",
-            (-0.3, -0.3): "疲倦",
-            (-0.4, -0.7): "疲倦",
-            # 第四象限：低唤醒，正愉悦
-            (0.2, -0.1): "平静",
-            (0.3, -0.2): "安宁",
-            (0.5, -0.4): "放松",
-        }
-
-    @classmethod
-    def get_instance(cls) -> "MoodManager":
-        """获取MoodManager的单例实例"""
-        if cls._instance is None:
-            cls._instance = MoodManager()
-        return cls._instance
-
-    def start_mood_update(self, update_interval: float = 5.0) -> None:
-        """
-        启动情绪更新线程
-        :param update_interval: 更新间隔（秒）
-        """
-        if self._running:
-            return
-
-        self._running = True
-        self._update_thread = threading.Thread(
-            target=self._continuous_mood_update, args=(update_interval,), daemon=True
-        )
-        self._update_thread.start()
-
-    def stop_mood_update(self) -> None:
-        """停止情绪更新线程"""
-        self._running = False
-        if self._update_thread and self._update_thread.is_alive():
-            self._update_thread.join()
-
-    def _continuous_mood_update(self, update_interval: float) -> None:
-        """
-        持续更新情绪状态的线程函数
-        :param update_interval: 更新间隔（秒）
-        """
-        while self._running:
-            self._apply_decay()
-            self._update_mood_text()
-            time.sleep(update_interval)
-
-    def _apply_decay(self) -> None:
-        """应用情绪衰减，正向和负向情绪分开计算"""
-        current_time = time.time()
-        time_diff = current_time - self.last_update
-        agreeableness_factor = 1
-        agreeableness_bias = 0
-        neuroticism_factor = 0.5
-
-        # 获取人格特质
-        personality = Individuality.get_instance().personality
-        if personality:
-            # 神经质：影响情绪变化速度
-            neuroticism_factor = 1 + (personality.neuroticism - 0.5) * 0.4
-            agreeableness_factor = 1 + (personality.agreeableness - 0.5) * 0.4
-
-            # 宜人性：影响情绪基准线
-            if personality.agreeableness < 0.2:
-                agreeableness_bias = (personality.agreeableness - 0.2) * 0.5
-            elif personality.agreeableness > 0.8:
-                agreeableness_bias = (personality.agreeableness - 0.8) * 0.5
-            else:
-                agreeableness_bias = 0
-
-        # 分别计算正向和负向的衰减率
-        if self.current_mood.valence >= 0:
-            # 正向情绪衰减
-            decay_rate_positive = self.decay_rate_valence * (1 / agreeableness_factor)
-            valence_target = 0 + agreeableness_bias
-            self.current_mood.valence = valence_target + (self.current_mood.valence - valence_target) * math.exp(
-                -decay_rate_positive * time_diff * neuroticism_factor
-            )
-        else:
-            # 负向情绪衰减
-            decay_rate_negative = self.decay_rate_valence * agreeableness_factor
-            valence_target = 0 + agreeableness_bias
-            self.current_mood.valence = valence_target + (self.current_mood.valence - valence_target) * math.exp(
-                -decay_rate_negative * time_diff * neuroticism_factor
-            )
-
-        # Arousal 向中性（0）回归
-        arousal_target = 0
-        self.current_mood.arousal = arousal_target + (self.current_mood.arousal - arousal_target) * math.exp(
-            -self.decay_rate_arousal * time_diff * neuroticism_factor
-        )
-
-        # 确保值在合理范围内
-        self.current_mood.valence = max(-1.0, min(1.0, self.current_mood.valence))
-        self.current_mood.arousal = max(-1.0, min(1.0, self.current_mood.arousal))
-
-        self.last_update = current_time
-
-    def update_mood_from_text(self, text: str, valence_change: float, arousal_change: float) -> None:
-        """根据输入文本更新情绪状态"""
-
-        self.current_mood.valence += valence_change
-        self.current_mood.arousal += arousal_change
-
-        # 限制范围
-        self.current_mood.valence = max(-1.0, min(1.0, self.current_mood.valence))
-        self.current_mood.arousal = max(-1.0, min(1.0, self.current_mood.arousal))
-
-        self._update_mood_text()
-
-    def set_mood_text(self, text: str) -> None:
-        """直接设置心情文本"""
-        self.current_mood.text = text
-
-    def _update_mood_text(self) -> None:
-        """根据当前情绪状态更新文本描述"""
-        closest_mood = None
-        min_distance = float("inf")
-
-        for (v, a), text in self.mood_text_map.items():
-            distance = math.sqrt((self.current_mood.valence - v) ** 2 + (self.current_mood.arousal - a) ** 2)
-            if distance < min_distance:
-                min_distance = distance
-                closest_mood = text
-
-        if closest_mood:
-            self.current_mood.text = closest_mood
-
-    def update_mood_by_user(self, user_id: str, valence_change: float, arousal_change: float) -> None:
-        """根据用户ID更新情绪状态"""
-
-        # 这里可以根据用户ID添加特定的权重或规则
-        weight = 1.0  # 默认权重
-
-        self.current_mood.valence += valence_change * weight
-        self.current_mood.arousal += arousal_change * weight
-
-        # 限制范围
-        self.current_mood.valence = max(-1.0, min(1.0, self.current_mood.valence))
-        self.current_mood.arousal = max(-1.0, min(1.0, self.current_mood.arousal))
-
-        self._update_mood_text()
-
-    def get_prompt(self) -> str:
-        """根据当前情绪状态生成提示词"""
-
-        base_prompt = f"当前心情：{self.current_mood.text}。"
-
-        # 根据情绪状态添加额外的提示信息
-        if self.current_mood.valence > 0.5:
-            base_prompt += "你现在心情很好，"
-        elif self.current_mood.valence < -0.5:
-            base_prompt += "你现在心情不太好，"
-
-        if self.current_mood.arousal > 0.4:
-            base_prompt += "情绪比较激动。"
-        elif self.current_mood.arousal < -0.4:
-            base_prompt += "情绪比较平静。"
-
-        return base_prompt
-
-    def get_arousal_multiplier(self) -> float:
-        """根据当前情绪状态返回唤醒度乘数"""
-        if self.current_mood.arousal > 0.4:
-            multiplier = 1 + min(0.15, (self.current_mood.arousal - 0.4) / 3)
-            return multiplier
-        elif self.current_mood.arousal < -0.4:
-            multiplier = 1 - min(0.15, ((0 - self.current_mood.arousal) - 0.4) / 3)
-            return multiplier
-        return 1.0
-
-    def get_current_mood(self) -> MoodState:
-        """获取当前情绪状态"""
-        return self.current_mood
-
-    def print_mood_status(self) -> None:
-        """打印当前情绪状态"""
-        logger.info(
-            f"愉悦度: {self.current_mood.valence:.2f}, "
-            f"唤醒度: {self.current_mood.arousal:.2f}, "
-            f"心情: {self.current_mood.text}"
-        )
-
-    def update_mood_from_emotion(self, emotion: str, intensity: float = 1.0) -> None:
-        """
-        根据情绪词更新心情状态
-        :param emotion: 情绪词（如'happy', 'sad'等）
-        :param intensity: 情绪强度（0.0-1.0）
-        """
-        if emotion not in self.emotion_map:
-            logger.debug(f"[情绪更新] 未知情绪词: {emotion}")
-            return
-
-        valence_change, arousal_change = self.emotion_map[emotion]
-        old_valence = self.current_mood.valence
-        old_arousal = self.current_mood.arousal
-        old_mood = self.current_mood.text
-
-        valence_change = relationship_manager.feedback_to_mood(valence_change)
-
-        # 应用情绪强度
-        valence_change *= intensity
-        arousal_change *= intensity
-
-        # 更新当前情绪状态
-        self.current_mood.valence += valence_change
-        self.current_mood.arousal += arousal_change
-
-        # 限制范围
-        self.current_mood.valence = max(-1.0, min(1.0, self.current_mood.valence))
-        self.current_mood.arousal = max(-1.0, min(1.0, self.current_mood.arousal))
-
-        self._update_mood_text()
-
-        logger.info(
-            f"[情绪变化] {emotion}(强度:{intensity:.2f}) | 愉悦度:{old_valence:.2f}->{self.current_mood.valence:.2f}, 唤醒度:{old_arousal:.2f}->{self.current_mood.arousal:.2f} | 心情:{old_mood}->{self.current_mood.text}"
-        )

src/plugins/person_info/relationship_manager.py

@@ -6,6 +6,9 @@ from .person_info import person_info_manager
 import time
 import random
 from maim_message import UserInfo
+
+from ...manager.mood_manager import mood_manager
+
 # import re
 # import traceback
 
@@ -22,9 +25,7 @@ class RelationshipManager:
     @property
     def mood_manager(self):
         if self._mood_manager is None:
-            from ..moods.moods import MoodManager  # 延迟导入
-
-            self._mood_manager = MoodManager.get_instance()
+            self._mood_manager = mood_manager
         return self._mood_manager
 
     def positive_feedback_sys(self, label: str, stance: str):
@@ -60,9 +61,7 @@ class RelationshipManager:
     def mood_feedback(self, value):
         """情绪反馈"""
         mood_manager = self.mood_manager
-        mood_gain = mood_manager.get_current_mood().valence ** 2 * math.copysign(
-            1, value * mood_manager.get_current_mood().valence
-        )
+        mood_gain = mood_manager.current_mood.valence**2 * math.copysign(1, value * mood_manager.current_mood.valence)
         value += value * mood_gain
         logger.info(f"当前relationship增益系数：{mood_gain:.3f}")
         return value

src/plugins/remote/__init__.py

@@ -1,4 +0,0 @@
-from .remote import main
-
-# 启动心跳线程
-heartbeat_thread = main()

src/plugins/remote/remote.py

@@ -1,248 +1,142 @@
+import asyncio
+
 import requests
-import time
-import uuid
 import platform
-import os
-import json
-import threading
-import subprocess
 
 # from loguru import logger
 from src.common.logger_manager import get_logger
 from src.config.config import global_config
+from src.manager.async_task_manager import AsyncTask
+from src.manager.local_store_manager import local_storage
 
 logger = get_logger("remote")
 
-# --- 使用向上导航的方式定义路径 ---
-
-# 1. 获取当前文件 (remote.py) 所在的目录
-current_dir = os.path.dirname(os.path.abspath(__file__))
-
-# 2. 从当前目录向上导航三级找到项目根目录
-#    (src/plugins/remote/ -> src/plugins/ -> src/ -> project_root)
-root_dir = os.path.abspath(os.path.join(current_dir, "..", "..", ".."))
-
-# 3. 定义 data 目录的路径 (位于项目根目录下)
-data_dir = os.path.join(root_dir, "data")
-
-# 4. 定义 UUID 文件在 data 目录下的完整路径
-UUID_FILE = os.path.join(data_dir, "client_uuid.json")
-
-# --- 路径定义结束 ---
+TELEMETRY_SERVER_URL = "http://localhost:8080"
+"""遥测服务地址"""
 
 
-# 生成或获取客户端唯一ID
-def get_unique_id():
-    # --- 在尝试读写 UUID_FILE 之前确保 data 目录存在 ---
-    # 将目录检查和创建逻辑移到这里，在首次需要写入前执行
-    try:
-        # exist_ok=True 意味着如果目录已存在也不会报错
-        os.makedirs(data_dir, exist_ok=True)
-    except OSError as e:
-        # 处理可能的权限错误等
-        logger.error(f"无法创建数据目录 {data_dir}: {e}")
-        # 根据你的错误处理逻辑，可能需要在这里返回错误或抛出异常
-        # 暂且返回 None 或抛出，避免继续执行导致问题
-        raise RuntimeError(f"无法创建必要的数据目录 {data_dir}") from e
-    # --- 目录检查结束 ---
+class TelemetryHeartBeatTask(AsyncTask):
+    HEARTBEAT_INTERVAL = 300
 
-    # 检查是否已经有保存的UUID
-    if os.path.exists(UUID_FILE):
-        try:
-            with open(UUID_FILE, "r", encoding="utf-8") as f:  # 指定 encoding
-                data = json.load(f)
-                if "client_id" in data:
-                    logger.debug(f"从本地文件读取客户端ID: {UUID_FILE}")
-                    return data["client_id"]
-        except (json.JSONDecodeError, IOError) as e:
-            logger.warning(f"读取UUID文件 {UUID_FILE} 出错: {e}，将生成新的UUID")
-        except Exception as e:  # 捕捉其他可能的异常
-            logger.error(f"读取UUID文件 {UUID_FILE} 时发生未知错误: {e}")
+    def __init__(self):
+        super().__init__(task_name="Telemetry Heart Beat Task", run_interval=self.HEARTBEAT_INTERVAL)
+        self.server_url = TELEMETRY_SERVER_URL
+        """遥测服务地址"""
 
-    # 如果没有保存的UUID或读取出错，则生成新的
-    client_id = generate_unique_id()
-    logger.info(f"生成新的客户端ID: {client_id}")
+        self.client_uuid = local_storage["mmc_uuid"] if "mmc_uuid" in local_storage else None
+        """客户端UUID"""
 
-    # 保存UUID到文件
-    try:
-        # 再次确认目录存在 (虽然理论上前面已创建，但更保险)
-        os.makedirs(data_dir, exist_ok=True)
-        with open(UUID_FILE, "w", encoding="utf-8") as f:  # 指定 encoding
-            json.dump({"client_id": client_id}, f, indent=4)  # 添加 indent 使json可读
-        logger.info(f"已保存新生成的客户端ID到本地文件: {UUID_FILE}")
-    except IOError as e:
-        logger.error(f"保存UUID时出错: {UUID_FILE} - {e}")
-    except Exception as e:  # 捕捉其他可能的异常
-        logger.error(f"保存UUID文件 {UUID_FILE} 时发生未知错误: {e}")
+        self.info_dict = self._get_sys_info()
+        """系统信息字典"""
 
-    return client_id
+    @staticmethod
+    def _get_sys_info() -> dict[str, str]:
+        """获取系统信息"""
+        info_dict = {
+            "os_type": "Unknown",
+            "py_version": platform.python_version(),
+            "mmc_version": global_config.MAI_VERSION,
+        }
 
+        match platform.system():
+            case "Windows":
+                info_dict["os_type"] = "Windows"
+            case "Linux":
+                info_dict["os_type"] = "Linux"
+            case "Darwin":
+                info_dict["os_type"] = "macOS"
+            case _:
+                info_dict["os_type"] = "Unknown"
 
-# 生成客户端唯一ID
-def generate_unique_id():
-    # 基于机器码生成唯一ID，同一台机器上生成的UUID是固定的，只要机器码不变
-    import hashlib
+        return info_dict
 
-    system_info = platform.system()
-    machine_code = None
+    async def _req_uuid(self) -> bool:
+        """
+        向服务端请求UUID（不应在已存在UUID的情况下调用，会覆盖原有的UUID）
+        """
 
-    try:
-        if system_info == "Windows":
-            # 使用wmic命令获取主机UUID（更稳定）
-            result = subprocess.check_output(
-                "wmic csproduct get uuid", shell=True, stderr=subprocess.DEVNULL, stdin=subprocess.DEVNULL
-            )
-            lines = result.decode(errors="ignore").splitlines()
-            # 过滤掉空行和表头，只取有效UUID
-            uuids = [line.strip() for line in lines if line.strip() and line.strip().lower() != "uuid"]
-            if uuids:
-                uuid_val = uuids[0]
-                # logger.debug(f"主机UUID: {uuid_val}")
-                # 增加无效值判断
-                if uuid_val and uuid_val.lower() not in ["to be filled by o.e.m.", "none", "", "standard"]:
-                    machine_code = uuid_val
-        elif system_info == "Linux":
-            # 优先读取 /etc/machine-id，其次 /var/lib/dbus/machine-id，取第一个非空且内容有效的
-            for path in ["/etc/machine-id", "/var/lib/dbus/machine-id"]:
-                if os.path.exists(path):
-                    with open(path, "r") as f:
-                        code = f.read().strip()
-                        # 只要内容非空且不是全0
-                        if code and set(code) != {"0"}:
-                            machine_code = code
-                            break
-        elif system_info == "Darwin":
-            # macOS: 使用IOPlatformUUID
-            result = subprocess.check_output(
-                "ioreg -rd1 -c IOPlatformExpertDevice | awk '/IOPlatformUUID/'", shell=True
-            )
-            uuid_line = result.decode(errors="ignore")
-            # 解析出 "IOPlatformUUID" = "xxxx-xxxx-xxxx-xxxx"
-            import re
-
-            m = re.search(r'"IOPlatformUUID"\s*=\s*"([^"]+)"', uuid_line)
-            if m:
-                uuid_val = m.group(1)
-                logger.debug(f"IOPlatformUUID: {uuid_val}")
-                if uuid_val and uuid_val.lower() not in ["to be filled by o.e.m.", "none", "", "standard"]:
-                    machine_code = uuid_val
-    except Exception as e:
-        logger.debug(f"获取机器码失败: {e}")
-
-    # 如果主板序列号无效，尝试用MAC地址
-    if not machine_code:
-        try:
-            mac = uuid.getnode()
-            if (mac >> 40) % 2 == 0:  # 不是本地伪造MAC
-                machine_code = str(mac)
-        except Exception as e:
-            logger.debug(f"获取MAC地址失败: {e}")
-
-    def md5_to_uuid(md5hex):
-        # 将32位md5字符串格式化为8-4-4-4-12的UUID格式
-        return f"{md5hex[0:8]}-{md5hex[8:12]}-{md5hex[12:16]}-{md5hex[16:20]}-{md5hex[20:32]}"
-
-    if machine_code:
-        # print(f"machine_code={machine_code!r}")  # 可用于调试
-        md5 = hashlib.md5(machine_code.encode("utf-8")).hexdigest()
-        uuid_str = md5_to_uuid(md5)
-    else:
-        uuid_str = str(uuid.uuid4())
-
-    unique_id = f"{system_info}-{uuid_str}"
-    return unique_id
-
-
-def send_heartbeat(server_url, client_id):
-    """向服务器发送心跳"""
-    sys = platform.system()
-    try:
-        headers = {"Client-ID": client_id, "User-Agent": f"HeartbeatClient/{client_id[:8]}"}
-        data = json.dumps(
-            {"system": sys, "Version": global_config.MAI_VERSION},
-        )
-        logger.debug(f"正在发送心跳到服务器: {server_url}")
-        logger.debug(f"心跳数据: {data}")
-        response = requests.post(f"{server_url}/api/clients", headers=headers, data=data)
-
-        if response.status_code == 201:
-            data = response.json()
-            logger.debug(f"心跳发送成功。服务器响应: {data}")
-            return True
-        else:
-            logger.debug(f"心跳发送失败。状态码: {response.status_code}, 响应内容: {response.text}")
+        if "deploy_time" not in local_storage:
+            logger.error("本地存储中缺少部署时间，无法请求UUID")
             return False
 
-    except requests.RequestException as e:
-        # 如果请求异常，可能是网络问题，不记录错误
-        logger.debug(f"发送心跳时出错: {e}")
-        return False
+        try_count: int = 0
+        while True:
+            # 如果不存在，则向服务端请求一个新的UUID（注册客户端）
+            logger.info("正在向遥测服务端请求UUID...")
 
+            try:
+                response = requests.post(
+                    f"{TELEMETRY_SERVER_URL}/stat/reg_client",
+                    json={"deploy_time": local_storage["deploy_time"]},
+                )
 
-class HeartbeatThread(threading.Thread):
-    """心跳线程类"""
+                if response.status_code == 200:
+                    data = response.json()
+                    client_id = data.get("mmc_uuid")
+                    if client_id:
+                        # 将UUID存储到本地
+                        local_storage["mmc_uuid"] = client_id
+                        self.client_uuid = client_id
+                        logger.info(f"成功获取UUID: {self.client_uuid}")
+                        return True  # 成功获取UUID，返回True
+                    else:
+                        logger.error("无效的服务端响应")
+                else:
+                    logger.error(f"请求UUID失败，状态码: {response.status_code}, 响应内容: {response.text}")
+            except requests.RequestException as e:
+                logger.error(f"请求UUID时出错: {e}")  # 可能是网络问题
 
-    def __init__(self, server_url, interval):
-        super().__init__(daemon=True)  # 设置为守护线程，主程序结束时自动结束
-        self.server_url = server_url
-        self.interval = interval
-        self.client_id = get_unique_id()
-        self.running = True
-        self.stop_event = threading.Event()  # 添加事件对象用于可中断的等待
-        self.last_heartbeat_time = 0  # 记录上次发送心跳的时间
-
-    def run(self):
-        """线程运行函数"""
-        logger.debug(f"心跳线程已启动，客户端ID: {self.client_id}")
-
-        while self.running:
-            # 发送心跳
-            if send_heartbeat(self.server_url, self.client_id):
-                logger.info(f"{self.interval}秒后发送下一次心跳...")
+            # 请求失败，重试次数+1
+            try_count += 1
+            if try_count > 3:
+                # 如果超过3次仍然失败，则退出
+                logger.error("获取UUID失败，请检查网络连接或服务端状态")
+                return False
             else:
-                logger.info(f"{self.interval}秒后重试...")
+                # 如果可以重试，等待后继续（指数退避）
+                await asyncio.sleep(4**try_count)
 
-            self.last_heartbeat_time = time.time()
+    async def _send_heartbeat(self):
+        """向服务器发送心跳"""
+        try:
+            headers = {
+                "Client-UUID": self.client_uuid,
+                "User-Agent": f"HeartbeatClient/{self.client_uuid[:8]}",
+            }
 
-            # 使用可中断的等待代替 sleep
-            # 每秒检查一次是否应该停止或发送心跳
-            remaining_wait = self.interval
-            while remaining_wait > 0 and self.running:
-                # 每次最多等待1秒，便于及时响应停止请求
-                wait_time = min(1, remaining_wait)
-                if self.stop_event.wait(wait_time):
-                    break  # 如果事件被设置，立即退出等待
-                remaining_wait -= wait_time
+            logger.debug(f"正在发送心跳到服务器: {self.server_url}")
 
-                # 检查是否由于外部原因导致间隔异常延长
-                if time.time() - self.last_heartbeat_time >= self.interval * 1.5:
-                    logger.warning("检测到心跳间隔异常延长，立即发送心跳")
-                    break
+            response = requests.post(
+                f"{self.server_url}/stat/client_heartbeat",
+                headers=headers,
+                json=self.info_dict,
+            )
 
-    def stop(self):
-        """停止线程"""
-        self.running = False
-        self.stop_event.set()  # 设置事件，中断等待
-        logger.debug("心跳线程已收到停止信号")
+            # 处理响应
+            if 200 <= response.status_code < 300:
+                # 成功
+                logger.debug(f"心跳发送成功，状态码: {response.status_code}")
+            elif response.status_code == 403:
+                # 403 Forbidden
+                logger.error(
+                    "心跳发送失败，403 Forbidden: 可能是UUID无效或未注册。"
+                    "处理措施：重置UUID，下次发送心跳时将尝试重新注册。"
+                )
+                self.client_uuid = None
+                del local_storage["mmc_uuid"]  # 删除本地存储的UUID
+            else:
+                # 其他错误
+                logger.error(f"心跳发送失败，状态码: {response.status_code}, 响应内容: {response.text}")
 
+        except requests.RequestException as e:
+            logger.error(f"心跳发送失败: {e}")
 
-def main():
-    if global_config.remote_enable:
-        """主函数，启动心跳线程"""
-        # 配置
-        server_url = "http://hyybuth.xyz:10058"
-        # server_url = "http://localhost:10058"
-        heartbeat_interval = 300  # 5分钟（秒）
+    async def run(self):
+        # 发送心跳
+        if global_config.remote_enable:
+            if self.client_uuid is None:
+                if not await self._req_uuid():
+                    logger.error("获取UUID失败，跳过此次心跳")
+                    return
 
-        # 创建并启动心跳线程
-        heartbeat_thread = HeartbeatThread(server_url, heartbeat_interval)
-        heartbeat_thread.start()
-
-        return heartbeat_thread  # 返回线程对象，便于外部控制
-    return None
-
-
-# --- 测试用例 ---
-if __name__ == "__main__":
-    print("测试唯一ID生成：")
-    print("唯一ID:", get_unique_id())
+            await self._send_heartbeat()