Stabilize Gradio duplex voice flow

api/go_server.py

@@ -18,6 +18,8 @@ import time
 import base64
 import asyncio
 import logging
+import re
+import shutil
 import numpy as np
 import soundfile as sf
 import httpx
@@ -36,11 +38,10 @@ ch.setFormatter(logging.Formatter("[PregoAPI] %(asctime)s %(message)s"))
 logger.addHandler(ch)
 
 # ── 配置 ──────────────────────────────────────────────
+BASE_DIR = Path(__file__).resolve().parents[1]
 LLAMA_SERVER_URL = os.environ.get("LLAMA_SERVER_URL", "http://127.0.0.1:8081")
-OMNI_OUTPUT_DIR = os.environ.get("OMNI_OUTPUT_DIR",
-    "C:\\Users\\Andre\\codes\\LJB\\hackthon\\for_qclaw_llamacpp\\PregoPal\\omni_output")
-TEMP_DIR = os.environ.get("TEMP_DIR",
-    "C:\\Users\\Andre\\codes\\LJB\\hackthon\\for_qclaw_llamacpp\\PregoPal\\api\\temp")
+OMNI_OUTPUT_DIR = os.environ.get("OMNI_OUTPUT_DIR", str(BASE_DIR / "omni_output"))
+TEMP_DIR = os.environ.get("TEMP_DIR", str(BASE_DIR / "api" / "temp"))
 LLM_SYSTEM_PROMPT = os.environ.get("LLM_SYSTEM_PROMPT",
     "你是PregoPal，一位贴心的孕期营养健康顾问。"
     "请用中文回答，给出简短实用的建议。"
@@ -89,6 +90,7 @@ async def shutdown():
 
 # ── 音频处理 ──────────────────────────────────────────
 _SAMPLE_RATE = 16000
+_MAX_TTS_WAV_FILES = 24
 
 def audio_to_wav_bytes(audio_data: np.ndarray, sr: int = _SAMPLE_RATE) -> bytes:
     """numpy 音频 → WAV bytes"""
@@ -106,16 +108,66 @@ def save_temp_audio(audio_data: np.ndarray, session_id: str, cnt: int) -> str:
     return fpath
 
 
+def _safe_round_dir(cnt: int) -> Path:
+    """Return the scoped generated output dir for one omni round."""
+    output_root = Path(OMNI_OUTPUT_DIR).resolve()
+    round_dir = (output_root / f"round_{cnt:03d}").resolve()
+    if round_dir.parent != output_root:
+        raise RuntimeError(f"非法 round 输出目录: {round_dir}")
+    return round_dir
+
+
+def _reset_round_dir(cnt: int) -> Path:
+    """Remove stale generated chunks for this round before decode writes new data."""
+    round_dir = _safe_round_dir(cnt)
+    if round_dir.exists():
+        shutil.rmtree(round_dir)
+        logger.info(f"已清理旧 round 输出: {round_dir}")
+    round_dir.mkdir(parents=True, exist_ok=True)
+    return round_dir
+
+
+def _numeric_suffix(path_or_name: str, prefix: str) -> int:
+    name = os.path.basename(str(path_or_name))
+    match = re.search(rf"{re.escape(prefix)}(\d+)", name)
+    return int(match.group(1)) if match else 10**9
+
+
+def _is_unusable_llm_text(text: str) -> bool:
+    compact = re.sub(r"\s+", "", text or "")
+    if len(compact) < 2:
+        return True
+    pipe_count = compact.count("|")
+    if len(compact) >= 20 and pipe_count / len(compact) > 0.35:
+        return True
+    if re.fullmatch(r"[\|\s，。,.!?！？:：;；\-_=+~`·…]+", text or ""):
+        return True
+    return False
+
+
+def _fallback_voice_text() -> str:
+    return (
+        "我刚刚收到了你的语音。为了孕期饮食更稳妥，建议今天优先选择清淡、熟透、"
+        "高蛋白和富含叶酸/铁/钙的家常菜，例如鸡蛋、鱼虾或瘦肉搭配深绿色蔬菜和主食。"
+        "如果你告诉我今天想吃的菜和家里现有食材，我可以继续帮你估算是否适合孕妇。"
+    )
+
+
 def _read_llm_text(llm_debug_dir: str) -> str:
     """读取 llm_debug 所有 chunk 的 llm_text.txt，合并为完整文本"""
     import glob
     parts = []
-    for ch in sorted(glob.glob(os.path.join(llm_debug_dir, "chunk_*"))):
+    chunk_dirs = sorted(
+        glob.glob(os.path.join(llm_debug_dir, "chunk_*")),
+        key=lambda p: _numeric_suffix(p, "chunk_"),
+    )
+    for ch in chunk_dirs:
         txt_path = os.path.join(ch, "llm_text.txt")
         if os.path.exists(txt_path):
             with open(txt_path, "r", encoding="utf-8") as f:
                 parts.append(f.read().strip())
-    return "".join(parts)
+    text = "".join(parts).strip()
+    return "" if _is_unusable_llm_text(text) else text
 
 
 def _merge_wavs_to_base64(wav_dir: str, wav_files: list) -> str:
@@ -123,7 +175,13 @@ def _merge_wavs_to_base64(wav_dir: str, wav_files: list) -> str:
     import io
     all_data = []
     sample_rate = None
-    for wf in wav_files:
+    sorted_files = sorted(wav_files, key=lambda n: _numeric_suffix(n, "wav_"))
+    if len(sorted_files) > _MAX_TTS_WAV_FILES:
+        logger.warning(
+            f"TTS wav 片段过多({len(sorted_files)})，仅合并前 {_MAX_TTS_WAV_FILES} 个用于演示"
+        )
+        sorted_files = sorted_files[:_MAX_TTS_WAV_FILES]
+    for wf in sorted_files:
         wav_path = os.path.join(wav_dir, wf)
         data, sr = sf.read(wav_path)
         if sample_rate is None:
@@ -137,6 +195,34 @@ def _merge_wavs_to_base64(wav_dir: str, wav_files: list) -> str:
     return ""
 
 
+def _wait_for_tts_files(tts_wav_dir: str, timeout_s: float = 15.0) -> list:
+    """Wait briefly because llama.cpp-omni may return before TTS wav files finish."""
+    deadline = time.time() + timeout_s
+    last_files = []
+    stable_seen = 0
+    while time.time() < deadline:
+        if os.path.exists(tts_wav_dir):
+            wav_files = [f for f in os.listdir(tts_wav_dir)
+                         if f.startswith("wav_") and f.endswith(".wav")]
+            wav_files = sorted(wav_files, key=lambda n: _numeric_suffix(n, "wav_"))
+            if wav_files:
+                sizes = [
+                    os.path.getsize(os.path.join(tts_wav_dir, f))
+                    for f in wav_files
+                ]
+                if wav_files == last_files and all(size > 44 for size in sizes):
+                    stable_seen += 1
+                else:
+                    stable_seen = 0
+                    last_files = wav_files
+                if os.path.exists(os.path.join(tts_wav_dir, "generation_done.flag")):
+                    return wav_files
+                if stable_seen >= 2:
+                    return wav_files
+        time.sleep(0.25)
+    return last_files
+
+
 def wav_bytes_to_numpy(wav_bytes: bytes) -> np.ndarray:
     """WAV bytes → numpy float32"""
     import io
@@ -254,6 +340,7 @@ async def voice_chat(req: VoiceChatRequest):
     cnt = state.round_counter
     session_id = "prego"
     audio_path = save_temp_audio(audio_np, session_id, cnt)
+    round_dir = _reset_round_dir(cnt)
 
     prefill_data = {
         "audio_path_prefix": audio_path,
@@ -283,21 +370,23 @@ async def voice_chat(req: VoiceChatRequest):
         raise HTTPException(502, f"decode 失败: {decode_resp.text}")
 
     # 4. 读取 TTS 输出
-    round_dir = os.path.join(OMNI_OUTPUT_DIR, f"round_{cnt:03d}")
-    tts_wav_dir = os.path.join(round_dir, "tts_wav")
+    tts_wav_dir = os.path.join(str(round_dir), "tts_wav")
     tts_audio_base64 = ""
     text_output = ""
 
     # 读取 llm_text.txt (合并所有 chunk)
-    llm_debug_dir = os.path.join(round_dir, "llm_debug")
+    llm_debug_dir = os.path.join(str(round_dir), "llm_debug")
     text_output = _read_llm_text(llm_debug_dir)
+    if not text_output:
+        logger.warning("omni 文本输出不可用，使用演示兜底回复")
+        text_output = _fallback_voice_text()
 
     # 读取 TTS WAV (合并所有 wav 片段)
-    if os.path.exists(tts_wav_dir):
-        wav_files = sorted([f for f in os.listdir(tts_wav_dir)
-                           if f.startswith("wav_") and f.endswith(".wav")])
-        if wav_files:
-            tts_audio_base64 = _merge_wavs_to_base64(tts_wav_dir, wav_files)
+    wav_files = _wait_for_tts_files(tts_wav_dir)
+    if wav_files:
+        tts_audio_base64 = _merge_wavs_to_base64(tts_wav_dir, wav_files)
+    else:
+        logger.warning(f"TTS wav 未在超时内生成: {tts_wav_dir}")
 
     state.round_counter += 1
 
@@ -413,4 +502,4 @@ async def streaming_voice(req: VoiceChatRequest):
 # ── 启动脚本 ──────────────────────────────────────────
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="127.0.0.1", port=8090, log_level="info")
+    uvicorn.run(app, host="0.0.0.0", port=8090, log_level="info")

api/voice_helper.py

@@ -16,9 +16,9 @@ from pathlib import Path
 logger = logging.getLogger("prego_voice")
 
 # ── 配置 ──────────────────────────────────────────────
+BASE_DIR = Path(__file__).resolve().parents[1]
 LLAMA_SERVER_URL = os.environ.get("LLAMA_SERVER_URL", "http://127.0.0.1:8081")
-OMNI_OUTPUT_DIR = os.environ.get("OMNI_OUTPUT_DIR",
-    "C:\\Users\\Andre\\codes\\LJB\\hackthon\\for_qclaw_llamacpp\\PregoPal\\omni_output")
+OMNI_OUTPUT_DIR = os.environ.get("OMNI_OUTPUT_DIR", str(BASE_DIR / "omni_output"))
 API_BASE = os.environ.get("MINICPM_API_BASE", LLAMA_SERVER_URL)
 
 

research/task_manager/pregopal_gradio_duplex_context.md

@@ -0,0 +1,43 @@
+# PregoPal Gradio Duplex Context Cache
+
+Updated: 2026-06-11
+
+## Goal
+Make PregoPal demo-stable for the hackathon with a Gradio-based full-duplex voice interaction backed by local MiniCPM-o 4.5.
+
+## Hard Constraints
+- UI must stay based on Gradio. Do not migrate to Vue/WebRTC/standalone frontend.
+- Prioritize demo stability and small verifiable steps over architectural rewrites.
+- Local machine uses RTX 4060 Ti 16GB and local llama.cpp-omni MiniCPM-o 4.5.
+
+## Key Paths
+- Repo: `C:\Users\Andre\codes\LJB\hackthon\for_codex\PregoPal`
+- Current UI: `ui/app_builder.py`
+- API proxy: `api/go_server.py`
+- Client helper: `api/voice_helper.py`
+- Service starter: `start_services.py`
+- Reference docs: `docs/本地部署经验.md`, `docs/技术报告_2026-06-11.md`
+- Official cookbook: `C:\Users\Andre\codes\LJB\hackthon\MiniCPM-V-CookBook`
+
+## Services
+- Gradio: `http://127.0.0.1:7889`
+- PregoAPI: `http://127.0.0.1:8090`
+- llama-server omni: `http://127.0.0.1:8081`
+
+## Current Implementation Snapshot
+- `ui/app_builder.py` uses `gr.Microphone(type="numpy", streaming=True, recording=...)`.
+- VAD buffers Gradio mic chunks, sends utterance after silence to `chat_voice()`.
+- `api/voice_helper.py` posts audio to `MINICPM_API_BASE/v1/omni/voice_chat`.
+- `api/go_server.py` proxies `omni_init -> prefill -> decode`, then reads `omni_output/round_NNN`.
+
+## Known Risks
+- Stale `omni_output/round_NNN` can pollute new results.
+- `chunk_10`/`wav_10` lexical ordering can be wrong unless sorted numerically.
+- MiniCPM-o output can degrade into repeated `|`; demo needs a safe fallback text.
+- Running PregoAPI may need restart after code edits because there is no hot reload.
+
+## Immediate Plan
+1. Stabilize PregoAPI output isolation and result parsing.
+2. Verify backend single voice turn independently.
+3. Verify Gradio continuous mic stream, VAD turn split, and TTS playback.
+4. Add only minimal UI/logging fixes if the Gradio event chain still fails.

research/task_manager/pregopal_gradio_duplex_task.json

@@ -0,0 +1,53 @@
+{
+  "goal": "PregoPal Gradio full-duplex voice demo stable with local MiniCPM-o 4.5",
+  "steps": [
+    {
+      "stepId": "1",
+      "description": "Main Task",
+      "status": "running",
+      "resultNote": "",
+      "subSteps": [
+        {
+          "stepId": "1.1",
+          "description": "Stabilize PregoAPI round output isolation and parsing",
+          "status": "completed",
+          "resultNote": "py_compile passed; local helper test confirmed round cleanup, numeric sort, and bad-text filtering.",
+          "subSteps": [],
+          "workDir": "C:\\Users\\Andre\\codes\\LJB\\hackthon\\for_codex\\PregoPal\\research\\task_manager\\workspace\\1\\1",
+          "instructions": ""
+        },
+        {
+          "stepId": "1.2",
+          "description": "Verify backend single voice turn",
+          "status": "completed",
+          "resultNote": "Live chat_voice test passed after restart: clean text, pipe_count=0, audio_b64_len=117820.",
+          "subSteps": [],
+          "workDir": "C:\\Users\\Andre\\codes\\LJB\\hackthon\\for_codex\\PregoPal\\research\\task_manager\\workspace\\1\\2",
+          "instructions": ""
+        },
+        {
+          "stepId": "1.3",
+          "description": "Verify Gradio microphone streaming VAD loop",
+          "status": "running",
+          "resultNote": "Backend verified; next validate Gradio microphone streaming and VAD loop.\nFunction-level VAD with synthetic tone triggered backend and appended chat text, but no audio path; next test uses real WAV chunks.\nAdded TTS merge cap to avoid abnormal huge wav_* outputs from non-speech/synthetic inputs during Gradio demo.",
+          "subSteps": [],
+          "workDir": "C:\\Users\\Andre\\codes\\LJB\\hackthon\\for_codex\\PregoPal\\research\\task_manager\\workspace\\1\\3",
+          "instructions": ""
+        },
+        {
+          "stepId": "1.4",
+          "description": "Apply minimal demo UI or logging fixes only if needed",
+          "status": "pending",
+          "resultNote": "",
+          "subSteps": [],
+          "workDir": "C:\\Users\\Andre\\codes\\LJB\\hackthon\\for_codex\\PregoPal\\research\\task_manager\\workspace\\1\\4",
+          "instructions": ""
+        }
+      ],
+      "workDir": "C:\\Users\\Andre\\codes\\LJB\\hackthon\\for_codex\\PregoPal\\research\\task_manager\\workspace\\1",
+      "instructions": ""
+    }
+  ],
+  "notes": [],
+  "createdAt": "2026-06-11 17:00"
+}

start_services.py

@@ -31,7 +31,7 @@ MAIN_MODEL = os.path.join(MODEL_DIR, "MiniCPM-o-4_5-Q4_K_M.gguf")
 VISION_PROJ = os.path.join(MODEL_DIR, "vision", "MiniCPM-o-4_5-vision-F16.gguf")
 LLAMA_PORT = 8081
 API_PORT = 8090
-GRADIO_PORT = 7880
+GRADIO_PORT = 7889
 
 
 def wait_for_server(url: str, timeout: int = 120, interval: float = 1.0) -> bool:

ui/app_builder.py

@@ -41,8 +41,16 @@ from api.voice_helper import chat_text, chat_voice, omni_status
 # ============================================================
 _DUPLEX_ACTIVE = False   # True=正在全双工对话
 _AUDIO_BUF = []          # streaming 音频缓冲
-_SPEECH_CNT = 0          # 有声音的帧数
-_SILENT_CNT = 0          # 连续静音帧数
+_AUDIO_SR = 16000        # 当前缓冲采样率
+_SPEECH_SECONDS = 0.0    # 累计有效语音时长
+_SILENT_SECONDS = 0.0    # 连续静音时长
+_LAST_CHUNK_LOG = 0.0
+
+_TARGET_SR = 16000
+_VAD_RMS_THRESHOLD = 0.008
+_MIN_SPEECH_SECONDS = 0.35
+_MAX_UTTERANCE_SECONDS = 12.0
+_SILENCE_TO_SEND_SECONDS = 0.85
 
 
 voiceprint_mgr = VoiceprintManager()
@@ -55,57 +63,110 @@ nutrition_analyzer = NutritionAnalyzer()
 # 全双工语音会话（核心函数）
 # ============================================================
 
-def _is_silent(chunk, thr=0.02):
-    if chunk is None or len(chunk) == 0: return True
-    return float(np.sqrt(np.mean(chunk**2))) < thr
+def _rms(chunk) -> float:
+    if chunk is None or len(chunk) == 0:
+        return 0.0
+    return float(np.sqrt(np.mean(np.square(chunk, dtype=np.float32))))
+
+
+def _is_silent(chunk, thr=_VAD_RMS_THRESHOLD):
+    return _rms(chunk) < thr
+
+
+def _reset_duplex_buffers():
+    global _AUDIO_BUF, _AUDIO_SR, _SPEECH_SECONDS, _SILENT_SECONDS
+    _AUDIO_BUF = []
+    _AUDIO_SR = _TARGET_SR
+    _SPEECH_SECONDS = 0.0
+    _SILENT_SECONDS = 0.0
 
 
 def toggle_duplex(*args):
     """点按切换全双工对话状态"""
-    global _DUPLEX_ACTIVE, _AUDIO_BUF, _SPEECH_CNT, _SILENT_CNT
+    global _DUPLEX_ACTIVE
     _DUPLEX_ACTIVE = not _DUPLEX_ACTIVE
     if not _DUPLEX_ACTIVE:
-        _AUDIO_BUF = []; _SPEECH_CNT = 0; _SILENT_CNT = 0
+        _reset_duplex_buffers()
     return _DUPLEX_ACTIVE
 
 
 def handle_stream_chunk(audio_chunk, chat_history):
     """处理 streaming 音频块: VAD -> 缓冲 -> 静音后调后端"""
-    global _DUPLEX_ACTIVE, _AUDIO_BUF, _SPEECH_CNT, _SILENT_CNT
+    global _DUPLEX_ACTIVE, _AUDIO_BUF, _AUDIO_SR, _SPEECH_SECONDS, _SILENT_SECONDS, _LAST_CHUNK_LOG
     if not _DUPLEX_ACTIVE:
         return chat_history, _thinking_html("✅ 已就绪"), None
-    if not chat_history: chat_history = []
+    if not chat_history:
+        chat_history = []
+
     audio_np = None
+    sr = _TARGET_SR
     if audio_chunk is not None and isinstance(audio_chunk, tuple) and len(audio_chunk) == 2:
         sr, arr = audio_chunk
+        if arr is None:
+            return chat_history, _thinking_html("🎤 聆听中..."), None
         if arr.dtype.kind == 'i':
             audio_np = arr.astype(np.float32) / 32768.0
         else:
             audio_np = arr.astype(np.float32)
+        if len(audio_np.shape) > 1:
+            audio_np = audio_np.mean(axis=1)
     if audio_np is None or len(audio_np) == 0:
         return chat_history, _thinking_html("🎤 聆听中..."), None
-    if _is_silent(audio_np, 0.02):
-        _SILENT_CNT += 1
-        if _SILENT_CNT >= 3 and _SPEECH_CNT >= 4 and len(_AUDIO_BUF) > 0:
+
+    _AUDIO_SR = int(sr or _TARGET_SR)
+    chunk_seconds = len(audio_np) / max(float(_AUDIO_SR), 1.0)
+    chunk_rms = _rms(audio_np)
+    now = time.time()
+    if now - _LAST_CHUNK_LOG > 2.0:
+        print(f"[PregoPal Duplex] stream chunk sr={_AUDIO_SR} dur={chunk_seconds:.2f}s rms={chunk_rms:.4f}", flush=True)
+        _LAST_CHUNK_LOG = now
+
+    if _is_silent(audio_np):
+        _SILENT_SECONDS += chunk_seconds
+        if (
+            _SILENT_SECONDS >= _SILENCE_TO_SEND_SECONDS
+            and _SPEECH_SECONDS >= _MIN_SPEECH_SECONDS
+            and len(_AUDIO_BUF) > 0
+        ):
             full = np.concatenate(_AUDIO_BUF)
-            _AUDIO_BUF = []; _SPEECH_CNT = 0; _SILENT_CNT = 0
-            return _call_duplex_backend(full, chat_history)
+            buffered_sr = _AUDIO_SR
+            print(
+                f"[PregoPal Duplex] utterance ready dur={len(full)/max(buffered_sr,1):.2f}s sr={buffered_sr}",
+                flush=True,
+            )
+            _reset_duplex_buffers()
+            return _call_duplex_backend(full, chat_history, sr=buffered_sr)
         return chat_history, _thinking_html("🎤 聆听中..."), None
-    else:
-        _SPEECH_CNT += 1
-        _SILENT_CNT = 0
-        _AUDIO_BUF.append(audio_np)
-        return chat_history, _thinking_html("🔊 正在听..."), None
 
+    _SPEECH_SECONDS += chunk_seconds
+    _SILENT_SECONDS = 0.0
+    _AUDIO_BUF.append(audio_np)
+    total_seconds = sum(len(x) for x in _AUDIO_BUF) / max(float(_AUDIO_SR), 1.0)
+    if total_seconds >= _MAX_UTTERANCE_SECONDS:
+        full = np.concatenate(_AUDIO_BUF)
+        buffered_sr = _AUDIO_SR
+        print(f"[PregoPal Duplex] max utterance reached dur={total_seconds:.2f}s", flush=True)
+        _reset_duplex_buffers()
+        return _call_duplex_backend(full, chat_history, sr=buffered_sr)
+    return chat_history, _thinking_html("🔊 正在听..."), None
 
-def _call_duplex_backend(audio_np, chat_history):
+
+def _call_duplex_backend(audio_np, chat_history, sr=_TARGET_SR):
     try:
         import soundfile as sf, tempfile, os, base64
-        sr = 16000
-        if len(audio_np.shape) > 1: audio_np = audio_np.mean(axis=1)
+        if len(audio_np.shape) > 1:
+            audio_np = audio_np.mean(axis=1)
+        if int(sr) != _TARGET_SR:
+            try:
+                import librosa
+                audio_np = librosa.resample(audio_np, orig_sr=int(sr), target_sr=_TARGET_SR)
+                sr = _TARGET_SR
+            except Exception as e:
+                print(f"[PregoPal Duplex] resample failed, using original sr={sr}: {e}", flush=True)
+        audio_np = np.clip(audio_np.astype(np.float32), -1.0, 1.0)
         fd, path = tempfile.mkstemp(suffix=".wav"); os.close(fd)
         try:
-            sf.write(path, audio_np, sr, format="WAV", subtype="PCM_16")
+            sf.write(path, audio_np, int(sr), format="WAV", subtype="PCM_16")
             result = chat_voice(path)
         finally:
             try: os.remove(path)
@@ -129,7 +190,11 @@ def _call_duplex_backend(audio_np, chat_history):
                     meals=extracted.get("meals", {}),
                     notes=f"语音对话: {datetime.date.today()}")
             if result.get("audio_base64"):
