@siact/sime-x-vue 0.0.10 → 0.0.12

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

@@ -1,1005 +1,810 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue'), require('@siact/sime-bridge'), require('web-voice-kit')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'vue', '@siact/sime-bridge', 'web-voice-kit'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SimeXVue = {}, global.Vue, global.simeBridge, global.webVoiceKit));
-})(this, (function (exports, vue, simeBridge, webVoiceKit) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue'), require('@ai-sdk/vue'), require('ai'), require('web-voice-kit')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'vue', '@ai-sdk/vue', 'ai', 'web-voice-kit'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SimeXVue = {}, global.Vue, global.AiSdkVue, global.AI, global.WebVoiceKit));
+})(this, (function (exports, vue, vue$1, ai, webVoiceKit) { 'use strict';
 
-  const AiChatbotXKey = Symbol("sime-x");
-  function injectStrict(key, defaultValue, treatDefaultAsFactory) {
-    let result;
-    if (defaultValue === void 0) {
-      result = vue.inject(key);
-    } else if (treatDefaultAsFactory === true) {
-      result = vue.inject(key, defaultValue, true);
-    } else {
-      result = vue.inject(key, defaultValue, false);
-    }
-    if (!result) {
-      throw new Error(`Could not resolve ${key.description}`);
-    }
-    return result;
+  function createAgentChatTransport(options) {
+    const { api, projectId, getCommands, headers: extraHeaders, body: extraBody } = options;
+    return new ai.DefaultChatTransport({
+      api,
+      headers: extraHeaders,
+      prepareSendMessagesRequest({ messages }) {
+        const lastUserMessage = findLastUserMessage(messages);
+        const input = lastUserMessage ? lastUserMessage.parts.filter((p) => p.type === "text").map((p) => p.text).join("") : "";
+        const historyMessages = buildHistoryMessages(messages, lastUserMessage?.id);
+        const resolvedExtraBody = typeof extraBody === "function" ? extraBody() : extraBody || {};
+        return {
+          body: {
+            input,
+            projectId: projectId || "",
+            messages: historyMessages.length > 0 ? historyMessages : void 0,
+            ...resolvedExtraBody
+          }
+        };
+      }
+    });
   }
-
-  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$4 = /* @__PURE__ */ vue.defineComponent({
-    __name: "sime-provider",
-    props: {
-      project: {},
-      description: {},
-      debug: { type: Boolean },
-      chatbotUrl: {},
-      appId: {},
-      appToken: {},
-      voiceConfig: {}
-    },
-    setup(__props) {
-      const props = __props;
-      const hostBridge = vue.shallowRef(new simeBridge.HostBridge({ debug: false }));
-      const startListeningRef = vue.shallowRef(async () => {
-      });
-      const stopListeningRef = vue.shallowRef(async () => {
-      });
-      const stopBroadcastRef = vue.shallowRef(async () => {
-      });
-      const toggleCollapseRef = vue.shallowRef(async () => {
-      });
-      const openDialogRef = vue.shallowRef(async () => {
-      });
-      const closeDialogRef = vue.shallowRef(async () => {
-      });
-      vue.provide(AiChatbotXKey, {
-        chatbotUrl: () => props.chatbotUrl,
-        appId: () => props.appId,
-        appToken: () => props.appToken,
-        voiceConfig: () => props.voiceConfig || { appId: "", apiKey: "", websocketUrl: "" },
-        startListening: () => startListeningRef.value(),
-        stopListening: () => stopListeningRef.value(),
-        stopBroadcast: () => stopBroadcastRef.value(),
-        toggleCollapse: () => toggleCollapseRef.value(),
-        openDialog: () => openDialogRef.value(),
-        closeDialog: () => closeDialogRef.value(),
-        registerVoiceMethods: (methods) => {
-          startListeningRef.value = methods.start;
-          stopListeningRef.value = methods.stop;
-          if (methods.stopBroadcast) stopBroadcastRef.value = methods.stopBroadcast;
-          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);
+  class AgentChatTransport extends ai.DefaultChatTransport {
+    agentOptions;
+    constructor(options) {
+      const { api, headers: extraHeaders, body: extraBody, projectId } = options;
+      super({
+        api,
+        headers: extraHeaders,
+        prepareSendMessagesRequest({ messages }) {
+          const lastUserMessage = findLastUserMessage(messages);
+          const input = lastUserMessage ? lastUserMessage.parts.filter((p) => p.type === "text").map((p) => p.text).join("") : "";
+          const historyMessages = buildHistoryMessages(messages, lastUserMessage?.id);
+          const resolvedExtraBody = typeof extraBody === "function" ? extraBody() : extraBody || {};
+          return {
+            body: {
+              input,
+              projectId: projectId || "",
+              messages: historyMessages.length > 0 ? historyMessages : void 0,
+              ...resolvedExtraBody
+            }
+          };
         }
       });
-      return (_ctx, _cache) => {
-        return vue.renderSlot(_ctx.$slots, "default");
-      };
-    }
-  });
-
-  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$2 = {
-    key: 1,
-    class: "placeholder-text"
-  };
-  const _sfc_main$3 = /* @__PURE__ */ vue.defineComponent({
-    __name: "voice-status",
-    props: {
-      status: {},
-      transcriptionText: {},
-      isTranscribing: { type: Boolean }
-    },
-    setup(__props) {
-      const props = __props;
-      const currentMode = vue.computed(() => {
-        if (props.isTranscribing) return "mode-transcribing";
-        if (props.status === "wake") return "mode-wake";
-        return "mode-standby";
-      });
-      const statusLabel = vue.computed(() => {
-        if (props.isTranscribing) return "正在聆听您的问题...";
-        if (props.status === "wake") return "您好，有什么可以帮助您的吗？";
-        return "Standby";
-      });
-      return (_ctx, _cache) => {
-        return vue.openBlock(), vue.createBlock(vue.Transition, { name: "voice-panel" }, {
-          default: vue.withCtx(() => [
-            __props.status === "wake" || __props.isTranscribing ? (vue.openBlock(), vue.createElementBlock("div", {
-              key: 0,
-              class: vue.normalizeClass(["voice-status-wrapper", currentMode.value])
-            }, [
-              _cache[0] || (_cache[0] = vue.createElementVNode("div", { class: "indicator-container" }, [
-                vue.createElementVNode("div", { class: "ambient-glow" }),
-                vue.createElementVNode("div", { class: "ripple-layer" }, [
-                  vue.createElementVNode("div", { class: "ripple delay-1" }),
-                  vue.createElementVNode("div", { class: "ripple delay-2" }),
-                  vue.createElementVNode("div", { class: "ripple delay-3" })
-                ]),
-                vue.createElementVNode("div", { class: "icon-core" }, [
-                  vue.createElementVNode("svg", {
-                    class: "mic-icon",
-                    viewBox: "0 0 24 24",
-                    fill: "none",
-                    stroke: "currentColor",
-                    "stroke-width": "2",
-                    "stroke-linecap": "round",
-                    "stroke-linejoin": "round"
-                  }, [
-                    vue.createElementVNode("rect", {
-                      x: "9",
-                      y: "2",
-                      width: "6",
-                      height: "12",
-                      rx: "3",
-                      class: "mic-capsule"
-                    }),
-                    vue.createElementVNode("path", {
-                      d: "M5 10C5 13.866 8.13401 17 12 17C15.866 17 19 13.866 19 10",
-                      class: "mic-stand"
-                    }),
-                    vue.createElementVNode("path", {
-                      d: "M12 17V21M8 21H16",
-                      class: "mic-base"
-                    })
-                  ])
-                ])
-              ], -1)),
-              vue.createElementVNode("div", _hoisted_1$3, [
-                vue.createElementVNode("div", _hoisted_2$3, [
-                  vue.createElementVNode("span", _hoisted_3$2, vue.toDisplayString(statusLabel.value), 1)
-                ]),
-                vue.createElementVNode("div", {
-                  class: vue.normalizeClass(["text-window", { "has-text": !!__props.transcriptionText }])
-                }, [
-                  vue.createVNode(vue.Transition, {
-                    name: "fade-slide",
-                    mode: "out-in"
-                  }, {
-                    default: vue.withCtx(() => [
-                      __props.transcriptionText ? (vue.openBlock(), vue.createElementBlock("p", _hoisted_4$2, vue.toDisplayString(__props.transcriptionText), 1)) : __props.status === "wake" ? (vue.openBlock(), vue.createElementBlock("p", _hoisted_5$2, "Listening...")) : vue.createCommentVNode("", true)
-                    ]),
-                    _: 1
-                  })
-                ], 2)
-              ])
-            ], 2)) : vue.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$3, [["__scopeId", "data-v-c9fa6caf"]]);
-
-  const _hoisted_1$2 = {
-    key: 0,
-    class: "execution-bubble"
-  };
-  const _hoisted_2$2 = { class: "exec-text" };
-  const _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
-    __name: "execution-status",
-    props: {
-      visible: { type: Boolean },
-      text: {}
-    },
-    setup(__props) {
-      return (_ctx, _cache) => {
-        return vue.openBlock(), vue.createBlock(vue.Transition, { name: "exec-bubble" }, {
-          default: vue.withCtx(() => [
-            __props.visible ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$2, [
-              vue.createElementVNode("span", _hoisted_2$2, vue.toDisplayString(__props.text || "执行中"), 1),
-              _cache[0] || (_cache[0] = vue.createElementVNode("div", { class: "loading-dots" }, [
-                vue.createElementVNode("span", { class: "dot" }),
-                vue.createElementVNode("span", { class: "dot" }),
-                vue.createElementVNode("span", { class: "dot" })
-              ], -1))
-            ])) : vue.createCommentVNode("", true)
-          ]),
-          _: 1
-        });
-      };
-    }
-  });
-
-  const ExecutionStatus = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__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;
+      this.agentOptions = options;
     }
-    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) {
+    async sendMessages(options) {
+      if (this.agentOptions.getCommands) {
         try {
-          const status = await navigator.permissions.query({ name: "microphone" });
-          if (status.state === "denied") {
-            console.log("麦克风权限被禁用，请在浏览器设置中开启。");
-            return false;
+          const commands = await this.agentOptions.getCommands();
+          if (commands && commands.length > 0) {
+            options.body = {
+              ...options.body || {},
+              commands
+            };
           }
-        } catch (e) {
-          console.warn("Permission query not supported:", e);
+        } catch {
         }
       }
-      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());
-        }
+      return super.sendMessages(options);
+    }
+  }
+  function findLastUserMessage(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+      if (messages[i].role === "user") {
+        return messages[i];
       }
-    } 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 void 0;
+  }
+  function buildHistoryMessages(messages, excludeId) {
+    const history = [];
+    for (const msg of messages) {
+      if (msg.id === excludeId) continue;
+      if (msg.role !== "user" && msg.role !== "assistant") continue;
+      const textContent = msg.parts.filter((p) => p.type === "text").map((p) => p.text).join("");
+      if (textContent.trim()) {
+        history.push({
+          role: msg.role,
+          content: textContent
+        });
       }
-      return false;
     }
-  };
+    return history;
+  }
 
-  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 = {
+  const _hoisted_1$1 = {
     key: 0,
-    class: "voice-indicator"
+    class: "ai-chat__welcome"
   };
-  const _hoisted_11$1 = ["title"];
-  const _hoisted_12$1 = ["title"];
+  const _hoisted_2$1 = { class: "ai-chat__welcome-header" };
+  const _hoisted_3$1 = { class: "ai-chat__welcome-title" };
+  const _hoisted_4$1 = { class: "ai-chat__welcome-desc" };
+  const _hoisted_5$1 = { class: "ai-chat__input-area" };
+  const _hoisted_6$1 = { class: "ai-chat__input-wrapper" };
+  const _hoisted_7$1 = ["disabled"];
+  const _hoisted_8$1 = {
+    key: 0,
+    class: "ai-chat__suggestions"
+  };
+  const _hoisted_9$1 = ["onClick"];
+  const _hoisted_10$1 = { class: "ai-chat__messages-inner" };
+  const _hoisted_11$1 = { class: "ai-chat__message-content" };
+  const _hoisted_12$1 = ["innerHTML"];
   const _hoisted_13$1 = {
-    width: "16",
-    height: "16",
+    key: 1,
+    class: "ai-chat__reasoning"
+  };
+  const _hoisted_14 = ["onClick"];
+  const _hoisted_15 = {
+    key: 0,
+    class: "ai-chat__reasoning-streaming"
+  };
+  const _hoisted_16 = {
+    key: 0,
+    class: "ai-chat__reasoning-content"
+  };
+  const _hoisted_17 = {
+    key: 2,
+    class: "ai-chat__tool"
+  };
+  const _hoisted_18 = { class: "ai-chat__tool-icon" };
+  const _hoisted_19 = {
+    key: 0,
+    class: "ai-chat__tool-spinner",
+    width: "14",
+    height: "14",
     viewBox: "0 0 24 24",
     fill: "none"
   };
-  const _hoisted_14 = ["d"];
-  const _hoisted_15 = ["src"];
-  const FAB_SAFE_GAP = 24;
-  const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
-    __name: "sime-x",
+  const _hoisted_20 = {
+    key: 1,
+    width: "14",
+    height: "14",
+    viewBox: "0 0 24 24",
+    fill: "none"
+  };
+  const _hoisted_21 = {
+    key: 2,
+    width: "14",
+    height: "14",
+    viewBox: "0 0 24 24",
+    fill: "none"
+  };
+  const _hoisted_22 = { class: "ai-chat__tool-name" };
+  const _hoisted_23 = {
+    key: 0,
+    class: "ai-chat__message-actions"
+  };
+  const _hoisted_24 = ["onClick"];
+  const _hoisted_25 = ["onClick"];
+  const _hoisted_26 = {
+    key: 0,
+    width: "12",
+    height: "12",
+    viewBox: "0 0 24 24",
+    fill: "none",
+    stroke: "currentColor",
+    "stroke-width": "2",
+    "stroke-linecap": "round",
+    "stroke-linejoin": "round"
+  };
+  const _hoisted_27 = {
+    key: 1,
+    width: "12",
+    height: "12",
+    viewBox: "0 0 24 24",
+    fill: "none",
+    stroke: "currentColor",
+    "stroke-width": "2",
+    "stroke-linecap": "round",
+    "stroke-linejoin": "round"
+  };
+  const _hoisted_28 = {
+    key: 0,
+    class: "ai-chat__thinking"
+  };
+  const _hoisted_29 = {
+    key: 0,
+    class: "ai-chat__input-area ai-chat__input-area--bottom"
+  };
+  const _hoisted_30 = { class: "ai-chat__input-wrapper" };
+  const _hoisted_31 = ["disabled"];
+  const _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
+    __name: "ai-chat",
     props: {
-      xLogo: {},
-      xSize: {},
-      xTitle: {},
-      xTheme: {},
-      xDialogSize: {},
-      wakeWords: {},
-      modelPath: {}
+      api: {},
+      projectId: {},
+      isReadonly: { type: Boolean, default: false },
+      welcomeTitle: { default: "你好，有什么可以帮助你的吗？" },
+      welcomeDescription: { default: "我可以帮你回答问题、分析数据、生成报告等。" },
+      suggestions: { default: () => [] },
+      fullWidth: { type: Boolean, default: false },
+      toolNames: { default: () => ({}) },
+      transportOptions: {},
+      headers: {},
+      body: {}
     },
-    emits: ["start-transcribing", "stop-transcribing", "wakeUp"],
-    setup(__props, { emit: __emit }) {
+    emits: ["error", "finish"],
+    setup(__props, { expose: __expose, emit: __emit }) {
+      const toolDisplayNames = {
+        generateReport: "生成报告",
+        searchKnowledge: "知识库检索",
+        resolveInstanceTargets: "解析实例目标",
+        getHistoryMetrics: "历史数据查询",
+        getRealtimeMetrics: "实时数据查询",
+        queryBitableData: "多维表格查询",
+        searchUser: "搜索用户",
+        createBitableRecord: "创建表格记录",
+        timeTool: "时间工具",
+        loadSkill: "加载技能",
+        executeCommand: "执行命令",
+        dataAnalyzer: "数据分析",
+        dataPredictor: "数据预测"
+      };
       const props = __props;
       const emit = __emit;
-      const aiChatbotX = injectStrict(AiChatbotXKey);
-      const chatbotUrl = vue.ref("");
-      const voiceStatus = vue.ref("standby");
-      const wakeAnimating = vue.ref(false);
-      const wakeResponses = ["在呢", "在的", "我在", "您好", "在呢，请说"];
-      const transcriptionText = vue.ref("");
-      const isTranscribing = vue.ref(false);
-      const isProcessing = vue.ref(false);
-      const visible = vue.ref(false);
-      const isCollapsed = vue.ref(false);
-      const fabRef = vue.ref(null);
-      const positionReady = vue.ref(false);
-      let detector = null;
-      const isInitializing = vue.ref(false);
-      const initError = vue.ref("");
-      const getSystemTheme = () => {
-        return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
-      };
-      const currentTheme = vue.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 = vue.computed(() => currentTheme.value === "light" ? "切换到深色模式" : "切换到浅色模式");
-      const voiceButtonTooltip = vue.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 "语音监听";
+      const transport = new AgentChatTransport({
+        api: props.api,
+        projectId: props.projectId,
+        headers: props.headers,
+        body: props.body,
+        ...props.transportOptions
+      });
+      const chat = new vue$1.Chat({
+        transport,
+        onError: (error) => {
+          console.error("[AiChat] error:", error);
+          emit("error", error instanceof Error ? error : new Error(String(error)));
+        },
+        onFinish: ({ message }) => {
+          emit("finish", message);
         }
       });
-      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);
-        vue.onBeforeUnmount(() => {
-          mediaQuery.removeEventListener("change", handleThemeChange);
+      const inputText = vue.ref("");
+      const textareaRef = vue.ref(null);
+      const messagesContainerRef = vue.ref(null);
+      const showScrollButton = vue.ref(false);
+      const copiedId = vue.ref(null);
+      const reasoningOpen = vue.reactive({});
+      const isEmpty = vue.computed(() => chat.messages.length === 0);
+      const isLoading = vue.computed(() => chat.status === "streaming" || chat.status === "submitted");
+      const scrollToBottom = () => {
+        vue.nextTick(() => {
+          const el = messagesContainerRef.value;
+          if (el) {
+            el.scrollTop = el.scrollHeight;
+          }
         });
-      }
-      const initVoiceDetector = () => {
-        if (detector || isInitializing.value) return;
-        isInitializing.value = true;
-        initError.value = "";
-        if (!props.modelPath) {
-          initError.value = "未提供语音模型文件";
-          isInitializing.value = false;
-          return;
-        }
-        try {
-          detector = new webVoiceKit.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] 检测到唤醒词");
-            wakeAnimating.value = true;
-            playWakeResponse();
-            emit("wakeUp", true);
-            aiChatbotX.weak();
-            aiChatbotX.openDialog();
-            setTimeout(() => {
-              wakeAnimating.value = false;
-            }, 1500);
-            voiceStatus.value = "listening";
-          });
-          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;
-        }
       };
-      const playWakeResponse = () => {
-        try {
-          if (typeof window === "undefined" || !window.speechSynthesis) {
-            console.warn("[TTS] SpeechSynthesis API 不可用");
-            return;
+      const handleScroll = () => {
+        const el = messagesContainerRef.value;
+        if (!el) return;
+        const threshold = 100;
+        showScrollButton.value = el.scrollHeight - el.scrollTop - el.clientHeight > threshold;
+      };
+      vue.watch(
+        () => chat.messages.length,
+        () => {
+          if (!showScrollButton.value) {
+            scrollToBottom();
           }
-          const text = wakeResponses[Math.floor(Math.random() * wakeResponses.length)];
-          const utterance = new SpeechSynthesisUtterance(text);
-          utterance.lang = "zh-CN";
-          utterance.rate = 1;
-          utterance.pitch = 0.8;
-          utterance.volume = 0.9;
-          const voices = window.speechSynthesis.getVoices();
-          const maleVoice = voices.find((v) => v.lang.startsWith("zh") && /male|男/i.test(v.name));
-          const zhVoice = maleVoice || voices.find((v) => v.lang.startsWith("zh"));
-          if (zhVoice) {
-            utterance.voice = zhVoice;
+        }
+      );
+      vue.watch(
+        () => {
+          const msgs = chat.messages;
+          if (msgs.length === 0) return "";
+          const last = msgs[msgs.length - 1];
+          return last.parts.filter((p) => p.type === "text").map((p) => p.text).join("");
+        },
+        () => {
+          if (!showScrollButton.value) {
+            scrollToBottom();
           }
-          window.speechSynthesis.speak(utterance);
-        } catch (error) {
-          console.error("[TTS] 播报失败:", error);
         }
+      );
+      const autoResize = () => {
+        const el = textareaRef.value;
+        if (!el) return;
+        el.style.height = "auto";
+        el.style.height = `${Math.min(el.scrollHeight, 200)}px`;
       };
-      const stopTranscribing = async () => {
-      };
-      const toggleVoiceMode = async (targetState) => {
-        const permission = await ensureMicrophonePermission();
-        if (!permission) return;
-        if (isInitializing.value) return;
-        if (!detector) {
-          await initVoiceDetector();
-          if (!detector) return;
+      const handleKeydown = (e) => {
+        if (e.key === "Enter" && !e.shiftKey) {
+          e.preventDefault();
+          handleSubmit();
         }
-        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;
+      };
+      const handleSubmit = () => {
+        const text = inputText.value.trim();
+        if (!text || isLoading.value) return;
+        chat.sendMessage({ text });
+        inputText.value = "";
+        vue.nextTick(() => {
+          if (textareaRef.value) {
+            textareaRef.value.style.height = "auto";
           }
-        } catch (error) {
-          console.error("[VoiceDetector] 操作失败:", error);
-          voiceStatus.value = "standby";
-          transcriptionText.value = "操作失败";
-          isTranscribing.value = false;
-          setTimeout(() => {
-            transcriptionText.value = "";
-          }, 2e3);
-        }
+        });
       };
-      const position = vue.reactive({ x: 0, y: 0 });
-      const containerWidth = vue.ref(props.xDialogSize?.width || 420);
-      const containerHeight = vue.ref(props.xDialogSize?.height || 600);
-      const isFirstOpen = vue.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 handleSuggestionClick = (suggestion) => {
+        chat.sendMessage({ text: suggestion });
       };
-      const getOverlapArea = (rectA, rectB) => {
-        const overlapX = Math.max(0, Math.min(rectA.right, rectB.right) - Math.max(rectA.left, rectB.left));
-        const overlapY = Math.max(0, Math.min(rectA.bottom, rectB.bottom) - Math.max(rectA.top, rectB.top));
-        return overlapX * overlapY;
+      const handleStop = () => {
+        chat.stop();
       };
-      const keepDistanceFromFab = (x, y, width, height) => {
-        if (!fabRef.value) return { x, y };
-        const fabRect = fabRef.value.getBoundingClientRect();
-        const safeFabRect = {
-          left: fabRect.left - FAB_SAFE_GAP,
-          right: fabRect.right + FAB_SAFE_GAP,
-          top: fabRect.top - FAB_SAFE_GAP,
-          bottom: fabRect.bottom + FAB_SAFE_GAP
-        };
-        const candidates = [
-          { x, y },
-          { x: safeFabRect.left - width - FAB_SAFE_GAP, y },
-          { x: safeFabRect.right + FAB_SAFE_GAP, y },
-          { x, y: safeFabRect.top - height - FAB_SAFE_GAP },
-          { x, y: safeFabRect.bottom + FAB_SAFE_GAP }
-        ];
-        let best = validatePosition(candidates[0].x, candidates[0].y, width, height);
-        let bestOverlap = getOverlapArea(
-          { left: best.x, right: best.x + width, top: best.y, bottom: best.y + height },
-          safeFabRect
-        );
-        for (let i = 1; i < candidates.length; i++) {
-          const validated = validatePosition(candidates[i].x, candidates[i].y, width, height);
-          const overlap = getOverlapArea(
-            { left: validated.x, right: validated.x + width, top: validated.y, bottom: validated.y + height },
-            safeFabRect
-          );
-          if (overlap < bestOverlap) {
-            best = validated;
-            bestOverlap = overlap;
-            if (overlap === 0) break;
+      const handleRegenerate = (assistantMessageId) => {
+        const msgs = chat.messages;
+        const index = msgs.findIndex((m) => m.id === assistantMessageId);
+        if (index <= 0) return;
+        let userMsg = null;
+        for (let i = index - 1; i >= 0; i--) {
+          if (msgs[i].role === "user") {
+            userMsg = msgs[i];
+            break;
           }
         }
-        return best;
+        if (!userMsg) return;
+        const userText = userMsg.parts.filter((p) => p.type === "text").map((p) => p.text).join("");
+        chat.messages = msgs.slice(0, msgs.indexOf(userMsg));
+        vue.nextTick(() => {
+          chat.sendMessage({ text: userText });
+        });
       };
-      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 handleCopy = async (message) => {
+        const text = message.parts.filter((p) => p.type === "text").map((p) => p.text).join("");
+        try {
+          await navigator.clipboard.writeText(text);
+          copiedId.value = message.id;
+          setTimeout(() => {
+            copiedId.value = null;
+          }, 2e3);
+        } catch {
+          console.error("Failed to copy");
         }
-        const validated = validatePosition(x, y, dialogWidth, dialogHeight);
-        const separated = keepDistanceFromFab(validated.x, validated.y, dialogWidth, dialogHeight);
-        position.x = separated.x;
-        position.y = separated.y;
       };
-      const toggleCollapse = async () => {
-        isCollapsed.value = !isCollapsed.value;
-        vue.nextTick(() => {
-          const currentHeight = isCollapsed.value ? 60 : containerHeight.value;
-          const validated = validatePosition(position.x, position.y, containerWidth.value, currentHeight);
-          const separated = keepDistanceFromFab(validated.x, validated.y, containerWidth.value, currentHeight);
-          position.x = separated.x;
-          position.y = separated.y;
-        });
+      const isToolPart = (part) => {
+        return typeof part.type === "string" && part.type.startsWith("tool-");
       };
-      const drag = vue.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 isToolLoading = (part) => {
+        return part.state === "partial-call" || part.state === "call" || part.state === "input-streaming" || part.state === "input-available";
       };
-      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 isToolDone = (part) => {
+        return part.state === "result" || part.state === "output-available";
       };
-      const stopDrag = () => {
-        drag.isDragging = false;
-        document.removeEventListener("mousemove", onDrag);
-        document.removeEventListener("mouseup", stopDrag);
+      const isToolError = (part) => {
+        return part.state === "error" || part.state === "output-error";
       };
-      const toggleDialog = async (state) => {
-        if (state) {
-          visible.value = true;
-          positionReady.value = false;
-          emit("wakeUp", true);
-          await vue.nextTick();
-          if (isFirstOpen.value) {
-            calculateInitialPosition();
-            isFirstOpen.value = false;
-          } else {
-            const validated = validatePosition(
-              position.x,
-              position.y,
-              containerWidth.value,
-              isCollapsed.value ? 60 : containerHeight.value
-            );
-            const separated = keepDistanceFromFab(
-              validated.x,
-              validated.y,
-              containerWidth.value,
-              isCollapsed.value ? 60 : containerHeight.value
-            );
-            position.x = separated.x;
-            position.y = separated.y;
-          }
-          await vue.nextTick();
-          positionReady.value = true;
-        } else {
-          positionReady.value = false;
-          visible.value = false;
-          isCollapsed.value = false;
-          emit("wakeUp", false);
-        }
+      const getToolName = (part) => {
+        return part.toolName || part.type?.replace("tool-", "") || "unknown";
       };
-      const handleIframeLoad = async (event) => {
-        aiChatbotX.setIframeElement(event.target);
-        aiChatbotX.setTheme(currentTheme.value);
+      const getToolDisplayName = (name) => {
+        return props.toolNames?.[name] || toolDisplayNames[name] || name;
       };
-      vue.watch(
-        () => [aiChatbotX.chatbotUrl()],
-        ([url]) => {
-          console.log("[AiChatbotX] 初始化", url);
-          if (url) {
-            chatbotUrl.value = `${url}/app/${aiChatbotX.appId()}?token=${aiChatbotX.appToken()}`;
-          }
-        },
-        { immediate: true }
-      );
-      vue.onBeforeUnmount(async () => {
-        if (detector) {
-          try {
-            if (detector.isActive()) {
-              await detector.stop();
-            }
-            detector = null;
-          } catch (error) {
-            console.error("[VoiceDetector] 清理失败:", error);
-          }
-        }
-      });
-      aiChatbotX?.registerVoiceMethods({
-        start: () => toggleVoiceMode(true),
-        stop: () => toggleVoiceMode(false),
-        openDialog: () => toggleDialog(true),
-        closeDialog: () => toggleDialog(false),
-        toggleCollapse: () => toggleCollapse()
+      const isStreamingMessage = (messageId) => {
+        if (chat.status !== "streaming" && chat.status !== "submitted") return false;
+        const msgs = chat.messages;
+        return msgs.length > 0 && msgs[msgs.length - 1].id === messageId;
+      };
+      const toggleReasoning = (messageId) => {
+        reasoningOpen[messageId] = !reasoningOpen[messageId];
+      };
+      const renderMarkdown = (text) => {
+        if (!text) return "";
+        return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\*\*(.*?)\*\*/g, "<strong>$1</strong>").replace(/\*(.*?)\*/g, "<em>$1</em>").replace(/`([^`]+)`/g, "<code>$1</code>").replace(/```(\w*)\n([\s\S]*?)```/g, '<pre><code class="language-$1">$2</code></pre>').replace(/\n/g, "<br/>");
+      };
+      vue.onMounted(() => {
+        autoResize();
       });
-      return (_ctx, _cache) => {
-        return vue.openBlock(), vue.createElementBlock("div", {
-          class: "sime-x",
-          "data-theme": currentTheme.value
-        }, [
-          vue.createVNode(vue.Transition, { name: "fade" }, {
-            default: vue.withCtx(() => [
-              vue.createElementVNode("div", {
-                ref_key: "fabRef",
-                ref: fabRef,
-                class: "assistant-fab",
-                onClick: _cache[0] || (_cache[0] = ($event) => toggleDialog(!visible.value))
-              }, [
-                !isProcessing.value ? (vue.openBlock(), vue.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"])) : (vue.openBlock(), vue.createBlock(ExecutionStatus, {
-                  key: 1,
-                  class: "voice-status",
-                  visible: isProcessing.value,
-                  text: transcriptionText.value
-                }, null, 8, ["visible", "text"])),
-                vue.createElementVNode("div", _hoisted_2$1, [
-                  vue.createElementVNode("img", {
-                    src: __props.xLogo ? __props.xLogo : "/sime.png",
-                    alt: "assistant",
-                    style: vue.normalizeStyle({
-                      width: __props.xSize?.width + "px"
-                    })
-                  }, null, 12, _hoisted_3$1),
-                  vue.createVNode(vue.Transition, { name: "indicator-fade" }, {
-                    default: vue.withCtx(() => [
-                      voiceStatus.value === "listening" ? (vue.openBlock(), vue.createElementBlock("div", {
-                        key: 0,
-                        class: vue.normalizeClass(["listening-badge", { "wake-active": wakeAnimating.value }])
-                      }, [..._cache[3] || (_cache[3] = [
-                        vue.createElementVNode("div", { class: "listening-waves" }, [
-                          vue.createElementVNode("div", { class: "wave wave-1" }),
-                          vue.createElementVNode("div", { class: "wave wave-2" }),
-                          vue.createElementVNode("div", { class: "wave wave-3" })
-                        ], -1),
-                        vue.createElementVNode("div", { class: "listening-icon" }, [
-                          vue.createElementVNode("svg", {
-                            width: "24",
-                            height: "24",
-                            viewBox: "0 0 24 24",
-                            fill: "none"
-                          }, [
-                            vue.createElementVNode("path", {
-                              d: "M12 14c1.66 0 3-1.34 3-3V5c0-1.66-1.34-3-3-3S9 3.34 9 5v6c0 1.66 1.34 3 3 3z",
-                              fill: "currentColor"
-                            }),
-                            vue.createElementVNode("path", {
-                              d: "M17 11c0 2.76-2.24 5-5 5s-5-2.24-5-5",
-                              stroke: "currentColor",
-                              "stroke-width": "2",
-                              "stroke-linecap": "round"
-                            })
-                          ])
-                        ], -1)
-                      ])], 2)) : vue.createCommentVNode("", true)
-                    ]),
-                    _: 1
-                  })
-                ]),
-                vue.createElementVNode("div", {
-                  class: vue.normalizeClass(["fab-pulse", { active: voiceStatus.value === "listening" }])
-                }, null, 2)
-              ], 512)
-            ]),
-            _: 1
-          }),
-          vue.createVNode(vue.Transition, { name: "dialog-fade" }, {
-            default: vue.withCtx(() => [
-              vue.createElementVNode("div", {
-                ref: "dialogRef",
-                class: vue.normalizeClass(["x-dialog-container", {
-                  collapsed: isCollapsed.value,
-                  "is-hidden": !visible.value,
-                  "position-ready": positionReady.value
-                }]),
-                style: vue.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
-              }, [
-                vue.createElementVNode("div", {
-                  class: "x-dialog-header",
-                  onMousedown: vue.withModifiers(startDrag, ["stop"])
-                }, [
-                  vue.createElementVNode("div", _hoisted_4$1, [
-                    vue.createElementVNode("div", _hoisted_5$1, [
-                      vue.createElementVNode("img", {
-                        src: __props.xLogo ? __props.xLogo : "/sime.png",
-                        alt: "assistant",
-                        class: "logo"
-                      }, null, 8, _hoisted_6$1)
-                    ]),
-                    vue.createElementVNode("span", _hoisted_7$1, vue.toDisplayString(__props.xTitle), 1)
-                  ]),
-                  vue.createElementVNode("div", _hoisted_8$1, [
-                    vue.createElementVNode("button", {
-                      class: "action-btn theme-btn",
-                      title: "开启新对话",
-                      onClick: startNewConversation
-                    }, [..._cache[4] || (_cache[4] = [
-                      vue.createElementVNode("svg", {
-                        width: "16",
-                        height: "16",
-                        viewBox: "0 0 24 24",
-                        fill: "none"
-                      }, [
-                        vue.createElementVNode("path", {
-                          d: "M12 5v14M5 12h14",
-                          stroke: "currentColor",
-                          "stroke-width": "2",
-                          "stroke-linecap": "round"
-                        })
-                      ], -1)
-                    ])]),
-                    vue.createElementVNode("button", {
-                      class: vue.normalizeClass(["action-btn theme-btn", {
-                        active: voiceStatus.value !== "standby",
-                        listening: voiceStatus.value === "listening",
-                        woke: voiceStatus.value === "wake"
-                      }]),
-                      onClick: _cache[1] || (_cache[1] = vue.withModifiers(() => toggleVoiceMode(), ["stop"])),
-                      title: voiceButtonTooltip.value
+      __expose({
+        chat,
+        sendMessage: (text) => chat.sendMessage({ text }),
+        clearMessages: () => {
+          chat.messages = [];
+        },
+        stop: () => chat.stop()
+      });
+      return (_ctx, _cache) => {
+        return vue.openBlock(), vue.createElementBlock("div", {
+          class: vue.normalizeClass(["ai-chat", { "ai-chat--full-width": __props.fullWidth }])
+        }, [
+          isEmpty.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$1, [
+            vue.createElementVNode("div", _hoisted_2$1, [
+              vue.createElementVNode("h1", _hoisted_3$1, vue.toDisplayString(__props.welcomeTitle), 1),
+              vue.createElementVNode("p", _hoisted_4$1, vue.toDisplayString(__props.welcomeDescription), 1)
+            ]),
+            vue.createElementVNode("div", _hoisted_5$1, [
+              vue.createElementVNode("form", {
+                class: "ai-chat__form",
+                onSubmit: vue.withModifiers(handleSubmit, ["prevent"])
+              }, [
+                vue.createElementVNode("div", _hoisted_6$1, [
+                  vue.withDirectives(vue.createElementVNode("textarea", {
+                    ref_key: "textareaRef",
+                    ref: textareaRef,
+                    "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => inputText.value = $event),
+                    class: "ai-chat__textarea",
+                    placeholder: "发送消息...",
+                    rows: "1",
+                    onKeydown: handleKeydown,
+                    onInput: autoResize
+                  }, null, 544), [
+                    [vue.vModelText, inputText.value]
+                  ]),
+                  vue.createElementVNode("button", {
+                    type: "submit",
+                    class: "ai-chat__send-btn",
+                    disabled: !inputText.value.trim() || isLoading.value
+                  }, [..._cache[2] || (_cache[2] = [
+                    vue.createElementVNode("svg", {
+                      width: "16",
+                      height: "16",
+                      viewBox: "0 0 24 24",
+                      fill: "none",
+                      stroke: "currentColor",
+                      "stroke-width": "2",
+                      "stroke-linecap": "round",
+                      "stroke-linejoin": "round"
                     }, [
-                      _cache[5] || (_cache[5] = vue.createElementVNode("svg", {
-                        width: "16",
-                        height: "16",
-                        viewBox: "0 0 24 24",
-                        fill: "none"
+                      vue.createElementVNode("line", {
+                        x1: "22",
+                        y1: "2",
+                        x2: "11",
+                        y2: "13"
+                      }),
+                      vue.createElementVNode("polygon", { points: "22 2 15 22 11 13 2 9 22 2" })
+                    ], -1)
+                  ])], 8, _hoisted_7$1)
+                ])
+              ], 32),
+              __props.suggestions.length > 0 ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_8$1, [
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.suggestions, (suggestion) => {
+                  return vue.openBlock(), vue.createElementBlock("button", {
+                    key: suggestion,
+                    class: "ai-chat__suggestion",
+                    onClick: ($event) => handleSuggestionClick(suggestion)
+                  }, vue.toDisplayString(suggestion), 9, _hoisted_9$1);
+                }), 128))
+              ])) : vue.createCommentVNode("", true)
+            ])
+          ])) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+            vue.createElementVNode("div", {
+              ref_key: "messagesContainerRef",
+              ref: messagesContainerRef,
+              class: "ai-chat__messages",
+              onScroll: handleScroll
+            }, [
+              vue.createElementVNode("div", _hoisted_10$1, [
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(chat).messages, (message) => {
+                  return vue.openBlock(), vue.createElementBlock("div", {
+                    key: message.id,
+                    class: "ai-chat__message-group"
+                  }, [
+                    (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(message.parts, (part, partIndex) => {
+                      return vue.openBlock(), vue.createElementBlock(vue.Fragment, {
+                        key: `${message.id}-${partIndex}`
                       }, [
-                        vue.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"
-                        }),
-                        vue.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"
-                        }),
-                        vue.createElementVNode("path", {
-                          d: "M12 19V17",
-                          stroke: "currentColor",
-                          "stroke-width": "2",
-                          "stroke-linecap": "round",
-                          "stroke-linejoin": "round"
-                        }),
-                        vue.createElementVNode("path", {
-                          d: "M9 21H15",
+                        part.type === "text" ? (vue.openBlock(), vue.createElementBlock("div", {
+                          key: 0,
+                          class: vue.normalizeClass(["ai-chat__message", `ai-chat__message--${message.role}`])
+                        }, [
+                          vue.createElementVNode("div", _hoisted_11$1, [
+                            vue.createElementVNode("div", {
+                              class: "ai-chat__message-text",
+                              innerHTML: renderMarkdown(part.text)
+                            }, null, 8, _hoisted_12$1)
+                          ])
+                        ], 2)) : part.type === "reasoning" ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_13$1, [
+                          vue.createElementVNode("button", {
+                            class: "ai-chat__reasoning-trigger",
+                            onClick: ($event) => toggleReasoning(message.id)
+                          }, [
+                            (vue.openBlock(), vue.createElementBlock("svg", {
+                              class: vue.normalizeClass(["ai-chat__reasoning-icon", { "ai-chat__reasoning-icon--open": reasoningOpen[message.id] }]),
+                              width: "12",
+                              height: "12",
+                              viewBox: "0 0 24 24",
+                              fill: "none",
+                              stroke: "currentColor",
+                              "stroke-width": "2"
+                            }, [..._cache[3] || (_cache[3] = [
+                              vue.createElementVNode("polyline", { points: "9 18 15 12 9 6" }, null, -1)
+                            ])], 2)),
+                            _cache[4] || (_cache[4] = vue.createElementVNode("span", null, "思考过程", -1)),
+                            isStreamingMessage(message.id) && partIndex === message.parts.length - 1 ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_15)) : vue.createCommentVNode("", true)
+                          ], 8, _hoisted_14),
+                          reasoningOpen[message.id] ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_16, vue.toDisplayString(part.text), 1)) : vue.createCommentVNode("", true)
+                        ])) : isToolPart(part) ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_17, [
+                          vue.createElementVNode("div", {
+                            class: vue.normalizeClass(["ai-chat__tool-step", {
+                              "ai-chat__tool-step--loading": isToolLoading(part),
+                              "ai-chat__tool-step--done": isToolDone(part),
+                              "ai-chat__tool-step--error": isToolError(part)
+                            }])
+                          }, [
+                            vue.createElementVNode("span", _hoisted_18, [
+                              isToolLoading(part) ? (vue.openBlock(), vue.createElementBlock("svg", _hoisted_19, [..._cache[5] || (_cache[5] = [
+                                vue.createElementVNode("circle", {
+                                  cx: "12",
+                                  cy: "12",
+                                  r: "10",
+                                  stroke: "currentColor",
+                                  "stroke-width": "2.5",
+                                  "stroke-linecap": "round",
+                                  "stroke-dasharray": "31.4 31.4"
+                                }, null, -1)
+                              ])])) : isToolDone(part) ? (vue.openBlock(), vue.createElementBlock("svg", _hoisted_20, [..._cache[6] || (_cache[6] = [
+                                vue.createElementVNode("path", {
+                                  d: "M20 6L9 17l-5-5",
+                                  stroke: "currentColor",
+                                  "stroke-width": "2.5",
+                                  "stroke-linecap": "round",
+                                  "stroke-linejoin": "round"
+                                }, null, -1)
+                              ])])) : isToolError(part) ? (vue.openBlock(), vue.createElementBlock("svg", _hoisted_21, [..._cache[7] || (_cache[7] = [
+                                vue.createElementVNode("circle", {
+                                  cx: "12",
+                                  cy: "12",
+                                  r: "10",
+                                  stroke: "currentColor",
+                                  "stroke-width": "2"
+                                }, null, -1),
+                                vue.createElementVNode("path", {
+                                  d: "M15 9l-6 6M9 9l6 6",
+                                  stroke: "currentColor",
+                                  "stroke-width": "2",
+                                  "stroke-linecap": "round"
+                                }, null, -1)
+                              ])])) : vue.createCommentVNode("", true)
+                            ]),
+                            vue.createElementVNode("span", _hoisted_22, vue.toDisplayString(getToolDisplayName(getToolName(part))), 1)
+                          ], 2)
+                        ])) : vue.createCommentVNode("", true)
+                      ], 64);
+                    }), 128)),
+                    message.role === "assistant" && !isStreamingMessage(message.id) ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_23, [
+                      vue.createElementVNode("button", {
+                        class: "ai-chat__action-btn",
+                        title: "重新生成",
+                        onClick: ($event) => handleRegenerate(message.id)
+                      }, [..._cache[8] || (_cache[8] = [
+                        vue.createElementVNode("svg", {
+                          width: "12",
+                          height: "12",
+                          viewBox: "0 0 24 24",
+                          fill: "none",
                           stroke: "currentColor",
                           "stroke-width": "2",
                           "stroke-linecap": "round",
                           "stroke-linejoin": "round"
-                        })
-                      ], -1)),
-                      voiceStatus.value !== "standby" ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_10$1)) : vue.createCommentVNode("", true)
-                    ], 10, _hoisted_9$1),
-                    vue.createElementVNode("button", {
-                      class: "action-btn theme-btn",
-                      onClick: vue.withModifiers(cycleTheme, ["stop"]),
-                      title: themeTooltip.value
-                    }, [..._cache[6] || (_cache[6] = [
-                      vue.createElementVNode("svg", {
-                        width: "16",
-                        height: "16",
-                        viewBox: "0 0 24 24",
-                        fill: "none"
+                        }, [
+                          vue.createElementVNode("polyline", { points: "23 4 23 10 17 10" }),
+                          vue.createElementVNode("polyline", { points: "1 20 1 14 7 14" }),
+                          vue.createElementVNode("path", { d: "M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15" })
+                        ], -1)
+                      ])], 8, _hoisted_24),
+                      vue.createElementVNode("button", {
+                        class: "ai-chat__action-btn",
+                        title: "复制",
+                        onClick: ($event) => handleCopy(message)
                       }, [
-                        vue.createElementVNode("circle", {
-                          cx: "12",
-                          cy: "12",
-                          r: "7",
-                          stroke: "currentColor",
-                          "stroke-width": "2"
-                        }),
-                        vue.createElementVNode("path", {
-                          d: "M12 5A7 7 0 1 1 12 19",
-                          fill: "currentColor"
-                        })
-                      ], -1)
-                    ])], 8, _hoisted_11$1),
-                    vue.createElementVNode("button", {
-                      class: "action-btn collapse-btn",
-                      onClick: vue.withModifiers(toggleCollapse, ["stop"]),
-                      title: isCollapsed.value ? "展开" : "折叠"
+                        !copiedId.value || copiedId.value !== message.id ? (vue.openBlock(), vue.createElementBlock("svg", _hoisted_26, [..._cache[9] || (_cache[9] = [
+                          vue.createElementVNode("rect", {
+                            x: "9",
+                            y: "9",
+                            width: "13",
+                            height: "13",
+                            rx: "2",
+                            ry: "2"
+                          }, null, -1),
+                          vue.createElementVNode("path", { d: "M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" }, null, -1)
+                        ])])) : (vue.openBlock(), vue.createElementBlock("svg", _hoisted_27, [..._cache[10] || (_cache[10] = [
+                          vue.createElementVNode("polyline", { points: "20 6 9 17 4 12" }, null, -1)
+                        ])]))
+                      ], 8, _hoisted_25)
+                    ])) : vue.createCommentVNode("", true)
+                  ]);
+                }), 128)),
+                vue.unref(chat).status === "submitted" ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_28, [..._cache[11] || (_cache[11] = [
+                  vue.createElementVNode("div", { class: "ai-chat__thinking-dots" }, [
+                    vue.createElementVNode("span"),
+                    vue.createElementVNode("span"),
+                    vue.createElementVNode("span")
+                  ], -1)
+                ])])) : vue.createCommentVNode("", true)
+              ])
+            ], 544),
+            vue.createVNode(vue.Transition, { name: "fade" }, {
+              default: vue.withCtx(() => [
+                showScrollButton.value ? (vue.openBlock(), vue.createElementBlock("button", {
+                  key: 0,
+                  class: "ai-chat__scroll-btn",
+                  onClick: scrollToBottom
+                }, [..._cache[12] || (_cache[12] = [
+                  vue.createElementVNode("svg", {
+                    width: "16",
+                    height: "16",
+                    viewBox: "0 0 24 24",
+                    fill: "none",
+                    stroke: "currentColor",
+                    "stroke-width": "2",
+                    "stroke-linecap": "round",
+                    "stroke-linejoin": "round"
+                  }, [
+                    vue.createElementVNode("polyline", { points: "6 9 12 15 18 9" })
+                  ], -1)
+                ])])) : vue.createCommentVNode("", true)
+              ]),
+              _: 1
+            }),
+            !__props.isReadonly ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_29, [
+              vue.createElementVNode("form", {
+                class: "ai-chat__form",
+                onSubmit: vue.withModifiers(handleSubmit, ["prevent"])
+              }, [
+                vue.createElementVNode("div", _hoisted_30, [
+                  vue.withDirectives(vue.createElementVNode("textarea", {
+                    ref_key: "textareaRef",
+                    ref: textareaRef,
+                    "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => inputText.value = $event),
+                    class: "ai-chat__textarea",
+                    placeholder: "发送消息...",
+                    rows: "1",
+                    onKeydown: handleKeydown,
+                    onInput: autoResize
+                  }, null, 544), [
+                    [vue.vModelText, inputText.value]
+                  ]),
+                  vue.unref(chat).status === "streaming" || vue.unref(chat).status === "submitted" ? (vue.openBlock(), vue.createElementBlock("button", {
+                    key: 0,
+                    type: "button",
+                    class: "ai-chat__stop-btn",
+                    onClick: handleStop
+                  }, [..._cache[13] || (_cache[13] = [
+                    vue.createElementVNode("svg", {
+                      width: "14",
+                      height: "14",
+                      viewBox: "0 0 24 24",
+                      fill: "currentColor"
                     }, [
-                      (vue.openBlock(), vue.createElementBlock("svg", _hoisted_13$1, [
-                        vue.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_14)
-                      ]))
-                    ], 8, _hoisted_12$1),
-                    vue.createElementVNode("button", {
-                      class: "action-btn minimize-btn",
-                      onClick: _cache[2] || (_cache[2] = vue.withModifiers(($event) => toggleDialog(false), ["stop"])),
-                      title: "最小化"
-                    }, [..._cache[7] || (_cache[7] = [
-                      vue.createElementVNode("svg", {
-                        width: "16",
-                        height: "16",
-                        viewBox: "0 0 24 24",
-                        fill: "none"
-                      }, [
-                        vue.createElementVNode("path", {
-                          d: "M5 12H19",
-                          stroke: "currentColor",
-                          "stroke-width": "2",
-                          "stroke-linecap": "round"
-                        })
-                      ], -1)
-                    ])])
-                  ])
-                ], 32),
-                vue.createElementVNode("div", {
-                  class: vue.normalizeClass(["x-dialog-content", { "is-hidden": isCollapsed.value }]),
-                  style: vue.normalizeStyle({ opacity: isCollapsed.value ? 0 : 1 })
-                }, [
-                  vue.createElementVNode("iframe", {
-                    ref: "iframeRef",
-                    src: chatbotUrl.value,
-                    class: "x-iframe",
-                    allow: "microphone *; storage-access *; camera *",
-                    frameborder: "0",
-                    onLoad: handleIframeLoad
-                  }, null, 40, _hoisted_15)
-                ], 6)
-              ], 38)
-            ]),
-            _: 1
-          })
-        ], 8, _hoisted_1$1);
+                      vue.createElementVNode("rect", {
+                        x: "6",
+                        y: "6",
+                        width: "12",
+                        height: "12",
+                        rx: "2"
+                      })
+                    ], -1)
+                  ])])) : (vue.openBlock(), vue.createElementBlock("button", {
+                    key: 1,
+                    type: "submit",
+                    class: "ai-chat__send-btn",
+                    disabled: !inputText.value.trim()
+                  }, [..._cache[14] || (_cache[14] = [
+                    vue.createElementVNode("svg", {
+                      width: "16",
+                      height: "16",
+                      viewBox: "0 0 24 24",
+                      fill: "none",
+                      stroke: "currentColor",
+                      "stroke-width": "2",
+                      "stroke-linecap": "round",
+                      "stroke-linejoin": "round"
+                    }, [
+                      vue.createElementVNode("line", {
+                        x1: "22",
+                        y1: "2",
+                        x2: "11",
+                        y2: "13"
+                      }),
+                      vue.createElementVNode("polygon", { points: "22 2 15 22 11 13 2 9 22 2" })
+                    ], -1)
+                  ])], 8, _hoisted_31))
+                ])
+              ], 32)
+            ])) : vue.createCommentVNode("", true)
+          ], 64))
+        ], 2);
       };
     }
   });
 
-  const simeX = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-91f104d1"]]);
+  const _export_sfc = (sfc, props) => {
+    const target = sfc.__vccOpts || sfc;
+    for (const [key, val] of props) {
+      target[key] = val;
+    }
+    return target;
+  };
+
+  const aiChat = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-958fd919"]]);
+
+  class CommandManager {
+    commands = /* @__PURE__ */ new Map();
+    debug;
+    constructor(options = {}) {
+      this.debug = options.debug ?? false;
+    }
+    registerCommand(command) {
+      this.commands.set(command.name, command);
+      this.log("注册命令", `${command.name}: ${command.description}`);
+    }
+    unregisterCommand(name) {
+      const deleted = this.commands.delete(name);
+      if (deleted) {
+        this.log("命令已注销", name);
+      }
+    }
+    async executeCommand(command, args = []) {
+      const commandDef = this.commands.get(command);
+      if (!commandDef) {
+        throw new Error(`命令 "${command}" 未找到`);
+      }
+      this.log("执行命令", command, args);
+      return await commandDef.handler(...args);
+    }
+    getCommands() {
+      return Array.from(this.commands.values()).map((cmd) => ({
+        name: cmd.name,
+        description: cmd.description,
+        parameters: cmd.parameters
+      }));
+    }
+    hasCommand(name) {
+      return this.commands.has(name);
+    }
+    clear() {
+      this.commands.clear();
+      this.log("", "所有命令已清空");
+    }
+    log(prefix, msg, ...args) {
+      (/* @__PURE__ */ new Date()).toLocaleTimeString([], {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      });
+      console.log(
+        `%c ${prefix}`,
+        "background:#7c3aed;color:white;padding:2px 6px;border-radius:3px 0 0 3px;font-weight:bold;",
+        `${msg}`
+      );
+      if (args.length > 0) {
+        console.log(...args);
+      }
+    }
+  }
+
+  const AiChatbotXKey = Symbol("sime-x");
+  function injectStrict(key, defaultValue, treatDefaultAsFactory) {
+    let result;
+    if (defaultValue === void 0) {
+      result = vue.inject(key);
+    } else if (treatDefaultAsFactory === true) {
+      result = vue.inject(key, defaultValue, true);
+    } else {
+      result = vue.inject(key, defaultValue, false);
+    }
+    if (!result) {
+      throw new Error(`Could not resolve ${key.description}`);
+    }
+    return result;
+  }
+
+  const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
+    __name: "sime-provider",
+    props: {
+      project: {},
+      description: {},
+      debug: { type: Boolean },
+      chatbotUrl: {},
+      appId: {},
+      appToken: {}
+    },
+    setup(__props) {
+      const props = __props;
+      const commandManager = vue.shallowRef(new CommandManager({ debug: props.debug ?? false }));
+      const stopBroadcastRef = vue.shallowRef(async () => {
+      });
+      vue.provide(AiChatbotXKey, {
+        chatbotUrl: () => props.chatbotUrl,
+        appId: () => props.appId,
+        appToken: () => props.appToken,
+        stopBroadcast: () => stopBroadcastRef.value(),
+        registerVoiceMethods: (methods) => {
+          if (methods.stopBroadcast) stopBroadcastRef.value = methods.stopBroadcast;
+        },
+        getCommads: async () => commandManager.value.getCommands(),
+        registerCommand: (cmd) => {
+          commandManager.value.registerCommand(cmd);
+        },
+        unregisterCommand: (name) => {
+          commandManager.value.unregisterCommand(name);
+        },
+        async executeCommand(commandName, args = []) {
+          return await commandManager.value.executeCommand(commandName, args);
+        }
+      });
+      return (_ctx, _cache) => {
+        return vue.renderSlot(_ctx.$slots, "default");
+      };
+    }
+  });
 
   function useTTS(getVoiceConfig) {
     const isSpeaking = vue.ref(false);
@@ -1238,6 +1043,73 @@
     };
   }
 
+  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;
+    }
+  };
+
   function useVoiceRecognition(options) {
     const voiceStatus = vue.ref("standby");
     const isTranscribing = vue.ref(false);
@@ -1463,7 +1335,8 @@
         callbacks.onFinish?.(parsed);
         break;
       case "error":
-        callbacks.onError?.(parsed.errorText || parsed.error || "Unknown error");
+      case "tool-output-error":
+        callbacks.onError?.(parsed.errorText || parsed.error || "Unknown error", parsed);
         break;
       case "start":
       case "text-start":
@@ -1722,7 +1595,16 @@
         }
         emitUpdate();
       },
-      onError(error) {
+      onError(error, data) {
+        const toolCallId = data?.toolCallId;
+        if (toolCallId) {
+          toolCalls.delete(toolCallId);
+          const idx = findToolPartIndex(toolCallId);
+          if (idx !== -1) {
+            parts.splice(idx, 1);
+            emitUpdate();
+          }
+        }
         console.error("[DataStreamParser] stream error:", error);
       },
       onStepFinish(_data) {
@@ -1792,20 +1674,63 @@
       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;
+    const extractExecutableCommands = (payload) => {
+      if (!payload || typeof payload !== "object") return [];
+      const commands = payload.commands;
+      if (!Array.isArray(commands) || commands.length === 0) return [];
+      return commands.filter((cmd) => cmd && typeof cmd === "object" && typeof cmd.name === "string" && cmd.name.trim()).map((cmd) => ({
+        name: cmd.name,
+        args: Array.isArray(cmd.args) ? cmd.args : []
+      }));
+    };
+    const buildCommandDefinitionMap = (commands) => {
+      return new Map(commands.map((command) => [command.name, command]));
+    };
+    const toExecutableCommand = (toolName, payload, commandDefinitions) => {
+      const commandDefinition = commandDefinitions.get(toolName);
+      if (!commandDefinition) {
+        return null;
+      }
+      const parameters = commandDefinition.parameters || [];
+      if (Array.isArray(payload)) {
+        return {
+          name: toolName,
+          args: payload
+        };
+      }
+      if (!payload || typeof payload !== "object") {
+        return {
+          name: toolName,
+          args: []
+        };
+      }
+      const payloadRecord = payload;
+      return {
+        name: toolName,
+        args: parameters.map((parameter) => payloadRecord[parameter.name])
+      };
+    };
+    const resolveExecutableCommands = (toolName, payload, commandDefinitions) => {
+      const extractedCommands = extractExecutableCommands(payload);
+      if (extractedCommands.length > 0) {
+        return extractedCommands;
+      }
+      const directCommand = toExecutableCommand(toolName, payload, commandDefinitions);
+      return directCommand ? [directCommand] : [];
+    };
+    const executeHostCommands = async (toolCallId, toolName, payload, commandDefinitions) => {
+      const commands = resolveExecutableCommands(toolName, payload, commandDefinitions);
+      if (commands.length === 0) return false;
       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);
+            await aiChatbotX.executeCommand(cmd.name, cmd.args);
           } catch (cmdErr) {
             console.error(`[AgentInvoke] 执行命令 ${cmd.name} 失败:`, cmdErr);
           }
         }
+        return true;
       } finally {
         const next = new Set(executingTools.value);
         next.delete(toolCallId);
@@ -1839,8 +1764,10 @@
       bubble.open();
       let prevTextLength = 0;
       const processedToolResults = /* @__PURE__ */ new Set();
+      const processingToolResults = /* @__PURE__ */ new Set();
       abortController = new AbortController();
-      const commands = await aiChatbotX.hostCommads();
+      const commands = await aiChatbotX.getCommads();
+      const commandDefinitions = buildCommandDefinitionMap(commands);
       conversationHistory.value.length > 0 ? [...conversationHistory.value] : void 0;
       try {
         const response = await fetch(options.endpoint.value, {
@@ -1875,8 +1802,8 @@
                 state: "result"
               };
               currentToolParts.value = [...currentToolParts.value, toolPart];
-              if (tr.toolName === "executeCommand") {
-                executeHostCommands(toolPart.toolCallId, tr.result);
+              if (commandDefinitions.has(tr.toolName)) {
+                void executeHostCommands(toolPart.toolCallId, tr.toolName, tr.result, commandDefinitions);
               }
             }
           }
@@ -1893,13 +1820,27 @@
             );
             currentToolParts.value = toolParts;
             for (const part of toolParts) {
-              if (part.toolName === "executeCommand" && !processedToolResults.has(part.toolCallId)) {
+              if (commandDefinitions.has(part.toolName) && !processedToolResults.has(part.toolCallId) && !processingToolResults.has(part.toolCallId)) {
                 if (part.type === "tool-call" && part.state === "call" && part.args) {
-                  processedToolResults.add(part.toolCallId);
-                  executeHostCommands(part.toolCallId, part.args);
+                  processingToolResults.add(part.toolCallId);
+                  void executeHostCommands(part.toolCallId, part.toolName, part.args, commandDefinitions).then(
+                    (executed) => {
+                      if (executed) {
+                        processedToolResults.add(part.toolCallId);
+                      }
+                      processingToolResults.delete(part.toolCallId);
+                    }
+                  );
                 } else if (part.type === "tool-result" && part.result) {
-                  processedToolResults.add(part.toolCallId);
-                  executeHostCommands(part.toolCallId, part.result);
+                  processingToolResults.add(part.toolCallId);
+                  void executeHostCommands(part.toolCallId, part.toolName, part.result, commandDefinitions).then(
+                    (executed) => {
+                      if (executed) {
+                        processedToolResults.add(part.toolCallId);
+                      }
+                      processingToolResults.delete(part.toolCallId);
+                    }
+                  );
                 }
               }
             }
@@ -2020,11 +1961,7 @@
       const aiChatbotX = injectStrict(AiChatbotXKey);
       const getVoiceConfig = () => {
         if (props.voiceConfig) return props.voiceConfig;
-        try {
-          return aiChatbotX.voiceConfig();
-        } catch {
-          return null;
-        }
+        return null;
       };
       const endpoint = vue.computed(() => {
         return props.invokeUrl || "http://localhost:3001/agent/zyy55sw40nrl801056m0o/stream-invoke";
@@ -2093,12 +2030,7 @@
       const { voiceStatus, transcriptionText, wakeAnimating, isTranscribing } = voice;
       const { isInvoking, currentTextContent, currentToolParts, executingTools, hasAnyContent, toolDisplayName } = agent;
       aiChatbotX?.registerVoiceMethods({
-        start: () => toggleVoiceMode(true),
-        stop: () => toggleVoiceMode(false),
-        stopBroadcast: async () => interruptCurrentResponse(),
-        openDialog: async () => Promise.resolve(),
-        closeDialog: async () => Promise.resolve(),
-        toggleCollapse: async () => Promise.resolve()
+        stopBroadcast: async () => interruptCurrentResponse()
       });
       vue.onBeforeUnmount(async () => {
         bubble.destroy();
@@ -2237,13 +2169,26 @@
     }
   });
 
-  const voiceAssistant = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-77c6ae95"]]);
+  const voiceAssistant = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-fda883a9"]]);
+
+  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 || {});
 
-  exports.AiChatbotProvider = _sfc_main$4;
+  exports.AgentChatTransport = AgentChatTransport;
+  exports.AiChat = aiChat;
+  exports.AiChatbotProvider = _sfc_main$1;
   exports.AiChatbotVoiceAssistant = voiceAssistant;
-  exports.AiChatbotX = simeX;
   exports.AiChatbotXKey = AiChatbotXKey;
   exports.clientCommandKey = clientCommandKey;
+  exports.createAgentChatTransport = createAgentChatTransport;
   exports.injectStrict = injectStrict;
 
   Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });