调整vrm注视逻辑、节约系统资源；组织voice_id假变更导致的live2d模型刷新 (#447)

* refactor(plugin): split built-in and user plugin roots

Treat plugin.plugins as built-in packaged plugins and move user plugin discovery to the ConfigManager documents plugins directory. This avoids packaged namespace collisions while keeping plugin loading, config resolution, and extension injection working across both roots.

Made-with: Cursor

* fix(plugin): preserve legacy root semantics and skip builtin sys.path injection

Avoid re-exposing built-in plugins through top-level import roots in packaged builds, and restore the old single-root compatibility behavior for legacy callers while steering new code toward explicit multi-root settings.

Made-with: Cursor

* feat(mllm): add user input validation for message processing

- Introduced a new function `_message_has_user_input` to validate if messages contain user input.
- Updated `LMMAgent` to raise a `ValueError` if no valid user messages are found before LLM generation.
- Enhanced user input handling to support various content types, ensuring robust message processing.

This change improves the reliability of message handling in the LLM generation process.

* fix(characters_router): improve voice_id update handling and validation

- Added checks for missing voice_id in update requests, returning early if absent.
- Implemented idempotency to skip unnecessary updates when the voice_id hasn't changed.
- Enhanced logging to provide clearer information on voice_id updates.
- Updated response structure to include voice_id_changed status for better client-side handling.

These changes enhance the robustness of the voice_id update process and improve user experience.

Author: wehos

brain/cua/core/mllm.py

@@ -14,6 +14,29 @@
 )
 
 
+def _message_has_user_input(message) -> bool:
+    if not isinstance(message, dict):
+        return False
+    if message.get("role") != "user":
+        return False
+
+    content = message.get("content")
+    if isinstance(content, str):
+        return bool(content.strip())
+    if isinstance(content, list):
+        for item in content:
+            if isinstance(item, str) and item.strip():
+                return True
+            if isinstance(item, dict):
+                item_type = item.get("type")
+                if item_type == "text" and str(item.get("text", "")).strip():
+                    return True
+                if item_type in {"image_url", "image"}:
+                    return True
+        return False
+    return bool(content)
+
+
 class LMMAgent:
     def __init__(self, engine_params=None, system_prompt=None, engine=None):
         if engine is None:
@@ -288,6 +311,9 @@ def get_response(
                 {"role": "user", "content": [{"type": "text", "text": user_message}]}
             )
 