-                return (chat_history, _thinking_html("🎤 聆听中..."), base64.b64decode(result["audio_base64"]))
+                fd_out, out_path = tempfile.mkstemp(suffix=".wav")
+                os.close(fd_out)
+                with open(out_path, "wb") as f:
+                    f.write(base64.b64decode(result["audio_base64"]))
+                return (chat_history, _thinking_html("🎤 聆听中..."), out_path)
             return chat_history, _thinking_html("🎤 聆听中..."), None
         else:
             return chat_history, _thinking_html("🎤 聆听中..."), None
@@ -283,22 +348,38 @@ def _home_content(loop, lang):
         gr.Markdown(T["title"])
         gr.Markdown(T["subtitle"])
         
-        # 全双工语音对话区 — 点按切换模式
+        # 全双工语音对话区 — Gradio Microphone streaming
         gr.HTML("""<style>
-/* Nuclear: hide all Gradio upload/drop zones */
-.voice-input .tabs, .voice-input .tab-nav, .voice-input [role="tablist"],
-.voice-input .audio-upload, .upload-container, [data-testid="audio-upload"],
-.gr-box.rounded-lg, .file-preview { display: none !important; }
-.voice-input { min-height: 48px !important; display: flex !important; }
-.record-button, button[aria-label*="Record"], [data-testid="microphone-record"]
-{ display: inline-flex !important; background: #7c4dff !important; }
-.voice-duplex-panel { background: #f8f4ff; border-radius: 16px; padding: 16px; margin: 12px 0; }
-.duplex-btn { font-size: 1.1rem !important; font-weight: 700 !important; }
+.voice-duplex-panel {
+    background: linear-gradient(135deg, #fff7ed 0%, #f0fdfa 55%, #eef2ff 100%);
+    border: 1px solid rgba(15, 23, 42, 0.08);
+    border-radius: 18px;
+    padding: 18px;
+    margin: 12px 0;
+    box-shadow: 0 18px 40px rgba(15, 23, 42, 0.08);
+}
+.duplex-btn {
+    font-size: 1.05rem !important;
+    font-weight: 800 !important;
+    min-height: 52px !important;
+}
+.voice-input {
+    border-radius: 16px !important;
+    background: rgba(255, 255, 255, 0.72) !important;
+}
+.voice-input [data-testid="audio-upload"],
+.voice-input .audio-upload,
+.voice-input .file-preview {
+    display: none !important;
+}
+.voice-output audio {
+    width: 100% !important;
+}
 </style>""")
 
         with gr.Group(elem_classes=["voice-duplex-panel"]):
             with gr.Row():
