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

.devcontainer/devcontainer.json

@@ -0,0 +1,31 @@
+{
+	"name": "MaiBot-DevContainer",
+	"image": "mcr.microsoft.com/devcontainers/python:1-3.12-bullseye",
+	"features": {
+		"ghcr.io/rocker-org/devcontainer-features/apt-packages:1": {
+			"packages": [
+				"tmux"
+			]
+		},
+		"ghcr.io/devcontainers/features/github-cli:1": {}
+	},
+	"forwardPorts": [
+		"8000:8000"
+	],
+	"postCreateCommand": "pip3 install --user -r requirements.txt",
+	"customizations": {
+		"jetbrains": {
+			"backend": "PyCharm"
+		},
+		"vscode": {
+			"extensions": [
+				"tamasfe.even-better-toml",
+				"njpwerner.autodocstring",
+				"ms-python.python",
+				"KevinRose.vsc-python-indent",
+				"ms-python.vscode-pylance",
+				"ms-python.autopep8"
+			]
+		}
+	}
+}

.github/workflows/docker-image.yml

@@ -6,20 +6,21 @@ on:
       - main
       - classical
       - dev
-      - new_knowledge
     tags:
-      - 'v*'
-  workflow_dispatch:
+      - "v*.*.*"
+      - "v*"
 
 jobs:
-  build-and-push:
+  build-amd64:
+    name: Build AMD64 Image
     runs-on: ubuntu-latest
     env:
       DOCKERHUB_USER: ${{ secrets.DOCKERHUB_USERNAME }}
-      DATE_TAG: $(date -u +'%Y-%m-%dT%H-%M-%S')
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
 
       - name: Clone maim_message
         run: git clone https://github.com/MaiM-with-u/maim_message maim_message
@@ -29,6 +30,8 @@ jobs:
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
+        with:
+          buildkitd-flags: --debug
 
       - name: Login to Docker Hub
         uses: docker/login-action@v3
