myagent-ai 1.13.7 → 1.14.0

package/agents/main_agent.py

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

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

package/setup.py

@@ -48,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":
@@ -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

@@ -4016,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' });
@@ -4048,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;
@@ -4067,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;
   },
 
@@ -4161,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');
@@ -4215,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;
@@ -4265,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');
@@ -4391,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 });
     }
   }
 };
@@ -4440,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

@@ -1124,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;
@@ -1173,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
@@ -1207,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,
     });
@@ -1402,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>