From 565c371e5c1982dde3cc6085db848c4bc0e503c4 Mon Sep 17 00:00:00 2001
From: Soulter <905617992@qq.com>
Date: Mon, 16 Mar 2026 22:36:29 +0800
Subject: [PATCH] feat: enhance Live Mode with text input functionality and UI
 improvements

- Added a text input panel to allow users to send plain text messages while in Live Mode.
- Updated the LiveMode.vue component to handle text input and integrate it with WebSocket communication.
- Improved the layout and styling of the Live Mode interface for better user experience.
- Documented the new `text_input` message type in the Live API README.
---
 astrbot/dashboard/routes/live_chat.py      |  161 ++-
 dashboard/src/components/chat/LiveMode.vue | 1087 +++++++++++---------
 docs/live-api/README.md                    |   11 +
 3 files changed, 730 insertions(+), 529 deletions(-)

diff --git a/astrbot/dashboard/routes/live_chat.py b/astrbot/dashboard/routes/live_chat.py
index 839ac6555..f089b659f 100644
--- a/astrbot/dashboard/routes/live_chat.py
+++ b/astrbot/dashboard/routes/live_chat.py
@@ -723,6 +723,16 @@ class LiveChatRoute(Route):
 
         elif msg_type == "end_speaking":
             # 结束说话
+            if session.is_processing:
+                await websocket.send_json(
+                    {
+                        "t": "error",
+                        "data": "Session is busy",
+                        "code": "PROCESSING_ERROR",
+                    }
+                )
+                return
+
             stamp = message.get("stamp")
             if not stamp:
                 logger.warning("[Live Chat] end_speaking 缺少 stamp")
@@ -736,45 +746,59 @@ class LiveChatRoute(Route):
             # 处理音频：STT -> LLM -> TTS
             await self._process_audio(session, audio_path, assemble_duration)
 
+        elif msg_type == "text_input":
+            if session.is_processing:
+                await websocket.send_json(
+                    {
+                        "t": "error",
+                        "data": "Session is busy",
+                        "code": "PROCESSING_ERROR",
+                    }
+                )
+                return
+
+            user_text = message.get("text")
+            if not isinstance(user_text, str):
+                user_text = message.get("message")
+
+            if not isinstance(user_text, str) or not user_text.strip():
+                await websocket.send_json(
+                    {
+                        "t": "error",
+                        "data": "message must be non-empty text",
+                        "code": "INVALID_MESSAGE_FORMAT",
+                    }
+                )
+                return
+
+            await self._process_live_user_text(
+                session,
+                user_text=user_text.strip(),
+                initial_metrics={"input_type": "text"},
+                processing_start_time=time.time(),
+            )
+
         elif msg_type == "interrupt":
             # 用户打断
             session.should_interrupt = True
             logger.info(f"[Live Chat] 用户打断: {session.username}")
 
-    async def _process_audio(
-        self, session: LiveChatSession, audio_path: str, assemble_duration: float
+    async def _process_live_user_text(
+        self,
+        session: LiveChatSession,
+        user_text: str,
+        initial_metrics: dict[str, Any] | None = None,
+        processing_start_time: float | None = None,
     ) -> None:
-        """处理音频：STT -> LLM -> 流式 TTS"""
+        """处理 Live 用户文本：走 run_live_agent pipeline 并回传流式 TTS."""
         try:
-            # 发送 WAV 组装耗时
-            await websocket.send_json(
-                {"t": "metrics", "data": {"wav_assemble_time": assemble_duration}}
-            )
-            wav_assembly_finish_time = time.time()
+            if initial_metrics:
+                await websocket.send_json({"t": "metrics", "data": initial_metrics})
 
+            processing_start = processing_start_time or time.time()
             session.is_processing = True
             session.should_interrupt = False
 
-            # 1. STT - 语音转文字
-            ctx = self.plugin_manager.context
-            stt_provider = ctx.provider_manager.stt_provider_insts[0]
-
-            if not stt_provider:
-                logger.error("[Live Chat] STT Provider 未配置")
-                await websocket.send_json({"t": "error", "data": "语音识别服务未配置"})
-                return
-
-            await websocket.send_json(
-                {"t": "metrics", "data": {"stt": stt_provider.meta().type}}
-            )
-
-            user_text = await stt_provider.get_text(audio_path)
-            if not user_text:
-                logger.warning("[Live Chat] STT 识别结果为空")
-                return
-
-            logger.info(f"[Live Chat] STT 结果: {user_text}")
-
             await websocket.send_json(
                 {
                     "t": "user_msg",
@@ -794,7 +818,6 @@ class LiveChatRoute(Route):
                 "action_type": "live",  # 标记为 live mode
             }
 
-            # 将消息放入队列
             await queue.put((session.username, cid, payload))
 
             # 3. 等待响应并流式发送 TTS 音频
@@ -809,11 +832,9 @@ class LiveChatRoute(Route):
                         # 用户打断，停止处理
                         logger.info("[Live Chat] 检测到用户打断")
                         await websocket.send_json({"t": "stop_play"})
-                        # 保存消息并标记为被打断
                         await self._save_interrupted_message(
                             session, user_text, bot_text
                         )
-                        # 清空队列中未处理的消息
                         while not back_queue.empty():
                             try:
                                 back_queue.get_nowait()
@@ -861,12 +882,7 @@ class LiveChatRoute(Route):
                     if result_chain_type == "tts_stats":
                         try:
                             stats = json.loads(data)
-                            await websocket.send_json(
-                                {
-                                    "t": "metrics",
-                                    "data": stats,
-                                }
-                            )
+                            await websocket.send_json({"t": "metrics", "data": stats})
                         except Exception as e:
                             logger.error(f"[Live Chat] 解析 TTSStats 失败: {e}")
                         continue
@@ -893,18 +909,14 @@ class LiveChatRoute(Route):
                                     "data": {"text": data},
                                 }
                             )
-                        # 普通文本消息
                         bot_text += data
 
                     elif result_type == "audio_chunk":
-                        # 流式音频数据
                         if not audio_playing:
                             audio_playing = True
                             logger.debug("[Live Chat] 开始播放音频流")
