myagent-ai 1.13.6 → 1.14.0

package/agents/main_agent.py

@@ -42,8 +42,8 @@ class MainAgent(BaseAgent):
 严格以XML格式化输出以下内容:
 <output>
 <response>直接回复用户的内容。这是一段友好、自然的话语，用于向用户说明你正在做什么，或者回应用户的问题/问候。要求简洁、有礼貌、符合对话场景。如果用户只是问候，简单回应即可；如果用户有具体任务，要说明你的计划。</response>
-<usersays_correct>根据用户输入的"usersays"内容，结合上下文优化为新的用户输入，如果"usersays"为空，这里输出为空。</usersays_correct>
-<task_plan>任务计划（仅复杂任务使用）：如"context"包含非空"task_plan"，则更新它。否则，先评估任务复杂度——如果预计操作步骤不超过5步（如：单次查询、简单问答、格式转换、单文件修改、简单计算等简单任务），则<task_plan>输出为空，不要创建任务列表；只有当任务较复杂（预计超过5步操作，如：多文件修改、需要调研+实现+测试、涉及多个模块联动等），才以Markdown列表格式制定新任务列表。格式：每项用 "- [ ] 任务描述" 或 "- [x] 已完成任务"，含完成状态标记。</task_plan>
+<usersays_correct>根据用户输入的"usersays"内容（语音转写文本），结合对话语境优化为更准确的用户意图表达（修正识别错误、补充标点、口语转书面语）。如果"usersays"为空，这里输出为空。</usersays_correct>
+<task_plan>任务计划（仅复杂任务使用）：如"context"包含非空"task_plan"，则更新它。否则，先评估任务复杂度——如果预计操作步骤不超过3步（如：单次查询、简单问答、格式转换、单文件修改、简单计算等简单任务），则<task_plan>输出为空，不要创建任务列表；只有当任务较复杂（预计超过3步操作，如：多文件修改、需要调研+实现+测试、涉及多个模块联动等），才以Markdown列表格式制定新任务列表。格式：每项用 "- [ ] 任务描述" 或 "- [x] 已完成任务"，含完成状态标记。</task_plan>
 
 <toolstocal>
 <tool><beforecalltext>连接词，介绍调用什么工具，达到什么目的。</beforecalltext><toolname>工具名</toolname><parms>JSON格式的参数对象，例如: {"query": "搜索关键词", "num": 5}</parms><timeout>预估超时时限(秒)</timeout><callback>true/false,要求解析器在该工具执行完后是否要回调llm大模型，将所有工具输出结果+新构造的"context"输入给llm</callback></tool>
@@ -62,8 +62,8 @@ class MainAgent(BaseAgent):
 ## 核心规则
 1. 你必须且只能输出 <output> XML 结构，不要输出任何其他文本
 2. <response>: 必须输出一段直接回复用户的话语（这是用户实际看到的回复），要求简洁友好、自然流畅。不要只输出任务计划而不说话！
-3. <usersays_correct>: 如果 context 中 usersays 非空，则根据对话语境优化为更准确的用户意图表达
-4. <task_plan>: 仅用于复杂任务（预计超过5步操作）。简单任务（≤5步）输出为空。复杂任务使用 Markdown 列表格式，每项包含任务描述和完成状态标记 [x]/[ ]
+3. <usersays_correct>: 如果 context 中 usersays 非空（说明用户通过语音输入），则根据对话语境将语音转写文本优化为更准确的用户意图表达，修正识别错误、补充标点、口语转书面语。如果 usersays 为空，这里输出为空。
+4. <task_plan>: 仅用于复杂任务（预计超过3步操作）。简单任务（≤3步）输出为空。复杂任务使用 Markdown 列表格式，每项包含任务描述和完成状态标记 [x]/[ ]
 5. <toolstocal>: 列出所有需要执行的工具调用，每个工具包含完整的参数说明
 6. <parms>: **必须使用严格合法的JSON格式**，例如 {"query": "关键词", "num": 10}，不要使用其他格式
 7. <timeout>: 预估超时秒数（简单操作10-30s，文件操作30-60s，网络请求60-120s，数据处理120-300s）
@@ -514,7 +514,7 @@ class MainAgent(BaseAgent):
                 session_id=context.session_id,
                 conversation_history=conversation_history,
                 user_typed_text=context.user_message,
-                user_voice_text="",
+                user_voice_text=context.metadata.get("user_voice_text", ""),
                 task_plan=current_task_plan,
                 agent_override_prompt=agent_override_prompt,
                 get_knowledge=get_knowledge_content,

package/core/context_builder.py

@@ -605,8 +605,15 @@ class ContextBuilder:
         Returns:
             <userprint> 和 <usersays> XML 段落字符串
         """
-        safe_typed = _xml_escape(user_typed_text.strip()) if user_typed_text else ""
-        safe_voice = _xml_escape(user_voice_text.strip()) if user_voice_text else ""
+        # 语音输入时：userprint 为空，usersays 存原始语音文本
+        # 键盘输入时：userprint 存文本，usersays 为空
+        # 两者互斥
+        if user_voice_text and user_voice_text.strip():
+            safe_typed = ""
+            safe_voice = _xml_escape(user_voice_text.strip())
+        else:
+            safe_typed = _xml_escape(user_typed_text.strip()) if user_typed_text else ""
+            safe_voice = ""
 
         lines = [
             f"<userprint>",

package/core/deps_checker.py

@@ -17,7 +17,6 @@ core/deps_checker.py - 自动依赖检测与安装
   托盘功能: pystray, PIL
   语音合成: edge_tts
   浏览器自动化: chrome-devtools-mcp (Node.js, Chrome DevTools Protocol)
-  (备用) playwright (+ chromium 浏览器二进制)
   桌面GUI自动化: mss, pynput, pygetwindow
 """
 from __future__ import annotations
@@ -76,9 +75,9 @@ DEPENDENCIES: List[DepInfo] = [
     # ── 语音合成 ──
     DepInfo("edge_tts", "edge-tts", "6.1.0", "tts", "all"),
 
-    # ── 浏览器自动化 (ChromeDev MCP + Playwright 备用) ──
-    DepInfo("playwright", "playwright", "1.41.0", "browser", "all",
-            note="备用方案。推荐使用 chrome-devtools-mcp (需 Node.js >= 20.19)"),
+    # ── 浏览器自动化 (ChromeDev MCP) ──
+    # Playwright 已移除，浏览器自动化统一使用 ChromeDevTools Protocol (MCP)
+    # 需要 Node.js >= 20.19，参见 skills/chromedev_mcp.py
 
     # ── 桌面 GUI 自动化 ──
     DepInfo("mss", "mss", "9.0.0", "gui", "all",
@@ -209,33 +208,6 @@ def _pip_install(pip_names: List[str], category: str = "") -> Tuple[bool, str]:
     return False, f"安装失败: {packages} - {last_error}"
 
 
-def _install_playwright_browsers() -> Tuple[bool, str]:
-    """
-    安装 Playwright 浏览器二进制文件（Chromium）。
-    这是一个独立的步骤，因为 pip install playwright 只安装 Python 包，
-    浏览器二进制需要单独下载。
-    """
-    python = _get_python_executable()
-    try:
-        result = subprocess.run(
-            [python, "-m", "playwright", "install", "chromium"],
-            capture_output=True,
-            timeout=300,  # 5分钟超时（浏览器较大）
-        )
-        stdout = result.stdout.decode("utf-8", errors="replace") if result.stdout else ""
-        stderr = result.stderr.decode("utf-8", errors="replace") if result.stderr else ""
-        if result.returncode == 0:
-            return True, "Chromium 浏览器已安装"
-        # 检查是否已经安装
-        if "Chromium" in stdout and "already" in stdout.lower():
-            return True, "Chromium 浏览器已就绪"
-        return False, f"Chromium 安装失败: {stderr[:200]}"
-    except subprocess.TimeoutExpired:
-        return False, "Chromium 安装超时（5分钟），请手动运行: playwright install chromium"
-    except Exception as e:
-        return False, f"Chromium 安装异常: {e}"
-
-
 def _check_version(import_name: str, min_version: str) -> bool:
     """检查模块版本是否满足最低要求"""
     if not min_version:
@@ -279,7 +251,7 @@ def check_and_install_deps(
             "failed": int,         # 安装失败的数量
             "skipped_platform": int,  # 因平台不匹配而跳过的数量
             "details": {...},      # 每个依赖的状态
-            "playwright_browser": str,  # Chromium 状态
+            "browser": str,         # ChromeDev MCP 状态
         }
     """
     stats = {
@@ -290,7 +262,7 @@ def check_and_install_deps(
         "failed": 0,
         "skipped_platform": 0,
         "details": {},
-        "playwright_browser": "not_checked",
+        "browser": "not_checked",
     }
 
     # 按分类收集缺失的依赖，批量安装以减少 pip 调用次数
@@ -367,36 +339,6 @@ def check_and_install_deps(
                 if not silent:
                     logger.warning(f"  ✗ 安装失败: {dep.import_name} - {message}")
 
-    # 第三遍：如果 playwright 安装成功，还需要安装 Chromium 浏览器二进制
-    playwright_dep = next((d for d in DEPENDENCIES if d.import_name == "playwright"), None)
-    if playwright_dep and stats["details"].get("playwright", {}).get("status") == "installed":
-        if not silent:
-            logger.info("正在安装 Chromium 浏览器二进制...")
-        success, message = _install_playwright_browsers()
-        stats["playwright_browser"] = "installed" if success else "failed"
-        if not silent:
-            if success:
-                logger.info(f"  ✓ {message}")
-            else:
-                logger.warning(f"  ✗ {message}")
-    elif playwright_dep and stats["details"].get("playwright", {}).get("status") == "available":
-        # playwright 已安装，检查 chromium 是否已安装
-        try:
-            result = subprocess.run(
-                [_get_python_executable(), "-m", "playwright", "install", "--dry-run", "chromium"],
-                capture_output=True, timeout=10,
-            )
-            if result.returncode == 0:
-                stats["playwright_browser"] = "ready"
-            else:
-                # 尝试安装
-                if not silent:
-                    logger.info("正在安装 Chromium 浏览器二进制...")
-                success, message = _install_playwright_browsers()
-                stats["playwright_browser"] = "installed" if success else "failed"
-        except Exception:
-            stats["playwright_browser"] = "unknown"
-
     # 汇总日志
     if not silent and (total_installed > 0 or total_failed > 0):
         logger.info(
@@ -414,7 +356,7 @@ def ensure_skill_deps(skill_category: str) -> bool:
 
     Args:
         skill_category: 技能分类名称
-                        "browser" - 浏览器自动化 (chrome-devtools-mcp / playwright)
+                        "browser" - 浏览器自动化 (chrome-devtools-mcp)
                         "gui" - 桌面GUI自动化 (mss, pynput, pygetwindow)
                         "search" - 搜索技能
                         "tts" - 语音合成

package/main.py

@@ -73,55 +73,7 @@ def _get_screen_resolution() -> tuple[int, int]:
 
 
 def _open_browser_kiosk(url: str):
-    """打开浏览器窗口（无地址栏模式），回退到系统浏览器。
-
-    优先使用 Playwright 打开 app 模式的 Chromium 窗口（无地址栏），
-    如果 Playwright 不可用则回退到 webbrowser.open()。
-    """
-    try:
-        import asyncio
-        from playwright.async_api import async_playwright
-
-        async def _launch():
-            pw = await async_playwright().start()
-            # 获取实际屏幕分辨率，确保窗口占满屏幕
-            # --app 模式下 --start-maximized 不生效，需要手动设置窗口大小
-            screen_width, screen_height = _get_screen_resolution()
-            browser = await pw.chromium.launch(
-                headless=False,
-                args=[
-                    "--no-sandbox",
-                    f"--app={url}",  # app 模式: 无地址栏、无标签页
-                    f"--window-size={screen_width},{screen_height}",
-                    "--window-position=0,0",
-                ],
-            )
-            # 保持进程运行，浏览器关闭后退出
-            page = await browser.new_page()
-            await page.goto(url)
-            # 监听页面关闭
-            while True:
-                try:
-                    await asyncio.sleep(2)
-                    if not browser.is_connected():
-                        break
-                except Exception:
-                    break
-            try:
-                await pw.stop()
-            except Exception:
-                pass
-
-        # 在后台线程中运行，避免阻塞主线程
-        thread = threading.Thread(target=lambda: asyncio.run(_launch()), daemon=True)
-        thread.start()
-        return
-    except ImportError:
-        pass
-    except Exception:
-        pass
-
-    # 回退到系统浏览器
+    """打开浏览器窗口，使用系统默认浏览器。"""
     import webbrowser
     webbrowser.open(url)
 
@@ -212,10 +164,6 @@ class MyAgentApp:
             self.logger.warning(
                 f"{deps_result['failed']} 个依赖安装失败，相关功能可能不可用"
             )
-        if deps_result["playwright_browser"] in ("installed", "ready"):
-            self.logger.info("Chromium 浏览器已就绪")
-        elif deps_result["playwright_browser"] == "failed":
-            self.logger.warning("Chromium 浏览器安装失败，浏览器自动化技能可能不可用")
 
         # 2. LLM 客户端
         llm_cfg = self.config.llm
@@ -431,7 +379,7 @@ class MyAgentApp:
         ]:
             self.skill_registry.register(skill_cls())
 
-        # 浏览器自动化技能 (Playwright)
+        # 浏览器自动化技能 (ChromeDev MCP)
         for skill_cls in [
             BrowserOpenSkill, BrowserClickSkill, BrowserFillSkill,
             BrowserScreenshotSkill, BrowserEvalSkill, BrowserNavigateSkill, BrowserCloseSkill,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.13.6",
+  "version": "1.14.0",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {

package/requirements.txt

@@ -17,9 +17,10 @@ lxml>=5.0.0
 psutil>=5.9.0
 
 # ============================================================
-# 技能系统 - 浏览器自动化 (Playwright)
+# 技能系统 - 浏览器自动化 (ChromeDev MCP)
 # ============================================================
-playwright>=1.41.0
+# 浏览器自动化使用 ChromeDevTools Protocol (MCP)，无需 Playwright
+# 需要 Node.js >= 20.19，参见 skills/chromedev_mcp.py
 
 # ============================================================
 # 技能系统 - 桌面 GUI 自动化 (可选，无头服务器不需要)

package/setup.py

@@ -37,8 +37,7 @@ setup(
         "Pillow>=10.0.0",
         # 语音合成
         "edge-tts>=6.1.0",
-        # 浏览器自动化 (内置技能)
-        "playwright>=1.41.0",
+        # 浏览器自动化 (ChromeDev MCP, 无需 Playwright)
         # 桌面 GUI 自动化 (内置技能)
         "pynput>=1.7.6",
         "pygetwindow>=0.0.9",
@@ -49,12 +48,14 @@ setup(
         "discord": ["discord.py>=2.3.0"],
         "anthropic": ["anthropic>=0.18.0"],
         "communication": ["cryptography>=41.0.0", "websockets>=12.0"],
+        "voice": ["faster-whisper>=1.0.0"],
         "all": [
             "python-telegram-bot>=21.0",
             "discord.py>=2.3.0",
             "anthropic>=0.18.0",
             "cryptography>=41.0.0",
             "websockets>=12.0",
+            "faster-whisper>=1.0.0",
         ],
     },
     entry_points={

package/web/api_server.py

@@ -313,6 +313,7 @@ class ApiServer:
         r.add_post("/api/chat/stream", self.handle_chat_stream)
         r.add_post("/api/chat/inject", self.handle_chat_inject)
         r.add_post("/api/voice-optimize", self.handle_voice_optimize)
+        r.add_post("/api/voice-stt", self.handle_voice_stt)
         r.add_get("/chat", self.handle_chat_page)
         r.add_get("/api/execution/progress", self.handle_execution_progress)
         # ── 组织管理 ──
@@ -614,6 +615,7 @@ class ApiServer:
             session_id = f"{agent_path}_{raw_session_id}"
         chat_mode = data.get("mode", "")
         escalated = data.get("escalated", False)
+        voice_text = data.get("voice_text", "").strip()  # 语音转文字原始文本（用于 usersays_correct）
 
         # ── 检查是否有正在运行的同一会话任务 ──
         running_info = self._running_sessions.get(session_id)
@@ -718,12 +720,13 @@ class ApiServer:
                         model_chain, clean_message, session_id,
                         agent_path=agent_path, agent_system_prompt=agent_system_prompt,
                         chat_mode=chat_mode, stream_response=proxy,
+                        voice_text=voice_text,
                     )
                 elif self.core.main_agent and self.core.llm:
                     full_response = await self._stream_process_message(
                         clean_message, session_id, proxy,
                         agent_path=agent_path, agent_system_prompt=agent_system_prompt,
-                        chat_mode=chat_mode,
+                        chat_mode=chat_mode, voice_text=voice_text,
                     )
                 else:
                     full_response = await self.core.process_message(clean_message, session_id)
@@ -768,12 +771,13 @@ class ApiServer:
                             model_chain, clean_message_q, session_id,
                             agent_path=agent_path, agent_system_prompt=agent_system_prompt_q,
                             chat_mode=chat_mode, stream_response=proxy,
+                            voice_text="",
                         )
                     elif self.core.main_agent and self.core.llm:
                         full_response = await self._stream_process_message(
                             clean_message_q, session_id, proxy,
                             agent_path=agent_path, agent_system_prompt=agent_system_prompt_q,
-                            chat_mode=chat_mode,
+                            chat_mode=chat_mode, voice_text="",
                         )
                     else:
                         full_response = await self.core.process_message(clean_message_q, session_id)
@@ -1026,6 +1030,145 @@ class ApiServer:
             logger.error(f"Voice optimize failed: {e}")
             return web.json_response({"error": str(e)}, status=500)
 
+    async def handle_voice_stt(self, request):
+        """POST /api/voice-stt - 轻量级本地语音转文字
+
+        接受音频文件（WAV/WEBM/OGG），使用本地 STT 引擎转录。
+        支持的引擎（按优先级）：
+        1. faster-whisper（推荐，需安装：pip install faster-whisper）
+        2. vosk（备选，需安装：pip install vosk）
+        如果都未安装，返回错误提示。
+        """
+        try:
+            reader = await request.multipart()
+            audio_data = None
+            audio_format = None
+
+            while True:
+                field = await reader.next()
+                if field is None:
+                    break
+                if field.name == 'audio':
+                    audio_data = await field.read(decode=False)
+                elif field.name == 'format':
+                    audio_format = (await field.read(decode=True)).decode('utf-8').strip()
+
+            if not audio_data:
+                # 也支持 JSON body：{"audio": "base64...", "format": "wav"}
+                try:
+                    data = await request.json()
+                    audio_b64 = data.get("audio", "")
+                    audio_format = data.get("format", "wav")
+                    if audio_b64:
+                        import base64
+                        audio_data = base64.b64decode(audio_b64)
+                except Exception:
+                    pass
+
+            if not audio_data:
+                return web.json_response({"error": "未收到音频数据"}, status=400)
+
+            import io
+
+            # ── 尝试 faster-whisper ──
+            try:
+                from faster_whisper import WhisperModel
+                whisper_model = getattr(self, '_whisper_model', None)
+                if whisper_model is None:
+                    import os
+                    model_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'models', 'whisper')
+                    # 使用 tiny 模型（最轻量，~39MB），CPU int8 量化
+                    self._whisper_model = WhisperModel("tiny", device="cpu", compute_type="int8",
+                                                       download_root=model_dir)
+                    whisper_model = self._whisper_model
+                    logger.info("faster-whisper tiny 模型已加载 (CPU int8)")
+
+                # faster-whisper 需要 16kHz WAV
+                import wave
+                audio_buf = io.BytesIO(audio_data)
+
+                # 转换为 WAV 16kHz mono
+                wav_buf = io.BytesIO()
+                with wave.open(wav_buf, 'wb') as wf:
+                    # 尝试读取原始音频
+                    try:
+                        with wave.open(audio_buf, 'rb') as rf:
+                            wf.setnchannels(1)
+                            wf.setsampwidth(2)
+                            wf.setframerate(16000)
+                            # 读取所有帧并重采样
+                            frames = rf.readframes(rf.getnframes())
+                            wf.writeframes(frames)
+                    except Exception:
+                        # 非 WAV 格式，尝试通过 pydub 或直接写入
+                        wf.setnchannels(1)
+                        wf.setsampwidth(2)
+                        wf.setframerate(16000)
+                        wf.writeframes(audio_data)
+
+                wav_buf.seek(0)
+                segments, info = whisper_model.transcribe(wav_buf, language="zh", beam_size=1,
+                                                          vad_filter=True, vad_parameters=dict(
+                                                              min_silence_duration_ms=300))
+                text = "".join(seg.text for seg in segments).strip()
+
+                if text:
+                    return web.json_response({"text": text, "engine": "faster-whisper"})
+            except ImportError:
+                logger.debug("faster-whisper 未安装，跳过")
+            except Exception as e:
+                logger.warning(f"faster-whisper 转录失败: {e}")
+
+            # ── 尝试 vosk ──
+            try:
+                import vosk
+                model = getattr(self, '_vosk_model', None)
+                if model is None:
+                    import os, zipfile
+                    model_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'models', 'vosk', 'vosk-model-cn')
+                    if not os.path.exists(model_dir):
+                        # 自动下载 vosk 小型中文模型
+                        logger.info("正在下载 vosk 中文模型...")
+                        import urllib.request
+                        url = "https://alphacephei.com/vosk/models/vosk-model-small-cn-0.22.zip"
+                        zip_path = model_dir + ".zip"
+                        os.makedirs(os.path.dirname(model_dir), exist_ok=True)
+                        try:
+                            urllib.request.urlretrieve(url, zip_path)
+                            with zipfile.ZipFile(zip_path, 'r') as zf:
+                                zf.extractall(os.path.dirname(model_dir))
+                            os.remove(zip_path)
+                        except Exception as de:
+                            logger.warning(f"vosk 模型下载失败: {de}")
+                    if os.path.exists(model_dir):
+                        self._vosk_model = vosk.Model(model_dir)
+                        model = self._vosk_model
+
+                if model:
+                    import json as _json
+                    rec = vosk.KaldiRecognizer(model, 16000)
+                    rec.AcceptWaveform(audio_data)
+                    result = _json.loads(rec.Result())
+                    text = result.get("text", "").strip()
+                    if text:
+                        return web.json_response({"text": text, "engine": "vosk"})
+            except ImportError:
+                logger.debug("vosk 未安装，跳过")
+            except Exception as e:
+                logger.warning(f"vosk 转录失败: {e}")
+
+            # ── 没有可用的 STT 引擎 ──
+            return web.json_response({
+                "error": "未检测到本地 STT 引擎。请安装 faster-whisper（推荐）或 vosk：\n"
+                         "  pip install faster-whisper  (首次使用会自动下载 tiny 模型 ~39MB)\n"
+                         "  或 pip install vosk",
+                "available": False,
+            }, status=503)
+
+        except Exception as e:
+            logger.error(f"Voice STT failed: {e}", exc_info=True)
+            return web.json_response({"error": str(e)}, status=500)
+
     def _build_task_plan_context(self, agent_path: str, chat_mode: str, original_message: str, session_id: str = "") -> str:
         """构建任务规划上下文（仅 exec 模式，注入到 system_prompt 中）"""
         if chat_mode != "exec":
@@ -1035,8 +1178,8 @@ class ApiServer:
             "你当前处于【执行模式】(Execution Mode)。\n\n"
             "## 核心规则\n"
             "1. **任务列表（按复杂度决定）**：\n"
-            "   - 如果用户的需求是简单任务（预计操作步骤不超过5步，如：单次查询、简单计算、问答题、格式转换、文件读取等），【不要】使用 ```tasklist```，直接用纯文本回复并执行即可。\n"
-            "   - 只有当任务较复杂（预计需要超过5步操作，如：多文件修改、需要调研+实现+测试、涉及多个模块联动等），才使用 ```tasklist``` 代码块来跟踪进度。\n"
+            "   - 如果用户的需求是简单任务（预计操作步骤不超过3步，如：单次查询、简单计算、问答题、格式转换、文件读取等），【不要】使用 ```tasklist```，直接用纯文本回复并执行即可。\n"
+            "   - 只有当任务较复杂（预计需要超过3步操作，如：多文件修改、需要调研+实现+测试、涉及多个模块联动等），才使用 ```tasklist``` 代码块来跟踪进度。\n"
             "   - 格式：```tasklist\\n[{\"text\": \"步骤描述\", \"status\": \"pending\"}]\\n```\n"
             "   - status 可选值：pending(待执行)、running(进行中)、done(已完成)、blocked(受阻)\n"
             "   - 首次收到复杂任务时，拆分为多个步骤，全部标记为 pending\n"
@@ -1052,7 +1195,7 @@ class ApiServer:
         store_key = session_id or agent_path
         tasks = self._task_list_store.get(store_key, [])
         if not tasks:
-            return base_instruction + "\n## 当前状态\n暂无任务计划。如果是简单任务（不超过5步），直接执行即可，无需创建任务列表。如果是复杂任务（超过5步），请先分析用户需求，拆分为具体步骤，然后用 ```tasklist``` 输出计划。"
+            return base_instruction + "\n## 当前状态\n暂无任务计划。如果是简单任务（不超过3步），直接执行即可，无需创建任务列表。如果是复杂任务（超过3步），请先分析用户需求，拆分为具体步骤，然后用 ```tasklist``` 输出计划。"
 
         pending = [f"  - ⏳ {t['text']}" for t in tasks if t.get("status") in ("pending", "running", "blocked")]
         done = [f"  - ✅ {t['text']}" for t in tasks if t.get("status") == "done"]
@@ -3168,7 +3311,8 @@ class ApiServer:
 
     async def _try_model_chain_stream(self, model_chain, message, session_id,
                                        agent_path=None, agent_system_prompt=None,
-                                       chat_mode="", stream_response=None):
+                                       chat_mode="", stream_response=None,
+                                       voice_text=""):
         """流式版本的模型链调用，逐token输出到SSE
         
         使用 asyncio.Lock 保护共享的 self.core.llm，防止并发请求互相干扰。
@@ -3183,11 +3327,13 @@ class ApiServer:
                 model_chain, message, session_id,
                 agent_path=agent_path, agent_system_prompt=agent_system_prompt,
                 chat_mode=chat_mode, stream_response=stream_response,
+                voice_text=voice_text,
             )
 
     async def _try_model_chain_stream_inner(self, model_chain, message, session_id,
                                              agent_path=None, agent_system_prompt=None,
-                                             chat_mode="", stream_response=None):
+                                             chat_mode="", stream_response=None,
+                                             voice_text=""):
         """_try_model_chain_stream 的实际执行体（已在 _model_chain_lock 保护下）"""
         llm = self.core.llm
         full_text = ""
@@ -3212,7 +3358,7 @@ class ApiServer:
                 result = await self._stream_process_message(
                     message, session_id, stream_response,
                     agent_path=agent_path, agent_system_prompt=agent_system_prompt,
-                    chat_mode=chat_mode,
+                    chat_mode=chat_mode, voice_text=voice_text,
                 )
                 if result and not result.startswith("⚠️") and not result.startswith("❌"):
                     return result
@@ -3243,7 +3389,8 @@ class ApiServer:
                 await asyncio.sleep(delay)
 
     async def _stream_process_message(self, user_message, session_id, stream_response,
-                                      agent_path=None, agent_system_prompt=None, chat_mode=""):
+                                      agent_path=None, agent_system_prompt=None, chat_mode="",
+                                      voice_text=""):
         """使用流式LLM调用处理消息，支持完整的agent循环（工具调用/操作执行）+ 实时流式输出
 
         核心改进:
@@ -3269,6 +3416,7 @@ class ApiServer:
         context.metadata["agent_override_prompt"] = agent_system_prompt
         context.metadata["agent_override_path"] = agent_path
         context.metadata["chat_mode"] = chat_mode
+        context.metadata["user_voice_text"] = voice_text  # 语音输入原始文本（用于 usersays_correct）
 
         # ── 根据 Agent 配置设置执行引擎参数（execution_mode 等）──
         agent_cfg_for_exec = self._read_agent_config(agent_path)

package/web/ui/chat/chat_main.js

@@ -2429,7 +2429,11 @@ function _renderMessagesInner() {
       ? (content ? `<div class="message-bubble msg-bubble-wrapper">${content}${ttsIndicator}</div>` : '')
       : '';
 
-    // Exec events panel: only for backward compat (messages without parts loaded from DB)
+    // ── Task Plan (historical view only — hidden during streaming, shown after completion) ──
+    var taskPlanHtml = '';
+    if (!msg.streaming && msg._v2TaskPlan && msg._v2TaskPlan.trim()) {
+      taskPlanHtml = '<div class="v2-task-plan" style="margin-bottom:8px"><div class="v2-task-plan-header" style="font-size:12px;font-weight:600;color:var(--text3);margin-bottom:4px">📋 任务计划</div><div class="v2-task-plan-body">' + renderMarkdown(msg._v2TaskPlan) + '</div></div>';
+    }
     const execEventsHtml = (!isUser && !hasParts && msg.exec_events && msg.exec_events.length > 0)
       ? renderExecEvents(msg.exec_events, i) : '';
     html += `
@@ -2438,6 +2442,7 @@ function _renderMessagesInner() {
         <div class="message-content" style="flex:1;min-width:0">
           ${reasoningHtml}
           ${thoughtHtml}
+          ${taskPlanHtml}
           ${timelineHtml}
           ${singleBubbleHtml}
           ${streamingIndicator}
@@ -4011,28 +4016,38 @@ if (document.readyState === 'loading') {
 var VoiceInput = {
   mode: 'text',           // 'text' | 'voice'
   isRecording: false,
-  recognition: null,
+  mediaRecorder: null,
+  audioChunks: [],
   rawText: '',
-  optimizedText: '',
-  isOptimizing: false,
   _micPermissionGranted: false,   // 麦克风权限是否已确认
-  _startRetries: 0,               // 启动重试计数
-
-  /** 检查是否在安全上下文中（HTTPS 或 localhost） */
-  _isSecureContext: function() {
-    if (window.isSecureContext) return true;
-    // 某些浏览器不支持 isSecureContext，手动检查
-    var protocol = window.location.protocol;
-    var hostname = window.location.hostname;
-    return protocol === 'https:' || hostname === 'localhost' || hostname === '127.0.0.1';
+  _audioStream: null,       // 当前活跃的音频流
+  _sttEngine: null,         // 检测到的STT引擎名称
+
+  /** 检查STT引擎是否可用 */
+  checkSTTAvailable: async function() {
+    try {
+      var resp = await fetch('/api/voice-stt', { method: 'OPTIONS' }).catch(function() { return { ok: false }; });
+      // OPTIONS might not be supported, try a small test
+      var testData = new FormData();
+      testData.append('audio', new Blob([], { type: 'audio/wav' }));
+      var testResp = await fetch('/api/voice-stt', {
+        method: 'POST',
+        body: testData,
+      });
+      if (testResp.status === 400) {
+        // 400 means "no audio data" — endpoint exists and works
+        return true;
+      }
+      return testResp.ok;
+    } catch (e) {
+      return false;
+    }
   },
 
-  /** 主动请求麦克风权限（通过 getUserMedia 确认权限状态） */
+  /** 主动请求麦克风权限 */
   _ensureMicPermission: async function() {
-    // 如果已经确认有权限，跳过
     if (this._micPermissionGranted) return true;
 
-    // 检查 navigator.permissions API
     if (navigator.permissions && navigator.permissions.query) {
       try {
         var result = await navigator.permissions.query({ name: 'microphone' });
@@ -4043,16 +4058,12 @@ var VoiceInput = {
         if (result.state === 'denied') {
           return false;
         }
-      } catch (_) {
-        // permissions.query 可能不支持 microphone，继续尝试 getUserMedia
-      }
+      } catch (_) {}
     }
 
-    // 通过 getUserMedia 主动请求麦克风权限
     if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
       try {
         var stream = await navigator.mediaDevices.getUserMedia({ audio: true });
-        // 获取成功，立即释放（SpeechRecognition 会自己管理音频流）
         stream.getTracks().forEach(function(t) { t.stop(); });
         this._micPermissionGranted = true;
         return true;
@@ -4062,88 +4073,6 @@ var VoiceInput = {
         return false;
       }
     }
-
-    // 没有 mediaDevices API（HTTP 环境），但 SpeechRecognition 可能仍可用
-    return true;
-  },
-
-  /** Initialize Web Speech API */
-  init: function() {
-    var SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
-    if (!SpeechRecognition) {
-      console.warn('Web Speech API not supported');
-      return false;
-    }
-    this.recognition = new SpeechRecognition();
-    this.recognition.continuous = true;
-    this.recognition.interimResults = true;
-    this.recognition.lang = 'zh-CN';
-    this.recognition.maxAlternatives = 1;
-
-    var self = this;
-    this.recognition.onresult = function(event) {
-      var transcript = '';
-      for (var i = 0; i < event.results.length; i++) {
-        transcript += event.results[i][0].transcript;
-      }
-      self.rawText = transcript;
-      self._startRetries = 0;  // 成功获取结果，重置重试计数
-      var statusEl = document.getElementById('voiceStatus');
-      if (statusEl) {
-        statusEl.textContent = transcript || '正在聆听...';
-        statusEl.style.color = transcript ? 'var(--text)' : 'var(--text3)';
-      }
-    };
-
-    this.recognition.onerror = function(event) {
-      console.error('Speech recognition error:', event.error);
-      var statusEl = document.getElementById('voiceStatus');
-      var errMsg = '';
-
-      switch (event.error) {
-        case 'no-speech':
-          // 用户没有说话，静默处理
-          self._showStatus('未检测到语音，请重试', 'var(--text3)');
-          break;
-        case 'aborted':
-          // 用户取消，不显示错误
-          break;
-        case 'not-allowed':
-          errMsg = '麦克风权限被拒绝，请在浏览器地址栏左侧点击权限图标允许麦克风访问';
-          self._micPermissionGranted = false;
-          break;
-        case 'service-not-available':
-          errMsg = '语音识别服务不可用，请检查网络连接或尝试刷新页面';
-          break;
-        case 'service-not-allowed':
-          errMsg = '语音识别服务未授权，请检查浏览器设置是否允许语音识别';
-          break;
-        case 'audio-capture':
-          errMsg = '未找到麦克风设备，请确认已连接麦克风';
-          break;
-        case 'network':
-          errMsg = '语音识别网络错误，请检查网络连接后重试';
-          break;
-        default:
-          errMsg = '语音识别出错 (' + event.error + ')，请重试';
-          break;
-      }
-
-      if (errMsg) {
-        self._showStatus(errMsg, 'var(--danger)');
-      }
-      self.stopRecording();
-    };
-
-    this.recognition.onend = function() {
-      if (self.isRecording) {
-        self.stopRecording();
-      }
-    };
-
-    // Set up press-and-hold for the record button
-    this._setupHoldButton();
-
     return true;
   },
 
@@ -4156,6 +4085,12 @@ var VoiceInput = {
     }
   },
 
+  /** 初始化（设置按钮事件） */
+  init: function() {
+    this._setupHoldButton();
+    return true;
+  },
+
   /** Set up press-and-hold behavior on the voice record button */
   _setupHoldButton: function() {
     var btn = document.getElementById('voiceRecordBtn');
@@ -4210,45 +4145,38 @@ var VoiceInput = {
       if (textBtn) textBtn.classList.remove('active');
       if (voiceBtn) voiceBtn.classList.add('active');
       if (inputBox) inputBox.style.borderColor = '';
-      // Initialize speech recognition if not done
-      if (!this.recognition) {
+      // Init if not done
+      if (!this._setupDone) {
         this.init();
+        this._setupDone = true;
       }
+      // Check STT availability
+      this._showStatus('按住麦克风开始录音', 'var(--text3)');
     } else {
       if (textArea) textArea.style.display = 'flex';
       if (voiceArea) voiceArea.style.display = 'none';
       if (voicePreview) voicePreview.style.display = 'none';
       if (textBtn) textBtn.classList.add('active');
       if (voiceBtn) voiceBtn.classList.remove('active');
-      // Cancel any ongoing recording
       if (this.isRecording) {
         this.cancelRecording();
       }
     }
   },
 
-  /** Start recording（异步，先检查权限） */
+  /** Start recording（使用 MediaRecorder） */
   startRecording: async function() {
-    if (this.isRecording || !this.recognition) return;
-    if (this.isOptimizing) return;
-
-    // ── Step 1: 检查安全上下文 ──
-    if (!this._isSecureContext()) {
-      this._showStatus('语音识别需要 HTTPS 环境，当前页面不安全', 'var(--danger)');
-      if (typeof toast === 'function') {
-        toast('语音输入需要 HTTPS 环境，请通过 HTTPS 地址访问', 'error');
-      }
-      return;
-    }
+    if (this.isRecording) return;
 
     this.isRecording = true;
+    this.audioChunks = [];
     this.rawText = '';
 
     var btn = document.getElementById('voiceRecordBtn');
     if (btn) btn.classList.add('recording');
     this._showStatus('正在请求麦克风权限...', 'var(--text3)');
 
-    // ── Step 2: 主动请求麦克风权限 ──
+    // 获取麦克风权限
     var hasPermission = await this._ensureMicPermission();
     if (!hasPermission) {
       this.isRecording = false;
@@ -4260,121 +4188,179 @@ var VoiceInput = {
       return;
     }
 
-    this._showStatus('正在聆听...', 'var(--text3)');
-
-    // ── Step 3: 启动语音识别（带重试） ──
     try {
-      this.recognition.start();
-    } catch (e) {
-      // recognition 可能处于中间状态（stopped 但未完全重置），先 stop 再重试
-      console.warn('Recognition start failed, retrying:', e.message);
-      try { this.recognition.stop(); } catch(_) {}
-      if (this._startRetries < 2) {
-        this._startRetries++;
-        setTimeout(function() {
-          if (VoiceInput.isRecording) {
-            try { VoiceInput.recognition.start(); } catch(_) {
-              VoiceInput.isRecording = false;
-              if (btn) btn.classList.remove('recording');
-              VoiceInput._showStatus('语音识别启动失败，请重试', 'var(--danger)');
-            }
-          }
-        }, 150);
-      } else {
-        this.isRecording = false;
-        if (btn) btn.classList.remove('recording');
-        this._showStatus('语音识别启动失败，请刷新页面后重试', 'var(--danger)');
-        this._startRetries = 0;
+      // 创建音频流
+      this._audioStream = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          channelCount: 1,
+          sampleRate: 16000,
+          echoCancellation: true,
+          noiseSuppression: true,
+        }
+      });
+
+      // 创建 MediaRecorder（优先使用 WAV 格式，回退到 WEBM）
+      var mimeType = 'audio/webm;codecs=opus';
+      if (typeof MediaRecorder !== 'undefined' && MediaRecorder.isTypeSupported) {
+        if (MediaRecorder.isTypeSupported('audio/webm;codecs=opus')) {
+          mimeType = 'audio/webm;codecs=opus';
+        } else if (MediaRecorder.isTypeSupported('audio/webm')) {
+          mimeType = 'audio/webm';
+        } else if (MediaRecorder.isTypeSupported('audio/ogg;codecs=opus')) {
+          mimeType = 'audio/ogg;codecs=opus';
+        }
       }
+
+      this.mediaRecorder = new MediaRecorder(this._audioStream, { mimeType: mimeType });
+      var self = this;
+
+      this.mediaRecorder.ondataavailable = function(e) {
+        if (e.data && e.data.size > 0) {
+          self.audioChunks.push(e.data);
+        }
+      };
+
+      this.mediaRecorder.onstop = function() {
+        self._processAudio();
+      };
+
+      this.mediaRecorder.onerror = function(e) {
+        console.error('MediaRecorder error:', e.error);
+        self.isRecording = false;
+        if (btn) btn.classList.remove('recording');
+        self._showStatus('录音出错，请重试', 'var(--danger)');
+        self._cleanupStream();
+      };
+
+      // 开始录音（每100ms收集一次数据）
+      this.mediaRecorder.start(100);
+      this._showStatus('正在录音...', 'var(--text3)');
+      this._recordingStartTime = Date.now();
+
+    } catch (e) {
+      this.isRecording = false;
+      if (btn) btn.classList.remove('recording');
+      this._showStatus('无法启动录音: ' + (e.message || '未知错误'), 'var(--danger)');
+      this._cleanupStream();
     }
   },
 
-  /** Stop recording and trigger optimization */
+  /** Stop recording and process audio */
   stopRecording: function() {
-    if (!this.isRecording || !this.recognition) return;
-    this.isRecording = false;
-    this._startRetries = 0;
+    if (!this.isRecording || !this.mediaRecorder) return;
 
     var btn = document.getElementById('voiceRecordBtn');
     if (btn) btn.classList.remove('recording');
 
+    // 检查录音时长（太短则忽略）
+    var duration = Date.now() - (this._recordingStartTime || 0);
+    if (duration < 500) {
+      this._showStatus('录音时间太短，请按住麦克风说话', 'var(--text3)');
+      this.isRecording = false;
+      try { this.mediaRecorder.stop(); } catch (e) {}
+      this._cleanupStream();
+      return;
+    }
+
+    this._showStatus('正在识别...', 'var(--text3)');
+    this.isRecording = false;
+
     try {
-      this.recognition.stop();
+      this.mediaRecorder.stop();
     } catch (e) {}
-
-    // Only proceed if we have some text
-    if (this.rawText && this.rawText.trim()) {
-      this.optimizeAndPreview();
-    } else {
-      this._showStatus('未检测到语音，请重试', 'var(--text3)');
-    }
   },
 
-  /** Cancel recording without processing */
-  cancelRecording: function() {
-    this.isRecording = false;
-    if (this.recognition) {
-      try { this.recognition.abort(); } catch(e) {}
+  /** 清理音频流 */
+  _cleanupStream: function() {
+    if (this._audioStream) {
+      this._audioStream.getTracks().forEach(function(t) { t.stop(); });
+      this._audioStream = null;
     }
-    var btn = document.getElementById('voiceRecordBtn');
-    if (btn) btn.classList.remove('recording');
-    var statusEl = document.getElementById('voiceStatus');
-    if (statusEl) {
-      statusEl.textContent = '';
-    }
-    this.rawText = '';
   },
 
-  /** Send raw text to backend for LLM optimization, then show preview */
-  optimizeAndPreview: async function() {
-    if (!this.rawText.trim()) return;
+  /** 处理录音数据：发送到后端 STT */
+  _processAudio: async function() {
+    if (this.audioChunks.length === 0) {
+      this._showStatus('未检测到语音，请重试', 'var(--text3)');
+      this._cleanupStream();
+      return;
+    }
 
-    this.isOptimizing = true;
     var voiceArea = document.getElementById('voiceInputArea');
     var voicePreview = document.getElementById('voicePreview');
     var previewText = document.getElementById('voicePreviewText');
     var previewHint = document.getElementById('voicePreviewHint');
     var previewSend = document.getElementById('voicePreviewSend');
 
-    // Show preview area with raw text first
+    // 显示预览区域
     if (voiceArea) voiceArea.style.display = 'none';
     if (voicePreview) voicePreview.style.display = 'block';
-    if (previewText) previewText.textContent = this.rawText;
-    if (previewHint) previewHint.textContent = '优化中...';
+    if (previewText) previewText.textContent = '识别中...';
+    if (previewHint) previewHint.textContent = '正在发送到本地STT引擎';
     if (previewSend) previewSend.disabled = true;
 
-    // Show raw text in input for now
-    this.optimizedText = this.rawText;
-
     try {
-      var sessionId = state.activeSessionId || '';
-      var data = await api('/api/voice-optimize', {
+      var audioBlob = new Blob(this.audioChunks, { type: this.mediaRecorder ? this.mediaRecorder.mimeType : 'audio/webm' });
+
+      // 发送音频到后端 STT 端点
+      var formData = new FormData();
+      formData.append('audio', audioBlob, 'recording.webm');
+      formData.append('format', 'webm');
+
+      var resp = await fetch('/api/voice-stt', {
         method: 'POST',
-        body: JSON.stringify({
-          text: this.rawText,
-          agent_path: state.activeAgent,
-          session_id: sessionId,
-          mode: state.chatMode,
-        })
+        body: formData,
       });
 
-      if (data && data.optimized) {
-        this.optimizedText = data.optimized;
-        if (previewText) previewText.textContent = data.optimized;
-        if (previewHint) previewHint.textContent = '已优化';
+      var data = await resp.json();
+
+      if (data && data.text && data.text.trim()) {
+        this.rawText = data.text.trim();
+        this._sttEngine = data.engine || 'unknown';
+        if (previewText) previewText.textContent = this.rawText;
+        if (previewHint) previewHint.textContent = '已识别 (' + (this._sttEngine || 'local') + ')';
       } else if (data && data.error) {
-        if (previewHint) previewHint.textContent = '优化失败，使用原文';
-        console.warn('Voice optimization error:', data.error);
+        if (previewHint) previewHint.textContent = '识别失败';
+        if (previewText) previewText.textContent = data.error;
+        console.warn('Voice STT error:', data.error);
+        // 如果没有STT引擎，给出提示
+        if (data.available === false) {
+          if (previewHint) previewHint.textContent = '未检测到STT引擎';
+          if (typeof toast === 'function') {
+            toast('请安装语音识别引擎: pip install faster-whisper', 'error');
+          }
+        }
+      } else {
+        if (previewHint) previewHint.textContent = '未识别到文字';
+        if (previewText) previewText.textContent = '未识别到文字，请重试';
       }
     } catch (e) {
-      if (previewHint) previewHint.textContent = '网络错误，使用原文';
-      console.error('Voice optimize API error:', e);
+      console.error('Voice STT request error:', e);
+      if (previewHint) previewHint.textContent = '网络错误';
+      if (previewText) previewText.textContent = 'STT请求失败，请重试';
     }
 
-    this.isOptimizing = false;
+    this._cleanupStream();
     if (previewSend) previewSend.disabled = false;
   },
 
+  /** Cancel recording without processing */
+  cancelRecording: function() {
+    this.isRecording = false;
+    if (this.mediaRecorder && this.mediaRecorder.state !== 'inactive') {
+      try { this.mediaRecorder.abort(); } catch(e) {}
+    }
+    this._cleanupStream();
+    var btn = document.getElementById('voiceRecordBtn');
+    if (btn) btn.classList.remove('recording');
+    var statusEl = document.getElementById('voiceStatus');
+    if (statusEl) {
+      statusEl.textContent = '';
+    }
+    this.rawText = '';
+    this.audioChunks = [];
+  },
+
   /** Cancel voice preview and return to voice input mode */
   cancelPreview: function() {
     var voiceArea = document.getElementById('voiceInputArea');
@@ -4386,34 +4372,32 @@ var VoiceInput = {
     if (statusEl) statusEl.textContent = '';
 
     this.rawText = '';
-    this.optimizedText = '';
-    this.isOptimizing = false;
+    this.audioChunks = [];
   },
 
-  /** Send the optimized voice text as a regular message */
+  /** Send the voice text as a message（直接发送原始STT文本，由后端usersays_correct纠错） */
   sendMessage: function() {
-    if (!this.optimizedText || !this.optimizedText.trim()) return;
+    if (!this.rawText || !this.rawText.trim()) return;
 
-    var text = this.optimizedText.trim();
+    var text = this.rawText.trim();
 
-    // Switch back to text mode
+    // 切回文本模式
     this.switchMode('text');
 
-    // Set the text in the textarea and trigger send
+    // 将文本放入输入框并触发发送
     var input = document.getElementById('userInput');
     if (input) {
       input.value = text;
       input.dispatchEvent(new Event('input'));
     }
 
-    // Reset voice state
+    // 重置语音状态
     this.rawText = '';
-    this.optimizedText = '';
-    this.isOptimizing = false;
+    this.audioChunks = [];
 
-    // Send the message using the existing sendMessage function
+    // 使用 sendMessage 发送（附带 voice_text 标记）
     if (typeof sendMessage === 'function') {
-      sendMessage();
+      sendMessage({ voiceText: text });
     }
   }
 };
@@ -4435,18 +4419,8 @@ function sendVoiceMessage() {
 
 // Initialize voice input on DOM ready
 (function() {
-  var hasSpeechAPI = !!(window.SpeechRecognition || window.webkitSpeechRecognition);
-  var voiceBtn = document.getElementById('inputModeVoiceBtn');
-  if (!hasSpeechAPI && voiceBtn) {
-    voiceBtn.style.opacity = '0.3';
-    voiceBtn.style.cursor = 'not-allowed';
-    voiceBtn.title = '当前浏览器不支持语音输入';
-    voiceBtn.onclick = function(e) {
-      e.preventDefault();
-      if (typeof toast === 'function') {
-        toast('当前浏览器不支持语音识别，请使用 Chrome 或 Edge', 'error');
-      }
-    };
-  }
+  // Voice input now uses MediaRecorder (always available) + backend STT
+  // No need to check for SpeechRecognition API
+  // The voice button is always enabled; STT engine availability is checked when recording
 })();
 

package/web/ui/chat/flow_engine.js

@@ -671,17 +671,13 @@ function updateStreamingMessage(msgIdx) {
     indicator.remove();
   }
 
-  // V2 Task Plan rendering
+  // V2 Task Plan: NOT rendered in message bubble during streaming
+  // (task plan is displayed in the dedicated collapsible task panel instead)
+  // Only store _v2TaskPlan for historical message display
   if (msg._v2TaskPlan) {
-    let taskPlanEl = contentArea.querySelector('.v2-task-plan');
-    if (!taskPlanEl) {
-      taskPlanEl = document.createElement('div');
-      taskPlanEl.className = 'v2-task-plan';
-      // Insert before timeline or at appropriate position
-      var insertTarget = contentArea.querySelector('.msg-timeline') || contentArea;
-      insertTarget.insertBefore(taskPlanEl, insertTarget.firstChild);
-    }
-    taskPlanEl.innerHTML = '<div class="v2-task-plan-header">📋 任务计划</div><div class="v2-task-plan-body">' + renderMarkdown(msg._v2TaskPlan) + '</div>';
+    // Remove any existing task plan element from bubble (in case it was added before)
+    const existingPlan = contentArea.querySelector('.v2-task-plan');
+    if (existingPlan) existingPlan.remove();
   }
 
   // V2 Ask User rendering
@@ -1128,16 +1124,63 @@ function _assembleV2Content(msg, msgParts) {
   return '(无回复)';
 }
 
+// ══════════════════════════════════════════════════════
+// ── Voice Input: User Bubble Replacement ──
+// ══════════════════════════════════════════════════════
+
+/**
+ * 替换指定索引的用户气泡文本（用于 usersays_correct 纠错）
+ * 直接操作 DOM，不触发 renderMessages()，避免干扰流式输出
+ * @param {number} idx - state.messages 中的用户消息索引
+ * @param {string} newText - 纠错后的文本
+ */
+function _replaceUserBubble(idx, newText) {
+  var container = document.getElementById('messagesInner');
+  if (!container) return;
+
+  // 找到第 idx+1 个 message-row.user 元素（跳过 tool 消息）
+  var userRows = container.querySelectorAll('.message-row.user');
+  var userCount = 0;
+  for (var i = 0; i < state.messages.length && i <= idx; i++) {
+    if (state.messages[i].role === 'user') {
+      if (i === idx) {
+        // 找到目标行
+        if (userCount < userRows.length) {
+          var row = userRows[userCount];
+          var bubble = row.querySelector('.message-bubble');
+          if (bubble) {
+            // 平滑替换：先淡出，再更新内容，再淡入
+            bubble.style.transition = 'opacity 0.2s ease';
+            bubble.style.opacity = '0.4';
+            setTimeout(function() {
+              // 使用 renderMarkdown 渲染新文本
+              if (typeof renderMarkdown === 'function') {
+                bubble.innerHTML = renderMarkdown(newText);
+              } else {
+                bubble.textContent = newText;
+              }
+              bubble.style.opacity = '1';
+            }, 200);
+          }
+        }
+        break;
+      }
+      userCount++;
+    }
+  }
+}
+
 // ══════════════════════════════════════════════════════
 // ── Send Message (核心 SSE 流式消息发送) ──
 // ══════════════════════════════════════════════════════
 
-async function sendMessage() {
+async function sendMessage(opts) {
   if (currentView === 'group') {
     return sendGroupChat();
   }
   const input = document.getElementById('userInput');
   const text = input.value.trim();
+  const voiceText = (opts && opts.voiceText) ? opts.voiceText : '';  // 语音输入原始文本
   // ── 如果正在生成，弹出处理选择框 ──
   if (state.isGenerating) {
     state.tempInputText = text;
@@ -1177,7 +1220,7 @@ async function sendMessage() {
   }
 
   // Add user message
-  state.messages.push({ role: 'user', content: text, time: new Date().toISOString() });
+  state.messages.push({ role: 'user', content: text, time: new Date().toISOString(), _voiceText: voiceText });
   renderMessages();
 
   // Clear input
@@ -1211,6 +1254,7 @@ async function sendMessage() {
         agent_path: state.activeAgent,
         mode: state.chatMode,
         escalated: state.escalated,
+        voice_text: voiceText,  // 语音转文字原始文本（用于后端 usersays_correct）
       }),
       signal: state.abortController.signal,
     });
@@ -1406,6 +1450,31 @@ async function sendMessage() {
             // evt.data contains: {usersays_correct, task_plan, tools_to_call, remember, recall, ask_user, finish}
             // Store for rendering
             state.messages[msgIdx]._v2Parsed = evt.data;
+            // ── usersays_correct：语音输入纠错 — 替换用户气泡文本 ──
+            if (evt.data && evt.data.usersays_correct && evt.data.usersays_correct.trim()) {
+              var correctedText = evt.data.usersays_correct.trim();
+              // 找到对应的用户消息（当前消息的前一条）
+              var userMsgIdx = msgIdx - 1;
+              // 确认是语音消息（有 _voiceText 标记）
+              if (userMsgIdx >= 0 && state.messages[userMsgIdx] &&
+                  state.messages[userMsgIdx].role === 'user' &&
+                  state.messages[userMsgIdx]._voiceText) {
+                var oldContent = state.messages[userMsgIdx].content;
+                if (oldContent !== correctedText) {
+                  state.messages[userMsgIdx].content = correctedText;
+                  state.messages[userMsgIdx]._voiceCorrected = true;
+                  // 更新用户气泡的 DOM（不重绘整个列表，直接替换文本）
+                  _replaceUserBubble(userMsgIdx, correctedText);
+                  // 更新侧边栏会话预览
+                  if (state.sessions && state.sessions.length > 0) {
+                    state.sessions[0].preview = correctedText.length > 40 ? correctedText.slice(0, 40) + '...' : correctedText;
+                    if (typeof renderSessions === 'function') {
+                      renderSessions();
+                    }
+                  }
+                }
+              }
+            }
             // Render task plan if updated
             if (evt.data && evt.data.task_plan) {
               state.messages[msgIdx]._v2TaskPlan = evt.data.task_plan;

package/web/ui/chat/middle_chat.html

@@ -134,7 +134,7 @@
           </div>
           <!-- Voice preview area (shown after recording, before sending) -->
           <div class="voice-preview" id="voicePreview" style="display:none">
-            <div class="voice-preview-label">语音输入 · <span id="voicePreviewHint">优化中...</span></div>
+            <div class="voice-preview-label">语音输入 · <span id="voicePreviewHint">识别中...</span></div>
             <div class="voice-preview-text" id="voicePreviewText"></div>
             <div class="voice-preview-actions">
               <button class="voice-preview-cancel" onclick="cancelVoicePreview()">取消</button>