+        if not any(_message_has_user_input(message) for message in messages):
+            raise ValueError("At least one non-empty user message is required before LLM generation")
+
         # Thinking enabled for Claude Sonnet 3.7 and Gemini 2.5 Pro
         if use_thinking:
             return self.engine.generate_with_thinking(

main_routers/characters_router.py

@@ -757,23 +757,38 @@ async def update_catgirl_voice_id(name: str, request: Request):
     data = await request.json()
     if not data:
         return JSONResponse({'success': False, 'error': '无数据'}, status_code=400)
+    if 'voice_id' not in data:
+        logger.debug("猫娘 %s 的 voice_id 更新请求缺少字段，按无变更处理", name)
+        return {"success": True, "session_restarted": False, "voice_id_changed": False}
     _config_manager = get_config_manager()
     session_manager = get_session_manager()
     characters = _config_manager.load_characters()
     if name not in characters.get('猫娘', {}):
         return JSONResponse({'success': False, 'error': '猫娘不存在'}, status_code=404)
-    if 'voice_id' in data:
-        voice_id = data['voice_id']
-        # 验证voice_id是否在voice_storage中
-        if not _config_manager.validate_voice_id(voice_id):
-            voices = _config_manager.get_voices_for_current_api()
-            available_voices = list(voices.keys())
-            return JSONResponse({
-                'success': False, 
-                'error': f'voice_id "{voice_id}" 在当前API的音色库中不存在',
-                'available_voices': available_voices
-            }, status_code=400)
-        set_reserved(characters['猫娘'][name], 'voice_id', voice_id)
+    voice_id = str(data.get('voice_id') or '').strip()
+    old_voice_id = str(get_reserved(
+        characters['猫娘'][name],
+        'voice_id',
+        default='',
+        legacy_keys=('voice_id',)
+    ) or '').strip()
+
+    # 幂等保护：提交同值时直接返回，避免无实际变更触发 reload_page。
+    if old_voice_id == voice_id:
+        logger.info("猫娘 %s 的 voice_id 未变化，跳过刷新流程", name)
+        return {"success": True, "session_restarted": False, "voice_id_changed": False}
+
+    # 验证voice_id是否在voice_storage中
+    if not _config_manager.validate_voice_id(voice_id):
+        voices = _config_manager.get_voices_for_current_api()
+        available_voices = list(voices.keys())
+        return JSONResponse({
+            'success': False,
+            'error': f'voice_id "{voice_id}" 在当前API的音色库中不存在',
+            'available_voices': available_voices
+        }, status_code=400)
+
+    set_reserved(characters['猫娘'][name], 'voice_id', voice_id)
     _config_manager.save_characters(characters)
 
     # 如果是当前活跃的猫娘，需要先通知前端，再关闭session
@@ -783,7 +798,7 @@ async def update_catgirl_voice_id(name: str, request: Request):
     if is_current_catgirl and name in session_manager:
         # 检查是否有活跃的session
         if session_manager[name].is_active:
-            logger.info(f"检测到 {name} 的voice_id已更新，准备刷新...")
+            logger.info(f"检测到 {name} 的voice_id已更新（{old_voice_id} -> {voice_id}），准备刷新...")
 
             # 1. 先发送刷新消息（WebSocket还连着）
             await send_reload_page_notice(session_manager[name])
@@ -806,7 +821,7 @@ async def update_catgirl_voice_id(name: str, request: Request):
         # 不是当前猫娘，跳过重新加载，避免影响当前猫娘的session
         logger.info(f"切换的是其他猫娘 {name} 的音色，跳过重新加载以避免影响当前猫娘的session")
 
-    return {"success": True, "session_restarted": session_ended}
+    return {"success": True, "session_restarted": session_ended, "voice_id_changed": True}
 
 @router.get('/catgirl/{name}/voice_mode_status')
 async def get_catgirl_voice_mode_status(name: str):

plugin/message_plane/runner.py

@@ -4,8 +4,6 @@
 import concurrent.futures
 import os
 import socket
-import subprocess
-import sys
 import threading
 import time
 from dataclasses import dataclass
@@ -94,16 +92,14 @@ def _check_once() -> bool:
 
 
 class PythonMessagePlaneRunner(MessagePlaneRunner):
-    def __init__(self, *, run_mode: str, endpoints: MessagePlaneEndpoints) -> None:
-        self._run_mode = str(run_mode)
+    def __init__(self, *, endpoints: MessagePlaneEndpoints) -> None:
         self._endpoints = endpoints
 
         self._thread: threading.Thread | None = None
         self._ingest_thread: threading.Thread | None = None
         self._rpc = None
         self._ingest = None
         self._pub = None
-        self._proc: subprocess.Popen | None = None
 
     def _cleanup_embedded(
         self,
@@ -156,36 +152,7 @@ def _cleanup_embedded(
         self._thread = None
         self._ingest_thread = None
 
-    def _terminate_process(self, proc: subprocess.Popen | None) -> None:
-        if proc is None:
-            return
-        try:
-            if proc.poll() is None:
-                proc.terminate()
-        except Exception:
-            pass
-        try:
-            proc.wait(timeout=1.0)
-            return
-        except subprocess.TimeoutExpired:
-            pass
-        except Exception:
-            return
-        try:
-            if proc.poll() is None:
-                proc.kill()
-        except Exception:
-            return
-        try:
-            proc.wait(timeout=1.0)
-        except subprocess.TimeoutExpired:
-            logger.warning("message_plane process did not exit after kill pid={}", getattr(proc, "pid", "?"))
-        except Exception:
-            pass
-
     def start(self) -> MessagePlaneEndpoints:
-        if self._run_mode == "external":
-            return self._start_external()
         return self._start_embedded()
 
     def _start_embedded(self) -> MessagePlaneEndpoints:
@@ -245,45 +212,7 @@ def _run_rpc() -> None:
             raise
         return self._endpoints
 
-    def _start_external(self) -> MessagePlaneEndpoints:
-        if self._proc is not None and self._proc.poll() is None:
-            return self._endpoints
-
-        env = dict(os.environ)
-        env["NEKO_MESSAGE_PLANE_ZMQ_RPC_ENDPOINT"] = str(self._endpoints.rpc)
-        env["NEKO_MESSAGE_PLANE_ZMQ_PUB_ENDPOINT"] = str(self._endpoints.pub)
-        env["NEKO_MESSAGE_PLANE_ZMQ_INGEST_ENDPOINT"] = str(self._endpoints.ingest)
-
-        try:
-            cmd = [sys.executable, "-m", "plugin.message_plane.main"]
-            self._proc = subprocess.Popen(
-                cmd,
-                stdin=subprocess.DEVNULL,
-                stdout=None,
-                stderr=None,
-                close_fds=True,
-                env=env,
-            )
-            logger.info("message_plane external process started pid={}", int(self._proc.pid))
-        except Exception as e:
-            self._proc = None
-            logger.warning("message_plane external process start failed: {}", e)
-            raise
-
-        for label, ep in [("rpc", self._endpoints.rpc), ("ingest", self._endpoints.ingest), ("pub", self._endpoints.pub)]:
-            if not _wait_tcp_ready(str(ep), timeout_s=3.0):
-                logger.warning("message_plane {} endpoint not ready: {}", label, ep)
-        return self._endpoints
-
     def stop(self) -> None:
-        if self._run_mode == "external":
-            p = self._proc
-            self._proc = None
-            if p is None:
-                return
-            self._terminate_process(p)
-            return
-
         rpc_srv = self._rpc
         ingest_srv = self._ingest
         pub_srv = self._pub
@@ -368,16 +297,11 @@ def _resolve_endpoint_with_fallback(endpoint: str, used_ports: set[tuple[str, in
 
 def build_message_plane_runner() -> MessagePlaneRunner:
     from plugin.settings import (
-        MESSAGE_PLANE_RUN_MODE,
         MESSAGE_PLANE_ZMQ_INGEST_ENDPOINT,
         MESSAGE_PLANE_ZMQ_PUB_ENDPOINT,
         MESSAGE_PLANE_ZMQ_RPC_ENDPOINT,
     )
 
-    run_mode = os.getenv("NEKO_MESSAGE_PLANE_RUN_MODE", str(MESSAGE_PLANE_RUN_MODE)).strip().lower()
-    if run_mode not in ("embedded", "external"):
-        run_mode = str(MESSAGE_PLANE_RUN_MODE)
-
     rpc_env = os.getenv("NEKO_MESSAGE_PLANE_ZMQ_RPC_ENDPOINT", str(MESSAGE_PLANE_ZMQ_RPC_ENDPOINT))
     pub_env = os.getenv("NEKO_MESSAGE_PLANE_ZMQ_PUB_ENDPOINT", str(MESSAGE_PLANE_ZMQ_PUB_ENDPOINT))
     ingest_env = os.getenv("NEKO_MESSAGE_PLANE_ZMQ_INGEST_ENDPOINT", str(MESSAGE_PLANE_ZMQ_INGEST_ENDPOINT))
@@ -397,4 +321,4 @@ def build_message_plane_runner() -> MessagePlaneRunner:
         ingest=ingest_ep,
     )
 
-    return PythonMessagePlaneRunner(run_mode=run_mode, endpoints=endpoints)
+    return PythonMessagePlaneRunner(endpoints=endpoints)

plugin/settings.py

@@ -301,13 +301,8 @@ def get_plugin_config_roots() -> tuple[Path, ...]:
     os.getenv("NEKO_MESSAGE_PLANE_PUB", "tcp://127.0.0.1:38866"),
 )
 
-# Message plane 运行模式
-# - embedded: 作为主进程的后台线程启动（默认）
-# - external: 由主进程启动独立子进程（独立解释器），用于隔离控制面与数据面负载
-# Env: NEKO_MESSAGE_PLANE_RUN_MODE, default="external"
-MESSAGE_PLANE_RUN_MODE = os.getenv("NEKO_MESSAGE_PLANE_RUN_MODE", "external").strip().lower()
-if MESSAGE_PLANE_RUN_MODE not in ("embedded", "external"):
-    MESSAGE_PLANE_RUN_MODE = "external"
+# Message plane 始终以内嵌线程方式运行。
+# 保留端点配置，但不再支持 external 独立子进程模式。
 
 MESSAGE_PLANE_VALIDATE_MODE = os.getenv("NEKO_MESSAGE_PLANE_VALIDATE_MODE", "strict").lower()
 if MESSAGE_PLANE_VALIDATE_MODE not in ("off", "warn", "strict"):
@@ -581,7 +576,6 @@ def validate_config() -> None:
     "SYNC_CALL_IN_HANDLER_POLICY",
 
     # Message plane
-    "MESSAGE_PLANE_RUN_MODE",
     "MESSAGE_PLANE_ZMQ_RPC_ENDPOINT",
     "MESSAGE_PLANE_ZMQ_PUB_ENDPOINT",
     "MESSAGE_PLANE_ZMQ_INGEST_ENDPOINT",
@@ -648,7 +642,6 @@ def validate_config() -> None:
     "MESSAGE_PLANE_BACKEND",
     "MESSAGE_PLANE_RUST_BIN",
     "MESSAGE_PLANE_WORKERS",
-    "MESSAGE_PLANE_RUN_MODE",
     "MESSAGE_PLANE_ZMQ_RPC_ENDPOINT",
     "MESSAGE_PLANE_ZMQ_PUB_ENDPOINT",
     "MESSAGE_PLANE_ZMQ_INGEST_ENDPOINT",

static/app.js

@@ -577,8 +577,11 @@ function init_app() {
                         if (hasRunning && !agentTaskTimeUpdateInterval) {
                             agentTaskTimeUpdateInterval = setInterval(updateTaskRunningTimes, 1000);
                         }
+                    } else if (typeof window.checkAndToggleTaskHUD === 'function') {
+                        // Re-evaluate HUD visibility from enablement state instead of
+                        // force-hiding on an empty task snapshot.
+                        window.checkAndToggleTaskHUD();
                     } else if (window.AgentHUD && typeof window.AgentHUD.hideAgentTaskHUD === 'function') {
-                        // No tasks at all, hide HUD
                         window.AgentHUD.hideAgentTaskHUD();
                     }
                 }
@@ -1050,8 +1053,11 @@ function init_app() {
                                     timestamp: new Date().toISOString()
                                 });
                             }
+                        } else if (typeof window.checkAndToggleTaskHUD === 'function') {
+                            // An empty snapshot should not hide the HUD while any
+                            // agent capability is still enabled.
+                            window.checkAndToggleTaskHUD();
                         } else if (window.AgentHUD && typeof window.AgentHUD.hideAgentTaskHUD === 'function') {
-                            // No active tasks, hide HUD
                             window.AgentHUD.hideAgentTaskHUD();
                         }
                     } catch (_e) { /* ignore */ }