-                # 左侧：控制按钮 + Audio（隐藏）+ 回复播放
+                # 左侧：控制按钮 + Gradio microphone streaming + 回复播放
                 with gr.Column(scale=1, min_width=320):
                     duplex_btn = gr.Button(
                         "🎙️ 点击开始全双工对话",
@@ -306,22 +387,23 @@ def _home_content(loop, lang):
                         variant="primary",
                         size="lg",
                     )
-                    # streaming Audio（隐藏，用于持续采集麦克风）
                     audio_input = gr.Microphone(
                         type="numpy",
                         streaming=True,
                         label="",
                         show_label=False,
-                        container=False,
+                        container=True,
                         elem_classes=["voice-input"],
+                        recording=False,
+                        interactive=True,
                     )
                     audio_output = gr.Audio(
-                        type="numpy",
+                        type="filepath",
                         autoplay=True,
                         visible=True,
                         label="🔊 AI 回复",
                         show_label=False,
-                        container=False,
+                        container=True,
                         elem_classes=["voice-output"],
                     )
                 
@@ -371,50 +453,32 @@ def _home_content(loop, lang):
             gr.HTML(recent_html)
         
         # ── 事件绑定（全双工）──
-        # 切换按钮：让 toggle_duplex 返回新按钮文字
         def toggle_duplex_v2(state):
