@siact/sime-x-vue 0.0.7 → 0.0.8

package/dist/sime-x-vue.mjs

@@ -1,6 +1,6 @@
-import { inject, defineComponent, shallowRef, provide, renderSlot, computed, openBlock, createBlock, Transition, withCtx, createElementBlock, normalizeClass, createElementVNode, toDisplayString, createVNode, createCommentVNode, ref, onBeforeUnmount, reactive, watch, normalizeStyle, withModifiers, nextTick } from 'vue';
+import { inject, defineComponent, shallowRef, provide, renderSlot, computed, openBlock, createBlock, Transition, withCtx, createElementBlock, normalizeClass, createElementVNode, toDisplayString, createVNode, createCommentVNode, ref, onBeforeUnmount, reactive, watch, normalizeStyle, withModifiers, nextTick, unref, Fragment, renderList } from 'vue';
 import { HostBridge } from '@siact/sime-bridge';
-import { WakeWordDetectorStandalone } from 'web-voice-kit';
+import { WakeWordDetectorStandalone, SpeechSynthesizerStandalone, SpeechTranscriberStandalone } from 'web-voice-kit';
 
 const AiChatbotXKey = Symbol("sime-x");
 function injectStrict(key, defaultValue, treatDefaultAsFactory) {
@@ -29,7 +29,7 @@ var clientCommandKey = /* @__PURE__ */ ((clientCommandKey2) => {
   return clientCommandKey2;
 })(clientCommandKey || {});
 
-const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+const _sfc_main$4 = /* @__PURE__ */ defineComponent({
   __name: "sime-provider",
   props: {
     project: {},
@@ -42,7 +42,7 @@ const _sfc_main$3 = /* @__PURE__ */ defineComponent({
   },
   setup(__props) {
     const props = __props;
-    const hostBridge = shallowRef(new HostBridge());
+    const hostBridge = shallowRef(new HostBridge({ debug: false }));
     const startListeningRef = shallowRef(async () => {
     });
     const stopListeningRef = shallowRef(async () => {
@@ -57,7 +57,7 @@ const _sfc_main$3 = /* @__PURE__ */ defineComponent({
       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(),
@@ -106,18 +106,18 @@ const _sfc_main$3 = /* @__PURE__ */ defineComponent({
   }
 });
 
-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__ */ defineComponent({
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
   __name: "voice-status",
   props: {
     status: {},
@@ -179,9 +179,9 @@ const _sfc_main$2 = /* @__PURE__ */ defineComponent({
                 ])
               ])
             ], -1)),
-            createElementVNode("div", _hoisted_1$2, [
-              createElementVNode("div", _hoisted_2$2, [
-                createElementVNode("span", _hoisted_3$1, toDisplayString(statusLabel.value), 1)
+            createElementVNode("div", _hoisted_1$3, [
+              createElementVNode("div", _hoisted_2$3, [
+                createElementVNode("span", _hoisted_3$2, toDisplayString(statusLabel.value), 1)
               ]),
               createElementVNode("div", {
                 class: normalizeClass(["text-window", { "has-text": !!__props.transcriptionText }])
@@ -191,7 +191,7 @@ const _sfc_main$2 = /* @__PURE__ */ defineComponent({
                   mode: "out-in"
                 }, {
                   default: withCtx(() => [
-                    __props.transcriptionText ? (openBlock(), createElementBlock("p", _hoisted_4$1, toDisplayString(__props.transcriptionText), 1)) : __props.status === "wake" ? (openBlock(), createElementBlock("p", _hoisted_5$1, "Listening...")) : createCommentVNode("", true)
+                    __props.transcriptionText ? (openBlock(), createElementBlock("p", _hoisted_4$2, toDisplayString(__props.transcriptionText), 1)) : __props.status === "wake" ? (openBlock(), createElementBlock("p", _hoisted_5$2, "Listening...")) : createCommentVNode("", true)
                   ]),
                   _: 1
                 })
@@ -213,14 +213,14 @@ const _export_sfc = (sfc, props) => {
   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__ */ defineComponent({
+const _hoisted_2$2 = { class: "exec-text" };
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
   __name: "execution-status",
   props: {
     visible: { type: Boolean },
@@ -230,8 +230,8 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent({
     return (_ctx, _cache) => {
       return openBlock(), createBlock(Transition, { name: "exec-bubble" }, {
         default: withCtx(() => [
-          __props.visible ? (openBlock(), createElementBlock("div", _hoisted_1$1, [
-            createElementVNode("span", _hoisted_2$1, toDisplayString(__props.text || "执行中"), 1),
+          __props.visible ? (openBlock(), createElementBlock("div", _hoisted_1$2, [
+            createElementVNode("span", _hoisted_2$2, toDisplayString(__props.text || "执行中"), 1),
             _cache[0] || (_cache[0] = createElementVNode("div", { class: "loading-dots" }, [
               createElementVNode("span", { class: "dot" }),
               createElementVNode("span", { class: "dot" }),
@@ -245,7 +245,7 @@ const _sfc_main$1 = /* @__PURE__ */ defineComponent({
   }
 });
 
-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") {
@@ -314,22 +314,22 @@ const ensureMicrophonePermission = async () => {
   }
 };
 
-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",
@@ -338,7 +338,7 @@ const _hoisted_13 = {
 const _hoisted_14 = ["d"];
 const _hoisted_15 = ["src"];
 const FAB_SAFE_GAP = 24;
-const _sfc_main = /* @__PURE__ */ defineComponent({
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
   __name: "sime-x",
   props: {
     xLogo: {},
@@ -704,9 +704,9 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         emit("wakeUp", false);
       }
     };
-    const handleIframeLoad = (event) => {
+    const handleIframeLoad = async (event) => {
       aiChatbotX.setIframeElement(event.target);
-      aiChatbotX.setTheme("dark");
+      aiChatbotX.setTheme(currentTheme.value);
     };
     watch(
       () => [aiChatbotX.chatbotUrl()],
@@ -763,14 +763,14 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                 visible: isProcessing.value,
                 text: transcriptionText.value
               }, null, 8, ["visible", "text"])),
-              createElementVNode("div", _hoisted_2, [
+              createElementVNode("div", _hoisted_2$1, [
                 createElementVNode("img", {
                   src: __props.xLogo ? __props.xLogo : "/sime.png",
                   alt: "assistant",
                   style: normalizeStyle({
                     width: __props.xSize?.width + "px"
                   })
-                }, null, 12, _hoisted_3),
+                }, null, 12, _hoisted_3$1),
                 createVNode(Transition, { name: "indicator-fade" }, {
                   default: withCtx(() => [
                     voiceStatus.value === "listening" ? (openBlock(), createElementBlock("div", {
@@ -835,17 +835,17 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                 class: "x-dialog-header",
                 onMousedown: withModifiers(startDrag, ["stop"])
               }, [
-                createElementVNode("div", _hoisted_4, [
-                  createElementVNode("div", _hoisted_5, [
+                createElementVNode("div", _hoisted_4$1, [
+                  createElementVNode("div", _hoisted_5$1, [
                     createElementVNode("img", {
                       src: __props.xLogo ? __props.xLogo : "/sime.png",
                       alt: "assistant",
                       class: "logo"
-                    }, null, 8, _hoisted_6)
+                    }, null, 8, _hoisted_6$1)
                   ]),
-                  createElementVNode("span", _hoisted_7, toDisplayString(__props.xTitle), 1)
+                  createElementVNode("span", _hoisted_7$1, toDisplayString(__props.xTitle), 1)
                 ]),
-                createElementVNode("div", _hoisted_8, [
+                createElementVNode("div", _hoisted_8$1, [
                   createElementVNode("button", {
                     class: "action-btn theme-btn",
                     title: "开启新对话",
@@ -909,8 +909,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                         "stroke-linejoin": "round"
                       })
                     ], -1)),
-                    voiceStatus.value !== "standby" ? (openBlock(), createElementBlock("span", _hoisted_10)) : createCommentVNode("", true)
-                  ], 10, _hoisted_9),
+                    voiceStatus.value !== "standby" ? (openBlock(), createElementBlock("span", _hoisted_10$1)) : createCommentVNode("", true)
+                  ], 10, _hoisted_9$1),
                   createElementVNode("button", {
                     class: "action-btn theme-btn",
                     onClick: withModifiers(cycleTheme, ["stop"]),
@@ -934,13 +934,13 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                         fill: "currentColor"
                       })
                     ], -1)
-                  ])], 8, _hoisted_11),
+                  ])], 8, _hoisted_11$1),
                   createElementVNode("button", {
                     class: "action-btn collapse-btn",
                     onClick: withModifiers(toggleCollapse, ["stop"]),
                     title: isCollapsed.value ? "展开" : "折叠"
                   }, [
-                    (openBlock(), createElementBlock("svg", _hoisted_13, [
+                    (openBlock(), createElementBlock("svg", _hoisted_13$1, [
                       createElementVNode("path", {
                         d: isCollapsed.value ? "M18 15L12 9L6 15" : "M6 9L12 15L18 9",
                         stroke: "currentColor",
@@ -949,7 +949,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                         "stroke-linejoin": "round"
                       }, null, 8, _hoisted_14)
                     ]))
-                  ], 8, _hoisted_12),
+                  ], 8, _hoisted_12$1),
                   createElementVNode("button", {
                     class: "action-btn minimize-btn",
                     onClick: _cache[2] || (_cache[2] = withModifiers(($event) => toggleDialog(false), ["stop"])),
@@ -988,12 +988,1222 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
           ]),
           _: 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 = 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 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 = ref(false);
+  const fadingOut = ref(false);
+  const stackRef = ref(null);
+  let dismissTimer = null;
+  const show = computed(() => visible.value && !fadingOut.value);
+  const style = 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 = () => {
+    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 = ref("standby");
+  const isTranscribing = ref(false);
+  const isInitializing = ref(false);
+  const transcriptionText = ref("");
+  const wakeAnimating = 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 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 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 = ref(false);
+  const currentTextContent = ref("");
+  const currentToolParts = ref([]);
+  const executingTools = ref(/* @__PURE__ */ new Set());
+  const conversationHistory = 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 = 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__ */ 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 = 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()
+    });
+    onBeforeUnmount(async () => {
+      bubble.destroy();
+      agent.abort();
+      tts.destroy();
+      await voice.destroy();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: "voice-assistant",
+        "data-theme": currentTheme
+      }, [
+        createVNode(Transition, { name: "bubble-fade" }, {
+          default: withCtx(() => [
+            unref(showBubble) ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: "bubble-stack",
+              ref_key: "bubbleStackRef",
+              ref: bubbleStackRef,
+              style: normalizeStyle(unref(bubbleStyle))
+            }, [
+              createElementVNode("div", _hoisted_1, [
+                unref(currentToolParts).length > 0 ? (openBlock(), createElementBlock("div", _hoisted_2, [
+                  (openBlock(true), createElementBlock(Fragment, null, renderList(unref(currentToolParts), (toolPart) => {
+                    return openBlock(), createElementBlock("div", {
+                      key: toolPart.toolCallId,
+                      class: 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": unref(executingTools).has(toolPart.toolCallId)
+                      }])
+                    }, [
+                      createElementVNode("span", _hoisted_3, [
+                        toolPart.state === "partial-call" || toolPart.state === "call" ? (openBlock(), createElementBlock("svg", _hoisted_4, [..._cache[1] || (_cache[1] = [
+                          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" ? (openBlock(), createElementBlock("svg", _hoisted_5, [..._cache[2] || (_cache[2] = [
+                          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" ? (openBlock(), createElementBlock("svg", _hoisted_6, [..._cache[3] || (_cache[3] = [
+                          createElementVNode("circle", {
+                            cx: "12",
+                            cy: "12",
+                            r: "10",
+                            stroke: "currentColor",
+                            "stroke-width": "2"
+                          }, null, -1),
+                          createElementVNode("path", {
+                            d: "M15 9l-6 6M9 9l6 6",
+                            stroke: "currentColor",
+                            "stroke-width": "2",
+                            "stroke-linecap": "round"
+                          }, null, -1)
+                        ])])) : createCommentVNode("", true)
+                      ]),
+                      createElementVNode("span", _hoisted_7, toDisplayString(unref(toolDisplayName)(toolPart.toolName)), 1),
+                      unref(executingTools).has(toolPart.toolCallId) ? (openBlock(), createElementBlock("span", _hoisted_8, "命令执行中")) : createCommentVNode("", true)
+                    ], 2);
+                  }), 128))
+                ])) : createCommentVNode("", true),
+                unref(isInvoking) && !unref(hasAnyContent) ? (openBlock(), createElementBlock("div", _hoisted_9, [..._cache[4] || (_cache[4] = [
+                  createElementVNode("span", null, null, -1),
+                  createElementVNode("span", null, null, -1),
+                  createElementVNode("span", null, null, -1)
+                ])])) : createCommentVNode("", true),
+                unref(currentTextContent) ? (openBlock(), createElementBlock("div", _hoisted_10, toDisplayString(unref(currentTextContent)), 1)) : createCommentVNode("", true)
+              ])
+            ], 4)) : createCommentVNode("", true)
+          ]),
+          _: 1
+        }),
+        createElementVNode("div", {
+          class: "assistant-fab",
+          onClick: _cache[0] || (_cache[0] = ($event) => toggleVoiceMode())
+        }, [
+          unref(transcriptionText) || unref(isInvoking) ? (openBlock(), createElementBlock("div", _hoisted_11, toDisplayString(unref(isInvoking) ? "正在思考中..." : unref(transcriptionText)), 1)) : createCommentVNode("", true),
+          createElementVNode("div", _hoisted_12, [
+            createElementVNode("img", {
+              src: __props.xLogo ? __props.xLogo : "/sime.png",
+              alt: "voice assistant",
+              style: normalizeStyle({
+                width: `${__props.xSize?.width || 88}px`
+              })
+            }, null, 12, _hoisted_13),
+            createVNode(Transition, { name: "indicator-fade" }, {
+              default: withCtx(() => [
+                unref(voiceStatus) === "listening" ? (openBlock(), createElementBlock("div", {
+                  key: 0,
+                  class: normalizeClass(["listening-badge", { "wake-active": unref(wakeAnimating) }])
+                }, [..._cache[5] || (_cache[5] = [
+                  createElementVNode("div", { class: "listening-waves" }, [
+                    createElementVNode("div", { class: "wave wave-1" }),
+                    createElementVNode("div", { class: "wave wave-2" }),
+                    createElementVNode("div", { class: "wave wave-3" })
+                  ], -1),
+                  createElementVNode("div", { class: "listening-icon" }, [
+                    createElementVNode("svg", {
+                      width: "22",
+                      height: "22",
+                      viewBox: "0 0 24 24",
+                      fill: "none"
+                    }, [
+                      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"
+                      }),
+                      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)) : 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"]]);
 
-export { _sfc_main$3 as AiChatbotProvider, simeX as AiChatbotX, AiChatbotXKey, clientCommandKey, injectStrict };
+export { _sfc_main$4 as AiChatbotProvider, voiceAssistant as AiChatbotVoiceAssistant, simeX as AiChatbotX, AiChatbotXKey, clientCommandKey, injectStrict };
 //# sourceMappingURL=sime-x-vue.mjs.map