@siact/sime-x-vue 0.0.7 → 0.0.8

package/dist/sime-x-vue.umd.js

@@ -31,7 +31,7 @@
     return clientCommandKey2;
   })(clientCommandKey || {});
 
-  const _sfc_main$3 = /* @__PURE__ */ vue.defineComponent({
+  const _sfc_main$4 = /* @__PURE__ */ vue.defineComponent({
     __name: "sime-provider",
     props: {
       project: {},
@@ -44,7 +44,7 @@
     },
     setup(__props) {
       const props = __props;
-      const hostBridge = vue.shallowRef(new simeBridge.HostBridge());
+      const hostBridge = vue.shallowRef(new simeBridge.HostBridge({ debug: false }));
       const startListeningRef = vue.shallowRef(async () => {
       });
       const stopListeningRef = vue.shallowRef(async () => {
@@ -59,7 +59,7 @@
         chatbotUrl: () => props.chatbotUrl,
         appId: () => props.appId,
         appToken: () => props.appToken,
-        voiceConfig: () => props.voiceConfig,
+        voiceConfig: () => props.voiceConfig || { appId: "", apiKey: "", websocketUrl: "" },
         startListening: () => startListeningRef.value(),
         stopListening: () => stopListeningRef.value(),
         toggleCollapse: () => toggleCollapseRef.value(),
@@ -108,18 +108,18 @@
     }
   });
 
-  const _hoisted_1$2 = { class: "content-container" };
-  const _hoisted_2$2 = { class: "status-header" };
-  const _hoisted_3$1 = { class: "status-text" };
-  const _hoisted_4$1 = {
+  const _hoisted_1$3 = { class: "content-container" };
+  const _hoisted_2$3 = { class: "status-header" };
+  const _hoisted_3$2 = { class: "status-text" };
+  const _hoisted_4$2 = {
     key: 0,
     class: "transcription-content"
   };
-  const _hoisted_5$1 = {
+  const _hoisted_5$2 = {
     key: 1,
     class: "placeholder-text"
   };
-  const _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
+  const _sfc_main$3 = /* @__PURE__ */ vue.defineComponent({
     __name: "voice-status",
     props: {
       status: {},
@@ -181,9 +181,9 @@
                   ])
                 ])
               ], -1)),
-              vue.createElementVNode("div", _hoisted_1$2, [
-                vue.createElementVNode("div", _hoisted_2$2, [
-                  vue.createElementVNode("span", _hoisted_3$1, vue.toDisplayString(statusLabel.value), 1)
+              vue.createElementVNode("div", _hoisted_1$3, [
+                vue.createElementVNode("div", _hoisted_2$3, [
+                  vue.createElementVNode("span", _hoisted_3$2, vue.toDisplayString(statusLabel.value), 1)
                 ]),
                 vue.createElementVNode("div", {
                   class: vue.normalizeClass(["text-window", { "has-text": !!__props.transcriptionText }])
@@ -193,7 +193,7 @@
                     mode: "out-in"
                   }, {
                     default: vue.withCtx(() => [
-                      __props.transcriptionText ? (vue.openBlock(), vue.createElementBlock("p", _hoisted_4$1, vue.toDisplayString(__props.transcriptionText), 1)) : __props.status === "wake" ? (vue.openBlock(), vue.createElementBlock("p", _hoisted_5$1, "Listening...")) : vue.createCommentVNode("", true)
+                      __props.transcriptionText ? (vue.openBlock(), vue.createElementBlock("p", _hoisted_4$2, vue.toDisplayString(__props.transcriptionText), 1)) : __props.status === "wake" ? (vue.openBlock(), vue.createElementBlock("p", _hoisted_5$2, "Listening...")) : vue.createCommentVNode("", true)
                     ]),
                     _: 1
                   })
@@ -215,14 +215,14 @@
     return target;
   };
 
-  const VoiceStatus = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-c9fa6caf"]]);
+  const VoiceStatus = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__scopeId", "data-v-c9fa6caf"]]);
 
-  const _hoisted_1$1 = {
+  const _hoisted_1$2 = {
     key: 0,
     class: "execution-bubble"
   };
-  const _hoisted_2$1 = { class: "exec-text" };
-  const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
+  const _hoisted_2$2 = { class: "exec-text" };
+  const _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
     __name: "execution-status",
     props: {
       visible: { type: Boolean },
@@ -232,8 +232,8 @@
       return (_ctx, _cache) => {
         return vue.openBlock(), vue.createBlock(vue.Transition, { name: "exec-bubble" }, {
           default: vue.withCtx(() => [
-            __props.visible ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$1, [
-              vue.createElementVNode("span", _hoisted_2$1, vue.toDisplayString(__props.text || "执行中"), 1),
+            __props.visible ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$2, [
+              vue.createElementVNode("span", _hoisted_2$2, vue.toDisplayString(__props.text || "执行中"), 1),
               _cache[0] || (_cache[0] = vue.createElementVNode("div", { class: "loading-dots" }, [
                 vue.createElementVNode("span", { class: "dot" }),
                 vue.createElementVNode("span", { class: "dot" }),
@@ -247,7 +247,7 @@
     }
   });
 
-  const ExecutionStatus = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-8244ff0d"]]);
+  const ExecutionStatus = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-8244ff0d"]]);
 
   const ensureMicrophonePermission = async () => {
     if (typeof navigator === "undefined" || typeof window === "undefined") {
@@ -316,22 +316,22 @@
     }
   };
 
-  const _hoisted_1 = ["data-theme"];
-  const _hoisted_2 = { class: "fab-avatar-wrapper" };
-  const _hoisted_3 = ["src"];
-  const _hoisted_4 = { class: "header-left" };
-  const _hoisted_5 = { class: "logo-icon" };
-  const _hoisted_6 = ["src"];
-  const _hoisted_7 = { class: "title" };
-  const _hoisted_8 = { class: "actions" };
-  const _hoisted_9 = ["title"];
-  const _hoisted_10 = {
+  const _hoisted_1$1 = ["data-theme"];
+  const _hoisted_2$1 = { class: "fab-avatar-wrapper" };
+  const _hoisted_3$1 = ["src"];
+  const _hoisted_4$1 = { class: "header-left" };
+  const _hoisted_5$1 = { class: "logo-icon" };
+  const _hoisted_6$1 = ["src"];
+  const _hoisted_7$1 = { class: "title" };
+  const _hoisted_8$1 = { class: "actions" };
+  const _hoisted_9$1 = ["title"];
+  const _hoisted_10$1 = {
     key: 0,
     class: "voice-indicator"
   };
-  const _hoisted_11 = ["title"];
-  const _hoisted_12 = ["title"];
-  const _hoisted_13 = {
+  const _hoisted_11$1 = ["title"];
+  const _hoisted_12$1 = ["title"];
+  const _hoisted_13$1 = {
     width: "16",
     height: "16",
     viewBox: "0 0 24 24",
@@ -340,7 +340,7 @@
   const _hoisted_14 = ["d"];
   const _hoisted_15 = ["src"];
   const FAB_SAFE_GAP = 24;
-  const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
     __name: "sime-x",
     props: {
       xLogo: {},
@@ -706,9 +706,9 @@
           emit("wakeUp", false);
         }
       };
-      const handleIframeLoad = (event) => {
+      const handleIframeLoad = async (event) => {
         aiChatbotX.setIframeElement(event.target);
-        aiChatbotX.setTheme("dark");
+        aiChatbotX.setTheme(currentTheme.value);
       };
       vue.watch(
         () => [aiChatbotX.chatbotUrl()],
@@ -765,14 +765,14 @@
                   visible: isProcessing.value,
                   text: transcriptionText.value
                 }, null, 8, ["visible", "text"])),
-                vue.createElementVNode("div", _hoisted_2, [
+                vue.createElementVNode("div", _hoisted_2$1, [
                   vue.createElementVNode("img", {
                     src: __props.xLogo ? __props.xLogo : "/sime.png",
                     alt: "assistant",
                     style: vue.normalizeStyle({
                       width: __props.xSize?.width + "px"
                     })
-                  }, null, 12, _hoisted_3),
+                  }, null, 12, _hoisted_3$1),
                   vue.createVNode(vue.Transition, { name: "indicator-fade" }, {
                     default: vue.withCtx(() => [
                       voiceStatus.value === "listening" ? (vue.openBlock(), vue.createElementBlock("div", {
@@ -837,17 +837,17 @@
                   class: "x-dialog-header",
                   onMousedown: vue.withModifiers(startDrag, ["stop"])
                 }, [
-                  vue.createElementVNode("div", _hoisted_4, [
-                    vue.createElementVNode("div", _hoisted_5, [
+                  vue.createElementVNode("div", _hoisted_4$1, [
+                    vue.createElementVNode("div", _hoisted_5$1, [
                       vue.createElementVNode("img", {
                         src: __props.xLogo ? __props.xLogo : "/sime.png",
                         alt: "assistant",
                         class: "logo"
-                      }, null, 8, _hoisted_6)
+                      }, null, 8, _hoisted_6$1)
                     ]),
-                    vue.createElementVNode("span", _hoisted_7, vue.toDisplayString(__props.xTitle), 1)
+                    vue.createElementVNode("span", _hoisted_7$1, vue.toDisplayString(__props.xTitle), 1)
                   ]),
-                  vue.createElementVNode("div", _hoisted_8, [
+                  vue.createElementVNode("div", _hoisted_8$1, [
                     vue.createElementVNode("button", {
                       class: "action-btn theme-btn",
                       title: "开启新对话",
@@ -911,8 +911,8 @@
                           "stroke-linejoin": "round"
                         })
                       ], -1)),
-                      voiceStatus.value !== "standby" ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_10)) : vue.createCommentVNode("", true)
-                    ], 10, _hoisted_9),
+                      voiceStatus.value !== "standby" ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_10$1)) : vue.createCommentVNode("", true)
+                    ], 10, _hoisted_9$1),
                     vue.createElementVNode("button", {
                       class: "action-btn theme-btn",
                       onClick: vue.withModifiers(cycleTheme, ["stop"]),
@@ -936,13 +936,13 @@
                           fill: "currentColor"
                         })
                       ], -1)
-                    ])], 8, _hoisted_11),
+                    ])], 8, _hoisted_11$1),
                     vue.createElementVNode("button", {
                       class: "action-btn collapse-btn",
                       onClick: vue.withModifiers(toggleCollapse, ["stop"]),
                       title: isCollapsed.value ? "展开" : "折叠"
                     }, [
-                      (vue.openBlock(), vue.createElementBlock("svg", _hoisted_13, [
+                      (vue.openBlock(), vue.createElementBlock("svg", _hoisted_13$1, [
                         vue.createElementVNode("path", {
                           d: isCollapsed.value ? "M18 15L12 9L6 15" : "M6 9L12 15L18 9",
                           stroke: "currentColor",
@@ -951,7 +951,7 @@
                           "stroke-linejoin": "round"
                         }, null, 8, _hoisted_14)
                       ]))
-                    ], 8, _hoisted_12),
+                    ], 8, _hoisted_12$1),
                     vue.createElementVNode("button", {
                       class: "action-btn minimize-btn",
                       onClick: _cache[2] || (_cache[2] = vue.withModifiers(($event) => toggleDialog(false), ["stop"])),
@@ -990,14 +990,1225 @@
             ]),
             _: 1
           })
-        ], 8, _hoisted_1);
+        ], 8, _hoisted_1$1);
+      };
+    }
+  });
+
+  const simeX = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-91f104d1"]]);
+
+  function useTTS(getVoiceConfig) {
+    const isSpeaking = vue.ref(false);
+    let instance = null;
+    let initPromise = null;
+    let audioCtx = null;
+    let sentenceBuffer = "";
+    const sentenceDelimiters = /[。！？；\n.!?;]/;
+    const stripMarkdown = (text) => text.replace(/```[\s\S]*?```/g, "").replace(/\|[^\n]*\|/g, "").replace(/#{1,6}\s*/g, "").replace(/\*\*(.*?)\*\*/g, "$1").replace(/\*(.*?)\*/g, "$1").replace(/`([^`]*)`/g, "$1").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/[-*+]\s+/g, "").replace(/>\s+/g, "").replace(/\n{2,}/g, "。").replace(/\n/g, "，").trim();
+    const warmUpAudio = () => {
+      if (!audioCtx || audioCtx.state === "closed") {
+        try {
+          audioCtx = new AudioContext();
+        } catch {
+          return;
+        }
+      }
+      if (audioCtx.state === "suspended") {
+        audioCtx.resume();
+      }
+    };
+    let onQueueEmptyCb = null;
+    const ensureInstance = async () => {
+      if (instance) return instance;
+      if (initPromise) return initPromise;
+      const vc = getVoiceConfig();
+      if (!vc || !vc.apiSecret) {
+        console.warn("[TTS] 缺少 voiceConfig 或 apiSecret，语音播报已禁用");
+        return null;
+      }
+      initPromise = (async () => {
+        try {
+          const tts = new webVoiceKit.SpeechSynthesizerStandalone({
+            appId: vc.appId,
+            apiKey: vc.ttsApiKey || vc.apiKey,
+            apiSecret: vc.apiSecret,
+            websocketUrl: vc.ttsWebsocketUrl || "wss://tts-api.xfyun.cn/v2/tts",
+            vcn: vc.ttsVcn || "xiaoyan",
+            speed: 60,
+            volume: 50,
+            pitch: 50,
+            aue: "raw",
+            auf: "audio/L16;rate=16000",
+            tte: "UTF8",
+            autoPlay: true
+          });
+          tts.onStart(() => {
+            isSpeaking.value = true;
+          });
+          tts.onEnd(() => {
+          });
+          tts.onQueueEmpty(() => {
+            isSpeaking.value = false;
+            onQueueEmptyCb?.();
+          });
+          tts.onError((err) => {
+            console.error("[TTS] Error:", err);
+            isSpeaking.value = false;
+          });
+          if (audioCtx && audioCtx.state === "running") {
+            tts.audioContext = audioCtx;
+            tts.gainNode = audioCtx.createGain();
+            tts.gainNode.connect(audioCtx.destination);
+          }
+          instance = tts;
+          initPromise = null;
+          return tts;
+        } catch (err) {
+          console.error("[TTS] 初始化失败:", err);
+          initPromise = null;
+          return null;
+        }
+      })();
+      return initPromise;
+    };
+    const speak = async (text) => {
+      const clean = stripMarkdown(text);
+      if (!clean.trim()) return;
+      const tts = await ensureInstance();
+      if (!tts) return;
+      try {
+        tts.speak(clean);
+      } catch (err) {
+        console.error("[TTS] speak 失败:", err);
+      }
+    };
+    const feed = (delta) => {
+      sentenceBuffer += delta;
+      while (true) {
+        const match = sentenceBuffer.match(sentenceDelimiters);
+        if (!match || match.index === void 0) break;
+        const sentence = sentenceBuffer.slice(0, match.index + 1).trim();
+        sentenceBuffer = sentenceBuffer.slice(match.index + 1);
+        if (sentence.length > 0) speak(sentence);
+      }
+    };
+    const flush = () => {
+      const remaining = sentenceBuffer.trim();
+      sentenceBuffer = "";
+      if (remaining.length > 0) speak(remaining);
+    };
+    const stop = () => {
+      sentenceBuffer = "";
+      isSpeaking.value = false;
+      if (instance) {
+        try {
+          instance.stop();
+        } catch {
+        }
+      }
+    };
+    const setOnQueueEmpty = (cb) => {
+      onQueueEmptyCb = cb;
+    };
+    const destroy = () => {
+      stop();
+      if (instance) {
+        try {
+          instance.destroy();
+        } catch {
+        }
+        instance = null;
+      }
+      if (audioCtx) {
+        try {
+          audioCtx.close();
+        } catch {
+        }
+        audioCtx = null;
+      }
+    };
+    return {
+      isSpeaking,
+      warmUpAudio,
+      speak,
+      feed,
+      flush,
+      stop,
+      destroy,
+      setOnQueueEmpty
+    };
+  }
+
+  function useBubble(options = {}) {
+    const visible = vue.ref(false);
+    const fadingOut = vue.ref(false);
+    const stackRef = vue.ref(null);
+    let dismissTimer = null;
+    const show = vue.computed(() => visible.value && !fadingOut.value);
+    const style = vue.computed(() => ({
+      width: options.bubbleSize?.width || void 0,
+      maxHeight: options.bubbleSize?.maxHeight || void 0
+    }));
+    const open = () => {
+      cancelDismiss();
+      fadingOut.value = false;
+      visible.value = true;
+    };
+    const cancelDismiss = () => {
+      if (dismissTimer) {
+        clearTimeout(dismissTimer);
+        dismissTimer = null;
+      }
+    };
+    const scheduleDismiss = () => {
+      cancelDismiss();
+      if (options.isSpeaking?.value) return;
+      if (options.isInvoking?.value) return;
+      const delay = options.dismissDelay ?? 4e3;
+      dismissTimer = setTimeout(() => {
+        fadingOut.value = true;
+        setTimeout(() => {
+          visible.value = false;
+          fadingOut.value = false;
+        }, 400);
+      }, delay);
+    };
+    const hide = () => {
+      cancelDismiss();
+      fadingOut.value = false;
+      visible.value = false;
+    };
+    const scrollToBottom = () => {
+      vue.nextTick(() => {
+        if (stackRef.value) {
+          stackRef.value.scrollTop = stackRef.value.scrollHeight;
+        }
+      });
+    };
+    const destroy = () => {
+      cancelDismiss();
+    };
+    return {
+      visible,
+      fadingOut,
+      show,
+      style,
+      stackRef,
+      open,
+      hide,
+      cancelDismiss,
+      scheduleDismiss,
+      scrollToBottom,
+      destroy
+    };
+  }
+
+  function useVoiceRecognition(options) {
+    const voiceStatus = vue.ref("standby");
+    const isTranscribing = vue.ref(false);
+    const isInitializing = vue.ref(false);
+    const transcriptionText = vue.ref("");
+    const wakeAnimating = vue.ref(false);
+    let detector = null;
+    let transcriber = null;
+    const initTranscriber = () => {
+      if (transcriber) return;
+      const vc = options.getVoiceConfig();
+      if (!vc || !vc.appId || !vc.apiKey || !vc.websocketUrl) {
+        console.error("[VoiceRecognition] 缺少 voiceConfig，无法初始化转写器");
+        return;
+      }
+      transcriber = new webVoiceKit.SpeechTranscriberStandalone({
+        appId: vc.appId,
+        apiKey: vc.apiKey,
+        websocketUrl: vc.websocketUrl,
+        autoStop: {
+          enabled: true,
+          silenceTimeoutMs: 2e3,
+          noSpeechTimeoutMs: 5e3,
+          maxDurationMs: 45e3
+        }
+      });
+      transcriber.onResult((result) => {
+        transcriptionText.value = result.transcript || "";
+      });
+      transcriber.onAutoStop(async () => {
+        const finalText = transcriptionText.value;
+        await stopTranscribing();
+        transcriptionText.value = "";
+        if (finalText.trim()) {
+          options.onTranscriptionDone?.(finalText);
+        }
+      });
+      transcriber.onError((error) => {
+        console.error("[VoiceRecognition] 转写错误:", error);
+        stopTranscribing();
+        transcriptionText.value = "";
+      });
+    };
+    const startTranscribing = async () => {
+      if (isTranscribing.value) return;
+      if (!transcriber) initTranscriber();
+      if (!transcriber) return;
+      try {
+        await transcriber.start();
+        isTranscribing.value = true;
+        transcriptionText.value = "";
+      } catch (error) {
+        console.error("[VoiceRecognition] 启动转写失败:", error);
+      }
+    };
+    const stopTranscribing = async () => {
+      if (!transcriber || !transcriber.isActive()) {
+        isTranscribing.value = false;
+        return;
+      }
+      try {
+        await transcriber.stop();
+      } catch (error) {
+        console.error("[VoiceRecognition] 停止转写失败:", error);
+      } finally {
+        isTranscribing.value = false;
+      }
+    };
+    const initDetector = () => {
+      if (detector || isInitializing.value) return;
+      if (!options.modelPath) {
+        console.error("[VoiceRecognition] 未传入 modelPath，无法启用唤醒词");
+        return;
+      }
+      isInitializing.value = true;
+      try {
+        detector = new webVoiceKit.WakeWordDetectorStandalone({
+          modelPath: options.modelPath,
+          sampleRate: 16e3,
+          usePartial: true,
+          autoReset: {
+            enabled: true,
+            resetDelayMs: 4e3
+          }
+        });
+        detector.setWakeWords(options.wakeWords || ["你好", "您好"]);
+        detector.onWake(async () => {
+          wakeAnimating.value = true;
+          options.onWake?.();
+          await startTranscribing();
+          setTimeout(() => {
+            wakeAnimating.value = false;
+          }, 1200);
+        });
+        detector.onError((error) => {
+          console.error("[VoiceRecognition] 唤醒监听错误:", error);
+          voiceStatus.value = "standby";
+          stopTranscribing();
+        });
+      } finally {
+        isInitializing.value = false;
+      }
+    };
+    const toggleVoiceMode = async (targetState) => {
+      const permission = await ensureMicrophonePermission();
+      if (!permission || isInitializing.value) return;
+      if (!detector) {
+        initDetector();
+        if (!detector) return;
+      }
+      const isListening = voiceStatus.value === "listening";
+      const shouldStart = targetState !== void 0 ? targetState : !isListening;
+      if (isListening === shouldStart) return;
+      try {
+        if (shouldStart) {
+          await detector.start();
+          voiceStatus.value = "listening";
+        } else {
+          await detector.stop();
+          voiceStatus.value = "standby";
+          transcriptionText.value = "";
+          await stopTranscribing();
+        }
+      } catch (error) {
+        console.error("[VoiceRecognition] 监听切换失败:", error);
+        voiceStatus.value = "standby";
+      }
+    };
+    const abortTranscription = async () => {
+      transcriptionText.value = "";
+      await stopTranscribing();
+    };
+    const destroy = async () => {
+      if (detector) {
+        try {
+          if (detector.isActive()) await detector.stop();
+        } catch {
+        }
+        detector = null;
+      }
+      if (transcriber) {
+        try {
+          if (transcriber.isActive()) await transcriber.stop();
+        } catch {
+        }
+        transcriber = null;
+      }
+    };
+    return {
+      voiceStatus,
+      isTranscribing,
+      isInitializing,
+      transcriptionText,
+      wakeAnimating,
+      startTranscribing,
+      stopTranscribing,
+      abortTranscription,
+      toggleVoiceMode,
+      destroy
+    };
+  }
+
+  const DATA_STREAM_LINE_RE = /^[0-9a-f]:/;
+  function detectFormat(firstChunk) {
+    const trimmed = firstChunk.trimStart();
+    if (trimmed.startsWith("data:")) {
+      const firstLine = trimmed.split("\n")[0];
+      const payload = firstLine.slice(5).trim();
+      try {
+        const parsed = JSON.parse(payload);
+        if (parsed && typeof parsed.type === "string") {
+          return "ui-message-stream";
+        }
+      } catch {
+      }
+      if (DATA_STREAM_LINE_RE.test(payload)) {
+        return "data-stream";
+      }
+      return "ui-message-stream";
+    }
+    if (DATA_STREAM_LINE_RE.test(trimmed)) {
+      return "data-stream";
+    }
+    return "plain-text";
+  }
+  function processUIMessageStreamEvent(payload, callbacks) {
+    const trimmed = payload.trim();
+    if (!trimmed || trimmed === "[DONE]") {
+      callbacks.onFinish?.({});
+      return;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      console.warn("[DataStreamParser] failed to parse UI message stream event:", trimmed.slice(0, 100));
+      return;
+    }
+    const type = parsed?.type;
+    if (!type) return;
+    switch (type) {
+      case "text-delta":
+        if (typeof parsed.delta === "string") {
+          callbacks.onTextDelta?.(parsed.delta);
+        }
+        break;
+      case "tool-input-start":
+        callbacks.onToolCallStart?.(parsed.toolCallId, parsed.toolName);
+        break;
+      case "tool-input-delta":
+        callbacks.onToolCallDelta?.(parsed.toolCallId, parsed.inputTextDelta);
+        break;
+      case "tool-input-available":
+        callbacks.onToolCallComplete?.(parsed.toolCallId, parsed.toolName, parsed.input);
+        break;
+      case "tool-output-available":
+        callbacks.onToolResult?.(parsed.toolCallId, parsed.output);
+        break;
+      case "finish-step":
+        callbacks.onStepFinish?.(parsed);
+        break;
+      case "finish":
+        callbacks.onFinish?.(parsed);
+        break;
+      case "error":
+        callbacks.onError?.(parsed.errorText || parsed.error || "Unknown error");
+        break;
+      case "start":
+      case "text-start":
+      case "text-end":
+      case "start-step":
+      case "reasoning-start":
+      case "reasoning-delta":
+      case "reasoning-end":
+      case "source-url":
+      case "source-document":
+      case "file":
+      case "abort":
+        break;
+      default:
+        if (type.startsWith("data-")) ; else {
+          console.log("[DataStreamParser] unhandled UI message stream type:", type);
+        }
+        break;
+    }
+  }
+  function parseLegacyProtocolLine(line, callbacks) {
+    if (!line || !DATA_STREAM_LINE_RE.test(line)) return;
+    const code = line[0];
+    const rawValue = line.slice(2);
+    let value;
+    try {
+      value = JSON.parse(rawValue);
+    } catch {
+      value = rawValue;
+    }
+    switch (code) {
+      case "0":
+        callbacks.onTextDelta?.(value);
+        break;
+      case "9":
+        callbacks.onToolCallStart?.(value.toolCallId, value.toolName);
+        break;
+      case "b":
+        callbacks.onToolCallDelta?.(value.toolCallId, value.argsTextDelta);
+        break;
+      case "c":
+        callbacks.onToolCallComplete?.(value.toolCallId, value.toolName, value.args);
+        break;
+      case "a":
+        callbacks.onToolResult?.(value.toolCallId, value.result);
+        break;
+      case "e":
+        callbacks.onStepFinish?.(value);
+        break;
+      case "d":
+        callbacks.onFinish?.(value);
+        break;
+      case "3":
+        callbacks.onError?.(value);
+        break;
+    }
+  }
+  async function readDataStream(response, callbacks) {
+    if (!response.body) return;
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let format = null;
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value, { stream: true });
+      buffer += chunk;
+      if (format === null && buffer.trim().length > 0) {
+        format = detectFormat(buffer);
+        console.log("[DataStreamParser] detected format:", format, "| first 200 chars:", buffer.slice(0, 200));
+      }
+      if (format === "plain-text") {
+        const text = buffer;
+        buffer = "";
+        if (text) callbacks.onTextDelta?.(text);
+        continue;
+      }
+      if (format === "ui-message-stream") {
+        while (true) {
+          const eventEnd = buffer.indexOf("\n\n");
+          if (eventEnd === -1) break;
+          const eventBlock = buffer.slice(0, eventEnd);
+          buffer = buffer.slice(eventEnd + 2);
+          const dataLines = eventBlock.split(/\r?\n/).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trimStart());
+          for (const dataLine of dataLines) {
+            processUIMessageStreamEvent(dataLine, callbacks);
+          }
+        }
+        continue;
+      }
+      if (format === "data-stream") {
+        const isSSEWrapped = buffer.trimStart().startsWith("data:");
+        if (isSSEWrapped) {
+          while (true) {
+            const eventEnd = buffer.indexOf("\n\n");
+            if (eventEnd === -1) break;
+            const eventBlock = buffer.slice(0, eventEnd);
+            buffer = buffer.slice(eventEnd + 2);
+            const dataLines = eventBlock.split(/\r?\n/).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trimStart());
+            for (const dl of dataLines) {
+              const t = dl.trim();
+              if (!t || t === "[DONE]") {
+                if (t === "[DONE]") callbacks.onFinish?.({});
+                continue;
+              }
+              parseLegacyProtocolLine(t, callbacks);
+            }
+          }
+        } else {
+          while (true) {
+            const newlineIdx = buffer.indexOf("\n");
+            if (newlineIdx === -1) break;
+            const line = buffer.slice(0, newlineIdx).trim();
+            buffer = buffer.slice(newlineIdx + 1);
+            if (line) parseLegacyProtocolLine(line, callbacks);
+          }
+        }
+        continue;
+      }
+    }
+    const tail = decoder.decode();
+    if (tail) buffer += tail;
+    if (buffer.trim()) {
+      if (format === "plain-text") {
+        callbacks.onTextDelta?.(buffer);
+      } else if (format === "ui-message-stream") {
+        const dataLines = buffer.split(/\r?\n/).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trimStart());
+        for (const dl of dataLines) {
+          processUIMessageStreamEvent(dl, callbacks);
+        }
+      } else if (format === "data-stream") {
+        parseLegacyProtocolLine(buffer.trim(), callbacks);
+      }
+    }
+    callbacks.onFinish?.({});
+  }
+  async function parseDataStreamToMessage(response, onUpdate) {
+    let textContent = "";
+    const parts = [];
+    const toolCalls = /* @__PURE__ */ new Map();
+    const ensureTextPart = () => {
+      for (let i = parts.length - 1; i >= 0; i--) {
+        if (parts[i].type === "text") {
+          return parts[i];
+        }
+      }
+      const textPart = { type: "text", text: "" };
+      parts.push(textPart);
+      return textPart;
+    };
+    const findToolPartIndex = (toolCallId) => {
+      return parts.findIndex((p) => (p.type === "tool-call" || p.type === "tool-result") && p.toolCallId === toolCallId);
+    };
+    const emitUpdate = () => {
+      onUpdate({ textContent, parts: [...parts], toolCalls: new Map(toolCalls) });
+    };
+    await readDataStream(response, {
+      onTextDelta(text) {
+        textContent += text;
+        const textPart = ensureTextPart();
+        textPart.text = textContent;
+        emitUpdate();
+      },
+      onToolCallStart(toolCallId, toolName) {
+        const tracker = {
+          toolCallId,
+          toolName,
+          argsText: "",
+          args: void 0,
+          state: "partial-call"
+        };
+        toolCalls.set(toolCallId, tracker);
+        const part = {
+          type: "tool-call",
+          toolCallId,
+          toolName,
+          args: void 0,
+          state: "partial-call"
+        };
+        parts.push(part);
+        emitUpdate();
+      },
+      onToolCallDelta(toolCallId, argsTextDelta) {
+        const tracker = toolCalls.get(toolCallId);
+        if (tracker) {
+          tracker.argsText += argsTextDelta;
+          try {
+            tracker.args = JSON.parse(tracker.argsText);
+          } catch {
+          }
+          const idx = findToolPartIndex(toolCallId);
+          if (idx !== -1 && parts[idx].type === "tool-call") {
+            parts[idx].args = tracker.args;
+          }
+          emitUpdate();
+        }
+      },
+      onToolCallComplete(toolCallId, toolName, args) {
+        const tracker = toolCalls.get(toolCallId);
+        if (tracker) {
+          tracker.state = "call";
+          tracker.args = typeof args === "string" ? safeJsonParse(args) : args;
+        } else {
+          toolCalls.set(toolCallId, {
+            toolCallId,
+            toolName,
+            argsText: typeof args === "string" ? args : JSON.stringify(args),
+            args: typeof args === "string" ? safeJsonParse(args) : args,
+            state: "call"
+          });
+        }
+        const idx = findToolPartIndex(toolCallId);
+        if (idx !== -1) {
+          parts[idx].state = "call";
+          parts[idx].toolName = toolName;
+          parts[idx].args = toolCalls.get(toolCallId).args;
+        } else {
+          parts.push({
+            type: "tool-call",
+            toolCallId,
+            toolName,
+            args: toolCalls.get(toolCallId).args,
+            state: "call"
+          });
+        }
+        emitUpdate();
+      },
+      onToolResult(toolCallId, result) {
+        const tracker = toolCalls.get(toolCallId);
+        if (tracker) {
+          tracker.result = result;
+          tracker.state = "result";
+        }
+        const idx = findToolPartIndex(toolCallId);
+        if (idx !== -1) {
+          const existing = parts[idx];
+          const resultPart = {
+            type: "tool-result",
+            toolCallId,
+            toolName: existing.toolName,
+            args: existing.args,
+            result,
+            state: "result"
+          };
+          parts[idx] = resultPart;
+        } else {
+          parts.push({
+            type: "tool-result",
+            toolCallId,
+            toolName: tracker?.toolName || "unknown",
+            args: tracker?.args,
+            result,
+            state: "result"
+          });
+        }
+        emitUpdate();
+      },
+      onError(error) {
+        console.error("[DataStreamParser] stream error:", error);
+      },
+      onStepFinish(_data) {
+        emitUpdate();
+      },
+      onFinish(_data) {
+        emitUpdate();
+      }
+    });
+    return { textContent, parts, toolCalls };
+  }
+  function safeJsonParse(str) {
+    try {
+      return JSON.parse(str);
+    } catch {
+      return str;
+    }
+  }
+
+  const toolDisplayNames = {
+    generateReport: "生成报告",
+    searchKnowledge: "知识库检索",
+    resolveInstanceTargets: "解析实例目标",
+    getHistoryMetrics: "历史数据查询",
+    getRealtimeMetrics: "实时数据查询",
+    queryBitableData: "多维表格查询",
+    searchUser: "搜索用户",
+    createBitableRecord: "创建表格记录",
+    timeTool: "时间工具",
+    loadSkill: "加载技能",
+    executeCommand: "执行命令",
+    dataAnalyzer: "数据分析",
+    dataPredictor: "数据预测"
+  };
+  function useAgentInvoke(options) {
+    const { aiChatbotX, tts, bubble } = options;
+    const sessionTimeoutMs = options.sessionTimeoutMs ?? 12e4;
+    const maxHistoryTurns = options.maxHistoryTurns ?? 10;
+    const isInvoking = vue.ref(false);
+    const currentTextContent = vue.ref("");
+    const currentToolParts = vue.ref([]);
+    const executingTools = vue.ref(/* @__PURE__ */ new Set());
+    const conversationHistory = vue.ref([]);
+    let lastInteractionTime = 0;
+    const checkSessionTimeout = () => {
+      if (lastInteractionTime > 0 && Date.now() - lastInteractionTime > sessionTimeoutMs) {
+        conversationHistory.value = [];
+      }
+    };
+    const appendToHistory = (role, content) => {
+      conversationHistory.value.push({ role, content });
+      const maxLen = maxHistoryTurns * 2;
+      if (conversationHistory.value.length > maxLen) {
+        conversationHistory.value = conversationHistory.value.slice(-maxLen);
+      }
+    };
+    const clearHistory = () => {
+      conversationHistory.value = [];
+    };
+    let abortController = null;
+    const hasAnyContent = vue.computed(() => {
+      return !!(currentTextContent.value || currentToolParts.value.length > 0);
+    });
+    const toolDisplayName = (name) => toolDisplayNames[name] || name;
+    const resetState = () => {
+      currentTextContent.value = "";
+      currentToolParts.value = [];
+      executingTools.value = /* @__PURE__ */ new Set();
+    };
+    const executeHostCommands = async (toolCallId, result) => {
+      if (!result || typeof result !== "object") return;
+      const commands = result.commands;
+      if (!Array.isArray(commands) || commands.length === 0) return;
+      try {
+        executingTools.value = /* @__PURE__ */ new Set([...executingTools.value, toolCallId]);
+        for (const cmd of commands) {
+          const args = Array.isArray(cmd.args) ? cmd.args : [];
+          try {
+            await aiChatbotX.executeCommand(cmd.name, args);
+          } catch (cmdErr) {
+            console.error(`[AgentInvoke] 执行命令 ${cmd.name} 失败:`, cmdErr);
+          }
+        }
+      } finally {
+        const next = new Set(executingTools.value);
+        next.delete(toolCallId);
+        executingTools.value = next;
+      }
+    };
+    const parseAssistantText = (payload) => {
+      if (!payload) return "";
+      if (typeof payload === "string") return payload;
+      if (typeof payload === "object") {
+        const data = payload;
+        const directText = data.output || data.answer || data.message || data.result;
+        if (typeof directText === "string" && directText.trim()) return directText;
+        if (data.data && typeof data.data === "object") {
+          const nested = data.data;
+          const nestedText = nested.output || nested.answer || nested.message || nested.result;
+          if (typeof nestedText === "string" && nestedText.trim()) return nestedText;
+        }
+        return JSON.stringify(payload);
+      }
+      return String(payload);
+    };
+    const invoke = async (question) => {
+      const content = question.trim();
+      if (!content) return;
+      abort();
+      checkSessionTimeout();
+      resetState();
+      tts.stop();
+      isInvoking.value = true;
+      bubble.open();
+      let prevTextLength = 0;
+      const processedToolResults = /* @__PURE__ */ new Set();
+      abortController = new AbortController();
+      const commands = await aiChatbotX.hostCommads();
+      const historyToSend = conversationHistory.value.length > 0 ? [...conversationHistory.value] : void 0;
+      try {
+        const response = await fetch(options.endpoint.value, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            input: content,
+            projectId: options.projectId || "",
+            commands: commands.length > 0 ? commands : void 0,
+            messages: historyToSend
+          }),
+          signal: abortController.signal
+        });
+        if (!response.ok) throw new Error(`HTTP ${response.status}`);
+        const contentType = response.headers.get("content-type") || "";
+        const isJsonResponse = contentType.includes("application/json");
+        if (isJsonResponse) {
+          const data = await response.json();
+          const reply = parseAssistantText(data) || "已收到，但没有返回可展示的文本内容。";
+          currentTextContent.value = reply;
+          tts.speak(reply);
+          appendToHistory("user", content);
+          appendToHistory("assistant", reply);
+          if (data.toolResults && Array.isArray(data.toolResults)) {
+            for (const tr of data.toolResults) {
+              const toolPart = {
+                type: "tool-result",
+                toolCallId: `invoke-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+                toolName: tr.toolName,
+                args: tr.args,
+                result: tr.result,
+                state: "result"
+              };
+              currentToolParts.value = [...currentToolParts.value, toolPart];
+              if (tr.toolName === "executeCommand") {
+                executeHostCommands(toolPart.toolCallId, tr.result);
+              }
+            }
+          }
+        } else {
+          await parseDataStreamToMessage(response, (result) => {
+            currentTextContent.value = result.textContent;
+            if (result.textContent.length > prevTextLength) {
+              const delta = result.textContent.slice(prevTextLength);
+              prevTextLength = result.textContent.length;
+              tts.feed(delta);
+            }
+            const toolParts = result.parts.filter(
+              (p) => p.type === "tool-call" || p.type === "tool-result"
+            );
+            currentToolParts.value = toolParts;
+            for (const part of toolParts) {
+              if (part.toolName === "executeCommand" && !processedToolResults.has(part.toolCallId)) {
+                if (part.type === "tool-call" && part.state === "call" && part.args) {
+                  processedToolResults.add(part.toolCallId);
+                  executeHostCommands(part.toolCallId, part.args);
+                } else if (part.type === "tool-result" && part.result) {
+                  processedToolResults.add(part.toolCallId);
+                  executeHostCommands(part.toolCallId, part.result);
+                }
+              }
+            }
+            bubble.scrollToBottom();
+          });
+          tts.flush();
+          const assistantReply = currentTextContent.value.trim();
+          appendToHistory("user", content);
+          if (assistantReply) {
+            appendToHistory("assistant", assistantReply);
+          }
+          if (!assistantReply && currentToolParts.value.length === 0) {
+            currentTextContent.value = "已收到，但没有返回可展示的文本内容。";
+          }
+        }
+      } catch (error) {
+        if (error.name === "AbortError") {
+          return;
+        }
+        console.error("[AgentInvoke] invoke failed:", error);
+        tts.stop();
+        currentTextContent.value = "请求失败，请检查服务地址或稍后重试。";
+      } finally {
+        isInvoking.value = false;
+        abortController = null;
+        lastInteractionTime = Date.now();
+        bubble.scheduleDismiss();
+      }
+    };
+    const abort = () => {
+      if (abortController) {
+        abortController.abort();
+        abortController = null;
+      }
+      tts.stop();
+      isInvoking.value = false;
+    };
+    return {
+      isInvoking,
+      currentTextContent,
+      currentToolParts,
+      executingTools,
+      hasAnyContent,
+      conversationHistory,
+      toolDisplayName,
+      invoke,
+      abort,
+      resetState,
+      clearHistory
+    };
+  }
+
+  const _hoisted_1 = { class: "agent-bubble" };
+  const _hoisted_2 = {
+    key: 0,
+    class: "tool-steps"
+  };
+  const _hoisted_3 = { class: "tool-step__icon" };
+  const _hoisted_4 = {
+    key: 0,
+    class: "tool-step__spinner",
+    width: "14",
+    height: "14",
+    viewBox: "0 0 24 24",
+    fill: "none"
+  };
+  const _hoisted_5 = {
+    key: 1,
+    width: "14",
+    height: "14",
+    viewBox: "0 0 24 24",
+    fill: "none"
+  };
+  const _hoisted_6 = {
+    key: 2,
+    width: "14",
+    height: "14",
+    viewBox: "0 0 24 24",
+    fill: "none"
+  };
+  const _hoisted_7 = { class: "tool-step__name" };
+  const _hoisted_8 = {
+    key: 0,
+    class: "tool-step__tag tool-step__tag--exec"
+  };
+  const _hoisted_9 = {
+    key: 1,
+    class: "thinking-dots"
+  };
+  const _hoisted_10 = {
+    key: 2,
+    class: "agent-text"
+  };
+  const _hoisted_11 = {
+    key: 0,
+    class: "status-pill"
+  };
+  const _hoisted_12 = { class: "fab-avatar-wrapper" };
+  const _hoisted_13 = ["src"];
+  const currentTheme = "dark";
+  const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+    __name: "voice-assistant",
+    props: {
+      xLogo: {},
+      xTitle: {},
+      xSize: {},
+      xTheme: {},
+      wakeWords: {},
+      modelPath: {},
+      projectId: {},
+      invokeUrl: {},
+      voiceConfig: {},
+      bubbleSize: {},
+      bubbleDismissDelay: {}
+    },
+    setup(__props) {
+      const props = __props;
+      const aiChatbotX = injectStrict(AiChatbotXKey);
+      const getVoiceConfig = () => {
+        if (props.voiceConfig) return props.voiceConfig;
+        try {
+          return aiChatbotX.voiceConfig();
+        } catch {
+          return null;
+        }
+      };
+      const endpoint = vue.computed(() => {
+        return props.invokeUrl || "http://localhost:3001/agent/zyy55sw40nrl801056m0o/stream-invoke";
+      });
+      const wakeResponses = ["您好"];
+      const tts = useTTS(getVoiceConfig);
+      const bubbleBridge = {
+        open: () => {
+        },
+        scheduleDismiss: () => {
+        },
+        scrollToBottom: () => {
+        }
+      };
+      const agent = useAgentInvoke({
+        endpoint,
+        projectId: props.projectId,
+        aiChatbotX,
+        tts: {
+          speak: tts.speak,
+          feed: tts.feed,
+          flush: tts.flush,
+          stop: tts.stop
+        },
+        bubble: {
+          open: () => bubbleBridge.open(),
+          scheduleDismiss: () => bubbleBridge.scheduleDismiss(),
+          scrollToBottom: () => bubbleBridge.scrollToBottom()
+        }
+      });
+      const bubble = useBubble({
+        dismissDelay: props.bubbleDismissDelay,
+        isSpeaking: tts.isSpeaking,
+        isInvoking: agent.isInvoking,
+        bubbleSize: props.bubbleSize
+      });
+      bubbleBridge.open = bubble.open;
+      bubbleBridge.scheduleDismiss = bubble.scheduleDismiss;
+      bubbleBridge.scrollToBottom = bubble.scrollToBottom;
+      const { show: showBubble, style: bubbleStyle, stackRef: bubbleStackRef } = bubble;
+      tts.setOnQueueEmpty(() => {
+        if (!agent.isInvoking.value) {
+          bubble.scheduleDismiss();
+        }
+      });
+      const interruptCurrentResponse = () => {
+        agent.abort();
+        agent.resetState();
+        tts.stop();
+        bubble.hide();
+      };
+      const voice = useVoiceRecognition({
+        modelPath: props.modelPath,
+        wakeWords: props.wakeWords,
+        getVoiceConfig,
+        onWake: () => {
+          interruptCurrentResponse();
+          tts.warmUpAudio();
+          const text = wakeResponses[Math.floor(Math.random() * wakeResponses.length)];
+          tts.speak(text);
+        },
+        onTranscriptionDone: (text) => {
+          agent.invoke(text);
+        }
+      });
+      const toggleVoiceMode = async (targetState) => {
+        tts.warmUpAudio();
+        await voice.toggleVoiceMode(targetState);
+      };
+      const { voiceStatus, transcriptionText, wakeAnimating } = voice;
+      const { isInvoking, currentTextContent, currentToolParts, executingTools, hasAnyContent, toolDisplayName } = agent;
+      aiChatbotX?.registerVoiceMethods({
+        start: () => toggleVoiceMode(true),
+        stop: () => toggleVoiceMode(false),
+        openDialog: async () => Promise.resolve(),
+        closeDialog: async () => Promise.resolve(),
+        toggleCollapse: async () => Promise.resolve()
+      });
+      vue.onBeforeUnmount(async () => {
+        bubble.destroy();
+        agent.abort();
+        tts.destroy();
+        await voice.destroy();
+      });
+      return (_ctx, _cache) => {
+        return vue.openBlock(), vue.createElementBlock("div", {
+          class: "voice-assistant",
+          "data-theme": currentTheme
+        }, [
+          vue.createVNode(vue.Transition, { name: "bubble-fade" }, {
+            default: vue.withCtx(() => [
+              vue.unref(showBubble) ? (vue.openBlock(), vue.createElementBlock("div", {
+                key: 0,
+                class: "bubble-stack",
+                ref_key: "bubbleStackRef",
+                ref: bubbleStackRef,
+                style: vue.normalizeStyle(vue.unref(bubbleStyle))
+              }, [
+                vue.createElementVNode("div", _hoisted_1, [
+                  vue.unref(currentToolParts).length > 0 ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2, [
+                    (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(currentToolParts), (toolPart) => {
+                      return vue.openBlock(), vue.createElementBlock("div", {
+                        key: toolPart.toolCallId,
+                        class: vue.normalizeClass(["tool-step", {
+                          "tool-step--loading": toolPart.state === "partial-call" || toolPart.state === "call",
+                          "tool-step--done": toolPart.state === "result",
+                          "tool-step--error": toolPart.state === "error",
+                          "tool-step--executing": vue.unref(executingTools).has(toolPart.toolCallId)
+                        }])
+                      }, [
+                        vue.createElementVNode("span", _hoisted_3, [
+                          toolPart.state === "partial-call" || toolPart.state === "call" ? (vue.openBlock(), vue.createElementBlock("svg", _hoisted_4, [..._cache[1] || (_cache[1] = [
+                            vue.createElementVNode("circle", {
+                              cx: "12",
+                              cy: "12",
+                              r: "10",
+                              stroke: "currentColor",
+                              "stroke-width": "2.5",
+                              "stroke-linecap": "round",
+                              "stroke-dasharray": "31.4 31.4"
+                            }, null, -1)
+                          ])])) : toolPart.state === "result" ? (vue.openBlock(), vue.createElementBlock("svg", _hoisted_5, [..._cache[2] || (_cache[2] = [
+                            vue.createElementVNode("path", {
+                              d: "M20 6L9 17l-5-5",
+                              stroke: "currentColor",
+                              "stroke-width": "2.5",
+                              "stroke-linecap": "round",
+                              "stroke-linejoin": "round"
+                            }, null, -1)
+                          ])])) : toolPart.state === "error" ? (vue.openBlock(), vue.createElementBlock("svg", _hoisted_6, [..._cache[3] || (_cache[3] = [
+                            vue.createElementVNode("circle", {
+                              cx: "12",
+                              cy: "12",
+                              r: "10",
+                              stroke: "currentColor",
+                              "stroke-width": "2"
+                            }, null, -1),
+                            vue.createElementVNode("path", {
+                              d: "M15 9l-6 6M9 9l6 6",
+                              stroke: "currentColor",
+                              "stroke-width": "2",
+                              "stroke-linecap": "round"
+                            }, null, -1)
+                          ])])) : vue.createCommentVNode("", true)
+                        ]),
+                        vue.createElementVNode("span", _hoisted_7, vue.toDisplayString(vue.unref(toolDisplayName)(toolPart.toolName)), 1),
+                        vue.unref(executingTools).has(toolPart.toolCallId) ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_8, "命令执行中")) : vue.createCommentVNode("", true)
+                      ], 2);
+                    }), 128))
+                  ])) : vue.createCommentVNode("", true),
+                  vue.unref(isInvoking) && !vue.unref(hasAnyContent) ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_9, [..._cache[4] || (_cache[4] = [
+                    vue.createElementVNode("span", null, null, -1),
+                    vue.createElementVNode("span", null, null, -1),
+                    vue.createElementVNode("span", null, null, -1)
+                  ])])) : vue.createCommentVNode("", true),
+                  vue.unref(currentTextContent) ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_10, vue.toDisplayString(vue.unref(currentTextContent)), 1)) : vue.createCommentVNode("", true)
+                ])
+              ], 4)) : vue.createCommentVNode("", true)
+            ]),
+            _: 1
+          }),
+          vue.createElementVNode("div", {
+            class: "assistant-fab",
+            onClick: _cache[0] || (_cache[0] = ($event) => toggleVoiceMode())
+          }, [
+            vue.unref(transcriptionText) || vue.unref(isInvoking) ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_11, vue.toDisplayString(vue.unref(isInvoking) ? "正在思考中..." : vue.unref(transcriptionText)), 1)) : vue.createCommentVNode("", true),
+            vue.createElementVNode("div", _hoisted_12, [
+              vue.createElementVNode("img", {
+                src: __props.xLogo ? __props.xLogo : "/sime.png",
+                alt: "voice assistant",
+                style: vue.normalizeStyle({
+                  width: `${__props.xSize?.width || 88}px`
+                })
+              }, null, 12, _hoisted_13),
+              vue.createVNode(vue.Transition, { name: "indicator-fade" }, {
+                default: vue.withCtx(() => [
+                  vue.unref(voiceStatus) === "listening" ? (vue.openBlock(), vue.createElementBlock("div", {
+                    key: 0,
+                    class: vue.normalizeClass(["listening-badge", { "wake-active": vue.unref(wakeAnimating) }])
+                  }, [..._cache[5] || (_cache[5] = [
+                    vue.createElementVNode("div", { class: "listening-waves" }, [
+                      vue.createElementVNode("div", { class: "wave wave-1" }),
+                      vue.createElementVNode("div", { class: "wave wave-2" }),
+                      vue.createElementVNode("div", { class: "wave wave-3" })
+                    ], -1),
+                    vue.createElementVNode("div", { class: "listening-icon" }, [
+                      vue.createElementVNode("svg", {
+                        width: "22",
+                        height: "22",
+                        viewBox: "0 0 24 24",
+                        fill: "none"
+                      }, [
+                        vue.createElementVNode("path", {
+                          d: "M12 14c1.66 0 3-1.34 3-3V5c0-1.66-1.34-3-3-3S9 3.34 9 5v6c0 1.66 1.34 3 3 3z",
+                          fill: "currentColor"
+                        }),
+                        vue.createElementVNode("path", {
+                          d: "M17 11c0 2.76-2.24 5-5 5s-5-2.24-5-5",
+                          stroke: "currentColor",
+                          "stroke-width": "2",
+                          "stroke-linecap": "round"
+                        })
+                      ])
+                    ], -1)
+                  ])], 2)) : vue.createCommentVNode("", true)
+                ]),
+                _: 1
+              })
+            ])
+          ])
+        ]);
       };
     }
   });
 
-  const simeX = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-84e3f35e"]]);
+  const voiceAssistant = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-9e420a26"]]);
 
-  exports.AiChatbotProvider = _sfc_main$3;
+  exports.AiChatbotProvider = _sfc_main$4;
+  exports.AiChatbotVoiceAssistant = voiceAssistant;
   exports.AiChatbotX = simeX;
   exports.AiChatbotXKey = AiChatbotXKey;
   exports.clientCommandKey = clientCommandKey;