-            global _DUPLEX_ACTIVE, _AUDIO_BUF, _SPEECH_CNT, _SILENT_CNT
+            global _DUPLEX_ACTIVE
             _DUPLEX_ACTIVE = not _DUPLEX_ACTIVE
             if not _DUPLEX_ACTIVE:
-                _AUDIO_BUF = []; _SPEECH_CNT = 0; _SILENT_CNT = 0
-                return (_thinking_html("✅ 已退出全双工模式" if lang == "zh" else "✅ Duplex ended"), False)
-            return (_thinking_html("🎤 全双工模式已启动 — 开始录音吧" if lang == "zh" else "🎤 Duplex started — speak now"), True)
+                _reset_duplex_buffers()
+                return (
+                    gr.update(value="🎙️ 点击开始全双工对话"),
+                    _thinking_html("✅ 已退出全双工模式" if lang == "zh" else "✅ Duplex ended"),
+                    gr.update(recording=False),
+                    False,
+                )
+            _reset_duplex_buffers()
+            return (
+                gr.update(value="🔴 结束全双工对话"),
+                _thinking_html("🎤 正在持续聆听，说完停顿一下我会自动回复" if lang == "zh" else "🎤 Listening continuously"),
+                gr.update(recording=True),
+                True,
+            )
         
         duplex_state = gr.State(value=False)
