@siact/sime-x-vue 0.0.2

package/dist/sime-x-vue.mjs

@@ -0,0 +1,1033 @@
+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 { HostBridge } from '@siact/sime-bridge';
+import { WakeWordDetectorStandalone, SpeechTranscriberStandalone } from 'web-voice-kit';
+
+const AiChatbotXKey = Symbol("sime-x");
+function injectStrict(key, defaultValue, treatDefaultAsFactory) {
+  let result;
+  if (defaultValue === void 0) {
+    result = inject(key);
+  } else if (treatDefaultAsFactory === true) {
+    result = inject(key, defaultValue, true);
+  } else {
+    result = inject(key, defaultValue, false);
+  }
+  if (!result) {
+    throw new Error(`Could not resolve ${key.description}`);
+  }
+  return result;
+}
+
+var clientCommandKey = /* @__PURE__ */ ((clientCommandKey2) => {
+  clientCommandKey2["SET_THEME"] = "SiMeAgent_setTheme";
+  clientCommandKey2["APPEND_MESSAGE"] = "SiMeAgent_appendMessage";
+  clientCommandKey2["WAKE"] = "SiMeAgent_wake";
+  clientCommandKey2["TRANSITION"] = "SiMeAgent_transition";
+  clientCommandKey2["TRANSITION_END"] = "SiMeAgent_transition_end";
+  clientCommandKey2["START_NEW_CONVERSATION"] = "SiMeAgent_startNewConversation";
+  clientCommandKey2["RECOGNITION"] = "SiMeAgent_recognition";
+  return clientCommandKey2;
+})(clientCommandKey || {});
+
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  __name: "sime-provider",
+  props: {
+    project: {},
+    description: {},
+    debug: { type: Boolean },
+    chatbotUrl: {},
+    appId: {},
+    appToken: {},
+    voiceConfig: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const hostBridge = shallowRef(new HostBridge());
+    const startListeningRef = shallowRef(async () => {
+    });
+    const stopListeningRef = shallowRef(async () => {
+    });
+    const toggleCollapseRef = shallowRef(async () => {
+    });
+    const openDialogRef = shallowRef(async () => {
+    });
+    const closeDialogRef = shallowRef(async () => {
+    });
+    provide(AiChatbotXKey, {
+      chatbotUrl: () => props.chatbotUrl,
+      appId: () => props.appId,
+      appToken: () => props.appToken,
+      voiceConfig: () => props.voiceConfig,
+      startListening: () => startListeningRef.value(),
+      stopListening: () => stopListeningRef.value(),
+      toggleCollapse: () => toggleCollapseRef.value(),
+      openDialog: () => openDialogRef.value(),
+      closeDialog: () => closeDialogRef.value(),
+      registerVoiceMethods: (methods) => {
+        startListeningRef.value = methods.start;
+        stopListeningRef.value = methods.stop;
+        toggleCollapseRef.value = methods.toggleCollapse;
+        openDialogRef.value = methods.openDialog;
+        closeDialogRef.value = methods.closeDialog;
+      },
+      clientCommand: () => hostBridge.value.clientCommands(),
+      hostCommads: () => hostBridge.value.hostCommands(),
+      registerCommand: (cmd) => {
+        hostBridge.value.registerCommand(cmd);
+      },
+      unregisterCommand: (name) => {
+        hostBridge.value.unregisterCommand(name);
+      },
+      async appendMessage(message) {
+        await hostBridge.value.executeClientCommand(clientCommandKey.APPEND_MESSAGE, [message]);
+      },
+      async setTheme(theme) {
+        await hostBridge.value.executeClientCommand(clientCommandKey.SET_THEME, [theme]);
+      },
+      async weak() {
+        await hostBridge.value.executeClientCommand(clientCommandKey.WAKE);
+      },
+      async startNewConversation() {
+        await hostBridge.value.executeClientCommand(clientCommandKey.START_NEW_CONVERSATION);
+      },
+      setIframeElement(iframe) {
+        hostBridge.value.setIframe(iframe);
+      },
+      async recognition(message, commands) {
+        return await hostBridge.value.executeClientCommand(clientCommandKey.RECOGNITION, [message, commands]);
+      },
+      async executeCommand(commandName, args = []) {
+        return await hostBridge.value.executeCommand(commandName, args);
+      }
+    });
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default");
+    };
+  }
+});
+
+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 = {
+  key: 0,
+  class: "transcription-content"
+};
+const _hoisted_5$1 = {
+  key: 1,
+  class: "placeholder-text"
+};
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "voice-status",
+  props: {
+    status: {},
+    transcriptionText: {},
+    isTranscribing: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const currentMode = computed(() => {
+      if (props.isTranscribing) return "mode-transcribing";
+      if (props.status === "wake") return "mode-wake";
+      return "mode-standby";
+    });
+    const statusLabel = computed(() => {
+      if (props.isTranscribing) return "正在聆听您的问题...";
+      if (props.status === "wake") return "您好，有什么可以帮助您的吗？";
+      return "Standby";
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Transition, { name: "voice-panel" }, {
+        default: withCtx(() => [
+          __props.status === "wake" || __props.isTranscribing ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            class: normalizeClass(["voice-status-wrapper", currentMode.value])
+          }, [
+            _cache[0] || (_cache[0] = createElementVNode("div", { class: "indicator-container" }, [
+              createElementVNode("div", { class: "ambient-glow" }),
+              createElementVNode("div", { class: "ripple-layer" }, [
+                createElementVNode("div", { class: "ripple delay-1" }),
+                createElementVNode("div", { class: "ripple delay-2" }),
+                createElementVNode("div", { class: "ripple delay-3" })
+              ]),
+              createElementVNode("div", { class: "icon-core" }, [
+                createElementVNode("svg", {
+                  class: "mic-icon",
+                  viewBox: "0 0 24 24",
+                  fill: "none",
+                  stroke: "currentColor",
+                  "stroke-width": "2",
+                  "stroke-linecap": "round",
+                  "stroke-linejoin": "round"
+                }, [
+                  createElementVNode("rect", {
+                    x: "9",
+                    y: "2",
+                    width: "6",
+                    height: "12",
+                    rx: "3",
+                    class: "mic-capsule"
+                  }),
+                  createElementVNode("path", {
+                    d: "M5 10C5 13.866 8.13401 17 12 17C15.866 17 19 13.866 19 10",
+                    class: "mic-stand"
+                  }),
+                  createElementVNode("path", {
+                    d: "M12 17V21M8 21H16",
+                    class: "mic-base"
+                  })
+                ])
+              ])
+            ], -1)),
+            createElementVNode("div", _hoisted_1$2, [
+              createElementVNode("div", _hoisted_2$2, [
+                createElementVNode("span", _hoisted_3$1, toDisplayString(statusLabel.value), 1)
+              ]),
+              createElementVNode("div", {
+                class: normalizeClass(["text-window", { "has-text": !!__props.transcriptionText }])
+              }, [
+                createVNode(Transition, {
+                  name: "fade-slide",
+                  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)
+                  ]),
+                  _: 1
+                })
+              ], 2)
+            ])
+          ], 2)) : createCommentVNode("", true)
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+
+const VoiceStatus = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-c9fa6caf"]]);
+
+const _hoisted_1$1 = {
+  key: 0,
+  class: "execution-bubble"
+};
+const _hoisted_2$1 = { class: "exec-text" };
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "execution-status",
+  props: {
+    visible: { type: Boolean },
+    text: {}
+  },
+  setup(__props) {
+    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),
+            _cache[0] || (_cache[0] = createElementVNode("div", { class: "loading-dots" }, [
+              createElementVNode("span", { class: "dot" }),
+              createElementVNode("span", { class: "dot" }),
+              createElementVNode("span", { class: "dot" })
+            ], -1))
+          ])) : createCommentVNode("", true)
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+
+const ExecutionStatus = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-8244ff0d"]]);
+
+const ensureMicrophonePermission = async () => {
+  if (typeof navigator === "undefined" || typeof window === "undefined") {
+    console.log("当前环境不支持麦克风访问");
+    return false;
+  }
+  if (!navigator.mediaDevices?.getUserMedia || !navigator.mediaDevices?.enumerateDevices) {
+    console.log("当前环境不支持麦克风访问");
+    return false;
+  }
+  try {
+    const devices = await navigator.mediaDevices.enumerateDevices();
+    const audioInputDevices = devices.filter((device) => device.kind === "audioinput");
+    if (audioInputDevices.length === 0) {
+      console.log("未检测到麦克风设备，请连接麦克风后重试。");
+      return false;
+    }
+    if ("permissions" in navigator && navigator.permissions?.query) {
+      try {
+        const status = await navigator.permissions.query({ name: "microphone" });
+        if (status.state === "denied") {
+          console.log("麦克风权限被禁用，请在浏览器设置中开启。");
+          return false;
+        }
+      } catch (e) {
+        console.warn("Permission query not supported:", e);
+      }
+    }
+    let stream = null;
+    try {
+      stream = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          echoCancellation: true,
+          noiseSuppression: true,
+          autoGainControl: true
+        }
+      });
+      const audioTracks = stream.getAudioTracks();
+      if (audioTracks.length === 0) {
+        console.log("无法获取麦克风音频轨道。");
+        return false;
+      }
+      const activeTrack = audioTracks[0];
+      if (!activeTrack.enabled || activeTrack.readyState !== "live") {
+        console.log("麦克风设备不可用，请检查设备连接。");
+        return false;
+      }
+      return true;
+    } finally {
+      if (stream) {
+        stream.getTracks().forEach((track) => track.stop());
+      }
+    }
+  } catch (error) {
+    console.error("Microphone permission check failed", error);
+    if (error.name === "NotFoundError" || error.name === "DevicesNotFoundError") {
+      console.log("未检测到麦克风设备，请连接麦克风后重试。");
+    } else if (error.name === "NotAllowedError" || error.name === "PermissionDeniedError") {
+      console.log("麦克风权限被拒绝，请在浏览器设置中允许访问。");
+    } else if (error.name === "NotReadableError" || error.name === "TrackStartError") {
+      console.log("麦克风被其他应用占用或无法访问。");
+    } else {
+      console.log("无法访问麦克风，请检查设备连接和浏览器权限。");
+    }
+    return false;
+  }
+};
+
+const _hoisted_1 = ["data-theme"];
+const _hoisted_2 = { class: "fab-avatar-wrapper" };
+const _hoisted_3 = ["src"];
+const _hoisted_4 = {
+  key: 0,
+  class: "listening-badge"
+};
+const _hoisted_5 = { class: "header-left" };
+const _hoisted_6 = { class: "logo-icon" };
+const _hoisted_7 = ["src"];
+const _hoisted_8 = { class: "title" };
+const _hoisted_9 = { class: "actions" };
+const _hoisted_10 = ["title"];
+const _hoisted_11 = {
+  key: 0,
+  class: "voice-indicator"
+};
+const _hoisted_12 = ["title"];
+const _hoisted_13 = ["title"];
+const _hoisted_14 = {
+  width: "16",
+  height: "16",
+  viewBox: "0 0 24 24",
+  fill: "none"
+};
+const _hoisted_15 = ["d"];
+const _hoisted_16 = ["src"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "sime-x",
+  props: {
+    xLogo: {},
+    xSize: {},
+    xTitle: {},
+    xTheme: {},
+    xDialogSize: {},
+    wakeWords: {},
+    modelPath: {}
+  },
+  emits: ["start-transcribing", "stop-transcribing"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const aiChatbotX = injectStrict(AiChatbotXKey);
+    const chatbotUrl = ref("");
+    const voiceStatus = ref("standby");
+    const transcriptionText = ref("");
+    const isTranscribing = ref(false);
+    const isProcessing = ref(false);
+    const visible = ref(false);
+    const isCollapsed = ref(false);
+    const fabRef = ref(null);
+    const positionReady = ref(false);
+    let detector = null;
+    let transcriber = null;
+    const isInitializing = ref(false);
+    const initError = ref("");
+    const getSystemTheme = () => {
+      return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+    };
+    const currentTheme = ref(props.xTheme === "system" ? getSystemTheme() : props.xTheme || "light");
+    const cycleTheme = async () => {
+      currentTheme.value = currentTheme.value === "light" ? "dark" : "light";
+      aiChatbotX.setTheme(currentTheme.value);
+    };
+    const startNewConversation = () => {
+      aiChatbotX.startNewConversation();
+    };
+    const themeTooltip = computed(() => currentTheme.value === "light" ? "切换到深色模式" : "切换到浅色模式");
+    const voiceButtonTooltip = computed(() => {
+      if (isInitializing.value) return "初始化中...";
+      if (initError.value) return `错误: ${initError.value}`;
+      switch (voiceStatus.value) {
+        case "standby":
+          return "开启语音监听";
+        case "listening":
+          return "监听中，等待唤醒词...";
+        case "wake":
+          return "已唤醒！";
+        default:
+          return "语音监听";
+      }
+    });
+    if (props.xTheme === "system") {
+      const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+      const handleThemeChange = (e) => {
+        currentTheme.value = e.matches ? "dark" : "light";
+      };
+      mediaQuery.addEventListener("change", handleThemeChange);
+      onBeforeUnmount(() => {
+        mediaQuery.removeEventListener("change", handleThemeChange);
+      });
+    }
+    const initVoiceDetector = () => {
+      if (detector || isInitializing.value) return;
+      isInitializing.value = true;
+      initError.value = "";
+      if (!props.modelPath) {
+        initError.value = "未提供语音模型文件";
+        isInitializing.value = false;
+        return;
+      }
+      try {
+        detector = new WakeWordDetectorStandalone({
+          modelPath: props.modelPath,
+          sampleRate: 16e3,
+          usePartial: true,
+          autoReset: {
+            enabled: true,
+            resetDelayMs: 5e3
+          }
+        });
+        const wakeWords = props.wakeWords || ["你好", "您好"];
+        detector.setWakeWords(wakeWords);
+        detector.onWake(() => {
+          console.log("[VoiceDetector] 检测到唤醒词");
+          voiceStatus.value = "wake";
+          transcriptionText.value = "";
+          isTranscribing.value = false;
+          startTranscribing();
+        });
+        detector.onError((error) => {
+          console.error("[VoiceDetector] 错误:", error);
+          initError.value = error.message;
+          voiceStatus.value = "standby";
+          isTranscribing.value = false;
+          if (error.message.includes("permission")) {
+            transcriptionText.value = "需要麦克风权限";
+          } else if (error.message.includes("model")) {
+            transcriptionText.value = "模型加载失败";
+          } else {
+            transcriptionText.value = "初始化失败";
+          }
+          setTimeout(() => {
+            transcriptionText.value = "";
+          }, 3e3);
+        });
+        console.log("[VoiceDetector] 初始化成功");
+      } catch (error) {
+        console.error("[VoiceDetector] 初始化失败:", error);
+        initError.value = error instanceof Error ? error.message : "初始化失败";
+        voiceStatus.value = "standby";
+        isTranscribing.value = false;
+      } finally {
+        isInitializing.value = false;
+      }
+    };
+    function initTranscriber() {
+      if (transcriber) return;
+      try {
+        const { appId, apiKey, websocketUrl } = aiChatbotX.voiceConfig();
+        if (!appId || !apiKey || !websocketUrl) {
+          initError.value = "未配置语音配置";
+          voiceStatus.value = "standby";
+          isTranscribing.value = false;
+          return;
+        }
+        transcriber = new SpeechTranscriberStandalone({
+          appId,
+          apiKey,
+          websocketUrl,
+          autoStop: {
+            enabled: true,
+            silenceTimeoutMs: 3e3,
+            noSpeechTimeoutMs: 5e3,
+            maxDurationMs: 6e4
+          }
+        });
+        transcriber.onResult((result) => {
+          transcriptionText.value = result.transcript;
+        });
+        transcriber.onAutoStop(async () => {
+          console.log("[Transcriber] Auto Stop");
+          const currentText = transcriptionText.value;
+          await stopTranscribing();
+          if (!currentText || !currentText.trim()) {
+            console.log("[Transcriber] No transcription text, returning to listening");
+            transcriptionText.value = "";
+            voiceStatus.value = "listening";
+            return;
+          }
+          isProcessing.value = true;
+          transcriptionText.value = currentText;
+          try {
+            const commands = await aiChatbotX.hostCommads();
+            const result = await aiChatbotX.recognition(currentText, commands);
+            if (result?.data?.intent === "command" && result?.data?.matchedCommands) {
+              const matchedCommands = result.data.matchedCommands;
+              for (const cmd of matchedCommands) {
+                try {
+                  const args = cmd.parameters ? Object.values(cmd.parameters) : [];
+                  const cmdResult = await aiChatbotX.executeCommand(cmd.name, args);
+                  console.log(`Command ${cmd.name} executed successfully:`, cmdResult);
+                } catch (error) {
+                  console.error(`Failed to execute command ${cmd.name}:`, error);
+                }
+              }
+            } else {
+              aiChatbotX.appendMessage(currentText);
+              toggleDialog(true);
+            }
+          } finally {
+            isProcessing.value = false;
+            transcriptionText.value = "";
+            voiceStatus.value = "listening";
+          }
+        });
+        transcriber.onError((error) => {
+          console.error("[Transcriber] Error:", error);
+          stopTranscribing();
+          transcriptionText.value = "转写错误";
+          setTimeout(() => {
+            transcriptionText.value = "";
+            voiceStatus.value = "listening";
+          }, 2e3);
+        });
+        console.log("[Transcriber] 初始化成功");
+      } catch (error) {
+        console.error("[Transcriber] 初始化失败:", error);
+        voiceStatus.value = "standby";
+        initError.value = error instanceof Error ? error.message : "转写初始化失败";
+      }
+    }
+    const startTranscribing = async () => {
+      if (!transcriber) {
+        initTranscriber();
+        if (!transcriber) return;
+      }
+      try {
+        emit("start-transcribing");
+        await transcriber.start();
+        isTranscribing.value = true;
+        transcriptionText.value = "";
+      } catch (error) {
+        console.error("[Transcriber] 启动失败:", error);
+        transcriptionText.value = "转写启动失败";
+        setTimeout(() => {
+          transcriptionText.value = "";
+        }, 2e3);
+      }
+    };
+    const stopTranscribing = async () => {
+      if (transcriber && transcriber.isActive()) {
+        try {
+          await transcriber.stop();
+          isTranscribing.value = false;
+          emit("stop-transcribing");
+        } catch (error) {
+          console.error("[Transcriber] 停止失败:", error);
+        }
+      }
+    };
+    const toggleVoiceMode = async (targetState) => {
+      const permission = await ensureMicrophonePermission();
+      if (!permission) return;
+      if (isInitializing.value) return;
+      if (!detector) {
+        await initVoiceDetector();
+        if (!detector) return;
+      }
+      const isCurrentlyListening = voiceStatus.value === "listening";
+      const shouldStart = targetState !== void 0 ? targetState : !isCurrentlyListening;
+      if (shouldStart === isCurrentlyListening) return;
+      try {
+        if (shouldStart) {
+          console.log("[VoiceDetector] 强制/自动启动监听...");
+          await detector.start();
+          voiceStatus.value = "listening";
+          transcriptionText.value = "";
+          isTranscribing.value = false;
+        } else {
+          console.log("[VoiceDetector] 强制/自动停止监听...");
+          await detector.stop();
+          stopTranscribing();
+          voiceStatus.value = "standby";
+          transcriptionText.value = "";
+          isTranscribing.value = false;
+        }
+      } catch (error) {
+        console.error("[VoiceDetector] 操作失败:", error);
+        voiceStatus.value = "standby";
+        transcriptionText.value = "操作失败";
+        isTranscribing.value = false;
+        setTimeout(() => {
+          transcriptionText.value = "";
+        }, 2e3);
+      }
+    };
+    const position = reactive({ x: 0, y: 0 });
+    const containerWidth = ref(props.xDialogSize?.width || 420);
+    const containerHeight = ref(props.xDialogSize?.height || 600);
+    const isFirstOpen = ref(true);
+    const validatePosition = (x, y, width, height) => {
+      const margin = 20;
+      const viewportWidth = window.innerWidth;
+      const viewportHeight = window.innerHeight;
+      const maxX = viewportWidth - width - margin;
+      const maxY = viewportHeight - height - margin;
+      return {
+        x: Math.max(margin, Math.min(x, maxX)),
+        y: Math.max(margin, Math.min(y, maxY))
+      };
+    };
+    const calculateInitialPosition = () => {
+      if (!fabRef.value) return;
+      const fabRect = fabRef.value.getBoundingClientRect();
+      const dialogWidth = containerWidth.value;
+      const dialogHeight = containerHeight.value;
+      const viewportWidth = window.innerWidth;
+      const viewportHeight = window.innerHeight;
+      const margin = 20;
+      const minMargin = 20;
+      let x = 0;
+      let y = 0;
+      const leftX = fabRect.left - dialogWidth - margin;
+      if (leftX >= minMargin) {
+        x = leftX;
+        y = fabRect.top;
+        if (y + dialogHeight > viewportHeight - minMargin) {
+          y = viewportHeight - dialogHeight - minMargin;
+        }
+        if (y < minMargin) {
+          y = minMargin;
+        }
+      } else {
+        const rightX = fabRect.right + margin;
+        if (rightX + dialogWidth <= viewportWidth - minMargin) {
+          x = rightX;
+          y = fabRect.top;
+          if (y + dialogHeight > viewportHeight - minMargin) {
+            y = viewportHeight - dialogHeight - minMargin;
+          }
+          if (y < minMargin) {
+            y = minMargin;
+          }
+        } else {
+          x = (viewportWidth - dialogWidth) / 2;
+          const aboveY = fabRect.top - dialogHeight - margin;
+          if (aboveY >= minMargin) {
+            y = aboveY;
+          } else {
+            const belowY = fabRect.bottom + margin;
+            if (belowY + dialogHeight <= viewportHeight - minMargin) {
+              y = belowY;
+            } else {
+              y = (viewportHeight - dialogHeight) / 2;
+            }
+          }
+        }
+      }
+      const validated = validatePosition(x, y, dialogWidth, dialogHeight);
+      position.x = validated.x;
+      position.y = validated.y;
+    };
+    const toggleCollapse = async () => {
+      isCollapsed.value = !isCollapsed.value;
+      nextTick(() => {
+        const currentHeight = isCollapsed.value ? 60 : containerHeight.value;
+        const validated = validatePosition(position.x, position.y, containerWidth.value, currentHeight);
+        position.x = validated.x;
+        position.y = validated.y;
+      });
+    };
+    const drag = reactive({
+      isDragging: false,
+      startX: 0,
+      startY: 0,
+      offsetX: 0,
+      offsetY: 0
+    });
+    const startDrag = (e) => {
+      drag.isDragging = true;
+      drag.startX = e.clientX;
+      drag.startY = e.clientY;
+      drag.offsetX = position.x;
+      drag.offsetY = position.y;
+      document.addEventListener("mousemove", onDrag);
+      document.addEventListener("mouseup", stopDrag);
+    };
+    const onDrag = (e) => {
+      if (!drag.isDragging) return;
+      const newX = drag.offsetX + (e.clientX - drag.startX);
+      const newY = drag.offsetY + (e.clientY - drag.startY);
+      const validated = validatePosition(newX, newY, containerWidth.value, isCollapsed.value ? 60 : containerHeight.value);
+      position.x = validated.x;
+      position.y = validated.y;
+    };
+    const stopDrag = () => {
+      drag.isDragging = false;
+      document.removeEventListener("mousemove", onDrag);
+      document.removeEventListener("mouseup", stopDrag);
+    };
+    const toggleDialog = async (state) => {
+      if (state) {
+        visible.value = true;
+        positionReady.value = false;
+        await nextTick();
+        if (isFirstOpen.value) {
+          calculateInitialPosition();
+          isFirstOpen.value = false;
+        } else {
+          const validated = validatePosition(
+            position.x,
+            position.y,
+            containerWidth.value,
+            isCollapsed.value ? 60 : containerHeight.value
+          );
+          position.x = validated.x;
+          position.y = validated.y;
+        }
+        await nextTick();
+        positionReady.value = true;
+      } else {
+        positionReady.value = false;
+        visible.value = false;
+        isCollapsed.value = false;
+      }
+    };
+    const handleIframeLoad = (event) => {
+      aiChatbotX.setIframeElement(event.target);
+      aiChatbotX.setTheme("dark");
+    };
+    watch(
+      () => [aiChatbotX.chatbotUrl()],
+      ([url]) => {
+        console.log("[AiChatbotX] 初始化", url);
+        if (url) {
+          chatbotUrl.value = `${url}/app/${aiChatbotX.appId()}?token=${aiChatbotX.appToken()}`;
+        }
+      },
+      { immediate: true }
+    );
+    onBeforeUnmount(async () => {
+      if (detector) {
+        try {
+          if (detector.isActive()) {
+            await detector.stop();
+          }
+          detector = null;
+        } catch (error) {
+          console.error("[VoiceDetector] 清理失败:", error);
+        }
+      }
+      if (transcriber) {
+        try {
+          if (transcriber.isActive()) {
+            await transcriber.stop();
+          }
+          transcriber = null;
+        } catch (error) {
+          console.error("[Transcriber] 清理失败:", error);
+        }
+      }
+    });
+    aiChatbotX?.registerVoiceMethods({
+      start: () => toggleVoiceMode(true),
+      stop: () => toggleVoiceMode(false),
+      openDialog: () => toggleDialog(true),
+      closeDialog: () => toggleDialog(false),
+      toggleCollapse: () => toggleCollapse()
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: "sime-x",
+        "data-theme": currentTheme.value
+      }, [
+        createVNode(Transition, { name: "fade" }, {
+          default: withCtx(() => [
+            createElementVNode("div", {
+              ref_key: "fabRef",
+              ref: fabRef,
+              class: "assistant-fab",
+              onClick: _cache[0] || (_cache[0] = ($event) => toggleDialog(true))
+            }, [
+              !isProcessing.value ? (openBlock(), createBlock(VoiceStatus, {
+                key: 0,
+                class: "voice-status",
+                status: voiceStatus.value,
+                "transcription-text": transcriptionText.value,
+                "is-transcribing": isTranscribing.value,
+                style: { "width": "480px" }
+              }, null, 8, ["status", "transcription-text", "is-transcribing"])) : (openBlock(), createBlock(ExecutionStatus, {
+                key: 1,
+                class: "voice-status",
+                visible: isProcessing.value,
+                text: transcriptionText.value
+              }, null, 8, ["visible", "text"])),
+              createElementVNode("div", _hoisted_2, [
+                createElementVNode("img", {
+                  src: __props.xLogo ? __props.xLogo : "/sime.png",
+                  alt: "assistant",
+                  style: normalizeStyle({
+                    width: __props.xSize?.width + "px"
+                  })
+                }, null, 12, _hoisted_3),
+                createVNode(Transition, { name: "indicator-fade" }, {
+                  default: withCtx(() => [
+                    voiceStatus.value === "listening" ? (openBlock(), createElementBlock("div", _hoisted_4, [..._cache[3] || (_cache[3] = [
+                      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: "24",
+                          height: "24",
+                          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)
+                    ])])) : createCommentVNode("", true)
+                  ]),
+                  _: 1
+                })
+              ]),
+              createElementVNode("div", {
+                class: normalizeClass(["fab-pulse", { active: voiceStatus.value === "listening" }])
+              }, null, 2)
+            ], 512)
+          ]),
+          _: 1
+        }),
+        createVNode(Transition, { name: "dialog-fade" }, {
+          default: withCtx(() => [
+            createElementVNode("div", {
+              ref: "dialogRef",
+              class: normalizeClass(["x-dialog-container", {
+                collapsed: isCollapsed.value,
+                "is-hidden": !visible.value,
+                "position-ready": positionReady.value
+              }]),
+              style: normalizeStyle({
+                width: containerWidth.value + "px",
+                height: isCollapsed.value ? "auto" : containerHeight.value + "px",
+                border: currentTheme.value === "light" && !isCollapsed.value ? "1px solid var(--border-color)" : "none",
+                "--dialog-x": position.x + "px",
+                "--dialog-y": position.y + "px"
+              }),
+              onMousedown: startDrag
+            }, [
+              createElementVNode("div", {
+                class: "x-dialog-header",
+                onMousedown: withModifiers(startDrag, ["stop"])
+              }, [
+                createElementVNode("div", _hoisted_5, [
+                  createElementVNode("div", _hoisted_6, [
+                    createElementVNode("img", {
+                      src: __props.xLogo ? __props.xLogo : "/sime.png",
+                      alt: "assistant",
+                      class: "logo"
+                    }, null, 8, _hoisted_7)
+                  ]),
+                  createElementVNode("span", _hoisted_8, toDisplayString(__props.xTitle), 1)
+                ]),
+                createElementVNode("div", _hoisted_9, [
+                  createElementVNode("button", {
+                    class: "action-btn theme-btn",
+                    title: "开启新对话",
+                    onClick: startNewConversation
+                  }, [..._cache[4] || (_cache[4] = [
+                    createElementVNode("svg", {
+                      width: "16",
+                      height: "16",
+                      viewBox: "0 0 24 24",
+                      fill: "none"
+                    }, [
+                      createElementVNode("path", {
+                        d: "M12 5v14M5 12h14",
+                        stroke: "currentColor",
+                        "stroke-width": "2",
+                        "stroke-linecap": "round"
+                      })
+                    ], -1)
+                  ])]),
+                  createElementVNode("button", {
+                    class: normalizeClass(["action-btn theme-btn", {
+                      active: voiceStatus.value !== "standby",
+                      listening: voiceStatus.value === "listening",
+                      woke: voiceStatus.value === "wake"
+                    }]),
+                    onClick: _cache[1] || (_cache[1] = withModifiers(() => toggleVoiceMode(), ["stop"])),
+                    title: voiceButtonTooltip.value
+                  }, [
+                    _cache[5] || (_cache[5] = createElementVNode("svg", {
+                      width: "16",
+                      height: "16",
+                      viewBox: "0 0 24 24",
+                      fill: "none"
+                    }, [
+                      createElementVNode("path", {
+                        d: "M12 15C13.6569 15 15 13.6569 15 12V7C15 5.34315 13.6569 4 12 4C10.3431 4 9 5.34315 9 7V12C9 13.6569 10.3431 15 12 15Z",
+                        stroke: "currentColor",
+                        "stroke-width": "2",
+                        "stroke-linecap": "round",
+                        "stroke-linejoin": "round"
+                      }),
+                      createElementVNode("path", {
+                        d: "M18 11C18 14.3137 15.3137 17 12 17C8.68629 17 6 14.3137 6 11",
+                        stroke: "currentColor",
+                        "stroke-width": "2",
+                        "stroke-linecap": "round",
+                        "stroke-linejoin": "round"
+                      }),
+                      createElementVNode("path", {
+                        d: "M12 19V17",
+                        stroke: "currentColor",
+                        "stroke-width": "2",
+                        "stroke-linecap": "round",
+                        "stroke-linejoin": "round"
+                      }),
+                      createElementVNode("path", {
+                        d: "M9 21H15",
+                        stroke: "currentColor",
+                        "stroke-width": "2",
+                        "stroke-linecap": "round",
+                        "stroke-linejoin": "round"
+                      })
+                    ], -1)),
+                    voiceStatus.value !== "standby" ? (openBlock(), createElementBlock("span", _hoisted_11)) : createCommentVNode("", true)
+                  ], 10, _hoisted_10),
+                  createElementVNode("button", {
+                    class: "action-btn theme-btn",
+                    onClick: withModifiers(cycleTheme, ["stop"]),
+                    title: themeTooltip.value
+                  }, [..._cache[6] || (_cache[6] = [
+                    createElementVNode("svg", {
+                      width: "16",
+                      height: "16",
+                      viewBox: "0 0 24 24",
+                      fill: "none"
+                    }, [
+                      createElementVNode("circle", {
+                        cx: "12",
+                        cy: "12",
+                        r: "7",
+                        stroke: "currentColor",
+                        "stroke-width": "2"
+                      }),
+                      createElementVNode("path", {
+                        d: "M12 5A7 7 0 1 1 12 19",
+                        fill: "currentColor"
+                      })
+                    ], -1)
+                  ])], 8, _hoisted_12),
+                  createElementVNode("button", {
+                    class: "action-btn collapse-btn",
+                    onClick: withModifiers(toggleCollapse, ["stop"]),
+                    title: isCollapsed.value ? "展开" : "折叠"
+                  }, [
+                    (openBlock(), createElementBlock("svg", _hoisted_14, [
+                      createElementVNode("path", {
+                        d: isCollapsed.value ? "M18 15L12 9L6 15" : "M6 9L12 15L18 9",
+                        stroke: "currentColor",
+                        "stroke-width": "2",
+                        "stroke-linecap": "round",
+                        "stroke-linejoin": "round"
+                      }, null, 8, _hoisted_15)
+                    ]))
+                  ], 8, _hoisted_13),
+                  createElementVNode("button", {
+                    class: "action-btn minimize-btn",
+                    onClick: _cache[2] || (_cache[2] = withModifiers(($event) => toggleDialog(false), ["stop"])),
+                    title: "最小化"
+                  }, [..._cache[7] || (_cache[7] = [
+                    createElementVNode("svg", {
+                      width: "16",
+                      height: "16",
+                      viewBox: "0 0 24 24",
+                      fill: "none"
+                    }, [
+                      createElementVNode("path", {
+                        d: "M5 12H19",
+                        stroke: "currentColor",
+                        "stroke-width": "2",
+                        "stroke-linecap": "round"
+                      })
+                    ], -1)
+                  ])])
+                ])
+              ], 32),
+              createElementVNode("div", {
+                class: normalizeClass(["x-dialog-content", { "is-hidden": isCollapsed.value }]),
+                style: normalizeStyle({ opacity: isCollapsed.value ? 0 : 1 })
+              }, [
+                createElementVNode("iframe", {
+                  ref: "iframeRef",
+                  src: chatbotUrl.value,
+                  class: "x-iframe",
+                  allow: "microphone",
+                  frameborder: "0",
+                  onLoad: handleIframeLoad
+                }, null, 40, _hoisted_16)
+              ], 6)
+            ], 38)
+          ]),
+          _: 1
+        })
+      ], 8, _hoisted_1);
+    };
+  }
+});
+
+const simeX = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-d8f992b0"]]);
+
+export { _sfc_main$3 as AiChatbotProvider, simeX as AiChatbotX, AiChatbotXKey, clientCommandKey, injectStrict };
+//# sourceMappingURL=sime-x-vue.mjs.map