-
-                            # Calculate latency from wav assembly finish to first audio chunk
                             speak_to_first_frame_latency = (
-                                time.time() - wav_assembly_finish_time
+                                time.time() - processing_start
                             )
                             await websocket.send_json(
                                 {
@@ -924,19 +936,15 @@ class LiveChatRoute(Route):
                                 }
                             )
 
-                        # 发送音频数据给前端
                         await websocket.send_json(
                             {
                                 "t": "response",
-                                "data": data,  # base64 编码的音频数据
+                                "data": data,
                             }
                         )
 
                     elif result_type in ["complete", "end"]:
-                        # 处理完成
                         logger.info(f"[Live Chat] Bot 回复完成: {bot_text}")
-
-                        # 如果没有音频流，发送 bot 消息文本
                         if not audio_playing:
                             await websocket.send_json(
                                 {
@@ -948,11 +956,8 @@ class LiveChatRoute(Route):
                                 }
                             )
 
-                        # 发送结束标记
                         await websocket.send_json({"t": "end"})
-
-                        # 发送总耗时
-                        wav_to_tts_duration = time.time() - wav_assembly_finish_time
+                        wav_to_tts_duration = time.time() - processing_start
                         await websocket.send_json(
                             {
                                 "t": "metrics",
@@ -964,13 +969,65 @@ class LiveChatRoute(Route):
                 webchat_queue_mgr.remove_back_queue(message_id)
 
         except Exception as e:
-            logger.error(f"[Live Chat] 处理音频失败: {e}", exc_info=True)
+            logger.error(f"[Live Chat] 处理文本失败: {e}", exc_info=True)
             await websocket.send_json({"t": "error", "data": f"处理失败: {str(e)}"})
 
         finally:
             session.is_processing = False
             session.should_interrupt = False
 
+    async def _process_audio(
+        self, session: LiveChatSession, audio_path: str, assemble_duration: float
+    ) -> None:
+        """处理音频：STT -> LLM -> 流式 TTS"""
+        try:
+            await websocket.send_json(
+                {
+                    "t": "metrics",
+                    "data": {
+                        "wav_assemble_time": assemble_duration,
+                        "input_type": "audio",
+                    },
+                }
+            )
+            wav_assembly_finish_time = time.time()
+
+            # 1. STT - 语音转文字
+            ctx = self.plugin_manager.context
+            stt_provider = ctx.provider_manager.stt_provider_insts[0]
+
+            if not stt_provider:
+                logger.error("[Live Chat] STT Provider 未配置")
+                await websocket.send_json({"t": "error", "data": "语音识别服务未配置"})
+                return
+
+            await websocket.send_json(
+                {
+                    "t": "metrics",
+                    "data": {
+                        "stt": stt_provider.meta().type,
+                    },
+                }
+            )
+
+            user_text = await stt_provider.get_text(audio_path)
+            if not user_text:
+                logger.warning("[Live Chat] STT 识别结果为空")
+                return
+
+            logger.info(f"[Live Chat] STT 结果: {user_text}")
+
+            await self._process_live_user_text(
+                session,
+                user_text=user_text,
+                initial_metrics=None,
+                processing_start_time=wav_assembly_finish_time,
+            )
+
+        except Exception as e:
+            logger.error(f"[Live Chat] 处理音频失败: {e}", exc_info=True)
+            await websocket.send_json({"t": "error", "data": f"处理失败: {str(e)}"})
+
     async def _save_interrupted_message(
         self, session: LiveChatSession, user_text: str, bot_text: str
     ) -> None:
diff --git a/dashboard/src/components/chat/LiveMode.vue b/dashboard/src/components/chat/LiveMode.vue
index 2740459d9..60773f802 100644
--- a/dashboard/src/components/chat/LiveMode.vue
+++ b/dashboard/src/components/chat/LiveMode.vue
@@ -1,65 +1,127 @@
 <template>
-    <div class="live-mode-container">
-        <div class="header-controls">
-            <v-btn icon="mdi-close" @click="handleClose" flat variant="text" />
-            <v-btn :icon="isCodeMode ? 'mdi-code-tags-check' : 'mdi-code-tags'" @click="toggleCodeMode" flat
-                variant="text" :color="isCodeMode ? 'primary' : ''" />
-            <v-btn :icon="isNervousMode ? 'mdi-emoticon-confused' : 'mdi-emoticon-confused-outline'"
-                @click="toggleNervousMode" flat variant="text" :color="isNervousMode ? 'primary' : ''" />
-        </div>
-
-        <span style="color: gray; padding-left: 16px;">We're developing Astr Live Mode on ChatUI & Desktop right now. Stay tuned!</span>
-
-        <div class="live-mode-content">
-            <div class="center-circle-container" @click="handleCircleClick">
-                <!-- 爆炸效果层 -->
-                <div v-if="isExploding" class="explosion-wave"></div>
-
-                <SiriOrb :energy="orbEnergy" :mode="isActive ? orbMode : 'idle'" :is-dark="isDark"
-                    :code-mode="isCodeMode" :nervous-mode="isNervousMode" class="siri-orb" />
-            </div>
-            <div class="status-text">
-                {{ statusText }}
-            </div>
-            <div class="messages-container" v-if="messages.length > 0">
-                <div v-for="(msg, index) in messages" :key="index" class="message-item" :class="msg.type">
-                    <div class="message-content">
-                        {{ msg.text }}
-                    </div>
-                </div>
-            </div>
-
-            <div class="metrics-container" v-if="Object.keys(metrics).length > 0">
-                <span v-if="metrics.wav_assemble_time">WAV Assemble: {{ (metrics.wav_assemble_time * 1000).toFixed(0)
-                    }}ms</span>
-                <span v-if="metrics.llm_ttft">LLM First Token Latency: {{ (metrics.llm_ttft * 1000).toFixed(0)
-                    }}ms</span>
-                <span v-if="metrics.llm_total_time">LLM Total Latency: {{ (metrics.llm_total_time * 1000).toFixed(0)
-                    }}ms</span>
-                <span v-if="metrics.tts_first_frame_time">TTS First Frame Latency: {{ (metrics.tts_first_frame_time *
-                    1000).toFixed(0) }}ms</span>
-                <span v-if="metrics.tts_total_time">TTS Total Larency: {{ (metrics.tts_total_time * 1000).toFixed(0)
-                    }}ms</span>
-                <span v-if="metrics.speak_to_first_frame">Speak -> First TTS Frame: {{ (metrics.speak_to_first_frame *
-                    1000).toFixed(0) }}ms</span>
-                <span v-if="metrics.wav_to_tts_total_time">Speak -> End: {{ (metrics.wav_to_tts_total_time *
-                    1000).toFixed(0) }}ms</span>
-                <span v-if="metrics.stt">STT Provider: {{ metrics.stt }}</span>
-                <span v-if="metrics.tts">TTS Provider: {{ metrics.tts }}</span>
-                <span v-if="metrics.chat_model">Chat Model: {{ metrics.chat_model }}</span>
-            </div>
-        </div>
+  <div class="live-mode-container">
+    <div class="header-controls">
+      <v-btn icon="mdi-close" @click="handleClose" flat variant="text" />
+      <v-btn
+        :icon="isCodeMode ? 'mdi-code-tags-check' : 'mdi-code-tags'"
+        @click="toggleCodeMode"
+        flat
+        variant="text"
+        :color="isCodeMode ? 'primary' : ''"
+      />
+      <v-btn
+        :icon="
+          isNervousMode
+            ? 'mdi-emoticon-confused'
+            : 'mdi-emoticon-confused-outline'
+        "
+        @click="toggleNervousMode"
+        flat
+        variant="text"
+        :color="isNervousMode ? 'primary' : ''"
+      />
     </div>
+
+    <span style="color: gray; padding-left: 16px"
+      >We're developing Astr Live Mode on ChatUI & Desktop right now. Stay
+      tuned!</span
+    >
+
+    <div class="live-mode-content">
+      <div class="text-input-panel">
+        <v-text-field
+          v-model="textInput"
+          label="给 Live 发文字"
+          variant="outlined"
+          density="comfortable"
+          hide-details
+          placeholder="在这里输入要发给 Live 的文字"
+          :disabled="!isActive || !isConnected || isProcessing"
+          @keydown.enter.exact.prevent="sendTextInput"
+        />
+        <v-btn
+          :disabled="!canSendText"
+          color="primary"
+          icon="mdi-send"
+          @click="sendTextInput"
+        />
+      </div>
+      <div class="center-circle-container" @click="handleCircleClick">
+        <!-- 爆炸效果层 -->
+        <div v-if="isExploding" class="explosion-wave"></div>
+
+        <SiriOrb
+          :energy="orbEnergy"
+          :mode="isActive ? orbMode : 'idle'"
+          :is-dark="isDark"
+          :code-mode="isCodeMode"
+          :nervous-mode="isNervousMode"
+          class="siri-orb"
+        />
+      </div>
+      <div class="status-text">
+        {{ statusText }}
+      </div>
+      <div class="messages-container" v-if="messages.length > 0">
+        <div
+          v-for="(msg, index) in messages"
+          :key="index"
+          class="message-item"
+          :class="msg.type"
+        >
+          <div class="message-content">
+            {{ msg.text }}
+          </div>
+        </div>
+      </div>
+
+      <div class="metrics-container" v-if="Object.keys(metrics).length > 0">
+        <span v-if="metrics.wav_assemble_time"
+          >WAV Assemble:
+          {{ (metrics.wav_assemble_time * 1000).toFixed(0) }}ms</span
+        >
+        <span v-if="metrics.llm_ttft"
+          >LLM First Token Latency:
+          {{ (metrics.llm_ttft * 1000).toFixed(0) }}ms</span
+        >
+        <span v-if="metrics.llm_total_time"
+          >LLM Total Latency:
+          {{ (metrics.llm_total_time * 1000).toFixed(0) }}ms</span
+        >
+        <span v-if="metrics.tts_first_frame_time"
+          >TTS First Frame Latency:
+          {{ (metrics.tts_first_frame_time * 1000).toFixed(0) }}ms</span
+        >
+        <span v-if="metrics.tts_total_time"
+          >TTS Total Larency:
+          {{ (metrics.tts_total_time * 1000).toFixed(0) }}ms</span
+        >
+        <span v-if="metrics.speak_to_first_frame"
+          >Speak -> First TTS Frame:
+          {{ (metrics.speak_to_first_frame * 1000).toFixed(0) }}ms</span
+        >
+        <span v-if="metrics.wav_to_tts_total_time"
+          >Speak -> End:
+          {{ (metrics.wav_to_tts_total_time * 1000).toFixed(0) }}ms</span
+        >
+        <span v-if="metrics.stt">STT Provider: {{ metrics.stt }}</span>
+        <span v-if="metrics.tts">TTS Provider: {{ metrics.tts }}</span>
+        <span v-if="metrics.chat_model"
+          >Chat Model: {{ metrics.chat_model }}</span
+        >
+      </div>
+    </div>
+  </div>
 </template>
 
 <script setup lang="ts">
-import { ref, computed, onBeforeUnmount, watch } from 'vue';
-import { useTheme } from 'vuetify';
-import { useVADRecording } from '@/composables/useVADRecording';
-import SiriOrb from './LiveOrb.vue';
+import { ref, computed, onBeforeUnmount, watch } from "vue";
+import { useTheme } from "vuetify";
+import { useVADRecording } from "@/composables/useVADRecording";
+import SiriOrb from "./LiveOrb.vue";
 
 const emit = defineEmits<{
-    'close': [];
+  close: [];
 }>();
 
 const theme = useTheme();
@@ -69,14 +131,14 @@ const isDark = computed(() => theme.global.current.value.dark);
 const vadRecording = useVADRecording();
 
 // 状态
-const isActive = ref(false);  // Live Mode 是否激活
+const isActive = ref(false); // Live Mode 是否激活
 const isExploding = ref(false); // 是否正在展示爆炸动画
 const isCodeMode = ref(false); // 是否开启代码模式
 const isNervousMode = ref(false); // 是否开启紧张模式
 // 使用 VAD 提供的 isSpeaking 状态
 const isSpeaking = computed(() => vadRecording.isSpeaking.value);
-const isListening = ref(false);  // 是否在监听
-const isProcessing = ref(false);  // 是否在处理
+const isListening = ref(false); // 是否在监听
+const isProcessing = ref(false); // 是否在处理
 
 // WebSocket
 let ws: WebSocket | null = null;
@@ -95,588 +157,659 @@ let isDecoding = false;
 let isPlayingAudio = false; // 内部状态：是否正在播放音频
 let currentSource: AudioBufferSourceNode | null = null;
 
-
 // 消息历史
-const messages = ref<Array<{ type: 'user' | 'bot', text: string }>>([]);
+const messages = ref<Array<{ type: "user" | "bot"; text: string }>>([]);
+const textInput = ref("");
+const isConnected = ref(false);
 
 interface LiveMetrics {
-    wav_assemble_time?: number;
-    speak_to_first_frame?: number;
-    llm_ttft?: number;
-    llm_total_time?: number;
-    tts_first_frame_time?: number;
-    tts_total_time?: number;
-    wav_to_tts_total_time?: number;
-    stt?: string;
-    tts?: string;
-    chat_model?: string;
+  wav_assemble_time?: number;
+  speak_to_first_frame?: number;
+  llm_ttft?: number;
+  llm_total_time?: number;
+  tts_first_frame_time?: number;
+  tts_total_time?: number;
+  wav_to_tts_total_time?: number;
+  stt?: string;
+  tts?: string;
+  chat_model?: string;
 }
 const metrics = ref<LiveMetrics>({});
 
 // 当前语音片段标记
-let currentStamp = '';
+let currentStamp = "";
 
 const statusText = computed(() => {
-    if (!isActive.value) return 'Astr Live';
-    if (isProcessing.value) return '正在处理...';
-    if (isSpeaking.value) return '正在说话...';
-    if (isListening.value) return '正在听...';
-    return '准备就绪';
+  if (!isActive.value) return "Astr Live";
+  if (isProcessing.value) return "正在处理...";
+  if (isSpeaking.value) return "正在说话...";
+  if (isListening.value) return "正在听...";
+  return "准备就绪";
 });
 
 const getIcon = computed(() => {
-    if (!isActive.value) return 'mdi-microphone';
-    if (isSpeaking.value) return 'mdi-account-voice';
-    if (isProcessing.value) return 'mdi-loading';
-    return 'mdi-check';
+  if (!isActive.value) return "mdi-microphone";
+  if (isSpeaking.value) return "mdi-account-voice";
+  if (isProcessing.value) return "mdi-loading";
+  return "mdi-check";
 });
 
 const getIconColor = computed(() => {
-    if (!isActive.value) return isDark.value ? 'white' : 'black';
-    if (isSpeaking.value) return 'success';
-    if (isProcessing.value) return 'warning';
-    return 'primary';
+  if (!isActive.value) return isDark.value ? "white" : "black";
+  if (isSpeaking.value) return "success";
+  if (isProcessing.value) return "warning";
+  return "primary";
 });
 
 const orbEnergy = computed(() => {
-    if (isPlaying.value) return botEnergy.value;
-    if (isSpeaking.value || isListening.value) return vadRecording.audioEnergy.value;
-    return 0;
+  if (isPlaying.value) return botEnergy.value;
+  if (isSpeaking.value || isListening.value)
+    return vadRecording.audioEnergy.value;
+  return 0;
 });
 
 const orbMode = computed(() => {
-    if (isProcessing.value) return 'processing';
-    if (isPlaying.value) return 'speaking';
-    if (isSpeaking.value || isListening.value) return 'listening';
-    return 'idle';
+  if (isProcessing.value) return "processing";
+  if (isPlaying.value) return "speaking";
+  if (isSpeaking.value || isListening.value) return "listening";
+  return "idle";
+});
+
+const canSendText = computed(() => {
+  return (
+    isConnected.value &&
+    isActive.value &&
+    Boolean(textInput.value.trim()) &&
+    !isProcessing.value
+  );
 });
 
 async function handleCircleClick() {
-    if (!isActive.value) {
-        // 触发爆炸动画
-        isExploding.value = true;
-        setTimeout(() => {
-            isExploding.value = false;
-        }, 1000);
+  if (!isActive.value) {
+    // 触发爆炸动画
+    isExploding.value = true;
+    setTimeout(() => {
+      isExploding.value = false;
+    }, 1000);
 
-        await startLiveMode();
-    } else {
-        await stopLiveMode();
-    }
+    await startLiveMode();
+  } else {
+    await stopLiveMode();
+  }
 }
 
 async function startLiveMode() {
-    try {
-        // 1. 建立 WebSocket 连接
-        await connectWebSocket();
+  try {
+    // 1. 建立 WebSocket 连接
+    await connectWebSocket();
 
-        // 2. 初始化音频上下文（用于播放回复音频）
-        audioContext = new AudioContext({ sampleRate: 16000 });
-        analyser = audioContext.createAnalyser();
-        analyser.fftSize = 256;
-        analyser.smoothingTimeConstant = 0.5;
+    // 2. 初始化音频上下文（用于播放回复音频）
+    audioContext = new AudioContext({ sampleRate: 16000 });
+    analyser = audioContext.createAnalyser();
+    analyser.fftSize = 256;
+    analyser.smoothingTimeConstant = 0.5;
 
-        // 启动能量更新循环
-        updateBotEnergy();
+    // 启动能量更新循环
+    updateBotEnergy();
 
-        // 3. 启动 VAD 录音
-        await vadRecording.startRecording(
-            // onSpeechStart 回调
-            () => {
-                console.log('[Live Mode] VAD 检测到开始说话');
-                isListening.value = false;
-                currentStamp = generateStamp();
+    // 3. 启动 VAD 录音
+    await vadRecording.startRecording(
+      // onSpeechStart 回调
+      () => {
+        console.log("[Live Mode] VAD 检测到开始说话");
+        isListening.value = false;
+        currentStamp = generateStamp();
 
-                // 发送开始说话消息
-                if (ws && ws.readyState === WebSocket.OPEN) {
-                    metrics.value = {}; // Reset metrics
-                    ws.send(JSON.stringify({
-                        t: 'start_speaking',
-                        stamp: currentStamp
-                    }));
-                }
-            },
-            // onSpeechEnd 回调
-            (audio: Float32Array) => {
-                console.log('[Live Mode] VAD 检测到语音结束，音频长度:', audio.length);
+        // 发送开始说话消息
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          metrics.value = {}; // Reset metrics
+          ws.send(
+            JSON.stringify({
+              t: "start_speaking",
+              stamp: currentStamp,
+            }),
+          );
+        }
+      },
+      // onSpeechEnd 回调
+      (audio: Float32Array) => {
+        console.log("[Live Mode] VAD 检测到语音结束，音频长度:", audio.length);
 
-                // 将完整音频转换为 PCM16 并发送
-                if (ws && ws.readyState === WebSocket.OPEN) {
-                    const pcm16 = new Int16Array(audio.length);
-                    for (let i = 0; i < audio.length; i++) {
-                        const s = Math.max(-1, Math.min(1, audio[i]));
-                        pcm16[i] = s < 0 ? s * 0x8000 : s * 0x7FFF;
-                    }
+        // 将完整音频转换为 PCM16 并发送
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          const pcm16 = new Int16Array(audio.length);
+          for (let i = 0; i < audio.length; i++) {
+            const s = Math.max(-1, Math.min(1, audio[i]));
+            pcm16[i] = s < 0 ? s * 0x8000 : s * 0x7fff;
+          }
 
-                    // Base64 编码（分块处理以避免堆栈溢出）
-                    const uint8 = new Uint8Array(pcm16.buffer);
-                    let base64 = '';
-                    const chunkSize = 0x8000; // 32KB chunks
-                    for (let i = 0; i < uint8.length; i += chunkSize) {
-                        const chunk = uint8.subarray(i, Math.min(i + chunkSize, uint8.length));
-                        base64 += String.fromCharCode.apply(null, Array.from(chunk));
-                    }
-                    base64 = btoa(base64);
+          // Base64 编码（分块处理以避免堆栈溢出）
+          const uint8 = new Uint8Array(pcm16.buffer);
+          let base64 = "";
+          const chunkSize = 0x8000; // 32KB chunks
+          for (let i = 0; i < uint8.length; i += chunkSize) {
+            const chunk = uint8.subarray(
+              i,
+              Math.min(i + chunkSize, uint8.length),
+            );
+            base64 += String.fromCharCode.apply(null, Array.from(chunk));
+          }
+          base64 = btoa(base64);
 
-                    // 发送完整音频
-                    ws.send(JSON.stringify({
-                        t: 'speaking_part',
-                        data: base64
-                    }));
+          // 发送完整音频
+          ws.send(
+            JSON.stringify({
+              t: "speaking_part",
+              data: base64,
+            }),
+          );
 
-                    // 发送结束说话消息
-                    ws.send(JSON.stringify({
-                        t: 'end_speaking',
-                        stamp: currentStamp
-                    }));
+          // 发送结束说话消息
+          ws.send(
+            JSON.stringify({
+              t: "end_speaking",
+              stamp: currentStamp,
+            }),
+          );
 
-                    isProcessing.value = true;
-                }
-            }
-        );
+          isProcessing.value = true;
+        }
+      },
+    );
 
-        isActive.value = true;
-        isListening.value = true;
-
-    } catch (error) {
-        console.error('启动 Live Mode 失败:', error);
-        alert('启动失败，请检查麦克风权限或网络连接');
-        await stopLiveMode();
-    }
+    isActive.value = true;
+    isListening.value = true;
+  } catch (error) {
+    console.error("启动 Live Mode 失败:", error);
+    alert("启动失败，请检查麦克风权限或网络连接");
+    await stopLiveMode();
+  }
 }
 
 async function stopLiveMode() {
-    cancelAnimationFrame(energyLoopId);
+  cancelAnimationFrame(energyLoopId);
 
-    // 停止 VAD 录音
-    vadRecording.stopRecording();
+  // 停止 VAD 录音
+  vadRecording.stopRecording();
 
-    // 停止音频播放
-    stopAudioPlayback();
+  // 停止音频播放
+  stopAudioPlayback();
 
-    // 关闭音频上下文
-    if (audioContext) {
-        await audioContext.close();
-        audioContext = null;
-    }
+  // 关闭音频上下文
+  if (audioContext) {
+    await audioContext.close();
+    audioContext = null;
+  }
 
-    // 关闭 WebSocket
-    if (ws) {
-        ws.close();
-        ws = null;
-    }
+  isConnected.value = false;
+  textInput.value = "";
 
-    isActive.value = false;
-    isListening.value = false;
-    isProcessing.value = false;
+  // 关闭 WebSocket
+  if (ws) {
+    ws.close();
+    ws = null;
+  }
+
+  isActive.value = false;
+  isListening.value = false;
+  isProcessing.value = false;
 }
 
 function connectWebSocket(): Promise<void> {
-    return new Promise((resolve, reject) => {
-        // 获取存储的 token
-        const token = localStorage.getItem('token');
-        if (!token) {
-            reject(new Error('未登录，请先登录'));
-            return;
-        }
+  return new Promise((resolve, reject) => {
+    // 获取存储的 token
+    const token = localStorage.getItem("token");
+    if (!token) {
+      reject(new Error("未登录，请先登录"));
+      return;
+    }
 
-        const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-        const wsUrl = `${protocol}//localhost:6185/api/live_chat/ws?token=${encodeURIComponent(token)}`;
+    const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+    const wsUrl = `${protocol}//localhost:6185/api/live_chat/ws?token=${encodeURIComponent(
+      token,
+    )}`;
 
-        ws = new WebSocket(wsUrl);
+    ws = new WebSocket(wsUrl);
 
-        ws.onopen = () => {
-            console.log('[Live Mode] WebSocket 连接成功');
-            resolve();
-        };
+    ws.onopen = () => {
+      console.log("[Live Mode] WebSocket 连接成功");
+      isConnected.value = true;
+      resolve();
+    };
 
-        ws.onerror = (error) => {
-            console.error('[Live Mode] WebSocket 错误:', error);
-            reject(error);
-        };
+    ws.onerror = (error) => {
+      console.error("[Live Mode] WebSocket 错误:", error);
+      reject(error);
+    };
 
-        ws.onmessage = handleWebSocketMessage;
+    ws.onmessage = handleWebSocketMessage;
 
-        ws.onclose = () => {
-            console.log('[Live Mode] WebSocket 连接关闭');
-        };
+    ws.onclose = () => {
+      console.log("[Live Mode] WebSocket 连接关闭");
+      isConnected.value = false;
+    };
 
-        // 超时处理
-        setTimeout(() => {
-            if (ws?.readyState !== WebSocket.OPEN) {
-                reject(new Error('WebSocket 连接超时'));
-            }
-        }, 5000);
-    });
+    // 超时处理
+    setTimeout(() => {
+      if (ws?.readyState !== WebSocket.OPEN) {
+        reject(new Error("WebSocket 连接超时"));
+      }
+    }, 5000);
+  });
 }
 
 // 这些函数不再需要，VAD 库会自动处理语音检测和音频上传
 
 function handleWebSocketMessage(event: MessageEvent) {
-    try {
-        const message = JSON.parse(event.data);
-        const msgType = message.t;
+  try {
+    const message = JSON.parse(event.data);
+    const msgType = message.t;
 
-        switch (msgType) {
-            case 'user_msg':
-                messages.value.push({
-                    type: 'user',
-                    text: message.data.text
-                });
-                break;
+    switch (msgType) {
+      case "user_msg":
+        messages.value.push({
+          type: "user",
+          text: message.data.text,
+        });
+        break;
 
-            case 'bot_text_chunk':
-                messages.value.push({
-                    type: 'bot',
-                    text: message.data.text
-                });
-                break;
+      case "bot_text_chunk":
+        messages.value.push({
+          type: "bot",
+          text: message.data.text,
+        });
+        break;
 
-            case 'bot_msg':
-                messages.value.push({
-                    type: 'bot',
-                    text: message.data.text
-                });
-                isProcessing.value = false;
-                isListening.value = true;
-                break;
+      case "bot_msg":
+        messages.value.push({
+          type: "bot",
+          text: message.data.text,
+        });
+        isProcessing.value = false;
+        isListening.value = true;
+        break;
 
-            case 'response':
-                // 音频数据
-                playAudioChunk(message.data);
-                break;
+      case "response":
+        // 音频数据
+        playAudioChunk(message.data);
+        break;
 
-            case 'stop_play':
-                // 停止播放
-                stopAudioPlayback();
-                break;
+      case "stop_play":
+        // 停止播放
+        stopAudioPlayback();
+        break;
 
-            case 'end':
-                // 处理完成
-                isProcessing.value = false;
-                isListening.value = true;
-                break;
+      case "end":
+        // 处理完成
+        isProcessing.value = false;
+        isListening.value = true;
+        break;
 
-            case 'error':
-                console.error('[Live Mode] 错误:', message.data);
-                alert('处理出错: ' + message.data);
-                isProcessing.value = false;
-                isListening.value = true;
-                break;
+      case "error":
+        console.error("[Live Mode] 错误:", message.data);
+        alert("处理出错: " + message.data);
+        isProcessing.value = false;
+        isListening.value = true;
+        break;
 
-            case 'metrics':
-                metrics.value = { ...metrics.value, ...message.data };
-                break;
-        }
-    } catch (error) {
-        console.error('[Live Mode] 处理消息失败:', error);
+      case "metrics":
+        metrics.value = { ...metrics.value, ...message.data };
+        break;
     }
+  } catch (error) {
+    console.error("[Live Mode] 处理消息失败:", error);
+  }
+}
+
+function sendTextInput() {
+  const text = textInput.value.trim();
+  if (!isConnected.value || !text || isProcessing.value || !isActive.value) {
+    return;
+  }
+
+  if (!ws || ws.readyState !== WebSocket.OPEN) {
+    return;
+  }
+
+  ws.send(
+    JSON.stringify({
+      t: "text_input",
+      text,
+    }),
+  );
+
+  isProcessing.value = true;
+  textInput.value = "";
 }
 
 function playAudioChunk(base64Data: string) {
-    if (!audioContext) return;
+  if (!audioContext) return;
 
-    try {
-        // 解码 base64
-        const binaryString = atob(base64Data);
-        const bytes = new Uint8Array(binaryString.length);
-        for (let i = 0; i < binaryString.length; i++) {
-            bytes[i] = binaryString.charCodeAt(i);
-        }
-
-        // 放入待解码队列
-        rawAudioQueue.push(bytes);
-
-        // 触发解码处理
-        processRawAudioQueue();
-
-    } catch (error) {
-        console.error('[Live Mode] 接收音频数据失败:', error);
+  try {
+    // 解码 base64
+    const binaryString = atob(base64Data);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
     }
+
+    // 放入待解码队列
+    rawAudioQueue.push(bytes);
+
+    // 触发解码处理
+    processRawAudioQueue();
+  } catch (error) {
+    console.error("[Live Mode] 接收音频数据失败:", error);
+  }
 }
 
 async function processRawAudioQueue() {
-    if (isDecoding || rawAudioQueue.length === 0) return;
+  if (isDecoding || rawAudioQueue.length === 0) return;
 
-    isDecoding = true;
+  isDecoding = true;
 
-    try {
-        while (rawAudioQueue.length > 0) {
-            const bytes = rawAudioQueue.shift();
-            if (!bytes || !audioContext) continue;
+  try {
+    while (rawAudioQueue.length > 0) {
+      const bytes = rawAudioQueue.shift();
+      if (!bytes || !audioContext) continue;
 
-            try {
-                // 解码
-                const audioBuffer = await audioContext.decodeAudioData(bytes.buffer as ArrayBuffer);
-                audioBufferQueue.push(audioBuffer);
+      try {
+        // 解码
+        const audioBuffer = await audioContext.decodeAudioData(
+          bytes.buffer as ArrayBuffer,
+        );
+        audioBufferQueue.push(audioBuffer);
 
-                // 如果当前没有播放，立即开始播放
-                if (!isPlayingAudio) {
-                    playNextAudio();
-                }
-            } catch (err) {
-                console.error('[Live Mode] 解码音频失败:', err);
-            }
-        }
-    } finally {
-        isDecoding = false;
-        // 如果在解码过程中又有新数据进来，继续处理
-        if (rawAudioQueue.length > 0) {
-            processRawAudioQueue();
+        // 如果当前没有播放，立即开始播放
+        if (!isPlayingAudio) {
+          playNextAudio();
         }
+      } catch (err) {
+        console.error("[Live Mode] 解码音频失败:", err);
+      }
     }
+  } finally {
+    isDecoding = false;
+    // 如果在解码过程中又有新数据进来，继续处理
+    if (rawAudioQueue.length > 0) {
+      processRawAudioQueue();
+    }
+  }
 }
 
 function playNextAudio() {
-    if (audioBufferQueue.length === 0) {
-        isPlayingAudio = false;
-        isPlaying.value = false;
-        return;
+  if (audioBufferQueue.length === 0) {
+    isPlayingAudio = false;
+    isPlaying.value = false;
+    return;
+  }
+
+  if (!audioContext) return;
+
+  isPlayingAudio = true;
+  isPlaying.value = true;
+
+  try {
+    const audioBuffer = audioBufferQueue.shift();
+    if (!audioBuffer) return;
+
+    const source = audioContext.createBufferSource();
+    source.buffer = audioBuffer;
+
+    // 连接到分析器
+    if (analyser) {
+      source.connect(analyser);
+      analyser.connect(audioContext.destination);
+    } else {
+      source.connect(audioContext.destination);
     }
 
-    if (!audioContext) return;
+    currentSource = source;
+    source.start();
 
-    isPlayingAudio = true;
-    isPlaying.value = true;
-
-    try {
-        const audioBuffer = audioBufferQueue.shift();
-        if (!audioBuffer) return;
-
-        const source = audioContext.createBufferSource();
-        source.buffer = audioBuffer;
-
-        // 连接到分析器
-        if (analyser) {
-            source.connect(analyser);
-            analyser.connect(audioContext.destination);
-        } else {
-            source.connect(audioContext.destination);
-        }
-
-        currentSource = source;
-        source.start();
-
-        source.onended = () => {
-            currentSource = null;
-            playNextAudio();
-        };
-
-    } catch (error) {
-        console.error('[Live Mode] 播放音频失败:', error);
-        isPlayingAudio = false;
-        isPlaying.value = false;
-        playNextAudio(); // 尝试播放下一个
-    }
+    source.onended = () => {
+      currentSource = null;
+      playNextAudio();
+    };
+  } catch (error) {
+    console.error("[Live Mode] 播放音频失败:", error);
+    isPlayingAudio = false;
+    isPlaying.value = false;
+    playNextAudio(); // 尝试播放下一个
+  }
 }
 
 function stopAudioPlayback() {
-    // 停止当前播放源
-    if (currentSource) {
-        try {
-            currentSource.stop();
-            currentSource.disconnect();
-        } catch (e) {
-            // ignore
-        }
-        currentSource = null;
+  // 停止当前播放源
+  if (currentSource) {
+    try {
+      currentSource.stop();
+      currentSource.disconnect();
+    } catch (e) {
+      // ignore
     }
+    currentSource = null;
+  }
 
-    // 清空队列
-    rawAudioQueue.length = 0;
-    audioBufferQueue.length = 0;
+  // 清空队列
+  rawAudioQueue.length = 0;
+  audioBufferQueue.length = 0;
 
-    // 重置状态
-    isPlayingAudio = false;
-    isPlaying.value = false;
-    isDecoding = false;
+  // 重置状态
+  isPlayingAudio = false;
+  isPlaying.value = false;
+  isDecoding = false;
 }
 
 function generateStamp(): string {
-    return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
 }
 
 function updateBotEnergy() {
-    if (analyser && isPlaying.value) {
-        const dataArray = new Uint8Array(analyser.frequencyBinCount);
-        analyser.getByteFrequencyData(dataArray);
+  if (analyser && isPlaying.value) {
+    const dataArray = new Uint8Array(analyser.frequencyBinCount);
+    analyser.getByteFrequencyData(dataArray);
 
-        let sum = 0;
-        // 只计算低频到中频部分，通常人声集中在这里
-        const range = Math.floor(dataArray.length * 0.7);
-        for (let i = 0; i < range; i++) {
-            sum += dataArray[i];
-        }
-        const average = sum / range;
-        // 归一化并放大一点
-        botEnergy.value = Math.min(1, (average / 255) * 2.0);
-    } else {
-        botEnergy.value = Math.max(0, botEnergy.value - 0.1);
+    let sum = 0;
+    // 只计算低频到中频部分，通常人声集中在这里
+    const range = Math.floor(dataArray.length * 0.7);
+    for (let i = 0; i < range; i++) {
+      sum += dataArray[i];
     }
+    const average = sum / range;
+    // 归一化并放大一点
+    botEnergy.value = Math.min(1, (average / 255) * 2.0);
+  } else {
+    botEnergy.value = Math.max(0, botEnergy.value - 0.1);
+  }
 
-    if (isActive.value) {
-        energyLoopId = requestAnimationFrame(updateBotEnergy);
-    }
+  if (isActive.value) {
+    energyLoopId = requestAnimationFrame(updateBotEnergy);
+  }
 }
 
 function handleClose() {
-    stopLiveMode();
-    emit('close');
+  stopLiveMode();
+  emit("close");
 }
 
 function toggleCodeMode() {
-    isCodeMode.value = !isCodeMode.value;
+  isCodeMode.value = !isCodeMode.value;
 }
 
 function toggleNervousMode() {
-    isNervousMode.value = !isNervousMode.value;
+  isNervousMode.value = !isNervousMode.value;
 }
 
 // 监听用户打断
 watch(isSpeaking, (newVal) => {
-    if (newVal && isPlaying.value) {
-        // 用户在播放时开始说话，发送打断信号
-        if (ws && ws.readyState === WebSocket.OPEN) {
-            ws.send(JSON.stringify({ t: 'interrupt' }));
-        }
-        // 本地立即停止播放
-        stopAudioPlayback();
+  if (newVal && isPlaying.value) {
+    // 用户在播放时开始说话，发送打断信号
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ t: "interrupt" }));
     }
+    // 本地立即停止播放
+    stopAudioPlayback();
+  }
 });
 
 onBeforeUnmount(() => {
-    stopLiveMode();
+  stopLiveMode();
 });
 </script>
 
 <style scoped>
 .live-mode-container {
-    display: flex;
-    flex-direction: column;
-    height: 100%;
-    width: 100%;
-    background: linear-gradient(135deg, rgba(103, 58, 183, 0.05) 0%, rgba(63, 81, 181, 0.05) 100%);
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  width: 100%;
+  background: linear-gradient(
+    135deg,
+    rgba(103, 58, 183, 0.05) 0%,
+    rgba(63, 81, 181, 0.05) 100%
+  );
 }
 
 .header-controls {
-    display: flex;
-    padding: 8px;
-    gap: 8px;
+  display: flex;
+  padding: 8px;
+  gap: 8px;
 }
 
 .live-mode-content {
-    flex: 1;
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    justify-content: center;
-    position: relative;
-    padding: 40px;
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  position: relative;
+  padding: 40px;
+}
+
+.text-input-panel {
+  position: absolute;
+  top: 16px;
+  left: 16px;
+  right: 16px;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  z-index: 15;
+}
+
+.text-input-panel .v-text-field {
+  flex: 1;
 }
 
 .center-circle-container {
-    position: relative;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    margin-bottom: 40px;
-    cursor: pointer;
-    /* 给一个最小尺寸，避免在加载或切换时跳动 */
-    min-width: 250px;
-    min-height: 250px;
+  position: relative;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin-bottom: 40px;
+  cursor: pointer;
+  /* 给一个最小尺寸，避免在加载或切换时跳动 */
+  min-width: 250px;
+  min-height: 250px;
 }
 
 .siri-orb {
-    /* 移除绝对定位，让 Orb 自然占据空间 */
-    z-index: 10;
-    position: relative;
+  /* 移除绝对定位，让 Orb 自然占据空间 */
+  z-index: 10;
+  position: relative;
 }
 
 .orb-overlay {
-    position: absolute;
-    /* 绝对定位，覆盖在 Orb 上 */
-    top: 50%;
-    left: 50%;
-    transform: translate(-50%, -50%);
-    z-index: 20;
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    justify-content: center;
-    pointer-events: none;
-    width: 100%;
-    height: 100%;
+  position: absolute;
+  /* 绝对定位，覆盖在 Orb 上 */
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  z-index: 20;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  pointer-events: none;
+  width: 100%;
+  height: 100%;
 }
 
 .explosion-wave {
-    position: absolute;
-    top: 50%;
-    left: 50%;
-    transform: translate(-50%, -50%);
-    width: 150px;
-    height: 150px;
-    border-radius: 50%;
-    opacity: 0.8;
-    background: radial-gradient(circle, transparent 50%, rgba(125, 80, 201, 0.8) 70%, transparent 100%);
-    animation: explode 3s cubic-bezier(0.16, 1, 0.3, 1) forwards;
-    filter: blur(30px);
-    z-index: 0;
-    pointer-events: none;
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  width: 150px;
+  height: 150px;
+  border-radius: 50%;
+  opacity: 0.8;
+  background: radial-gradient(
+    circle,
+    transparent 50%,
+    rgba(125, 80, 201, 0.8) 70%,
+    transparent 100%
+  );
+  animation: explode 3s cubic-bezier(0.16, 1, 0.3, 1) forwards;
+  filter: blur(30px);
+  z-index: 0;
+  pointer-events: none;
 }
 
 @keyframes explode {
-    0% {
-        transform: translate(-50%, -50%) scale(1);
-        opacity: 0.8;
-    }
+  0% {
+    transform: translate(-50%, -50%) scale(1);
+    opacity: 0.8;
+  }
 
-    100% {
-        transform: translate(-50%, -50%) scale(50);
-        opacity: 0;
-    }
+  100% {
+    transform: translate(-50%, -50%) scale(50);
+    opacity: 0;
+  }
 }
 
 .status-text {
-    font-size: 24px;
-    color: var(--v-theme-on-surface);
-    margin-bottom: 40px;
-    font-family: 'Outfit', sans-serif;
+  font-size: 24px;
+  color: var(--v-theme-on-surface);
+  margin-bottom: 40px;
+  font-family: "Outfit", sans-serif;
 }
 
 .messages-container {
-    position: absolute;
-    bottom: 40px;
-    left: 40px;
-    right: 40px;
-    max-height: 300px;
-    overflow-y: auto;
-    display: flex;
-    flex-direction: column;
-    gap: 12px;
+  position: absolute;
+  bottom: 40px;
+  left: 40px;
+  right: 40px;
+  max-height: 300px;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
 }
 
 .message-item {
-    color: rgb(var(--v-theme-on-surface));
-    display: flex;
-    align-items: flex-end;
-    align-self: flex-end;
-    gap: 12px;
+  color: rgb(var(--v-theme-on-surface));
+  display: flex;
+  align-items: flex-end;
+  align-self: flex-end;
+  gap: 12px;
 }
 
 .message-content {
-    flex: 1;
-    word-wrap: break-word;
+  flex: 1;
+  word-wrap: break-word;
 }
 
 .metrics-container {
-    position: absolute;
-    bottom: 10px;
-    left: 10px;
-    display: flex;
-    flex-direction: column;
-    gap: 4px;
-    font-size: 12px;
-    color: rgba(var(--v-theme-on-surface), 0.6);
-    z-index: 100;
+  position: absolute;
+  bottom: 10px;
+  left: 10px;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  font-size: 12px;
+  color: rgba(var(--v-theme-on-surface), 0.6);
+  z-index: 100;
 }
 </style>
diff --git a/docs/live-api/README.md b/docs/live-api/README.md
index 7bfff8154..7dc897284 100644
--- a/docs/live-api/README.md
+++ b/docs/live-api/README.md
@@ -128,6 +128,17 @@ Finish the current voice capture segment.
 }
 ```
 
+#### `text_input`
+
+Send a plain text input directly while using `ct=live`. The server will still route through Live mode with TTS and interrupt handling.
+
+```json
+{
+  "t": "text_input",
+  "text": "Hello, what is the weather today?"
+}
+```
+
 #### `interrupt`
 
 Interrupt the current model or TTS response.