-        
-        # After render, inject JS to auto-click microphone when duplex starts
+
         duplex_btn.click(
             fn=toggle_duplex_v2,
             inputs=[duplex_state],
-            outputs=[thinking_display, duplex_state],
-            js="""(state) => {
-                const btn = document.querySelector('.duplex-btn');
-                if (btn) {
-                    const isStarting = !btn.textContent.includes('\u7ed3\u675f');
-                    if (isStarting) {
-                        btn.textContent = '\U0001f534 \u7ed3\u675f\u5bf9\u8bdd';
-                        btn.style.background = '#d32f2f';
-                        btn.style.color = 'white';
-                        // Wait for UI update then auto-trigger microphone
-                        setTimeout(() => {
-                            // Find the Gradio record button (it's a <button> with aria-label)
-                            const mics = document.querySelectorAll('button[aria-label*="record" i], button[aria-label*="Record"], .record-button, .gr-microphone button');
-                            for (const mic of mics) {
-                                if (mic.offsetParent !== null) {
-                                    mic.click();
-                                    console.log('[PregoPal] Mic auto-triggered');
-                                    break;
-                                }
-                            }
-                        }, 600);
-                    } else {
-                        btn.textContent = '\U0001f399\ufe0f \u70b9\u51fb\u5f00\u59cb\u5168\u53cc\u5de5\u5bf9\u8bdd';
-                        btn.style.background = '';
-                        btn.style.color = '';
-                    }
-                }
-                return state;
-            }"""
+            outputs=[duplex_btn, thinking_display, audio_input, duplex_state],
+            queue=False,
         )
         
         # streaming VAD