@@ -36,31 +39,131 @@ jobs:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
-      - name: Determine Image Tags
-        id: tags
-        run: |
-          if [[ "${{ github.ref }}" == refs/tags/* ]]; then
-            echo "tags=${{ secrets.DOCKERHUB_USERNAME }}/maimbot:${{ github.ref_name }},${{ secrets.DOCKERHUB_USERNAME }}/maimbot:latest" >> $GITHUB_OUTPUT
-          elif [ "${{ github.ref }}" == "refs/heads/main" ]; then
-            echo "tags=${{ secrets.DOCKERHUB_USERNAME }}/maimbot:main,${{ secrets.DOCKERHUB_USERNAME }}/maimbot:main-$(date -u +'%Y%m%d%H%M%S')" >> $GITHUB_OUTPUT
-          elif [ "${{ github.ref }}" == "refs/heads/classical" ]; then
-            echo "tags=${{ secrets.DOCKERHUB_USERNAME }}/maimbot:classical,${{ secrets.DOCKERHUB_USERNAME }}/maimbot:classical-$(date -u +'%Y%m%d%H%M%S')" >> $GITHUB_OUTPUT
-          elif [ "${{ github.ref }}" == "refs/heads/dev" ]; then
-            echo "tags=${{ secrets.DOCKERHUB_USERNAME }}/maimbot:dev,${{ secrets.DOCKERHUB_USERNAME }}/maimbot:dev-$(date -u +'%Y%m%d%H%M%S')" >> $GITHUB_OUTPUT
-          elif [ "${{ github.ref }}" == "refs/heads/new_knowledge" ]; then 
-            echo "tags=${{ secrets.DOCKERHUB_USERNAME }}/maimbot:knowledge,${{ secrets.DOCKERHUB_USERNAME }}/maimbot:knowledge-$(date -u +'%Y%m%d%H%M%S')" >> $GITHUB_OUTPUT
-          fi
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ secrets.DOCKERHUB_USERNAME }}/maibot
+          tags: |
+            type=ref,event=branch
+            type=ref,event=tag
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+            type=sha
 
-      - name: Build and Push Docker Image
+      - name: Build and Push AMD64 Docker Image
         uses: docker/build-push-action@v5
         with:
           context: .
           file: ./Dockerfile
-          platforms: linux/amd64,linux/arm64
-          tags: ${{ steps.tags.outputs.tags }}
+          platforms: linux/amd64
+          tags: ${{ secrets.DOCKERHUB_USERNAME }}/maibot:amd64-${{ github.sha }}
           push: true
-          cache-from: type=registry,ref=${{ secrets.DOCKERHUB_USERNAME }}/maimbot:buildcache
-          cache-to: type=registry,ref=${{ secrets.DOCKERHUB_USERNAME }}/maimbot:buildcache,mode=max
-          labels: |
-            org.opencontainers.image.created=${{ steps.tags.outputs.date_tag }}
-            org.opencontainers.image.revision=${{ github.sha }}
+          cache-from: type=registry,ref=${{ secrets.DOCKERHUB_USERNAME }}/maibot:amd64-buildcache
+          cache-to: type=registry,ref=${{ secrets.DOCKERHUB_USERNAME }}/maibot:amd64-buildcache,mode=max
+          labels: ${{ steps.meta.outputs.labels }}
+          provenance: true
+          sbom: true
+          build-args: |
+            BUILD_DATE=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
+            VCS_REF=${{ github.sha }}
+          outputs: type=image,push=true
+
+  build-arm64:
+    name: Build ARM64 Image
+    runs-on: ubuntu-latest
+    env:
+      DOCKERHUB_USER: ${{ secrets.DOCKERHUB_USERNAME }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Clone maim_message
+        run: git clone https://github.com/MaiM-with-u/maim_message maim_message
+
+      - name: Clone lpmm
+        run: git clone https://github.com/MaiM-with-u/MaiMBot-LPMM.git MaiMBot-LPMM
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          buildkitd-flags: --debug
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ secrets.DOCKERHUB_USERNAME }}/maibot
+          tags: |
+            type=ref,event=branch
+            type=ref,event=tag
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+            type=sha
+
+      - name: Build and Push ARM64 Docker Image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./Dockerfile
+          platforms: linux/arm64
+          tags: ${{ secrets.DOCKERHUB_USERNAME }}/maibot:arm64-${{ github.sha }}
+          push: true
+          cache-from: type=registry,ref=${{ secrets.DOCKERHUB_USERNAME }}/maibot:arm64-buildcache
+          cache-to: type=registry,ref=${{ secrets.DOCKERHUB_USERNAME }}/maibot:arm64-buildcache,mode=max
+          labels: ${{ steps.meta.outputs.labels }}
+          provenance: true
+          sbom: true
+          build-args: |
+            BUILD_DATE=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
+            VCS_REF=${{ github.sha }}
+          outputs: type=image,push=true
+
+  create-manifest:
+    name: Create Multi-Arch Manifest
+    runs-on: ubuntu-latest
+    needs:
+      - build-amd64
+      - build-arm64
+    steps:
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+          
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ secrets.DOCKERHUB_USERNAME }}/maibot
+          tags: |
+            type=ref,event=branch
+            type=ref,event=tag
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+            type=sha
+
+      - name: Create and Push Manifest
+        run: |
+          # 为每个标签创建多架构镜像
+          for tag in $(echo "${{ steps.meta.outputs.tags }}" | tr '\n' ' '); do
+            echo "Creating manifest for $tag"
+            docker buildx imagetools create -t $tag \
+              ${{ secrets.DOCKERHUB_USERNAME }}/maibot:amd64-${{ github.sha }} \
+              ${{ secrets.DOCKERHUB_USERNAME }}/maibot:arm64-${{ github.sha }}
+          done

.gitignore

@@ -35,7 +35,6 @@ config/bot_config.toml
 config/bot_config.toml.bak
 config/lpmm_config.toml
 config/lpmm_config.toml.bak
-src/plugins/remote/client_uuid.json
 （测试版）麦麦生成人格.bat
 （临时版）麦麦开始学习.bat
 src/plugins/utils/statistic.py
@@ -43,7 +42,7 @@ src/plugins/utils/statistic.py
 __pycache__/
 *.py[cod]
 *$py.class
-llm_statistics.txt
+maibot_statistics.html
 mongodb
 napcat
 run_dev.bat

EULA.md

@@ -1,16 +1,16 @@
-# **MaiMBot最终用户许可协议**  
+# **MaiBot最终用户许可协议**  
 **版本：V1.0**  
-**更新日期：2025年3月18日**  
+**更新日期：2025年5月9日**  
 **生效日期：2025年3月18日**  
-**适用的MaiMBot版本号：<=v0.5.15**  
+**适用的MaiBot版本号：所有版本**   
 
-**2025© MaiMBot项目团队**
+**2025© MaiBot项目团队**
 
 ---
 
 ## 一、一般条款
 
-**1.1** MaiMBot项目（包括MaiMBot的源代码、可执行文件、文档，以及其它在本协议中所列出的文件）（以下简称“本项目”）是由开发者及贡献者（以下简称“项目团队”）共同维护，为用户提供自动回复功能的机器人代码项目。以下最终用户许可协议（EULA，以下简称“本协议”）是用户（以下简称“您”）与项目团队之间关于使用本项目所订立的合同条件。
+**1.1** MaiBot项目（包括MaiBot的源代码、可执行文件、文档，以及其它在本协议中所列出的文件）（以下简称“本项目”）是由开发者及贡献者（以下简称“项目团队”）共同维护，为用户提供自动回复功能的机器人代码项目。以下最终用户许可协议（EULA，以下简称“本协议”）是用户（以下简称“您”）与项目团队之间关于使用本项目所订立的合同条件。
 
 **1.2** 在运行或使用本项目之前，您**必须阅读并同意本协议的所有条款**。未成年人或其它无/不完全民事行为能力责任人请**在监护人的陪同下**阅读并同意本协议。如果您不同意，则不得运行或使用本项目。在这种情况下，您应立即从您的设备上卸载或删除本项目及其所有副本。
 

PRIVACY.md

@@ -1,12 +1,12 @@
-### MaiMBot用户隐私条款
+### MaiBot用户隐私条款
 **版本：V1.0**  
-**更新日期：2025年3月18日**  
+**更新日期：2025年5月9日**  
 **生效日期：2025年3月18日**  
-**适用的MaiMBot版本号：<=v0.5.15**  
+**适用的MaiBot版本号：所有版本**  
 
-**2025© MaiMBot项目团队**
+**2025© MaiBot项目团队**
 
-MaiMBot项目团队（以下简称项目团队）**尊重并保护**用户（以下简称您）的隐私。若您选择使用MaiMBot项目（以下简称本项目），则您需同意本项目按照以下隐私条款处理您的输入和输出内容：
+MaiBot项目团队（以下简称项目团队）**尊重并保护**用户（以下简称您）的隐私。若您选择使用MaiBot项目（以下简称本项目），则您需同意本项目按照以下隐私条款处理您的输入和输出内容：
 
 **1.1** 本项目**会**收集您的输入和输出内容并发送到第三方API，用于生成新的输出内容。因此您的输入和输出内容**会**同时受到本项目和第三方API的隐私政策约束。
 

README.md

@@ -36,7 +36,7 @@
   </p>
 </p>
 
-## 新版0.6.x部署前先阅读：https://docs.mai-mai.org/manual/usage/mmc_q_a
+## 新版0.6.x部署前先阅读：https://docs.mai-mai.org/faq/maibot/backup_update.html
 
 
 ## 📝 项目简介
@@ -85,7 +85,7 @@
 
 ### ⚠️ 重要提示
 
-- 升级到v0.6.x版本前请务必阅读：[升级指南](https://docs.mai-mai.org/manual/usage/mmc_q_a)
+- 升级到v0.6.x版本前请务必阅读：[升级指南](https://docs.mai-mai.org/faq/maibot/backup_update.html)
 - 本版本基于MaiCore重构，通过nonebot插件与QQ平台交互
 - 项目处于活跃开发阶段，功能和API可能随时调整
 
@@ -94,7 +94,7 @@
 - [二群](https://qm.qq.com/q/RzmCiRtHEW) 571780722
 - [五群](https://qm.qq.com/q/JxvHZnxyec) 1022489779
 - [三群](https://qm.qq.com/q/wlH5eT8OmQ) 1035228475【已满】
-- [四群](https://qm.qq.com/q/wlH5eT8OmQ) 729957033【已满】
+- [四群](https://qm.qq.com/q/wGePTl1UyY) 729957033【已满】
 
 
 

bot.py

@@ -1,7 +1,6 @@
 import asyncio
 import hashlib
 import os
-import shutil
 import sys
 from pathlib import Path
 import time
@@ -17,6 +16,8 @@ from rich.traceback import install
 from src.plugins.group_nickname.nickname_manager import nickname_manager
 import atexit
 
+from src.manager.async_task_manager import async_task_manager
+
 install(extra_lines=3)
 
 # 设置工作目录为脚本所在目录
@@ -35,6 +36,23 @@ driver = None
 app = None
 loop = None
 
+# shutdown_requested = False  # 新增全局变量
+
+
+async def request_shutdown() -> bool:
+    """请求关闭程序"""
+    try:
+        if loop and not loop.is_closed():
+            try:
+                loop.run_until_complete(graceful_shutdown())
+            except Exception as ge:  # 捕捉优雅关闭时可能发生的错误
+                logger.error(f"优雅关闭时发生错误: {ge}")
+                return False
+        return True
+    except Exception as e:
+        logger.error(f"请求关闭程序时发生错误: {e}")
+        return False
+
 
 def easter_egg():
     # 彩蛋
@@ -49,38 +67,6 @@ def easter_egg():
     print(rainbow_text)
 
 
-def init_config():
-    # 初次启动检测
-    if not os.path.exists("config/bot_config.toml"):
-        logger.warning("检测到bot_config.toml不存在，正在从模板复制")
-
-        # 检查config目录是否存在
-        if not os.path.exists("config"):
-            os.makedirs("config")
-            logger.info("创建config目录")
-
-        shutil.copy("template/bot_config_template.toml", "config/bot_config.toml")
-        logger.info("复制完成，请修改config/bot_config.toml和.env中的配置后重新启动")
-    if not os.path.exists("config/lpmm_config.toml"):
-        logger.warning("检测到lpmm_config.toml不存在，正在从模板复制")
-
-        # 检查config目录是否存在
-        if not os.path.exists("config"):
-            os.makedirs("config")
-            logger.info("创建config目录")
-
-        shutil.copy("template/lpmm_config_template.toml", "config/lpmm_config.toml")
-        logger.info("复制完成，请修改config/lpmm_config.toml和.env中的配置后重新启动")
-
-
-def init_env():
-    # 检测.env文件是否存在
-    if not os.path.exists(".env"):
-        logger.error("检测到.env文件不存在")
-        shutil.copy("template/template.env", "./.env")
-        logger.info("已从template/template.env复制创建.env，请修改配置后重新启动")
-
-
 def load_env():
     # 直接加载生产环境变量配置
     if os.path.exists(".env"):
@@ -125,6 +111,10 @@ def scan_provider(env_config: dict):
 async def graceful_shutdown():
     try:
         logger.info("正在优雅关闭麦麦...")
+
+        # 停止所有异步任务
+        await async_task_manager.stop_and_wait_all_tasks()
+
         tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
         for task in tasks:
             task.cancel()
@@ -220,9 +210,9 @@ def raw_main():
 
     check_eula()
     print("检查EULA和隐私条款完成")
+
     easter_egg()
-    init_config()
-    init_env()
+
     load_env()
 
     env_config = {key: os.getenv(key) for key in os.environ}
@@ -267,6 +257,8 @@ if __name__ == "__main__":
                     loop.run_until_complete(graceful_shutdown())
                 except Exception as ge:  # 捕捉优雅关闭时可能发生的错误
                     logger.error(f"优雅关闭时发生错误: {ge}")
+        # 新增：检测外部请求关闭
+
         # except Exception as e: # 将主异常捕获移到外层 try...except
         #     logger.error(f"事件循环内发生错误: {str(e)} {str(traceback.format_exc())}")
         #     exit_code = 1
@@ -286,5 +278,5 @@ if __name__ == "__main__":
             loop.close()
             logger.info("事件循环已关闭")
         # 在程序退出前暂停，让你有机会看到输出
-        input("按 Enter 键退出...")  # <--- 添加这行
+        # input("按 Enter 键退出...")  # <--- 添加这行
         sys.exit(exit_code)  # <--- 使用记录的退出码

docker-compose.yml

@@ -16,8 +16,11 @@ services:
       - maim_bot
   core:
     container_name: maim-bot-core
-    image: sengokucola/maimbot:main
-    # image: infinitycat/maimbot:main
+    image: sengokucola/maibot:latest
+    # image: infinitycat/maibot:latest
+    # dev
+    # image: sengokucola/maibot:dev
+    # image: infinitycat/maibot:dev
     environment:
       - TZ=Asia/Shanghai
 #      - EULA_AGREE=35362b6ea30f12891d46ef545122e84a  # 同意EULA

llm_tool_benchmark_results.json

@@ -1,145 +0,0 @@
-{
-  "测试时间": "2025-04-28 14:12:36",
-  "测试迭代次数": 10,
-  "不使用工具调用": {
-    "平均耗时": 4.596814393997192,
-    "最短耗时": 2.957131862640381,
-    "最长耗时": 10.121938705444336,
-    "标准差": 2.1705468730949593,
-    "所有耗时": [
-      3.18,
-      4.65,
-      10.12,
-      3.5,
-      4.46,
-      4.24,
-      3.23,
-      6.2,
-      2.96,
-      3.42
-    ]
-  },
-  "不使用工具调用_详细响应": [
-    {
-      "内容摘要": "```json\n{\n  \"action\": \"text_reply\",\n  \"content\": \"怎么啦？\",\n  \"emoji_query\": \"友好地询问\"\n}\n```",
-      "推理内容摘要": ""
-    },
-    {
-      "内容摘要": "decide_reply_action(\n    action=\"text_reply\",\n    reasoning=\"千石连续两次叫了我的名字，显然是想引起我的注意或有事要说，作为礼貌应当回应\",\n    emoji_query=\"友善的回应\"\n)",
-      "推理内容摘要": ""
-    },
-    {
-      "内容摘要": "```json\n{\n  \"action\": \"text_reply\",\n  \"content\": \"怎么啦？我在呢~\",\n  \"emoji_query\": \"友好的询问\",\n  \"reasoning\": \"由于对方连续两次提到我的名字，显然是想与我交流，应当及时给予友好回应避免冷场\"\n}\n```",
-      "推理内容摘要": ""
-    },
-    {
-      "内容摘要": "```json\n{\n  \"action\": \"text_reply\",\n  \"content\": \"在呢在呢~怎么啦？\",\n  \"emoji_query\": \"好奇的回应\"\n}\n```",
-      "推理内容摘要": ""
-    },
-    {
-      "内容摘要": "decide_reply_action(\n    action=\"text_reply\",\n    reasoning=\"千石连续两次提到我的名字，显然需要我回应。文字回复更正式且能明确表示我在关注他的信息。\",\n    emoji_query=\"友好的回应\"\n)",
-      "推理内容摘要": ""
-    },
-    {
-      "内容摘要": "```json\n{\n  \"action\": \"text_reply\",\n  \"reasoning\": \"千石连续两次提到我的名字，显然是需要我的回应。作为日常交流，应该给予友善简短的答复。\",\n  \"emoji_query\": \"疑惑的歪头\"\n}\n```",
-      "推理内容摘要": ""
-    },
-    {
-      "内容摘要": "```json\n{\n  \"action\": \"text_reply\",\n  \"content\": \"咋啦千石~\",\n  \"emoji_query\": \"好奇的询问\"\n}\n```",
-      "推理内容摘要": ""
-    },
-    {
-      "内容摘要": "decide_reply_action\n```json\n{\n  \"action\": \"text_reply\",\n  \"content\": \"我在呢～怎么啦？\",\n  \"emoji_query\": \"友好的关心\",\n  \"reasoning\": \"千石连续两次呼唤我的名字，显然是有事情要找我或想引起我的注意。根据回复原则2（有人提到你但未回应），应该用友善的文字进行回应，并附上表达关心的表情符号来延...",
-      "推理内容摘要": ""
-    },
-    {
-      "内容摘要": "```json\n{\n  \"action\": \"text_reply\",\n  \"content\": \"千石怎么啦～\",\n  \"emoji_query\": \"好奇的探询\"\n}\n```",
-      "推理内容摘要": ""
-    },
-    {
-      "内容摘要": "```json\n{\n  \"action\": \"text_reply\",\n  \"content\": \"怎么啦？突然叫我两次\",\n  \"emoji_query\": \"好奇的疑问\"\n}\n```",
-      "推理内容摘要": ""
-    }
-  ],
-  "使用工具调用": {
-    "平均耗时": 8.139546775817871,
-    "最短耗时": 4.9980738162994385,
-    "最长耗时": 18.803313732147217,
-    "标准差": 4.008772720760647,
-    "所有耗时": [
-      5.81,
-      18.8,
-      6.06,
-      8.06,
-      10.07,
-      6.34,
-      7.9,
-      6.66,
-      5.0,
-      6.69
-    ]
-  },
-  "使用工具调用_详细响应": [
-    {
-      "内容摘要": "",
-      "推理内容摘要": "",
-      "工具调用数量": 0,
-      "工具调用详情": []
-    },
-    {
-      "内容摘要": "",
-      "推理内容摘要": "",
-      "工具调用数量": 0,
-      "工具调用详情": []
-    },
-    {
-      "内容摘要": "",
-      "推理内容摘要": "",
-      "工具调用数量": 0,
-      "工具调用详情": []
-    },
-    {
-      "内容摘要": "",
-      "推理内容摘要": "",
-      "工具调用数量": 0,
-      "工具调用详情": []
-    },
-    {
-      "内容摘要": "",
-      "推理内容摘要": "",
-      "工具调用数量": 0,
-      "工具调用详情": []
-    },
-    {
-      "内容摘要": "",
-      "推理内容摘要": "",
-      "工具调用数量": 0,
-      "工具调用详情": []
-    },
-    {
-      "内容摘要": "",
-      "推理内容摘要": "",
-      "工具调用数量": 0,
-      "工具调用详情": []
-    },
-    {
-      "内容摘要": "",
-      "推理内容摘要": "",
-      "工具调用数量": 0,
-      "工具调用详情": []
-    },
-    {
-      "内容摘要": "",
-      "推理内容摘要": "",
-      "工具调用数量": 0,
-      "工具调用详情": []
-    },
-    {
-      "内容摘要": "",
-      "推理内容摘要": "",
-      "工具调用数量": 0,
-      "工具调用详情": []
-    }
-  ],
-  "差异百分比": 77.07
-}

src/api/apiforgui.py

@@ -1,5 +1,8 @@
 from src.heart_flow.heartflow import heartflow
 from src.heart_flow.sub_heartflow import ChatState
+from src.common.logger_manager import get_logger
+
+logger = get_logger("api")
 
 
 async def get_all_subheartflow_ids() -> list:
@@ -14,3 +17,21 @@ async def forced_change_subheartflow_status(subheartflow_id: str, status: ChatSt
     if subheartflow:
         return await heartflow.force_change_subheartflow_status(subheartflow_id, status)
     return False
+
+
+async def get_subheartflow_cycle_info(subheartflow_id: str, history_len: int) -> dict:
+    """获取子心流的循环信息"""
+    subheartflow_cycle_info = await heartflow.api_get_subheartflow_cycle_info(subheartflow_id, history_len)
+    logger.debug(f"子心流 {subheartflow_id} 循环信息: {subheartflow_cycle_info}")
+    if subheartflow_cycle_info:
+        return subheartflow_cycle_info
+    else:
+        logger.warning(f"子心流 {subheartflow_id} 循环信息未找到")
+        return None
+
+
+async def get_all_states():
+    """获取所有状态"""
+    all_states = await heartflow.api_get_all_states()
+    logger.debug(f"所有状态: {all_states}")
+    return all_states

src/api/basic_info_api.py

@@ -0,0 +1,169 @@
+import platform
+import psutil
+import sys
+import os
+
+
+def get_system_info():
+    """获取操作系统信息"""
+    return {
+        "system": platform.system(),
+        "release": platform.release(),
+        "version": platform.version(),
+        "machine": platform.machine(),
+        "processor": platform.processor(),
+    }
+
+
+def get_python_version():
+    """获取 Python 版本信息"""
+    return sys.version
+
+
+def get_cpu_usage():
+    """获取系统总CPU使用率"""
+    return psutil.cpu_percent(interval=1)
+
+
+def get_process_cpu_usage():
+    """获取当前进程CPU使用率"""
+    process = psutil.Process(os.getpid())
+    return process.cpu_percent(interval=1)
+
+
+def get_memory_usage():
+    """获取系统内存使用情况 (单位 MB)"""
+    mem = psutil.virtual_memory()
+    bytes_to_mb = lambda x: round(x / (1024 * 1024), 2)  # noqa
+    return {
+        "total_mb": bytes_to_mb(mem.total),
+        "available_mb": bytes_to_mb(mem.available),
+        "percent": mem.percent,
+        "used_mb": bytes_to_mb(mem.used),
+        "free_mb": bytes_to_mb(mem.free),
+    }
+
+
+def get_process_memory_usage():
+    """获取当前进程内存使用情况 (单位 MB)"""
+    process = psutil.Process(os.getpid())
+    mem_info = process.memory_info()
+    bytes_to_mb = lambda x: round(x / (1024 * 1024), 2)  # noqa
+    return {
+        "rss_mb": bytes_to_mb(mem_info.rss),  # Resident Set Size: 实际使用物理内存
+        "vms_mb": bytes_to_mb(mem_info.vms),  # Virtual Memory Size: 虚拟内存大小
+        "percent": process.memory_percent(),  # 进程内存使用百分比
+    }
+
+
+def get_disk_usage(path="/"):
+    """获取指定路径磁盘使用情况 (单位 GB)"""
+    disk = psutil.disk_usage(path)
+    bytes_to_gb = lambda x: round(x / (1024 * 1024 * 1024), 2)  # noqa
+    return {
+        "total_gb": bytes_to_gb(disk.total),
+        "used_gb": bytes_to_gb(disk.used),
+        "free_gb": bytes_to_gb(disk.free),
+        "percent": disk.percent,
+    }
+
+
+def get_all_basic_info():
+    """获取所有基本信息并封装返回"""
+    # 对于进程CPU使用率，需要先初始化
+    process = psutil.Process(os.getpid())
+    process.cpu_percent(interval=None)  # 初始化调用
+    process_cpu = process.cpu_percent(interval=0.1)  # 短暂间隔获取
+
+    return {
+        "system_info": get_system_info(),
+        "python_version": get_python_version(),
+        "cpu_usage_percent": get_cpu_usage(),
+        "process_cpu_usage_percent": process_cpu,
+        "memory_usage": get_memory_usage(),
+        "process_memory_usage": get_process_memory_usage(),
+        "disk_usage_root": get_disk_usage("/"),
+    }
+
+
+def get_all_basic_info_string() -> str:
+    """获取所有基本信息并以带解释的字符串形式返回"""
+    info = get_all_basic_info()
+
+    sys_info = info["system_info"]
+    mem_usage = info["memory_usage"]
+    proc_mem_usage = info["process_memory_usage"]
+    disk_usage = info["disk_usage_root"]
+
+    # 对进程内存使用百分比进行格式化，保留两位小数
+    proc_mem_percent = round(proc_mem_usage["percent"], 2)
+
+    output_string = f"""[系统信息]
+  - 操作系统: {sys_info["system"]} (例如: Windows, Linux)
+  - 发行版本: {sys_info["release"]} (例如: 11, Ubuntu 20.04)
+  - 详细版本: {sys_info["version"]}
+  - 硬件架构: {sys_info["machine"]} (例如: AMD64)
+  - 处理器信息: {sys_info["processor"]}
+
+[Python 环境]
+  - Python 版本: {info["python_version"]}
+
+[CPU 状态]
+  - 系统总 CPU 使用率: {info["cpu_usage_percent"]}%
+  - 当前进程 CPU 使用率: {info["process_cpu_usage_percent"]}%
+
+[系统内存使用情况]
+  - 总物理内存: {mem_usage["total_mb"]} MB
+  - 可用物理内存: {mem_usage["available_mb"]} MB
+  - 物理内存使用率: {mem_usage["percent"]}%
+  - 已用物理内存: {mem_usage["used_mb"]} MB
+  - 空闲物理内存: {mem_usage["free_mb"]} MB
+
+[当前进程内存使用情况]
+  - 实际使用物理内存 (RSS): {proc_mem_usage["rss_mb"]} MB
+  - 占用虚拟内存 (VMS): {proc_mem_usage["vms_mb"]} MB
+  - 进程内存使用率: {proc_mem_percent}%
+
+[磁盘使用情况 (根目录)]
+  - 总空间: {disk_usage["total_gb"]} GB
+  - 已用空间: {disk_usage["used_gb"]} GB
+  - 可用空间: {disk_usage["free_gb"]} GB
+  - 磁盘使用率: {disk_usage["percent"]}%
+"""
+    return output_string
+
+
+if __name__ == "__main__":
+    print(f"System Info: {get_system_info()}")
+    print(f"Python Version: {get_python_version()}")
+    print(f"CPU Usage: {get_cpu_usage()}%")
+    # 第一次调用 process.cpu_percent() 会返回0.0或一个无意义的值，需要间隔一段时间再调用
+    # 或者在初始化Process对象后，先调用一次cpu_percent(interval=None)，然后再调用cpu_percent(interval=1)
+    current_process = psutil.Process(os.getpid())
+    current_process.cpu_percent(interval=None)  # 初始化
+    print(f"Process CPU Usage: {current_process.cpu_percent(interval=1)}%")  # 实际获取
+
+    memory_usage_info = get_memory_usage()
+    print(
+        f"Memory Usage: Total={memory_usage_info['total_mb']}MB, Used={memory_usage_info['used_mb']}MB, Percent={memory_usage_info['percent']}%"
+    )
+
+    process_memory_info = get_process_memory_usage()
+    print(
+        f"Process Memory Usage: RSS={process_memory_info['rss_mb']}MB, VMS={process_memory_info['vms_mb']}MB, Percent={process_memory_info['percent']}%"
+    )
+
+    disk_usage_info = get_disk_usage("/")
+    print(
+        f"Disk Usage (Root): Total={disk_usage_info['total_gb']}GB, Used={disk_usage_info['used_gb']}GB, Percent={disk_usage_info['percent']}%"
+    )
+
+    print("\n--- All Basic Info (JSON) ---")
+    all_info = get_all_basic_info()
+    import json
+
+    print(json.dumps(all_info, indent=4, ensure_ascii=False))
+
+    print("\n--- All Basic Info (String with Explanations) ---")
+    info_string = get_all_basic_info_string()
+    print(info_string)

src/api/config_api.py

@@ -1,6 +1,7 @@
 from typing import List, Optional, Dict, Any
 import strawberry
-from packaging.version import Version
+
+# from packaging.version import Version
 import os
 
 ROOT_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
@@ -10,7 +11,7 @@ ROOT_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
 class APIBotConfig:
     """机器人配置类"""
 
-    INNER_VERSION: Version  # 配置文件内部版本号
+    INNER_VERSION: str  # 配置文件内部版本号（toml为字符串）
     MAI_VERSION: str  # 硬编码的版本信息
 
     # bot
@@ -34,28 +35,28 @@ class APIBotConfig:
     appearance: str  # 外貌特征描述
 
     # schedule
-    ENABLE_SCHEDULE_GEN: bool  # 是否启用日程生成
-    ENABLE_SCHEDULE_INTERACTION: bool  # 是否启用日程交互
-    PROMPT_SCHEDULE_GEN: str  # 日程生成提示词
-    SCHEDULE_DOING_UPDATE_INTERVAL: int  # 日程进行中更新间隔
-    SCHEDULE_TEMPERATURE: float  # 日程生成温度
-    TIME_ZONE: str  # 时区
+    enable_schedule_gen: bool  # 是否启用日程表
+    enable_schedule_interaction: bool  # 日程表是否影响回复模式
+    prompt_schedule_gen: str  # 日程生成提示词
+    schedule_doing_update_interval: int  # 日程表更新间隔（秒）
+    schedule_temperature: float  # 日程表温度
+    time_zone: str  # 时区
 
     # platforms
     platforms: Dict[str, str]  # 平台信息
 
     # chat
-    allow_focus_mode: bool  # 是否允许专注模式
-    base_normal_chat_num: int  # 基础普通聊天次数
-    base_focused_chat_num: int  # 基础专注聊天次数
-    observation_context_size: int  # 观察上下文大小
+    allow_focus_mode: bool  # 是否允许专注聊天状态
+    base_normal_chat_num: int  # 最多允许多少个群进行普通聊天
+    base_focused_chat_num: int  # 最多允许多少个群进行专注聊天
+    observation_context_size: int  # 观察到的最长上下文大小
     message_buffer: bool  # 是否启用消息缓冲
     ban_words: List[str]  # 禁止词列表
     ban_msgs_regex: List[str]  # 禁止消息的正则表达式列表
 
     # normal_chat
-    MODEL_R1_PROBABILITY: float  # 模型推理概率
-    MODEL_V3_PROBABILITY: float  # 模型普通概率
+    model_reasoning_probability: float  # 推理模型概率
+    model_normal_probability: float  # 普通模型概率
     emoji_chance: float  # 表情符号出现概率
     thinking_timeout: int  # 思考超时时间
     willing_mode: str  # 意愿模式
@@ -63,8 +64,8 @@ class APIBotConfig:
     response_interested_rate_amplifier: float  # 回复兴趣率放大器
     down_frequency_rate: float  # 降低频率率
     emoji_response_penalty: float  # 表情回复惩罚
-    mentioned_bot_inevitable_reply: bool  # 提到机器人时是否必定回复
-    at_bot_inevitable_reply: bool  # @机器人时是否必定回复
+    mentioned_bot_inevitable_reply: bool  # 提及 bot 必然回复
+    at_bot_inevitable_reply: bool  # @bot 必然回复
 
     # focus_chat
     reply_trigger_threshold: float  # 回复触发阈值
@@ -78,24 +79,25 @@ class APIBotConfig:
     # emoji
     max_emoji_num: int  # 最大表情符号数量
     max_reach_deletion: bool  # 达到最大数量时是否删除
-    EMOJI_CHECK_INTERVAL: int  # 表情检查间隔
-    EMOJI_REGISTER_INTERVAL: Optional[int]  # 表情注册间隔（兼容性保留）
-    EMOJI_SAVE: bool  # 是否保存表情
-    EMOJI_CHECK: bool  # 是否检查表情
-    EMOJI_CHECK_PROMPT: str  # 表情检查提示词
+    check_interval: int  # 检查表情包的时间间隔(分钟)
+    save_pic: bool  # 是否保存图片
+    save_emoji: bool  # 是否保存表情包
+    steal_emoji: bool  # 是否偷取表情包
+    enable_check: bool  # 是否启用表情包过滤
+    check_prompt: str  # 表情包过滤要求
 
     # memory
-    build_memory_interval: int  # 构建记忆间隔
-    memory_build_distribution: List[float]  # 记忆构建分布
-    build_memory_sample_num: int  # 构建记忆样本数量
-    build_memory_sample_length: int  # 构建记忆样本长度
+    build_memory_interval: int  # 记忆构建间隔
+    build_memory_distribution: List[float]  # 记忆构建分布
+    build_memory_sample_num: int  # 采样数量
+    build_memory_sample_length: int  # 采样长度
     memory_compress_rate: float  # 记忆压缩率
-    forget_memory_interval: int  # 忘记记忆间隔
-    memory_forget_time: int  # 记忆忘记时间
-    memory_forget_percentage: float  # 记忆忘记百分比
-    consolidate_memory_interval: int  # 巩固记忆间隔
-    consolidation_similarity_threshold: float  # 巩固相似度阈值
-    consolidation_check_percentage: float  # 巩固检查百分比
+    forget_memory_interval: int  # 记忆遗忘间隔
+    memory_forget_time: int  # 记忆遗忘时间（小时）
+    memory_forget_percentage: float  # 记忆遗忘比例
+    consolidate_memory_interval: int  # 记忆整合间隔
+    consolidation_similarity_threshold: float  # 相似度阈值
+    consolidation_check_percentage: float  # 检查节点比例
     memory_ban_words: List[str]  # 记忆禁止词列表
 
     # mood
@@ -128,21 +130,19 @@ class APIBotConfig:
     # experimental
     enable_friend_chat: bool  # 是否启用好友聊天
     talk_allowed_private: List[int]  # 允许私聊的QQ号列表
-    enable_pfc_chatting: bool  # 是否启用PFC聊天
+    pfc_chatting: bool  # 是否启用PFC聊天
 
     # 模型配置
     llm_reasoning: Dict[str, Any]  # 推理模型配置
     llm_normal: Dict[str, Any]  # 普通模型配置
     llm_topic_judge: Dict[str, Any]  # 主题判断模型配置
     llm_summary: Dict[str, Any]  # 总结模型配置
-    llm_emotion_judge: Optional[Dict[str, Any]]  # 情绪判断模型配置（兼容性保留）
-    embedding: Dict[str, Any]  # 嵌入模型配置
     vlm: Dict[str, Any]  # VLM模型配置
-    moderation: Optional[Dict[str, Any]]  # 审核模型配置（兼容性保留）
+    llm_heartflow: Dict[str, Any]  # 心流模型配置
     llm_observation: Dict[str, Any]  # 观察模型配置
     llm_sub_heartflow: Dict[str, Any]  # 子心流模型配置
-    llm_heartflow: Dict[str, Any]  # 心流模型配置
     llm_plan: Optional[Dict[str, Any]]  # 计划模型配置
+    embedding: Dict[str, Any]  # 嵌入模型配置
     llm_PFC_action_planner: Optional[Dict[str, Any]]  # PFC行动计划模型配置
     llm_PFC_chat: Optional[Dict[str, Any]]  # PFC聊天模型配置
     llm_PFC_reply_checker: Optional[Dict[str, Any]]  # PFC回复检查模型配置
@@ -150,6 +150,84 @@ class APIBotConfig:
 
     api_urls: Optional[Dict[str, str]]  # API地址配置
 
+    @staticmethod
+    def validate_config(config: dict):
+        """
+        校验传入的 toml 配置字典是否合法。
+        :param config: toml库load后的配置字典
+        :raises: ValueError, KeyError, TypeError
+        """
+        # 检查主层级
+        required_sections = [
+            "inner",
+            "bot",
+            "groups",
+            "personality",
+            "identity",
+            "schedule",
+            "platforms",
+            "chat",
+            "normal_chat",
+            "focus_chat",
+            "emoji",
+            "memory",
+            "mood",
+            "keywords_reaction",
+            "chinese_typo",
+            "response_splitter",
+            "remote",
+            "experimental",
+            "model",
+        ]
+        for section in required_sections:
+            if section not in config:
+                raise KeyError(f"缺少配置段: [{section}]")
+
+        # 检查部分关键字段
+        if "version" not in config["inner"]:
+            raise KeyError("缺少 inner.version 字段")
+        if not isinstance(config["inner"]["version"], str):
+            raise TypeError("inner.version 必须为字符串")
+
+        if "qq" not in config["bot"]:
+            raise KeyError("缺少 bot.qq 字段")
+        if not isinstance(config["bot"]["qq"], int):
+            raise TypeError("bot.qq 必须为整数")
+
+        if "personality_core" not in config["personality"]:
+            raise KeyError("缺少 personality.personality_core 字段")
+        if not isinstance(config["personality"]["personality_core"], str):
+            raise TypeError("personality.personality_core 必须为字符串")
+
+        if "identity_detail" not in config["identity"]:
+            raise KeyError("缺少 identity.identity_detail 字段")
+        if not isinstance(config["identity"]["identity_detail"], list):
+            raise TypeError("identity.identity_detail 必须为列表")
+
+        # 可继续添加更多字段的类型和值检查
+        # ...
+
+        # 检查模型配置
+        model_keys = [
+            "llm_reasoning",
+            "llm_normal",
+            "llm_topic_judge",
+            "llm_summary",
+            "vlm",
+            "llm_heartflow",
+            "llm_observation",
+            "llm_sub_heartflow",
+            "embedding",
+        ]
+        if "model" not in config:
+            raise KeyError("缺少 [model] 配置段")
+        for key in model_keys:
+            if key not in config["model"]:
+                raise KeyError(f"缺少 model.{key} 配置")
+
+        # 检查通过
+        return True
+
 
 @strawberry.type
 class APIEnvConfig:
@@ -182,6 +260,71 @@ class APIEnvConfig:
     def get_env(self) -> str:
         return "env"
 
+    @staticmethod
+    def validate_config(config: dict):
+        """
+        校验环境变量配置字典是否合法。
+        :param config: 环境变量配置字典
+        :raises: KeyError, TypeError
+        """
+        required_fields = [
+            "HOST",
+            "PORT",
+            "PLUGINS",
+            "MONGODB_HOST",
+            "MONGODB_PORT",
+            "DATABASE_NAME",
+            "CHAT_ANY_WHERE_BASE_URL",
+            "SILICONFLOW_BASE_URL",
+            "DEEP_SEEK_BASE_URL",
+        ]
+        for field in required_fields:
+            if field not in config:
+                raise KeyError(f"缺少环境变量配置字段: {field}")
+
+        if not isinstance(config["HOST"], str):
+            raise TypeError("HOST 必须为字符串")
+        if not isinstance(config["PORT"], int):
+            raise TypeError("PORT 必须为整数")
+        if not isinstance(config["PLUGINS"], list):
+            raise TypeError("PLUGINS 必须为列表")
+        if not isinstance(config["MONGODB_HOST"], str):
+            raise TypeError("MONGODB_HOST 必须为字符串")
+        if not isinstance(config["MONGODB_PORT"], int):
+            raise TypeError("MONGODB_PORT 必须为整数")
+        if not isinstance(config["DATABASE_NAME"], str):
+            raise TypeError("DATABASE_NAME 必须为字符串")
+        if not isinstance(config["CHAT_ANY_WHERE_BASE_URL"], str):
+            raise TypeError("CHAT_ANY_WHERE_BASE_URL 必须为字符串")
+        if not isinstance(config["SILICONFLOW_BASE_URL"], str):
+            raise TypeError("SILICONFLOW_BASE_URL 必须为字符串")
+        if not isinstance(config["DEEP_SEEK_BASE_URL"], str):
+            raise TypeError("DEEP_SEEK_BASE_URL 必须为字符串")
+
+        # 可选字段类型检查
+        optional_str_fields = [
+            "DEEP_SEEK_KEY",
+            "CHAT_ANY_WHERE_KEY",
+            "SILICONFLOW_KEY",
+            "CONSOLE_LOG_LEVEL",
+            "FILE_LOG_LEVEL",
+            "DEFAULT_CONSOLE_LOG_LEVEL",
+            "DEFAULT_FILE_LOG_LEVEL",
+        ]
+        for field in optional_str_fields:
+            if field in config and config[field] is not None and not isinstance(config[field], str):
+                raise TypeError(f"{field} 必须为字符串或None")
+
+        if (
+            "SIMPLE_OUTPUT" in config
+            and config["SIMPLE_OUTPUT"] is not None
+            and not isinstance(config["SIMPLE_OUTPUT"], bool)
+        ):
+            raise TypeError("SIMPLE_OUTPUT 必须为布尔值或None")
+
+        # 检查通过
+        return True
+
 
 print("当前路径：")
 print(ROOT_PATH)

src/api/main.py

@@ -1,12 +1,23 @@
 from fastapi import APIRouter
 from strawberry.fastapi import GraphQLRouter
+import os
+import sys
 
+# from src.heart_flow.heartflow import heartflow
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")))
 # from src.config.config import BotConfig
 from src.common.logger_manager import get_logger
 from src.api.reload_config import reload_config as reload_config_func
 from src.common.server import global_server
-from .apiforgui import get_all_subheartflow_ids, forced_change_subheartflow_status
+from src.api.apiforgui import (
+    get_all_subheartflow_ids,
+    forced_change_subheartflow_status,
+    get_subheartflow_cycle_info,
+    get_all_states,
+)
 from src.heart_flow.sub_heartflow import ChatState
+from src.api.basic_info_api import get_all_basic_info  # 新增导入
+
 # import uvicorn
 # import os
 
@@ -51,6 +62,54 @@ async def forced_change_subheartflow_status_api(subheartflow_id: str, status: Ch
         return {"status": "failed"}
 
 
+@router.get("/stop")
+async def force_stop_maibot():
+    """强制停止MAI Bot"""
+    from bot import request_shutdown
+
+    success = await request_shutdown()
+    if success:
+        logger.info("MAI Bot已强制停止")
+        return {"status": "success"}
+    else:
+        logger.error("MAI Bot强制停止失败")
+        return {"status": "failed"}
+
+
+@router.get("/gui/subheartflow/cycleinfo")
+async def get_subheartflow_cycle_info_api(subheartflow_id: str, history_len: int):
+    """获取子心流的循环信息"""
+    cycle_info = await get_subheartflow_cycle_info(subheartflow_id, history_len)
+    if cycle_info:
+        return {"status": "success", "data": cycle_info}
+    else:
+        logger.warning(f"子心流 {subheartflow_id} 循环信息未找到")
+        return {"status": "failed", "reason": "subheartflow not found"}
+
+
+@router.get("/gui/get_all_states")
+async def get_all_states_api():
+    """获取所有状态"""
+    all_states = await get_all_states()
+    if all_states:
+        return {"status": "success", "data": all_states}
+    else:
+        logger.warning("获取所有状态失败")
+        return {"status": "failed", "reason": "failed to get all states"}
+
+
+@router.get("/info")
+async def get_system_basic_info():
+    """获取系统基本信息"""
+    logger.info("请求系统基本信息")
+    try:
+        info = get_all_basic_info()
+        return {"status": "success", "data": info}
+    except Exception as e:
+        logger.error(f"获取系统基本信息失败: {e}")
+        return {"status": "failed", "reason": str(e)}
+
+
 def start_api_server():
     """启动API服务器"""
     global_server.register_router(router, prefix="/api/v1")

src/common/logger.py

@@ -6,56 +6,6 @@ from types import ModuleType
 from pathlib import Path
 from dotenv import load_dotenv
 
-"""
-日志颜色说明:
-
-1. 主程序(Main)
-浅黄色标题 | 浅黄色消息
-
-2. 海马体(Memory)  
-浅黄色标题 | 浅黄色消息
-
-3. PFC(前额叶皮质)
-浅绿色标题 | 浅绿色消息
-
-4. 心情(Mood)
-品红色标题 | 品红色消息
-
-5. 工具使用(Tool)
-品红色标题 | 品红色消息
-
-6. 关系(Relation)
-浅品红色标题 | 浅品红色消息
-
-7. 配置(Config)
-浅青色标题 | 浅青色消息
-
-8. 麦麦大脑袋
-浅绿色标题 | 浅绿色消息
-
-9. 在干嘛
-青色标题 | 青色消息
-
-10. 麦麦组织语言
-浅绿色标题 | 浅绿色消息
-
-11. 见闻(Chat)
-浅蓝色标题 | 绿色消息
-
-12. 表情包(Emoji)
-橙色标题 | 橙色消息 fg #FFD700
-
-13. 子心流
-
-13. 其他模块
-模块名标题 | 对应颜色消息
-
-
-注意:
-1. 级别颜色遵循loguru默认配置
-2. 可通过环境变量修改日志级别
-"""
-
 
 # 加载 .env 文件
 env_path = Path(__file__).resolve().parent.parent.parent / ".env"
@@ -80,7 +30,8 @@ _custom_style_handlers: dict[Tuple[str, str], List[int]] = {}  # 记录自定义
 
 # 获取日志存储根地址
 current_file_path = Path(__file__).resolve()
-LOG_ROOT = "logs"
+ROOT_PATH = os.path.abspath(os.path.join(current_file_path, "..", ".."))
+LOG_ROOT = str(ROOT_PATH) + "/" + "logs"
 
 SIMPLE_OUTPUT = os.getenv("SIMPLE_OUTPUT", "false").strip().lower()
 if SIMPLE_OUTPUT == "true":

src/common/server.py

@@ -1,4 +1,5 @@
 from fastapi import FastAPI, APIRouter
+from fastapi.middleware.cors import CORSMiddleware  # 新增导入
 from typing import Optional
 from uvicorn import Config, Server as UvicornServer
 import os
@@ -15,6 +16,21 @@ class Server:
         self._server: Optional[UvicornServer] = None
         self.set_address(host, port)
 
+        # 配置 CORS
+        origins = [
+            "http://localhost:3000",  # 允许的前端源
+            "http://127.0.0.1:3000",
+            # 在生产环境中，您应该添加实际的前端域名
+        ]
+
+        self.app.add_middleware(
+            CORSMiddleware,
+            allow_origins=origins,
+            allow_credentials=True,  # 是否支持 cookie
+            allow_methods=["*"],  # 允许所有 HTTP 方法
+            allow_headers=["*"],  # 允许所有 HTTP 请求头
+        )
+
     def register_router(self, router: APIRouter, prefix: str = ""):
         """注册路由
 

src/config/config.py

@@ -25,7 +25,7 @@ logger = get_logger("config")
 # 考虑到，实际上配置文件中的mai_version是不会自动更新的,所以采用硬编码
 is_test = False
 mai_version_main = "0.6.3"
-mai_version_fix = "fix-2"
+mai_version_fix = "fix-3"
 
 if mai_version_fix:
     if is_test:

src/do_tool/not_used/change_mood.py

@@ -1,10 +1,10 @@
-from src.do_tool.tool_can_use.base_tool import BaseTool
-from src.config.config import global_config
-from src.common.logger_manager import get_logger
-from src.plugins.moods.moods import MoodManager
-
 from typing import Any
 
+from src.common.logger_manager import get_logger
+from src.config.config import global_config
+from src.do_tool.tool_can_use.base_tool import BaseTool
+from src.manager.mood_manager import mood_manager
+
 logger = get_logger("change_mood_tool")
 
 
@@ -36,7 +36,6 @@ class ChangeMoodTool(BaseTool):
             response_set = function_args.get("response_set")
             _message_processed_plain_text = function_args.get("text")
 
-            mood_manager = MoodManager.get_instance()
             # gpt = ResponseGenerator()
 
             if response_set is None:

src/heart_flow/chat_state_info.py

@@ -1,4 +1,4 @@
-from src.plugins.moods.moods import MoodManager
+from src.manager.mood_manager import mood_manager
 import enum
 
 
@@ -13,5 +13,5 @@ class ChatStateInfo:
         self.chat_status: ChatState = ChatState.ABSENT
         self.current_state_time = 120
 
-        self.mood_manager = MoodManager()
-        self.mood = self.mood_manager.get_prompt()
+        self.mood_manager = mood_manager
+        self.mood = self.mood_manager.get_mood_prompt()

src/heart_flow/heartflow.py

@@ -67,6 +67,23 @@ class Heartflow:
         # 这里的 message 是可选的，可能是一个消息对象，也可能是其他类型的数据
         return await self.subheartflow_manager.force_change_state(subheartflow_id, status)
 
+    async def api_get_all_states(self):
+        """获取所有状态"""
+        return await self.interest_logger.api_get_all_states()
+
+    async def api_get_subheartflow_cycle_info(self, subheartflow_id: str, history_len: int) -> Optional[dict]:
+        """获取子心流的循环信息"""
+        subheartflow = await self.subheartflow_manager.get_or_create_subheartflow(subheartflow_id)
+        if not subheartflow:
+            logger.warning(f"尝试获取不存在的子心流 {subheartflow_id} 的周期信息")
+            return None
+        heartfc_instance = subheartflow.heart_fc_instance
+        if not heartfc_instance:
+            logger.warning(f"子心流 {subheartflow_id} 没有心流实例，无法获取周期信息")
+            return None
+
+        return heartfc_instance.get_cycle_history(last_n=history_len)
+
     async def heartflow_start_working(self):
         """启动后台任务"""
         await self.background_task_manager.start_tasks()

src/heart_flow/interest_logger.py

@@ -158,3 +158,55 @@ class InterestLogger:
         except Exception as e:
             logger.error(f"记录状态时发生意外错误: {e}")
             logger.error(traceback.format_exc())
+
+    async def api_get_all_states(self):
+        """获取主心流和所有子心流的状态。"""
+        try:
+            current_timestamp = time.time()
+
+            # main_mind = self.heartflow.current_mind
+            # 获取 Mai 状态名称
+            mai_state_name = self.heartflow.current_state.get_current_state().name
+
+            all_subflow_states = await self.get_all_subflow_states()
+
+            log_entry_base = {
+                "timestamp": round(current_timestamp, 2),
+                # "main_mind": main_mind,
+                "mai_state": mai_state_name,
+                "subflow_count": len(all_subflow_states),
+                "subflows": [],
+            }
+
+            subflow_details = []
+            items_snapshot = list(all_subflow_states.items())
+            for stream_id, state in items_snapshot:
+                group_name = stream_id
+                try:
+                    chat_stream = chat_manager.get_stream(stream_id)
+                    if chat_stream:
+                        if chat_stream.group_info:
+                            group_name = chat_stream.group_info.group_name
+                        elif chat_stream.user_info:
+                            group_name = f"私聊_{chat_stream.user_info.user_nickname}"
+                except Exception as e:
+                    logger.trace(f"无法获取 stream_id {stream_id} 的群组名: {e}")
+
+                interest_state = state.get("interest_state", {})
+
+                subflow_entry = {
+                    "stream_id": stream_id,
+                    "group_name": group_name,
+                    "sub_mind": state.get("current_mind", "未知"),
+                    "sub_chat_state": state.get("chat_state", "未知"),
+                    "interest_level": interest_state.get("interest_level", 0.0),
+                    "start_hfc_probability": interest_state.get("start_hfc_probability", 0.0),
+                    # "is_above_threshold": interest_state.get("is_above_threshold", False),
+                }
+                subflow_details.append(subflow_entry)
+
+            log_entry_base["subflows"] = subflow_details
+            return subflow_details
+        except Exception as e:
+            logger.error(f"记录状态时发生意外错误: {e}")
+            logger.error(traceback.format_exc())

src/heart_flow/mai_state_manager.py

@@ -3,7 +3,7 @@ import time
 import random
 from typing import List, Tuple, Optional
 from src.common.logger_manager import get_logger
-from src.plugins.moods.moods import MoodManager
+from src.manager.mood_manager import mood_manager
 from src.config.config import global_config
 
 logger = get_logger("mai_state")
@@ -88,7 +88,7 @@ class MaiStateInfo:
         self.last_min_check_time: float = time.time()  # 上次1分钟规则检查时间
 
         # Mood management is now part of MaiStateInfo
-        self.mood_manager = MoodManager.get_instance()  # Use singleton instance
+        self.mood_manager = mood_manager  # Use singleton instance
 
     def update_mai_status(self, new_status: MaiState) -> bool:
         """
@@ -124,7 +124,7 @@ class MaiStateInfo:
     def get_mood_prompt(self) -> str:
         """获取当前的心情提示词"""
         # Delegate to the internal mood manager
-        return self.mood_manager.get_prompt()
+        return self.mood_manager.get_mood_prompt()
 
     def get_current_state(self) -> MaiState:
         """获取当前的 MaiState"""

src/heart_flow/sub_heartflow.py

@@ -110,7 +110,7 @@ class SubHeartflow:
                 logger.error(f"{self.log_prefix} 停止 NormalChat 监控任务时出错: {e}")
                 logger.error(traceback.format_exc())
 
-    async def _start_normal_chat(self) -> bool:
+    async def _start_normal_chat(self, rewind=False) -> bool:
         """
         启动 NormalChat 实例，并进行异步初始化。
         进入 CHAT 状态时使用。
@@ -125,8 +125,10 @@ class SubHeartflow:
             if not chat_stream:
                 logger.error(f"{log_prefix} 无法获取 chat_stream，无法启动 NormalChat。")
                 return False
-
-            self.normal_chat_instance = NormalChat(chat_stream=chat_stream, interest_dict=self.get_interest_dict())
+            if rewind:
+                self.normal_chat_instance = NormalChat(chat_stream=chat_stream, interest_dict=self.get_interest_dict())
+            else:
+                self.normal_chat_instance = NormalChat(chat_stream=chat_stream)
 
             # 进行异步初始化
             await self.normal_chat_instance.initialize()
@@ -218,13 +220,22 @@ class SubHeartflow:
         if new_state == ChatState.CHAT:
             # 移除限额检查逻辑
             logger.debug(f"{log_prefix} 准备进入或保持 聊天 状态")
-            if await self._start_normal_chat():
-                # logger.info(f"{log_prefix} 成功进入或保持 NormalChat 状态。")
-                state_changed = True
+            if current_state == ChatState.FOCUSED:
+                if await self._start_normal_chat(rewind=False):
+                    # logger.info(f"{log_prefix} 成功进入或保持 NormalChat 状态。")
+                    state_changed = True
+                else:
+                    logger.error(f"{log_prefix} 从FOCUSED状态启动 NormalChat 失败，无法进入 CHAT 状态。")
+                    # 考虑是否需要回滚状态或采取其他措施
+                    return  # 启动失败，不改变状态
             else:
-                logger.error(f"{log_prefix} 启动 NormalChat 失败，无法进入 CHAT 状态。")
-                # 考虑是否需要回滚状态或采取其他措施
-                return  # 启动失败，不改变状态
+                if await self._start_normal_chat(rewind=True):
+                    # logger.info(f"{log_prefix} 成功进入或保持 NormalChat 状态。")
+                    state_changed = True
+                else:
+                    logger.error(f"{log_prefix} 从ABSENT状态启动 NormalChat 失败，无法进入 CHAT 状态。")
+                    # 考虑是否需要回滚状态或采取其他措施
+                    return  # 启动失败，不改变状态
 
         elif new_state == ChatState.FOCUSED:
             # 移除限额检查逻辑
@@ -239,6 +250,8 @@ class SubHeartflow:
 
         elif new_state == ChatState.ABSENT:
             logger.info(f"{log_prefix} 进入 ABSENT 状态，停止所有聊天活动...")
+            self.clear_interest_dict()
+
             await self._stop_normal_chat()
             await self._stop_heart_fc_chat()
             state_changed = True  # 总是可以成功转换到 ABSENT

src/heart_flow/sub_mind.py

@@ -14,6 +14,8 @@ from src.plugins.chat.chat_stream import chat_manager
 from src.plugins.heartFC_chat.heartFC_Cycleinfo import CycleInfo
 import difflib
 from src.plugins.person_info.relationship_manager import relationship_manager
+from src.plugins.memory_system.Hippocampus import HippocampusManager
+import jieba
 
 
 logger = get_logger("sub_heartflow")
@@ -223,7 +225,48 @@ class SubMind:
         chat_observe_info = observation.get_observe_info()
         person_list = observation.person_list
 
-        # ---------- 2. 准备工具和个性化数据 ----------
+        # ---------- 2. 获取记忆 ----------
+        try:
+            # 从聊天内容中提取关键词
+            chat_words = set(jieba.cut(chat_observe_info))
+            # 过滤掉停用词和单字词
+            keywords = [word for word in chat_words if len(word) > 1]
+            # 去重并限制数量
+            keywords = list(set(keywords))[:5]
+
+            logger.debug(f"{self.log_prefix} 提取的关键词: {keywords}")
+            # 检查已有记忆，过滤掉已存在的主题
+            existing_topics = set()
+            for item in self.structured_info:
+                if item["type"] == "memory":
+                    existing_topics.add(item["id"])
+
+            # 过滤掉已存在的主题
+            filtered_keywords = [k for k in keywords if k not in existing_topics]
+
+            if not filtered_keywords:
+                logger.debug(f"{self.log_prefix} 所有关键词对应的记忆都已存在，跳过记忆提取")
+            else:
+                # 调用记忆系统获取相关记忆
+                related_memory = await HippocampusManager.get_instance().get_memory_from_topic(
+                    valid_keywords=filtered_keywords, max_memory_num=3, max_memory_length=2, max_depth=3
+                )
+
+                logger.debug(f"{self.log_prefix} 获取到的记忆: {related_memory}")
+
+                if related_memory:
+                    for topic, memory in related_memory:
+                        new_item = {"type": "memory", "id": topic, "content": memory, "ttl": 3}
+                        self.structured_info.append(new_item)
+                        logger.debug(f"{self.log_prefix} 添加新记忆: {topic} - {memory}")
+                else:
+                    logger.debug(f"{self.log_prefix} 没有找到相关记忆")
+
+        except Exception as e:
+            logger.error(f"{self.log_prefix} 获取记忆时出错: {e}")
+            logger.error(traceback.format_exc())
+
+        # ---------- 3. 准备工具和个性化数据 ----------
         # 初始化工具
         tool_instance = ToolUser()
         tools = tool_instance._define_tools()
@@ -244,7 +287,7 @@ class SubMind:
         # 获取当前时间
         time_now = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
 
-        # ---------- 3. 构建思考指导部分 ----------
+        # ---------- 4. 构建思考指导部分 ----------
         # 创建本地随机数生成器，基于分钟数作为种子
         local_random = random.Random()
         current_minute = int(time.strftime("%M"))
@@ -328,7 +371,7 @@ class SubMind:
             [option[0] for option in hf_options], weights=[option[1] for option in hf_options], k=1
         )[0]
 
-        # ---------- 4. 构建最终提示词 ----------
+        # ---------- 5. 构建最终提示词 ----------
         # --- Choose template based on chat type ---
         logger.debug(f"is_group_chat: {is_group_chat}")
         if is_group_chat:
@@ -363,7 +406,7 @@ class SubMind:
             )
         # --- End choosing template ---
 
-        # ---------- 5. 执行LLM请求并处理响应 ----------
+        # ---------- 6. 执行LLM请求并处理响应 ----------
         content = ""  # 初始化内容变量
         _reasoning_content = ""  # 初始化推理内容变量
 
@@ -412,7 +455,7 @@ class SubMind:
             content = "(不知道该想些什么...)"
             logger.warning(f"{self.log_prefix} LLM返回空结果，思考失败。")
 
-        # ---------- 6. 应用概率性去重和修饰 ----------
+        # ---------- 7. 应用概率性去重和修饰 ----------
         new_content = content  # 保存 LLM 直接输出的结果
         try:
             similarity = calculate_similarity(previous_mind, new_content)
@@ -485,7 +528,7 @@ class SubMind:
             # 出错时保留原始 content
             content = new_content
 
-        # ---------- 7. 更新思考状态并返回结果 ----------
+        # ---------- 8. 更新思考状态并返回结果 ----------
         logger.info(f"{self.log_prefix} 最终心流思考结果: {content}")
         # 更新当前思考内容
         self.update_current_mind(content)

src/heart_flow/subheartflow_manager.py

@@ -274,19 +274,17 @@ class SubHeartflowManager:
     async def sbhf_absent_into_focus(self):
         """评估子心流兴趣度，满足条件且未达上限则提升到FOCUSED状态（基于start_hfc_probability）"""
         try:
-            log_prefix = "[兴趣评估]"
-            # 使用 self.mai_state_info 获取当前状态和限制
             current_state = self.mai_state_info.get_current_state()
             focused_limit = current_state.get_focused_chat_max_num()
 
             # --- 新增：检查是否允许进入 FOCUS 模式 --- #
             if not global_config.allow_focus_mode:
                 if int(time.time()) % 60 == 0:  # 每60秒输出一次日志避免刷屏
-                    logger.debug(f"{log_prefix} 配置不允许进入 FOCUSED 状态 (allow_focus_mode=False)")
+                    logger.trace("未开启 FOCUSED 状态 (allow_focus_mode=False)")
                 return  # 如果不允许，直接返回
             # --- 结束新增 ---
 
-            logger.debug(f"{log_prefix} 当前状态 ({current_state.value}) 可以在{focused_limit}个群激情聊天")
+            logger.info(f"当前状态 ({current_state.value}) 可以在{focused_limit}个群 专注聊天")
 
             if focused_limit <= 0:
                 # logger.debug(f"{log_prefix} 当前状态 ({current_state.value}) 不允许 FOCUSED 子心流")
@@ -294,35 +292,37 @@ class SubHeartflowManager:
 
             current_focused_count = self.count_subflows_by_state(ChatState.FOCUSED)
             if current_focused_count >= focused_limit:
-                logger.debug(f"{log_prefix} 已达专注上限 ({current_focused_count}/{focused_limit})")
+                logger.debug(f"已达专注上限 ({current_focused_count}/{focused_limit})")
                 return
 
             for sub_hf in list(self.subheartflows.values()):
                 flow_id = sub_hf.subheartflow_id
                 stream_name = chat_manager.get_stream_name(flow_id) or flow_id
 
-                logger.debug(f"{log_prefix} 检查子心流: {stream_name}，现在状态: {sub_hf.chat_state.chat_status.value}")
-
                 # 跳过非CHAT状态或已经是FOCUSED状态的子心流
                 if sub_hf.chat_state.chat_status == ChatState.FOCUSED:
                     continue
 
+                if sub_hf.interest_chatting.start_hfc_probability == 0:
+                    continue
+                else:
+                    logger.debug(
+                        f"{stream_name}，现在状态: {sub_hf.chat_state.chat_status.value}，进入专注概率: {sub_hf.interest_chatting.start_hfc_probability}"
+                    )
+
+                # 调试用
                 from .mai_state_manager import enable_unlimited_hfc_chat
 
                 if not enable_unlimited_hfc_chat:
                     if sub_hf.chat_state.chat_status != ChatState.CHAT:
                         continue
 
-                # 检查是否满足提升概率
-                logger.debug(
-                    f"{log_prefix} 检查子心流: {stream_name}，现在概率: {sub_hf.interest_chatting.start_hfc_probability}"
-                )
                 if random.random() >= sub_hf.interest_chatting.start_hfc_probability:
                     continue
 
                 # 再次检查是否达到上限
                 if current_focused_count >= focused_limit:
-                    logger.debug(f"{log_prefix} [{stream_name}] 已达专注上限")
+                    logger.debug(f"{stream_name} 已达专注上限")
                     break
 
                 # 获取最新状态并执行提升
@@ -331,7 +331,7 @@ class SubHeartflowManager:
                     continue
 
                 logger.info(
-                    f"{log_prefix} [{stream_name}] 触发 认真水群 (概率={current_subflow.interest_chatting.start_hfc_probability:.2f})"
+                    f"{stream_name} 触发 认真水群 (概率={current_subflow.interest_chatting.start_hfc_probability:.2f})"
                 )
 
                 # 执行状态提升
@@ -372,12 +372,6 @@ class SubHeartflowManager:
             stream_name = chat_manager.get_stream_name(flow_id) or flow_id
             log_prefix = f"[{stream_name}]"
 
-            # --- Private chat check (redundant due to filter above, but safe) ---
-            # if not sub_hf_to_evaluate.is_group_chat:
-            #     logger.debug(f"{log_prefix} 是私聊，跳过 CHAT 状态评估。")
-            #     return
-            # --- End check ---
-
             # 3. 检查 CHAT 上限
             current_chat_count = self.count_subflows_by_state_nolock(ChatState.CHAT)
             if current_chat_count >= chat_limit:
@@ -403,9 +397,9 @@ class SubHeartflowManager:
             first_observation = sub_hf_to_evaluate.observations[0]  # 喵~第一个观察者肯定存在的说
             await first_observation.observe()
             current_chat_log = first_observation.talking_message_str or "当前没啥聊天内容。"
-            _observation_summary = f"最近聊了这些:\n{current_chat_log}"
+            _observation_summary = f"在[{stream_name}]这个群中，你最近看群友聊了这些:\n{current_chat_log}"
 
-            mai_state_description = f"你当前状态: {current_mai_state.value}。"
+            _mai_state_description = f"你当前状态: {current_mai_state.value}。"
             individuality = Individuality.get_instance()
             personality_prompt = individuality.get_prompt(x_person=2, level=2)
             prompt_personality = f"你正在扮演名为{individuality.name}的人类，{personality_prompt}"
@@ -414,27 +408,28 @@ class SubHeartflowManager:
             chat_status_lines = []
             if chatting_group_names:
                 chat_status_lines.append(
-                    f"正在闲聊 ({current_chat_count}/{chat_limit}): {', '.join(chatting_group_names)}"
+                    f"正在这些群闲聊 ({current_chat_count}/{chat_limit}): {', '.join(chatting_group_names)}"
                 )
             if focused_group_names:
                 chat_status_lines.append(
-                    f"正在专注 ({current_focused_count}/{focused_limit}): {', '.join(focused_group_names)}"
+                    f"正在这些群专注的聊天 ({current_focused_count}/{focused_limit}): {', '.join(focused_group_names)}"
                 )
 
             chat_status_prompt = "当前没有在任何群聊中。"  # 默认消息喵~
             if chat_status_lines:
-                chat_status_prompt = "当前聊天情况：\n" + "\n".join(chat_status_lines)  # 拼接状态信息
+                chat_status_prompt = "当前聊天情况，你已经参与了下面这几个群的聊天：\n" + "\n".join(
+                    chat_status_lines
+                )  # 拼接状态信息
 
             prompt = (
-                f"{prompt_personality}\\n"
-                f"你当前没在 [{stream_name}] 群聊天。\\n"
-                f"{mai_state_description}\\n"
-                f"{chat_status_prompt}\\n"  # <-- 喵！用了新的状态信息~
-                f"{_observation_summary}\\n---\\n"
-                f"基于以上信息，你想不想开始在这个群闲聊？\\n"
-                f"请说明理由，并以 JSON 格式回答，包含 'decision' (布尔值) 和 'reason' (字符串)。\\n"
-                f'例如：{{"decision": true, "reason": "看起来挺热闹的，插个话"}}\\n'
-                f'例如：{{"decision": false, "reason": "已经聊了好多，休息一下"}}\\n'
+                f"{prompt_personality}\n"
+                f"{chat_status_prompt}\n"  # <-- 喵！用了新的状态信息~
+                f"你当前尚未加入 [{stream_name}] 群聊天。\n"
+                f"{_observation_summary}\n---\n"
+                f"基于以上信息，你想不想开始在这个群闲聊？\n"
+                f"请说明理由，并以 JSON 格式回答，包含 'decision' (布尔值) 和 'reason' (字符串)。\n"
+                f'例如：{{"decision": true, "reason": "看起来挺热闹的，插个话"}}\n'
+                f'例如：{{"decision": false, "reason": "已经聊了好多，休息一下"}}\n'
                 f"请只输出有效的 JSON 对象。"
             )
             # --- 结束修改 ---
@@ -493,7 +488,6 @@ class SubHeartflowManager:
             checked_count = len(subflows_snapshot)
 
             if not subflows_snapshot:
-                # logger.debug(f"{log_prefix_task} 没有子心流需要检查超时。")
                 return
 
             for sub_hf in subflows_snapshot:
@@ -509,25 +503,33 @@ class SubHeartflowManager:
                 reason = ""
 
                 try:
-                    # 使用变量名 last_bot_dong_zuo_time 替代 last_bot_activity_time
                     last_bot_dong_zuo_time = sub_hf.get_normal_chat_last_speak_time()
 
                     if last_bot_dong_zuo_time > 0:
                         current_time = time.time()
-                        # 使用变量名 time_since_last_bb 替代 time_since_last_reply
                         time_since_last_bb = current_time - last_bot_dong_zuo_time
+                        minutes_since_last_bb = time_since_last_bb / 60
 
-                        if time_since_last_bb > NORMAL_CHAT_TIMEOUT_SECONDS:
+                        # 60分钟强制退出
+                        if minutes_since_last_bb >= 60:
                             should_deactivate = True
-                            reason = f"超过 {NORMAL_CHAT_TIMEOUT_SECONDS / 60:.0f} 分钟没 BB"
-                            logger.info(
-                                f"{log_prefix} 太久没有发言 ({reason})，不看了。上次活动时间: {last_bot_dong_zuo_time:.0f}"
-                            )
-                        # else:
-                        #     logger.debug(f"{log_prefix} Bot活动时间未超时 ({time_since_last_bb:.0f}s < {NORMAL_CHAT_TIMEOUT_SECONDS}s)，保持 CHAT 状态。")
-                    # else:
-                    # 如果没有记录到Bot的活动时间，暂时不因为超时而转换状态
-                    # logger.debug(f"{log_prefix} 未找到有效的 Bot 最后活动时间记录，不执行超时检查。")
+                            reason = "超过60分钟未发言，强制退出"
+                        else:
+                            # 根据时间区间确定退出概率
+                            exit_probability = 0
+                            if minutes_since_last_bb < 5:
+                                exit_probability = 0.01  # 1%
+                            elif minutes_since_last_bb < 15:
+                                exit_probability = 0.02  # 2%
+                            elif minutes_since_last_bb < 30:
+                                exit_probability = 0.04  # 4%
+                            else:
+                                exit_probability = 0.08  # 8%
+
+                            # 随机判断是否退出
+                            if random.random() < exit_probability:
+                                should_deactivate = True
+                                reason = f"已{minutes_since_last_bb:.1f}分钟未发言，触发{exit_probability * 100:.0f}%退出概率"
 
                 except AttributeError:
                     logger.error(
@@ -536,7 +538,7 @@ class SubHeartflowManager:
                 except Exception as e:
                     logger.error(f"{log_prefix} 检查 Bot 超时状态时出错: {e}", exc_info=True)
 
-                # --- 执行状态转换（如果超时） ---
+                # 执行状态转换（如果超时）
                 if should_deactivate:
                     logger.debug(f"{log_prefix} 因超时 ({reason})，尝试转换为 ABSENT 状态。")
                     await sub_hf.change_chat_state(ChatState.ABSENT)
@@ -816,11 +818,6 @@ class SubHeartflowManager:
                         if has_new:
                             is_active = True
                             logger.debug(f"{log_prefix} 检测到新消息，标记为活跃。")
-                    # 可选：检查兴趣度是否大于0 (如果需要)
-                    # interest_level = await sub_hf.interest_chatting.get_interest()
-                    # if interest_level > 0:
-                    #    is_active = True
-                    #    logger.debug(f"{log_prefix} 检测到兴趣度 > 0 ({interest_level:.2f})，标记为活跃。")
                     else:
                         logger.warning(f"{log_prefix} 无法获取主要观察者来检查活动状态。")
 
@@ -850,56 +847,3 @@ class SubHeartflowManager:
             logger.debug(
                 f"{log_prefix_task} 完成，共检查 {checked_count} 个私聊，{transitioned_count} 个转换为 FOCUSED。"
             )
-
-    # --- 结束新增 --- #
-
-    # --- 结束新增：处理来自 HeartFChatting 的状态转换请求 --- #
-
-    # 临时函数，用于GUI切换，有api后删除
-    # async def detect_command_from_gui(self):
-    #     """检测来自GUI的命令"""
-    #     command_file = Path("temp_command/gui_command.json")
-    #     if not command_file.exists():
-    #         return
-
-    #     try:
-    #         # 读取并解析命令文件
-    #         command_data = json.loads(command_file.read_text())
-    #         subflow_id = command_data.get("subflow_id")
-    #         target_state = command_data.get("target_state")
-
-    #         if not subflow_id or not target_state:
-    #             logger.warning("GUI命令文件格式不正确，缺少必要字段")
-    #             return
-
-    #         # 尝试转换为ChatState枚举
-    #         try:
-    #             target_state_enum = ChatState[target_state.upper()]
-    #         except KeyError:
-    #             logger.warning(f"无效的目标状态: {target_state}")
-    #             command_file.unlink()
-    #             return
-
-    #         # 执行状态转换
-    #         await self.force_change_by_gui(subflow_id, target_state_enum)
-
-    #         # 转换成功后删除文件
-    #         command_file.unlink()
-    #         logger.debug(f"已处理GUI命令并删除命令文件: {command_file}")
-
-    #     except json.JSONDecodeError:
-    #         logger.warning("GUI命令文件不是有效的JSON格式")
-    #     except Exception as e:
-    #         logger.error(f"处理GUI命令时发生错误: {e}", exc_info=True)
-
-    # async def force_change_by_gui(self, subflow_id: Any, target_state: ChatState):
-    #     """强制改变指定子心流的状态"""
-    #     async with self._lock:
-    #         subflow = self.subheartflows.get(subflow_id)
-    #         if not subflow:
-    #             logger.warning(f"[强制状态转换] 尝试转换不存在的子心流 {subflow_id} 到 {target_state.value}")
-    #             return
-    #         await subflow.change_chat_state(target_state)
-    #         logger.info(f"[强制状态转换] 成功将 {subflow_id} 的状态转换为 {target_state.value}")
-
-    # --- 结束新增 --- #

src/main.py

@@ -1,7 +1,12 @@
 import asyncio
 import time
-from .plugins.utils.statistic import LLMStatistics
-from .plugins.moods.moods import MoodManager
+
+from maim_message import MessageServer
+
+from .plugins.remote.remote import TelemetryHeartBeatTask
+from .manager.async_task_manager import async_task_manager
+from .plugins.utils.statistic import OnlineTimeRecordTask, StatisticOutputTask
+from .manager.mood_manager import MoodPrintTask, MoodUpdateTask
 from .plugins.schedule.schedule_generator import bot_schedule
 from .plugins.emoji_system.emoji_manager import emoji_manager
 from .plugins.person_info.person_info import person_info_manager
@@ -14,9 +19,8 @@ from .plugins.storage.storage import MessageStorage
 from .config.config import global_config
 from .plugins.chat.bot import chat_bot
 from .common.logger_manager import get_logger
-from .plugins.remote import heartbeat_thread  # noqa: F401
 from .individuality.individuality import Individuality
-from .common.server import global_server
+from .common.server import global_server, Server
 from rich.traceback import install
 from .api.main import start_api_server
 
@@ -27,17 +31,14 @@ logger = get_logger("main")
 
 class MainSystem:
     def __init__(self):
-        self.llm_stats = LLMStatistics("llm_statistics.txt")
-        self.mood_manager = MoodManager.get_instance()
-        self.hippocampus_manager = HippocampusManager.get_instance()
-        self._message_manager_started = False
-        self.individuality = Individuality.get_instance()
+        self.hippocampus_manager: HippocampusManager = HippocampusManager.get_instance()
+        self.individuality: Individuality = Individuality.get_instance()
 
         # 使用消息API替代直接的FastAPI实例
         from .plugins.message import global_api
 
-        self.app = global_api
-        self.server = global_server
+        self.app: MessageServer = global_api
+        self.server: Server = global_server
 
     async def initialize(self):
         """初始化系统组件"""
@@ -51,9 +52,15 @@ class MainSystem:
     async def _init_components(self):
         """初始化其他组件"""
         init_start_time = time.time()
-        # 启动LLM统计
-        self.llm_stats.start()
-        logger.success("LLM统计功能启动成功")
+
+        # 添加在线时间统计任务
+        await async_task_manager.add_task(OnlineTimeRecordTask())
+
+        # 添加统计信息输出任务
+        await async_task_manager.add_task(StatisticOutputTask())
+
+        # 添加遥测心跳任务
+        await async_task_manager.add_task(TelemetryHeartBeatTask())
 
         # 启动API服务器
         start_api_server()
@@ -62,9 +69,10 @@ class MainSystem:
         emoji_manager.initialize()
         logger.success("表情包管理器初始化成功")
 
-        # 启动情绪管理器
-        self.mood_manager.start_mood_update(update_interval=global_config.mood_update_interval)
-        logger.success("情绪管理器启动成功")
+        # 添加情绪衰减任务
+        await async_task_manager.add_task(MoodUpdateTask())
+        # 添加情绪打印任务
+        await async_task_manager.add_task(MoodPrintTask())
 
         # 检查并清除person_info冗余字段，启动个人习惯推断
         await person_info_manager.del_all_undefined_field()
@@ -129,7 +137,6 @@ class MainSystem:
                 self.build_memory_task(),
                 self.forget_memory_task(),
                 self.consolidate_memory_task(),
-                self.print_mood_task(),
                 self.remove_recalled_message_task(),
                 emoji_manager.start_periodic_check_register(),
                 self.app.run(),
@@ -163,12 +170,6 @@ class MainSystem:
             await HippocampusManager.get_instance().consolidate_memory()
             print("\033[1;32m[记忆整合]\033[0m 记忆整合完成")
 
-    async def print_mood_task(self):
-        """打印情绪状态"""
-        while True:
-            self.mood_manager.print_mood_status()
-            await asyncio.sleep(60)
-
     @staticmethod
     async def remove_recalled_message_task():
         """删除撤回消息任务"""

src/manager/async_task_manager.py

@@ -0,0 +1,150 @@
+from abc import abstractmethod
+
+import asyncio
+from asyncio import Task, Event, Lock
+from typing import Callable, Dict
+
+from src.common.logger_manager import get_logger
+
+logger = get_logger("async_task_manager")
+
+
+class AsyncTask:
+    """异步任务基类"""
+
+    def __init__(self, task_name: str | None = None, wait_before_start: int = 0, run_interval: int = 0):
+        self.task_name: str = task_name or self.__class__.__name__
+        """任务名称"""
+
+        self.wait_before_start: int = wait_before_start
+        """运行任务前是否进行等待（单位：秒，设为0则不等待）"""
+
+        self.run_interval: int = run_interval
+        """多次运行的时间间隔（单位：秒，设为0则仅运行一次）"""
+
+    @abstractmethod
+    async def run(self):
+        """
+        任务的执行过程
+        """
+        pass
+
+    async def start_task(self, abort_flag: asyncio.Event):
+        if self.wait_before_start > 0:
+            # 等待指定时间后开始任务
+            await asyncio.sleep(self.wait_before_start)
+
+        while not abort_flag.is_set():
+            await self.run()
+            if self.run_interval > 0:
+                await asyncio.sleep(self.run_interval)
+            else:
+                break
+
+
+class AsyncTaskManager:
+    """异步任务管理器"""
+
+    def __init__(self):
+        self.tasks: Dict[str, Task] = {}
+        """任务列表"""
+
+        self.abort_flag: Event = Event()
+        """是否中止任务标志"""
+
+        self._lock: Lock = Lock()
+        """异步锁，当可能出现await时需要加锁"""
+
+    def _remove_task_call_back(self, task: Task):
+        """
+        call_back: 任务完成后移除任务
+        """
+        task_name = task.get_name()
+        if task_name in self.tasks:
+            # 任务完成后移除任务
+            del self.tasks[task_name]
+            logger.debug(f"已移除任务 '{task_name}'")
+        else:
+            logger.warning(f"尝试移除不存在的任务 '{task_name}'")
+
+    @staticmethod
+    def _default_finish_call_back(task: Task):
+        """
+        call_back: 默认的任务完成回调函数
+        """
+        try:
+            task.result()
+            logger.debug(f"任务 '{task.get_name()}' 完成")
+        except asyncio.CancelledError:
+            logger.debug(f"任务 '{task.get_name()}' 被取消")
+        except Exception as e:
+            logger.error(f"任务 '{task.get_name()}' 执行时发生异常: {e}", exc_info=True)
+
+    async def add_task(self, task: AsyncTask, call_back: Callable[[asyncio.Task], None] | None = None):
+        """
+        添加任务
+        """
+        if not issubclass(task.__class__, AsyncTask):
+            raise TypeError(f"task '{task.__class__.__name__}' 必须是继承 AsyncTask 的子类")
+
+        async with self._lock:  # 由于可能需要await等待任务完成，所以需要加异步锁
+            if task.task_name in self.tasks:
+                logger.warning(f"已存在名称为 '{task.task_name}' 的任务，正在尝试取消并替换")
+                self.tasks[task.task_name].cancel()  # 取消已存在的任务
+                await self.tasks[task.task_name]  # 等待任务完成
+                logger.info(f"成功结束任务 '{task.task_name}'")
+
+            # 创建新任务
+            task_inst = asyncio.create_task(task.start_task(self.abort_flag))
+            task_inst.set_name(task.task_name)
+            task_inst.add_done_callback(self._remove_task_call_back)  # 添加完成回调函数-完成任务后自动移除任务
+            task_inst.add_done_callback(
+                call_back or self._default_finish_call_back
+            )  # 添加完成回调函数-用户自定义，或默认的FallBack
+
+            self.tasks[task.task_name] = task_inst  # 将任务添加到任务列表
+            logger.info(f"已启动任务 '{task.task_name}'")
+
+    def get_tasks_status(self) -> Dict[str, Dict[str, str]]:
+        """
+        获取所有任务的状态
+        """
+        tasks_status = {}
+        for task_name, task in self.tasks.items():
+            tasks_status[task_name] = {
+                "status": "running" if not task.done() else "done",
+            }
+        return tasks_status
+
+    async def stop_and_wait_all_tasks(self):
+        """
+        终止所有任务并等待它们完成（该方法会阻塞其它尝试add_task()的操作）
+        """
+        async with self._lock:  # 由于可能需要await等待任务完成，所以需要加异步锁
+            # 设置中止标志
+            self.abort_flag.set()
+            # 取消所有任务
+            for name, inst in self.tasks.items():
+                try:
+                    inst.cancel()
+                except asyncio.CancelledError:
+                    logger.info(f"已取消任务 '{name}'")
+
+            # 等待所有任务完成
+            for task_name, task_inst in self.tasks.items():
+                if not task_inst.done():
+                    try:
+                        await task_inst
+                    except asyncio.CancelledError:  # 此处再次捕获取消异常，防止stop_all_tasks()时延迟抛出异常
+                        logger.info(f"任务 {task_name} 已取消")
+                    except Exception as e:
+                        logger.error(f"任务 {task_name} 执行时发生异常: {e}", ext_info=True)
+
+            # 清空任务列表
+            self.tasks.clear()
+            self.abort_flag.clear()
+            logger.info("所有异步任务已停止")
+
+
+async_task_manager = AsyncTaskManager()
+"""全局异步任务管理器实例"""

src/manager/local_store_manager.py

@@ -0,0 +1,67 @@
+import json
+import os
+
+from src.common.logger_manager import get_logger
+
+LOCAL_STORE_FILE_PATH = "data/local_store.json"
+
+logger = get_logger("local_storage")
+
+
+class LocalStoreManager:
+    file_path: str
+    """本地存储路径"""
+
+    store: dict[str, str | list | dict | int | float | bool]
+    """本地存储数据"""
+
+    def __init__(self, local_store_path: str | None = None):
+        self.file_path = local_store_path or LOCAL_STORE_FILE_PATH
+        self.store = {}
+        self.load_local_store()
+
+    def __getitem__(self, item: str) -> str | list | dict | int | float | bool | None:
+        """获取本地存储数据"""
+        return self.store.get(item, None)
+
+    def __setitem__(self, key: str, value: str | list | dict | int | float | bool):
+        """设置本地存储数据"""
+        self.store[key] = value
+        self.save_local_store()
+
+    def __contains__(self, item: str) -> bool:
+        """检查本地存储数据是否存在"""
+        return item in self.store
+
+    def load_local_store(self):
+        """加载本地存储数据"""
+        if os.path.exists(self.file_path):
+            # 存在本地存储文件，加载数据
+            logger.info("正在阅读记事本......我在看，我真的在看！")
+            logger.debug(f"加载本地存储数据: {self.file_path}")
+            try:
+                with open(self.file_path, "r", encoding="utf-8") as f:
+                    self.store = json.load(f)
+                    logger.success("全都记起来了！")
+            except json.JSONDecodeError:
+                logger.warning("啊咧？记事本被弄脏了，正在重建记事本......")
+                self.store = {}
+                with open(self.file_path, "w", encoding="utf-8") as f:
+                    json.dump({}, f, ensure_ascii=False, indent=4)
+                logger.success("记事本重建成功！")
+        else:
+            # 不存在本地存储文件，创建新的目录和文件
+            logger.warning("啊咧？记事本不存在，正在创建新的记事本......")
+            os.makedirs(os.path.dirname(self.file_path), exist_ok=True)
+            with open(self.file_path, "w", encoding="utf-8") as f:
+                json.dump({}, f, ensure_ascii=False, indent=4)
+            logger.success("记事本创建成功！")
+
+    def save_local_store(self):
+        """保存本地存储数据"""
+        logger.debug(f"保存本地存储数据: {self.file_path}")
+        with open(self.file_path, "w", encoding="utf-8") as f:
+            json.dump(self.store, f, ensure_ascii=False, indent=4)
+
+
+local_storage = LocalStoreManager("data/local_store.json")  # 全局单例化

src/manager/mood_manager.py

@@ -0,0 +1,296 @@
+import asyncio
+import math
+import time
+from dataclasses import dataclass
+from typing import Dict, Tuple
+
+from ..config.config import global_config
+from ..common.logger_manager import get_logger
+from ..manager.async_task_manager import AsyncTask
+from ..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
+    """心情的文本描述"""
+
+
+@dataclass
+class MoodChangeHistory:
+    valence_direction_factor: int
+    """愉悦度变化的系数（正为增益，负为抑制）"""
+    arousal_direction_factor: int
+    """唤醒度变化的系数（正为增益，负为抑制）"""
+
+
+class MoodUpdateTask(AsyncTask):
+    def __init__(self):
+        super().__init__(
+            task_name="Mood Update Task",
+            wait_before_start=global_config.mood_update_interval,
+            run_interval=global_config.mood_update_interval,
+        )
+
+        # 从配置文件获取衰减率
+        self.decay_rate_valence: float = 1 - global_config.mood_decay_rate
+        """愉悦度衰减率"""
+        self.decay_rate_arousal: float = 1 - global_config.mood_decay_rate
+        """唤醒度衰减率"""
+
+        self.last_update = time.time()
+        """上次更新时间"""
+
+    async def run(self):
+        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 mood_manager.current_mood.valence >= 0:
+            # 正向情绪衰减
+            decay_rate_positive = self.decay_rate_valence * (1 / agreeableness_factor)
+            valence_target = 0 + agreeableness_bias
+            new_valence = valence_target + (mood_manager.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
+            new_valence = valence_target + (mood_manager.current_mood.valence - valence_target) * math.exp(
+                -decay_rate_negative * time_diff * neuroticism_factor
+            )
+
+        # Arousal 向中性（0）回归
+        arousal_target = 0
+        new_arousal = arousal_target + (mood_manager.current_mood.arousal - arousal_target) * math.exp(
+            -self.decay_rate_arousal * time_diff * neuroticism_factor
+        )
+
+        mood_manager.set_current_mood(new_valence, new_arousal)
+
+        self.last_update = current_time
+
+
+class MoodPrintTask(AsyncTask):
+    def __init__(self):
+        super().__init__(
+            task_name="Mood Print Task",
+            wait_before_start=60,
+            run_interval=60,
+        )
+
+    async def run(self):
+        # 打印当前心情
+        logger.info(
+            f"愉悦度: {mood_manager.current_mood.valence:.2f}, "
+            f"唤醒度: {mood_manager.current_mood.arousal:.2f}, "
+            f"心情: {mood_manager.current_mood.text}"
+        )
+
+
+class MoodManager:
+    # TODO: 改进，使用具有实验支持的新情绪模型
+
+    EMOTION_FACTOR_MAP: Dict[str, Tuple[float, float]] = {
+        "开心": (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),
+    }
+    """
+    情绪词映射表 {mood: (valence, arousal)}
+    将情绪描述词映射到愉悦度和唤醒度的元组
+    """
+
+    EMOTION_POINT_MAP: Dict[Tuple[float, float], str] = {
+        # 第一象限：高唤醒，正愉悦
+        (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): "放松",
+    }
+    """
+    情绪文本映射表 {(valence, arousal): mood}
+    将量化的情绪状态元组映射到文本描述
+    """
+
+    def __init__(self):
+        self.current_mood = MoodState(
+            valence=0.0,
+            arousal=0.0,
+            text="平静",
+        )
+        """当前情绪状态"""
+
+        self.mood_change_history: MoodChangeHistory = MoodChangeHistory(
+            valence_direction_factor=0,
+            arousal_direction_factor=0,
+        )
+        """情绪变化历史"""
+
+        self._lock = asyncio.Lock()
+        """异步锁，用于保护线程安全"""
+
+    def set_current_mood(self, new_valence: float, new_arousal: float):
+        """
+        设置当前情绪状态
+        :param new_valence: 新的愉悦度
+        :param new_arousal: 新的唤醒度
+        """
+        # 限制范围
+        self.current_mood.valence = max(-1.0, min(new_valence, 1.0))
+        self.current_mood.arousal = max(-1.0, min(new_arousal, 1.0))
+
+        closest_mood = None
+        min_distance = float("inf")
+
+        for (v, a), text in self.EMOTION_POINT_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_current_mood(self, valence_delta: float, arousal_delta: float):
+        """
+        根据愉悦度和唤醒度变化量更新当前情绪状态
+        :param valence_delta: 愉悦度变化量
+        :param arousal_delta: 唤醒度变化量
+        """
+        # 计算连续增益/抑制
+        # 规则：多次相同方向的变化会有更大的影响系数，反方向的变化会清零影响系数（系数的正负号由变化方向决定）
+        if valence_delta * self.mood_change_history.valence_direction_factor > 0:
+            # 如果方向相同，则根据变化方向改变系数
+            if valence_delta > 0:
+                self.mood_change_history.valence_direction_factor += 1  # 若为正向，则增加
+            else:
+                self.mood_change_history.valence_direction_factor -= 1  # 若为负向，则减少
+        else:
+            # 如果方向不同，则重置计数
+            self.mood_change_history.valence_direction_factor = 0
+
+        if arousal_delta * self.mood_change_history.arousal_direction_factor > 0:
+            # 如果方向相同，则根据变化方向改变系数
+            if arousal_delta > 0:
+                self.mood_change_history.arousal_direction_factor += 1  # 若为正向，则增加计数
+            else:
+                self.mood_change_history.arousal_direction_factor -= 1  # 若为负向，则减少计数
+        else:
+            # 如果方向不同，则重置计数
+            self.mood_change_history.arousal_direction_factor = 0
+
+        # 计算增益/抑制的结果
+        # 规则：如果当前情绪状态与变化方向相同，则增益；否则抑制
+        if self.current_mood.valence * self.mood_change_history.valence_direction_factor > 0:
+            valence_delta = valence_delta * (1.01 ** abs(self.mood_change_history.valence_direction_factor))
+        else:
+            valence_delta = valence_delta * (0.99 ** abs(self.mood_change_history.valence_direction_factor))
+
+        if self.current_mood.arousal * self.mood_change_history.arousal_direction_factor > 0:
+            arousal_delta = arousal_delta * (1.01 ** abs(self.mood_change_history.arousal_direction_factor))
+        else:
+            arousal_delta = arousal_delta * (0.99 ** abs(self.mood_change_history.arousal_direction_factor))
+
+        self.set_current_mood(
+            new_valence=self.current_mood.valence + valence_delta,
+            new_arousal=self.current_mood.arousal + arousal_delta,
+        )
+
+    def get_mood_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 update_mood_from_emotion(self, emotion: str, intensity: float = 1.0) -> None:
+        """
+        根据情绪词更新心情状态
+        :param emotion: 情绪词（如'开心', '悲伤'等位于self.EMOTION_FACTOR_MAP中的键）
+        :param intensity: 情绪强度（0.0-1.0）
+        """
+        if emotion not in self.EMOTION_FACTOR_MAP:
+            logger.error(f"[情绪更新] 未知情绪词: {emotion}")
+            return
+
+        valence_change, arousal_change = self.EMOTION_FACTOR_MAP[emotion]
+        old_valence = self.current_mood.valence
+        old_arousal = self.current_mood.arousal
+        old_mood = self.current_mood.text
+
+        self.update_current_mood(valence_change, arousal_change)  # 更新当前情绪状态
+
+        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}"
+        )
+
+
+mood_manager = MoodManager()
+"""全局情绪管理器"""

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,33 +1,35 @@
 import asyncio
+import contextlib
+import json  # <--- 确保导入 json
+import random  # <--- 添加导入
 import time
 import traceback
-import random
-import json
-from typing import List, Optional, Dict, Any, Deque, Callable, Coroutine
 from collections import deque
-from src.plugins.chat.message import MessageRecv, BaseMessageInfo, MessageThinking, MessageSending
-from src.plugins.chat.message import Seg
-from src.plugins.chat.chat_stream import ChatStream
-from src.plugins.chat.message import UserInfo
-from src.plugins.chat.chat_stream import chat_manager
-from src.common.logger_manager import get_logger
-from src.plugins.models.utils_model import LLMRequest
-from src.config.config import global_config
-from src.plugins.chat.utils_image import image_path_to_base64
-from src.plugins.utils.timer_calculator import Timer
-from src.plugins.emoji_system.emoji_manager import emoji_manager
-from src.heart_flow.sub_mind import SubMind
-from src.heart_flow.observation import Observation
-from src.plugins.heartFC_chat.heartflow_prompt_builder import global_prompt_manager, prompt_builder
-import contextlib
-from src.plugins.utils.chat_message_builder import num_new_messages_since
-from src.plugins.heartFC_chat.heartFC_Cycleinfo import CycleInfo
-from .heartFC_sender import HeartFCSender
-from src.plugins.chat.utils import process_llm_response
-from src.plugins.respon_info_catcher.info_catcher import info_catcher_manager
-from src.plugins.moods.moods import MoodManager
-from src.heart_flow.utils_chat import get_chat_type_and_target_info
+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.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.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
 from src.plugins.utils.chat_message_builder import get_raw_msg_before_timestamp_with_chat
 from src.plugins.group_nickname.nickname_manager import nickname_manager
 
@@ -789,7 +791,7 @@ class HeartFChatting:
                 )
                 return current_mind
         except Exception as e:
-            logger.error(f"{self.log_prefix}[SubMind] 思考失败: {e}")
+            logger.error(f"{self.log_prefix}子心流 思考失败: {e}")
             logger.error(traceback.format_exc())
             return "[思考时出错]"
 
@@ -1299,7 +1301,7 @@ class HeartFChatting:
         """
         try:
             # 1. 获取情绪影响因子并调整模型温度
-            arousal_multiplier = MoodManager.get_instance().get_arousal_multiplier()
+            arousal_multiplier = mood_manager.get_arousal_multiplier()
             current_temp = global_config.llm_normal["temp"] * arousal_multiplier
             self.model_normal.temperature = current_temp  # 动态调整温度
 

src/plugins/heartFC_chat/heartflow_prompt_builder.py

@@ -10,7 +10,7 @@ from src.plugins.person_info.relationship_manager import relationship_manager
 from src.plugins.chat.utils import get_embedding
 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
@@ -351,8 +351,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,25 +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
 from src.plugins.group_nickname.nickname_manager import nickname_manager
 
 
@@ -27,7 +28,7 @@ logger = get_logger("chat")
 
 
 class NormalChat:
-    def __init__(self, chat_stream: ChatStream, interest_dict: dict):
+    def __init__(self, chat_stream: ChatStream, interest_dict: dict = None):
         """初始化 NormalChat 实例。只进行同步操作。"""
 
         # Basic info from chat_stream (sync)
@@ -46,7 +47,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
@@ -354,6 +355,8 @@ class NormalChat:
     # --- 新增：处理初始高兴趣消息的私有方法 ---
     async def _process_initial_interest_messages(self):
         """处理启动时存在于 interest_dict 中的高兴趣消息。"""
+        if not self.interest_dict:
+            return  # 如果 interest_dict 为 None或空，直接返回
         items_to_process = list(self.interest_dict.items())
         if not items_to_process:
             return  # 没有初始消息，直接返回

src/plugins/knowledge/src/embedding_store.py

@@ -28,6 +28,12 @@ from rich.progress import (
 
 install(extra_lines=3)
 ROOT_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))
+EMBEDDING_DATA_DIR = (
+    os.path.join(ROOT_PATH, "data", "embedding")
+    if global_config["persistence"]["embedding_data_dir"] is None
+    else os.path.join(ROOT_PATH, global_config["persistence"]["embedding_data_dir"])
+)
+EMBEDDING_DATA_DIR_STR = str(EMBEDDING_DATA_DIR).replace("\\", "/")
 TOTAL_EMBEDDING_TIMES = 3  # 统计嵌入次数
 
 # 嵌入模型测试字符串，测试模型一致性，来自开发群的聊天记录
@@ -288,17 +294,17 @@ class EmbeddingManager:
         self.paragraphs_embedding_store = EmbeddingStore(
             llm_client,
             PG_NAMESPACE,
-            global_config["persistence"]["embedding_data_dir"],
+            EMBEDDING_DATA_DIR_STR,
         )
         self.entities_embedding_store = EmbeddingStore(
             llm_client,
             ENT_NAMESPACE,
-            global_config["persistence"]["embedding_data_dir"],
+            EMBEDDING_DATA_DIR_STR,
         )
         self.relation_embedding_store = EmbeddingStore(
             llm_client,
             REL_NAMESPACE,
-            global_config["persistence"]["embedding_data_dir"],
+            EMBEDDING_DATA_DIR_STR,
         )
         self.stored_pg_hashes = set()
 

src/plugins/knowledge/src/kg_manager.py

@@ -31,6 +31,14 @@ from .lpmmconfig import (
 
 from .global_logger import logger
 
+ROOT_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..", "..", ".."))
+KG_DIR = (
+    os.path.join(ROOT_PATH, "data/rag")
+    if global_config["persistence"]["rag_data_dir"] is None
+    else os.path.join(ROOT_PATH, global_config["persistence"]["rag_data_dir"])
+)
+KG_DIR_STR = str(KG_DIR).replace("\\", "/")
+
 
 class KGManager:
     def __init__(self):
@@ -43,7 +51,7 @@ class KGManager:
         self.graph = di_graph.DiGraph()
 
         # 持久化相关
-        self.dir_path = global_config["persistence"]["rag_data_dir"]
+        self.dir_path = KG_DIR_STR
         self.graph_data_path = self.dir_path + "/" + RAG_GRAPH_NAMESPACE + ".graphml"
         self.ent_cnt_data_path = self.dir_path + "/" + RAG_ENT_CNT_NAMESPACE + ".parquet"
         self.pg_hash_file_path = self.dir_path + "/" + RAG_PG_HASH_NAMESPACE + ".json"

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

@@ -8,6 +8,9 @@ import random
 from typing import List, Dict
 from ...common.database import db
 from maim_message import UserInfo
+
+from ...manager.mood_manager import mood_manager
+
 # import re
 # import traceback
 
@@ -24,9 +27,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):
@@ -62,9 +63,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,177 +1,142 @@
+import asyncio
+
 import requests
-import time
-import uuid
 import platform
-import os
-import json
-import threading
-from src.common.logger import get_module_logger, LogConfig, REMOTE_STYLE_CONFIG
+
+# 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")
+
+TELEMETRY_SERVER_URL = "http://localhost:8080"
+"""遥测服务地址"""
 
 
-remote_log_config = LogConfig(
-    console_format=REMOTE_STYLE_CONFIG["console_format"],
-    file_format=REMOTE_STYLE_CONFIG["file_format"],
-)
-logger = get_module_logger("remote", config=remote_log_config)
+class TelemetryHeartBeatTask(AsyncTask):
+    HEARTBEAT_INTERVAL = 300
 
-# --- 使用向上导航的方式定义路径 ---
+    def __init__(self):
+        super().__init__(task_name="Telemetry Heart Beat Task", run_interval=self.HEARTBEAT_INTERVAL)
+        self.server_url = TELEMETRY_SERVER_URL
+        """遥测服务地址"""
 
-# 1. 获取当前文件 (remote.py) 所在的目录
-current_dir = os.path.dirname(os.path.abspath(__file__))
+        self.client_uuid = local_storage["mmc_uuid"] if "mmc_uuid" in local_storage else None
+        """客户端UUID"""
 
-# 2. 从当前目录向上导航三级找到项目根目录
-#    (src/plugins/remote/ -> src/plugins/ -> src/ -> project_root)
-root_dir = os.path.abspath(os.path.join(current_dir, "..", "..", ".."))
+        self.info_dict = self._get_sys_info()
+        """系统信息字典"""
 
-# 3. 定义 data 目录的路径 (位于项目根目录下)
-data_dir = os.path.join(root_dir, "data")
+    @staticmethod
+    def _get_sys_info() -> dict[str, str]:
+        """获取系统信息"""
+        info_dict = {
+            "os_type": "Unknown",
+            "py_version": platform.python_version(),
+            "mmc_version": global_config.MAI_VERSION,
+        }
 
-# 4. 定义 UUID 文件在 data 目录下的完整路径
-UUID_FILE = os.path.join(data_dir, "client_uuid.json")
+        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"
 
-# --- 路径定义结束 ---
+        return info_dict
 
+    async def _req_uuid(self) -> bool:
+        """
+        向服务端请求UUID（不应在已存在UUID的情况下调用，会覆盖原有的UUID）
+        """
 
-# 生成或获取客户端唯一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
-    # --- 目录检查结束 ---
-
-    # 检查是否已经有保存的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}")
-
-    # 如果没有保存的UUID或读取出错，则生成新的
-    client_id = generate_unique_id()
-    logger.info(f"生成新的客户端ID: {client_id}")
-
-    # 保存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}")
-
-    return client_id
-
-
-# 生成客户端唯一ID
-def generate_unique_id():
-    # 结合主机名、系统信息和随机UUID生成唯一ID
-    system_info = platform.system()
-    unique_id = f"{system_info}-{uuid.uuid4()}"
-    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
+            await self._send_heartbeat()

template/bot_config_meta.toml

@@ -0,0 +1,134 @@
+[inner.version]
+describe = "版本号"
+important = true
+can_edit = false
+
+[bot.qq]
+describe = "机器人的QQ号"
+important = true
+can_edit = true
+
+[bot.nickname]
+describe = "机器人的昵称"
+important = true
+can_edit = true
+
+[bot.alias_names]
+describe = "机器人的别名列表，该选项还在调试中，暂时未生效"
+important = false
+can_edit = true
+
+[groups.talk_allowed]
+describe = "可以回复消息的群号码列表"
+important = true
+can_edit = true
+
+[groups.talk_frequency_down]
+describe = "降低回复频率的群号码列表"
+important = false
+can_edit = true
+
+[groups.ban_user_id]
+describe = "禁止回复和读取消息的QQ号列表"
+important = false
+can_edit = true
+
+[personality.personality_core]
+describe = "用一句话或几句话描述人格的核心特点，建议20字以内"
+important = true
+can_edit = true
+
+[personality.personality_sides]
+describe = "用一句话或几句话描述人格的一些细节，条数任意，不能为0，该选项还在调试中"
+important = false
+can_edit = true
+
+[identity.identity_detail]
+describe = "身份特点列表，条数任意，不能为0，该选项还在调试中"
+important = false
+can_edit = true
+
+[identity.age]
+describe = "年龄，单位岁"
+important = false
+can_edit = true
+
+[identity.gender]
+describe = "性别"
+important = false
+can_edit = true
+
+[identity.appearance]
+describe = "外貌特征描述，该选项还在调试中，暂时未生效"
+important = false
+can_edit = true
+
+[schedule.enable_schedule_gen]
+describe = "是否启用日程表"
+important = false
+can_edit = true
+
+[schedule.enable_schedule_interaction]
+describe = "日程表是否影响回复模式"
+important = false
+can_edit = true
+
+[schedule.prompt_schedule_gen]
+describe = "用几句话描述描述性格特点或行动规律，这个特征会用来生成日程表"
+important = false
+can_edit = true
+
+[schedule.schedule_doing_update_interval]
+describe = "日程表更新间隔，单位秒"
+important = false
+can_edit = true
+
+[schedule.schedule_temperature]
+describe = "日程表温度，建议0.1-0.5"
+important = false
+can_edit = true
+
+[schedule.time_zone]
+describe = "时区设置，可以解决运行电脑时区和国内时区不同的情况，或者模拟国外留学生日程"
+important = false
+can_edit = true
+
+[platforms.nonebot-qq]
+describe = "nonebot-qq适配器提供的链接"
+important = true
+can_edit = true
+
+[chat.allow_focus_mode]
+describe = "是否允许专注聊天状态"
+important = false
+can_edit = true
+
+[chat.base_normal_chat_num]
+describe = "最多允许多少个群进行普通聊天"
+important = false
+can_edit = true
+
+[chat.base_focused_chat_num]
+describe = "最多允许多少个群进行专注聊天"
+important = false
+can_edit = true
+
+[chat.observation_context_size]
+describe = "观察到的最长上下文大小，建议15，太短太长都会导致脑袋尖尖"
+important = false
+can_edit = true
+
+[chat.message_buffer]
+describe = "启用消息缓冲器，启用此项以解决消息的拆分问题，但会使麦麦的回复延迟"
+important = false
+can_edit = true
+
+[chat.ban_words]
+describe = "需要过滤的消息列表"
+important = false
+can_edit = true
+
+[chat.ban_msgs_regex]
+describe = "需要过滤的消息（原始消息）匹配的正则表达式，匹配到的消息将被过滤（支持CQ码）"
+important = false
+can_edit = true 

template/bot_config_template.toml

@@ -68,7 +68,7 @@ nonebot-qq="http://127.0.0.1:18002/api/message"
 [chat] #麦麦的聊天通用设置
 allow_focus_mode = true # 是否允许专注聊天状态
 # 是否启用heart_flowC(HFC)模式
-# 启用后麦麦会自主选择进入heart_flowC模式(持续一段时间），进行主动的观察和回复，并给出回复，比较消耗token
+# 启用后麦麦会自主选择进入heart_flowC模式（持续一段时间），进行主动的观察和回复，并给出回复，比较消耗token
 base_normal_chat_num = 8 # 最多允许多少个群进行普通聊天
 base_focused_chat_num = 5 # 最多允许多少个群进行专注聊天
 

从0.6.0升级0.6.3请先看我.txt

@@ -1 +0,0 @@
-该版本变动了人格相关设置，原有的配置内容可能被自动更新，如果你没有备份，可以在\config\old找回