@siact/sime-x-vue 0.0.14 → 0.0.16

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

@@ -89,30 +89,30 @@
     return history;
   }
 
-  const _hoisted_1$1 = {
+  const _hoisted_1$2 = {
     key: 0,
     class: "ai-chat__welcome"
   };
-  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 = {
+  const _hoisted_2$2 = { class: "ai-chat__welcome-header" };
+  const _hoisted_3$2 = { class: "ai-chat__welcome-title" };
+  const _hoisted_4$2 = { class: "ai-chat__welcome-desc" };
+  const _hoisted_5$2 = { class: "ai-chat__input-area" };
+  const _hoisted_6$2 = { class: "ai-chat__input-wrapper" };
+  const _hoisted_7$2 = ["disabled"];
+  const _hoisted_8$2 = {
     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 = {
+  const _hoisted_9$2 = ["onClick"];
+  const _hoisted_10$2 = { class: "ai-chat__messages-inner" };
+  const _hoisted_11$2 = { class: "ai-chat__message-content" };
+  const _hoisted_12$2 = ["innerHTML"];
+  const _hoisted_13$2 = {
     key: 1,
     class: "ai-chat__reasoning"
   };
-  const _hoisted_14 = ["onClick"];
-  const _hoisted_15 = {
+  const _hoisted_14$1 = ["onClick"];
+  const _hoisted_15$1 = {
     key: 0,
     class: "ai-chat__reasoning-streaming"
   };
@@ -186,7 +186,7 @@
   };
   const _hoisted_30 = { class: "ai-chat__input-wrapper" };
   const _hoisted_31 = ["disabled"];
-  const _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
+  const _sfc_main$3 = /* @__PURE__ */ vue.defineComponent({
     __name: "ai-chat",
     props: {
       api: {},
@@ -384,17 +384,17 @@
         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)
+          isEmpty.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$2, [
+            vue.createElementVNode("div", _hoisted_2$2, [
+              vue.createElementVNode("h1", _hoisted_3$2, vue.toDisplayString(__props.welcomeTitle), 1),
+              vue.createElementVNode("p", _hoisted_4$2, vue.toDisplayString(__props.welcomeDescription), 1)
             ]),
-            vue.createElementVNode("div", _hoisted_5$1, [
+            vue.createElementVNode("div", _hoisted_5$2, [
               vue.createElementVNode("form", {
                 class: "ai-chat__form",
                 onSubmit: vue.withModifiers(handleSubmit, ["prevent"])
               }, [
-                vue.createElementVNode("div", _hoisted_6$1, [
+                vue.createElementVNode("div", _hoisted_6$2, [
                   vue.withDirectives(vue.createElementVNode("textarea", {
                     ref_key: "textareaRef",
                     ref: textareaRef,
@@ -430,16 +430,16 @@
                       }),
                       vue.createElementVNode("polygon", { points: "22 2 15 22 11 13 2 9 22 2" })
                     ], -1)
-                  ])], 8, _hoisted_7$1)
+                  ])], 8, _hoisted_7$2)
                 ])
               ], 32),
-              __props.suggestions.length > 0 ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_8$1, [
+              __props.suggestions.length > 0 ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_8$2, [
                 (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);
+                  }, vue.toDisplayString(suggestion), 9, _hoisted_9$2);
                 }), 128))
               ])) : vue.createCommentVNode("", true)
             ])
@@ -450,7 +450,7 @@
               class: "ai-chat__messages",
               onScroll: handleScroll
             }, [
-              vue.createElementVNode("div", _hoisted_10$1, [
+              vue.createElementVNode("div", _hoisted_10$2, [
                 (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(chat).messages, (message) => {
                   return vue.openBlock(), vue.createElementBlock("div", {
                     key: message.id,
@@ -464,13 +464,13 @@
                           key: 0,
                           class: vue.normalizeClass(["ai-chat__message", `ai-chat__message--${message.role}`])
                         }, [
-                          vue.createElementVNode("div", _hoisted_11$1, [
+                          vue.createElementVNode("div", _hoisted_11$2, [
                             vue.createElementVNode("div", {
                               class: "ai-chat__message-text",
                               innerHTML: renderMarkdown(part.text)
-                            }, null, 8, _hoisted_12$1)
+                            }, null, 8, _hoisted_12$2)
                           ])
-                        ], 2)) : part.type === "reasoning" ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_13$1, [
+                        ], 2)) : part.type === "reasoning" ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_13$2, [
                           vue.createElementVNode("button", {
                             class: "ai-chat__reasoning-trigger",
                             onClick: ($event) => toggleReasoning(message.id)
@@ -487,8 +487,8 @@
                               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),
+                            isStreamingMessage(message.id) && partIndex === message.parts.length - 1 ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_15$1)) : vue.createCommentVNode("", true)
+                          ], 8, _hoisted_14$1),
                           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", {
@@ -693,1213 +693,1457 @@
     return target;
   };
 
-  const aiChat = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-958fd919"]]);
+  const aiChat = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__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);
+  const DATA_STREAM_LINE_RE = /^[0-9a-f]:/;
+  function detectFormat(firstChunk) {
+    const trimmed = firstChunk.trimStart();
+    if (trimmed.startsWith("data:")) {
+      const firstLine = trimmed.split("\n")[0];
+      const payload = firstLine.slice(5).trim();
+      try {
+        const parsed = JSON.parse(payload);
+        if (parsed && typeof parsed.type === "string") {
+          return "ui-message-stream";
+        }
+      } catch {
       }
-    }
-    async executeCommand(command, args = []) {
-      const commandDef = this.commands.get(command);
-      if (!commandDef) {
-        throw new Error(`命令 "${command}" 未找到`);
+      if (DATA_STREAM_LINE_RE.test(payload)) {
+        return "data-stream";
       }
-      this.log("执行命令", command, args);
-      return await commandDef.handler(...args);
+      return "ui-message-stream";
     }
-    getCommands() {
-      return Array.from(this.commands.values()).map((cmd) => ({
-        name: cmd.name,
-        description: cmd.description,
-        parameters: cmd.parameters
-      }));
+    if (DATA_STREAM_LINE_RE.test(trimmed)) {
+      return "data-stream";
     }
-    hasCommand(name) {
-      return this.commands.has(name);
+    return "plain-text";
+  }
+  function processUIMessageStreamEvent(payload, callbacks) {
+    const trimmed = payload.trim();
+    if (!trimmed || trimmed === "[DONE]") {
+      callbacks.onFinish?.({});
+      return;
     }
-    clear() {
-      this.commands.clear();
-      this.log("", "所有命令已清空");
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      console.warn("[DataStreamParser] failed to parse UI message stream event:", trimmed.slice(0, 100));
+      return;
     }
-    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 type = parsed?.type;
+    if (!type) return;
+    switch (type) {
+      case "text-delta":
+        if (typeof parsed.delta === "string") {
+          callbacks.onTextDelta?.(parsed.delta);
+        }
+        break;
+      case "tool-input-start":
+        callbacks.onToolCallStart?.(parsed.toolCallId, parsed.toolName);
+        break;
+      case "tool-input-delta":
+        callbacks.onToolCallDelta?.(parsed.toolCallId, parsed.inputTextDelta);
+        break;
+      case "tool-input-available":
+        callbacks.onToolCallComplete?.(parsed.toolCallId, parsed.toolName, parsed.input);
+        break;
+      case "tool-output-available":
+        callbacks.onToolResult?.(parsed.toolCallId, parsed.output);
+        break;
+      case "finish-step":
+        callbacks.onStepFinish?.(parsed);
+        break;
+      case "finish":
+        callbacks.onFinish?.(parsed);
+        break;
+      case "error":
+      case "tool-output-error":
+        callbacks.onError?.(parsed.errorText || parsed.error || "Unknown error", parsed);
+        break;
+      case "start":
+      case "text-start":
+      case "text-end":
+      case "start-step":
+      case "reasoning-start":
+      case "reasoning-delta":
+      case "reasoning-end":
+      case "source-url":
+      case "source-document":
+      case "file":
+      case "abort":
+        break;
+      default:
+        if (type.startsWith("data-")) ; else {
+          console.log("[DataStreamParser] unhandled UI message stream type:", type);
+        }
+        break;
     }
   }
-
-  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);
+  function parseLegacyProtocolLine(line, callbacks) {
+    if (!line || !DATA_STREAM_LINE_RE.test(line)) return;
+    const code = line[0];
+    const rawValue = line.slice(2);
+    let value;
+    try {
+      value = JSON.parse(rawValue);
+    } catch {
+      value = rawValue;
     }
-    if (!result) {
-      throw new Error(`Could not resolve ${key.description}`);
+    switch (code) {
+      case "0":
+        callbacks.onTextDelta?.(value);
+        break;
+      case "9":
+        callbacks.onToolCallStart?.(value.toolCallId, value.toolName);
+        break;
+      case "b":
+        callbacks.onToolCallDelta?.(value.toolCallId, value.argsTextDelta);
+        break;
+      case "c":
+        callbacks.onToolCallComplete?.(value.toolCallId, value.toolName, value.args);
+        break;
+      case "a":
+        callbacks.onToolResult?.(value.toolCallId, value.result);
+        break;
+      case "e":
+        callbacks.onStepFinish?.(value);
+        break;
+      case "d":
+        callbacks.onFinish?.(value);
+        break;
+      case "3":
+        callbacks.onError?.(value);
+        break;
     }
-    return result;
   }
-
-  const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
-    __name: "sime-provider",
-    props: {
-      project: {},
-      description: {},
-      debug: { type: Boolean },
-      chatbotUrl: {},
-      appId: {},
-      appToken: {},
-      agentId: {}
-    },
-    setup(__props) {
-      const props = __props;
-      const commandManager = vue.shallowRef(new CommandManager({ debug: props.debug ?? false }));
-      const startListeningRef = vue.shallowRef(async () => {
-      });
-      const stopListeningRef = vue.shallowRef(async () => {
-      });
-      const stopBroadcastRef = vue.shallowRef(async () => {
-      });
-      vue.provide(AiChatbotXKey, {
-        chatbotUrl: () => props.chatbotUrl,
-        appId: () => props.appId,
-        appToken: () => props.appToken,
-        agentId: () => props.agentId,
-        startListening: () => startListeningRef.value(),
-        stopListening: () => stopListeningRef.value(),
-        stopBroadcast: () => stopBroadcastRef.value(),
-        registerVoiceMethods: (methods) => {
-          if (methods.stopBroadcast) stopBroadcastRef.value = methods.stopBroadcast;
-          if (methods.start) startListeningRef.value = methods.start;
-          if (methods.stop) stopListeningRef.value = methods.stop;
-        },
-        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);
-    const hasPendingAudio = vue.ref(false);
-    let instance = null;
-    let initPromise = null;
-    let audioCtx = null;
-    let sentenceBuffer = "";
-    const sentenceDelimiters = /[。！？；\n.!?;]/;
-    const stripMarkdown = (text) => text.replace(/```[\s\S]*?```/g, "").replace(/\|[^\n]*\|/g, "").replace(/#{1,6}\s*/g, "").replace(/\*\*(.*?)\*\*/g, "$1").replace(/\*(.*?)\*/g, "$1").replace(/`([^`]*)`/g, "$1").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/[-*+]\s+/g, "").replace(/>\s+/g, "").replace(/\n{2,}/g, "。").replace(/\n/g, "，").trim();
-    const warmUpAudio = () => {
-      if (!audioCtx || audioCtx.state === "closed") {
-        try {
-          audioCtx = new AudioContext();
-        } catch {
-          return;
-        }
+  async function readDataStream(response, callbacks) {
+    if (!response.body) return;
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let format = null;
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value, { stream: true });
+      buffer += chunk;
+      if (format === null && buffer.trim().length > 0) {
+        format = detectFormat(buffer);
+        console.log("[DataStreamParser] detected format:", format, "| first 200 chars:", buffer.slice(0, 200));
       }
-      if (audioCtx.state === "suspended") {
-        audioCtx.resume();
+      if (format === "plain-text") {
+        const text = buffer;
+        buffer = "";
+        if (text) callbacks.onTextDelta?.(text);
+        continue;
       }
-    };
-    let onQueueEmptyCb = null;
-    const ensureInstance = async () => {
-      if (instance) return instance;
-      if (initPromise) return initPromise;
-      const vc = getVoiceConfig();
-      if (!vc || !vc.apiSecret) {
-        console.warn("[TTS] 缺少 voiceConfig 或 apiSecret，语音播报已禁用");
-        return null;
-      }
-      initPromise = (async () => {
-        try {
-          const tts = new webVoiceKit.SpeechSynthesizerStandalone({
-            appId: vc.appId,
-            apiKey: vc.ttsApiKey || vc.apiKey,
-            apiSecret: vc.apiSecret,
-            websocketUrl: vc.ttsWebsocketUrl || "wss://tts-api.xfyun.cn/v2/tts",
-            vcn: vc.ttsVcn || "xiaoyan",
-            speed: vc.speed || 55,
-            volume: vc.volume || 90,
-            pitch: vc.pitch || 50,
-            aue: "raw",
-            auf: "audio/L16;rate=16000",
-            tte: "UTF8",
-            autoPlay: true
-          });
-          tts.onStart(() => {
-            isSpeaking.value = true;
-          });
-          tts.onEnd(() => {
-          });
-          tts.onQueueEmpty(() => {
-            isSpeaking.value = false;
-            hasPendingAudio.value = false;
-            onQueueEmptyCb?.();
-          });
-          tts.onError((err) => {
-            console.error("[TTS] Error:", err);
-            isSpeaking.value = false;
-          });
-          if (audioCtx && audioCtx.state === "running") {
-            tts.audioContext = audioCtx;
-            tts.gainNode = audioCtx.createGain();
-            tts.gainNode.connect(audioCtx.destination);
+      if (format === "ui-message-stream") {
+        while (true) {
+          const eventEnd = buffer.indexOf("\n\n");
+          if (eventEnd === -1) break;
+          const eventBlock = buffer.slice(0, eventEnd);
+          buffer = buffer.slice(eventEnd + 2);
+          const dataLines = eventBlock.split(/\r?\n/).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trimStart());
+          for (const dataLine of dataLines) {
+            processUIMessageStreamEvent(dataLine, callbacks);
           }
-          instance = tts;
-          initPromise = null;
-          return tts;
-        } catch (err) {
-          console.error("[TTS] 初始化失败:", err);
-          initPromise = null;
-          return null;
         }
-      })();
-      return initPromise;
-    };
-    const speak = async (text) => {
-      const clean = stripMarkdown(text);
-      if (!clean.trim()) return;
-      hasPendingAudio.value = true;
-      const tts = await ensureInstance();
-      if (!tts) return;
-      try {
-        tts.speak(clean);
-      } catch (err) {
-        console.error("[TTS] speak 失败:", err);
-      }
-    };
-    const feed = (delta) => {
-      sentenceBuffer += delta;
-      while (true) {
-        const match = sentenceBuffer.match(sentenceDelimiters);
-        if (!match || match.index === void 0) break;
-        const sentence = sentenceBuffer.slice(0, match.index + 1).trim();
-        sentenceBuffer = sentenceBuffer.slice(match.index + 1);
-        if (sentence.length > 0) speak(sentence);
+        continue;
       }
-    };
-    const flush = () => {
-      const remaining = sentenceBuffer.trim();
-      sentenceBuffer = "";
-      if (remaining.length > 0) speak(remaining);
-    };
-    const stop = () => {
-      sentenceBuffer = "";
-      isSpeaking.value = false;
-      hasPendingAudio.value = false;
-      if (instance) {
-        try {
-          instance.stop();
-        } catch {
+      if (format === "data-stream") {
+        const isSSEWrapped = buffer.trimStart().startsWith("data:");
+        if (isSSEWrapped) {
+          while (true) {
+            const eventEnd = buffer.indexOf("\n\n");
+            if (eventEnd === -1) break;
+            const eventBlock = buffer.slice(0, eventEnd);
+            buffer = buffer.slice(eventEnd + 2);
+            const dataLines = eventBlock.split(/\r?\n/).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trimStart());
+            for (const dl of dataLines) {
+              const t = dl.trim();
+              if (!t || t === "[DONE]") {
+                if (t === "[DONE]") callbacks.onFinish?.({});
+                continue;
+              }
+              parseLegacyProtocolLine(t, callbacks);
+            }
+          }
+        } else {
+          while (true) {
+            const newlineIdx = buffer.indexOf("\n");
+            if (newlineIdx === -1) break;
+            const line = buffer.slice(0, newlineIdx).trim();
+            buffer = buffer.slice(newlineIdx + 1);
+            if (line) parseLegacyProtocolLine(line, callbacks);
+          }
         }
+        continue;
       }
-    };
-    const setOnQueueEmpty = (cb) => {
-      onQueueEmptyCb = cb;
-    };
-    const destroy = () => {
-      stop();
-      if (instance) {
-        try {
-          instance.destroy();
-        } catch {
+    }
+    const tail = decoder.decode();
+    if (tail) buffer += tail;
+    if (buffer.trim()) {
+      if (format === "plain-text") {
+        callbacks.onTextDelta?.(buffer);
+      } else if (format === "ui-message-stream") {
+        const dataLines = buffer.split(/\r?\n/).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trimStart());
+        for (const dl of dataLines) {
+          processUIMessageStreamEvent(dl, callbacks);
         }
-        instance = null;
+      } else if (format === "data-stream") {
+        parseLegacyProtocolLine(buffer.trim(), callbacks);
       }
-      if (audioCtx) {
-        try {
-          audioCtx.close();
-        } catch {
+    }
+    callbacks.onFinish?.({});
+  }
+  async function parseDataStreamToMessage(response, onUpdate) {
+    let textContent = "";
+    const parts = [];
+    const toolCalls = /* @__PURE__ */ new Map();
+    const ensureTextPart = () => {
+      for (let i = parts.length - 1; i >= 0; i--) {
+        if (parts[i].type === "text") {
+          return parts[i];
         }
-        audioCtx = null;
       }
+      const textPart = { type: "text", text: "" };
+      parts.push(textPart);
+      return textPart;
     };
-    return {
-      isSpeaking,
-      hasPendingAudio,
-      warmUpAudio,
-      speak,
-      feed,
-      flush,
-      stop,
-      destroy,
-      setOnQueueEmpty
-    };
-  }
-
-  function useBubble(options = {}) {
-    const visible = vue.ref(false);
-    const fadingOut = vue.ref(false);
-    const stackRef = vue.ref(null);
-    let dismissTimer = null;
-    const hasOpened = vue.ref(false);
-    const isTTSActive = () => !!(options.isSpeaking?.value || options.hasPendingAudio?.value);
-    const isBusy = () => !!(options.isInvoking?.value || isTTSActive());
-    const show = vue.computed(() => {
-      if (!hasOpened.value) return false;
-      if (isTTSActive()) return true;
-      return visible.value && !fadingOut.value;
-    });
-    const style = vue.computed(() => ({
-      width: options.bubbleSize?.width || void 0,
-      maxHeight: options.bubbleSize?.maxHeight || void 0
-    }));
-    const open = () => {
-      cancelDismiss();
-      fadingOut.value = false;
-      visible.value = true;
-      hasOpened.value = true;
+    const findToolPartIndex = (toolCallId) => {
+      return parts.findIndex((p) => (p.type === "tool-call" || p.type === "tool-result") && p.toolCallId === toolCallId);
     };
-    const cancelDismiss = () => {
-      if (dismissTimer) {
-        clearTimeout(dismissTimer);
-        dismissTimer = null;
-      }
+    const emitUpdate = () => {
+      onUpdate({ textContent, parts: [...parts], toolCalls: new Map(toolCalls) });
     };
-    const scheduleDismiss = () => {
-      cancelDismiss();
-      if (isBusy()) return;
-      const delay = options.dismissDelay ?? 4e3;
-      dismissTimer = setTimeout(() => {
-        if (isBusy()) return;
-        fadingOut.value = true;
-        setTimeout(() => {
-          if (isBusy()) {
-            fadingOut.value = false;
-            return;
+    await readDataStream(response, {
+      onTextDelta(text) {
+        textContent += text;
+        const textPart = ensureTextPart();
+        textPart.text = textContent;
+        emitUpdate();
+      },
+      onToolCallStart(toolCallId, toolName) {
+        const tracker = {
+          toolCallId,
+          toolName,
+          argsText: "",
+          args: void 0,
+          state: "partial-call"
+        };
+        toolCalls.set(toolCallId, tracker);
+        const part = {
+          type: "tool-call",
+          toolCallId,
+          toolName,
+          args: void 0,
+          state: "partial-call"
+        };
+        parts.push(part);
+        emitUpdate();
+      },
+      onToolCallDelta(toolCallId, argsTextDelta) {
+        const tracker = toolCalls.get(toolCallId);
+        if (tracker) {
+          tracker.argsText += argsTextDelta;
+          try {
+            tracker.args = JSON.parse(tracker.argsText);
+          } catch {
           }
-          visible.value = false;
-          fadingOut.value = false;
-          hasOpened.value = false;
-        }, 400);
-      }, delay);
-    };
-    const watchTTSRef = (ttsRef) => {
-      vue.watch(ttsRef, (active) => {
-        if (active && hasOpened.value) {
-          cancelDismiss();
-          if (fadingOut.value) fadingOut.value = false;
-        } else if (!active && hasOpened.value && !isBusy()) {
-          scheduleDismiss();
+          const idx = findToolPartIndex(toolCallId);
+          if (idx !== -1 && parts[idx].type === "tool-call") {
+            parts[idx].args = tracker.args;
+          }
+          emitUpdate();
         }
-      });
-    };
-    if (options.isSpeaking) watchTTSRef(options.isSpeaking);
-    if (options.hasPendingAudio) watchTTSRef(options.hasPendingAudio);
-    const hide = () => {
-      cancelDismiss();
-      fadingOut.value = false;
-      visible.value = false;
-      hasOpened.value = false;
-    };
-    const scrollToBottom = () => {
-      vue.nextTick(() => {
-        if (stackRef.value) {
-          stackRef.value.scrollTop = stackRef.value.scrollHeight;
+      },
+      onToolCallComplete(toolCallId, toolName, args) {
+        const tracker = toolCalls.get(toolCallId);
+        if (tracker) {
+          tracker.state = "call";
+          tracker.args = typeof args === "string" ? safeJsonParse(args) : args;
+        } else {
+          toolCalls.set(toolCallId, {
+            toolCallId,
+            toolName,
+            argsText: typeof args === "string" ? args : JSON.stringify(args),
+            args: typeof args === "string" ? safeJsonParse(args) : args,
+            state: "call"
+          });
         }
-      });
-    };
-    const destroy = () => {
-      cancelDismiss();
-    };
-    return {
-      visible,
-      fadingOut,
-      show,
-      style,
-      stackRef,
-      open,
-      hide,
-      cancelDismiss,
-      scheduleDismiss,
-      scrollToBottom,
-      destroy
-    };
-  }
-
-  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);
+        const idx = findToolPartIndex(toolCallId);
+        if (idx !== -1) {
+          parts[idx].state = "call";
+          parts[idx].toolName = toolName;
+          parts[idx].args = toolCalls.get(toolCallId).args;
+        } else {
+          parts.push({
+            type: "tool-call",
+            toolCallId,
+            toolName,
+            args: toolCalls.get(toolCallId).args,
+            state: "call"
+          });
         }
-      }
-      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;
+        emitUpdate();
+      },
+      onToolResult(toolCallId, result) {
+        const tracker = toolCalls.get(toolCallId);
+        if (tracker) {
+          tracker.result = result;
+          tracker.state = "result";
         }
-        const activeTrack = audioTracks[0];
-        if (!activeTrack.enabled || activeTrack.readyState !== "live") {
-          console.log("麦克风设备不可用，请检查设备连接。");
-          return false;
+        const idx = findToolPartIndex(toolCallId);
+        if (idx !== -1) {
+          const existing = parts[idx];
+          const resultPart = {
+            type: "tool-result",
+            toolCallId,
+            toolName: existing.toolName,
+            args: existing.args,
+            result,
+            state: "result"
+          };
+          parts[idx] = resultPart;
+        } else {
+          parts.push({
+            type: "tool-result",
+            toolCallId,
+            toolName: tracker?.toolName || "unknown",
+            args: tracker?.args,
+            result,
+            state: "result"
+          });
         }
-        return true;
-      } finally {
-        if (stream) {
-          stream.getTracks().forEach((track) => track.stop());
+        emitUpdate();
+      },
+      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) {
+        emitUpdate();
+      },
+      onFinish(_data) {
+        emitUpdate();
       }
-    } 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;
+    });
+    return { textContent, parts, toolCalls };
+  }
+  function safeJsonParse(str) {
+    try {
+      return JSON.parse(str);
+    } catch {
+      return str;
     }
-  };
+  }
 
-  function useVoiceRecognition(options) {
-    const voiceStatus = vue.ref("standby");
-    const isTranscribing = vue.ref(false);
-    const isInitializing = vue.ref(false);
-    const transcriptionText = vue.ref("");
-    const wakeAnimating = vue.ref(false);
-    let detector = null;
-    let transcriber = null;
-    const initTranscriber = () => {
-      if (transcriber) return;
-      const vc = options.getVoiceConfig();
-      if (!vc || !vc.appId || !vc.apiKey || !vc.websocketUrl) {
-        console.error("[VoiceRecognition] 缺少 voiceConfig，无法初始化转写器");
-        return;
+  const toolDisplayNames = {
+    generateReport: "生成报告",
+    searchKnowledge: "知识库检索",
+    resolveInstanceTargets: "解析实例目标",
+    getHistoryMetrics: "历史数据查询",
+    getRealtimeMetrics: "实时数据查询",
+    queryBitableData: "多维表格查询",
+    searchUser: "搜索用户",
+    createBitableRecord: "创建表格记录",
+    timeTool: "时间工具",
+    loadSkill: "加载技能",
+    executeCommand: "执行命令",
+    dataAnalyzer: "数据分析",
+    dataPredictor: "数据预测"
+  };
+  function useAgentInvoke(options) {
+    const { aiChatbotX, tts, bubble } = options;
+    const sessionTimeoutMs = options.sessionTimeoutMs ?? 12e4;
+    const maxHistoryTurns = options.maxHistoryTurns ?? 10;
+    const isInvoking = vue.ref(false);
+    const currentTextContent = vue.ref("");
+    const currentToolParts = vue.ref([]);
+    const executingTools = vue.ref(/* @__PURE__ */ new Set());
+    const conversationHistory = vue.ref([]);
+    let lastInteractionTime = 0;
+    const checkSessionTimeout = () => {
+      if (lastInteractionTime > 0 && Date.now() - lastInteractionTime > sessionTimeoutMs) {
+        conversationHistory.value = [];
       }
-      transcriber = new webVoiceKit.SpeechTranscriberStandalone({
-        appId: vc.appId,
-        apiKey: vc.apiKey,
-        websocketUrl: vc.websocketUrl,
-        autoStop: {
-          enabled: true,
-          silenceTimeoutMs: 2e3,
-          noSpeechTimeoutMs: 5e3,
-          maxDurationMs: 45e3
-        }
-      });
-      transcriber.onResult((result) => {
-        transcriptionText.value = result.transcript || "";
-      });
-      transcriber.onAutoStop(async () => {
-        const finalText = transcriptionText.value;
-        await stopTranscribing();
-        transcriptionText.value = "";
-        if (finalText.trim()) {
-          options.onTranscriptionDone?.(finalText);
-        }
-      });
-      transcriber.onError((error) => {
-        console.error("[VoiceRecognition] 转写错误:", error);
-        stopTranscribing();
-        transcriptionText.value = "";
-      });
     };
-    const startTranscribing = async () => {
-      if (isTranscribing.value) return;
-      if (!transcriber) initTranscriber();
-      if (!transcriber) return;
-      try {
-        await transcriber.start();
-        isTranscribing.value = true;
-        transcriptionText.value = "";
-      } catch (error) {
-        console.error("[VoiceRecognition] 启动转写失败:", error);
+    const appendToHistory = (role, content) => {
+      conversationHistory.value.push({ role, content });
+      const maxLen = maxHistoryTurns * 2;
+      if (conversationHistory.value.length > maxLen) {
+        conversationHistory.value = conversationHistory.value.slice(-maxLen);
       }
     };
-    const stopTranscribing = async () => {
-      if (!transcriber || !transcriber.isActive()) {
-        isTranscribing.value = false;
-        return;
+    const clearHistory = () => {
+      conversationHistory.value = [];
+    };
+    let abortController = null;
+    const hasAnyContent = vue.computed(() => {
+      return !!(currentTextContent.value || currentToolParts.value.length > 0);
+    });
+    const toolDisplayName = (name) => toolDisplayNames[name] || name;
+    const resetState = () => {
+      currentTextContent.value = "";
+      currentToolParts.value = [];
+      executingTools.value = /* @__PURE__ */ new Set();
+    };
+    const 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;
       }
-      try {
-        await transcriber.stop();
-      } catch (error) {
-        console.error("[VoiceRecognition] 停止转写失败:", error);
-      } finally {
-        isTranscribing.value = false;
+      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 initDetector = () => {
-      if (detector || isInitializing.value) return;
-      if (!options.modelPath) {
-        console.error("[VoiceRecognition] 未传入 modelPath，无法启用唤醒词");
-        return;
+    const resolveExecutableCommands = (toolName, payload, commandDefinitions) => {
+      const extractedCommands = extractExecutableCommands(payload);
+      if (extractedCommands.length > 0) {
+        return extractedCommands;
       }
-      isInitializing.value = true;
+      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 {
-        detector = new webVoiceKit.WakeWordDetectorStandalone({
-          modelPath: options.modelPath,
-          sampleRate: 16e3,
-          usePartial: true,
-          autoReset: {
-            enabled: true,
-            resetDelayMs: 4e3
+        executingTools.value = /* @__PURE__ */ new Set([...executingTools.value, toolCallId]);
+        for (const cmd of commands) {
+          try {
+            await aiChatbotX.executeCommand(cmd.name, cmd.args);
+          } catch (cmdErr) {
+            console.error(`[AgentInvoke] 执行命令 ${cmd.name} 失败:`, cmdErr);
           }
-        });
-        detector.setWakeWords(options.wakeWords || ["你好", "您好"]);
-        detector.onWake(async () => {
-          wakeAnimating.value = true;
-          options.onWake?.();
-          await startTranscribing();
-          setTimeout(() => {
-            wakeAnimating.value = false;
-          }, 1200);
-        });
-        detector.onError((error) => {
-          console.error("[VoiceRecognition] 唤醒监听错误:", error);
-          voiceStatus.value = "standby";
-          stopTranscribing();
-        });
+        }
+        return true;
       } finally {
-        isInitializing.value = false;
+        const next = new Set(executingTools.value);
+        next.delete(toolCallId);
+        executingTools.value = next;
       }
     };
-    const toggleVoiceMode = async (targetState) => {
-      const permission = await ensureMicrophonePermission();
-      if (!permission || isInitializing.value) return;
-      if (!detector) {
-        initDetector();
-        if (!detector) return;
+    const parseAssistantText = (payload) => {
+      if (!payload) return "";
+      if (typeof payload === "string") return payload;
+      if (typeof payload === "object") {
+        const data = payload;
+        const directText = data.output || data.answer || data.message || data.result;
+        if (typeof directText === "string" && directText.trim()) return directText;
+        if (data.data && typeof data.data === "object") {
+          const nested = data.data;
+          const nestedText = nested.output || nested.answer || nested.message || nested.result;
+          if (typeof nestedText === "string" && nestedText.trim()) return nestedText;
+        }
+        return JSON.stringify(payload);
       }
-      const isListening = voiceStatus.value === "listening";
-      const shouldStart = targetState !== void 0 ? targetState : !isListening;
-      if (isListening === shouldStart) return;
+      return String(payload);
+    };
+    const invoke = async (question) => {
+      const content = question.trim();
+      if (!content) return;
+      abort();
+      checkSessionTimeout();
+      resetState();
+      tts.stop();
+      isInvoking.value = true;
+      bubble.open();
+      let prevTextLength = 0;
+      const processedToolResults = /* @__PURE__ */ new Set();
+      const processingToolResults = /* @__PURE__ */ new Set();
+      abortController = new AbortController();
+      const commands = await aiChatbotX.getCommads();
+      const commandDefinitions = buildCommandDefinitionMap(commands);
+      conversationHistory.value.length > 0 ? [...conversationHistory.value] : void 0;
       try {
-        if (shouldStart) {
-          await detector.start();
-          voiceStatus.value = "listening";
+        const response = await fetch(options.endpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", Authorization: `Bearer ${options.appToken || ""}` },
+          body: JSON.stringify({
+            input: content,
+            projectId: options.projectId || "",
+            commands: commands.length > 0 ? commands : void 0
+            // messages: historyToSend,
+          }),
+          signal: abortController.signal
+        });
+        if (!response.ok) throw new Error(`HTTP ${response.status}`);
+        const contentType = response.headers.get("content-type") || "";
+        const isJsonResponse = contentType.includes("application/json");
+        if (isJsonResponse) {
+          const data = await response.json();
+          const reply = parseAssistantText(data) || "已收到，但没有返回可展示的文本内容。";
+          currentTextContent.value = reply;
+          tts.speak(reply);
+          appendToHistory("user", content);
+          appendToHistory("assistant", reply);
+          if (data.toolResults && Array.isArray(data.toolResults)) {
+            for (const tr of data.toolResults) {
+              const toolPart = {
+                type: "tool-result",
+                toolCallId: `invoke-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+                toolName: tr.toolName,
+                args: tr.args,
+                result: tr.result,
+                state: "result"
+              };
+              currentToolParts.value = [...currentToolParts.value, toolPart];
+              if (commandDefinitions.has(tr.toolName)) {
+                void executeHostCommands(toolPart.toolCallId, tr.toolName, tr.result, commandDefinitions);
+              }
+            }
+          }
         } else {
-          await detector.stop();
-          voiceStatus.value = "standby";
-          transcriptionText.value = "";
-          await stopTranscribing();
+          await parseDataStreamToMessage(response, (result) => {
+            currentTextContent.value = result.textContent;
+            if (result.textContent.length > prevTextLength) {
+              const delta = result.textContent.slice(prevTextLength);
+              prevTextLength = result.textContent.length;
+              tts.feed(delta);
+            }
+            const toolParts = result.parts.filter(
+              (p) => p.type === "tool-call" || p.type === "tool-result"
+            );
+            currentToolParts.value = toolParts;
+            for (const part of toolParts) {
+              if (commandDefinitions.has(part.toolName) && !processedToolResults.has(part.toolCallId) && !processingToolResults.has(part.toolCallId)) {
+                if (part.type === "tool-call" && part.state === "call" && 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) {
+                  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);
+                    }
+                  );
+                }
+              }
+            }
+            bubble.scrollToBottom();
+          });
+          tts.flush();
+          const assistantReply = currentTextContent.value.trim();
+          appendToHistory("user", content);
+          if (assistantReply) {
+            appendToHistory("assistant", assistantReply);
+          }
+          if (!assistantReply && currentToolParts.value.length === 0) {
+            currentTextContent.value = "已收到，但没有返回可展示的文本内容。";
+          }
         }
       } catch (error) {
-        console.error("[VoiceRecognition] 监听切换失败:", error);
-        voiceStatus.value = "standby";
-      }
+        if (error.name === "AbortError") {
+          return;
+        }
+        console.error("[AgentInvoke] invoke failed:", error);
+        tts.stop();
+        currentTextContent.value = "请求失败，请检查服务地址或稍后重试。";
+      } finally {
+        isInvoking.value = false;
+        abortController = null;
+        lastInteractionTime = Date.now();
+        bubble.scheduleDismiss();
+      }
     };
-    const abortTranscription = async () => {
-      transcriptionText.value = "";
-      await stopTranscribing();
+    const abort = () => {
+      if (abortController) {
+        abortController.abort();
+        abortController = null;
+      }
+      tts.stop();
+      isInvoking.value = false;
     };
-    const destroy = async () => {
-      if (detector) {
-        try {
-          if (detector.isActive()) await detector.stop();
-        } catch {
-        }
-        detector = null;
+    return {
+      isInvoking,
+      currentTextContent,
+      currentToolParts,
+      executingTools,
+      hasAnyContent,
+      conversationHistory,
+      toolDisplayName,
+      invoke,
+      abort,
+      resetState,
+      clearHistory
+    };
+  }
+
+  function useBubble(options = {}) {
+    const visible = vue.ref(false);
+    const fadingOut = vue.ref(false);
+    const stackRef = vue.ref(null);
+    let dismissTimer = null;
+    const hasOpened = vue.ref(false);
+    const isTTSActive = () => !!(options.isSpeaking?.value || options.hasPendingAudio?.value);
+    const isBusy = () => !!(options.isInvoking?.value || isTTSActive());
+    const show = vue.computed(() => {
+      if (!hasOpened.value) return false;
+      if (isTTSActive()) return true;
+      return visible.value && !fadingOut.value;
+    });
+    const style = vue.computed(() => ({
+      width: options.bubbleSize?.width || void 0,
+      maxHeight: options.bubbleSize?.maxHeight || void 0
+    }));
+    const open = () => {
+      cancelDismiss();
+      fadingOut.value = false;
+      visible.value = true;
+      hasOpened.value = true;
+    };
+    const cancelDismiss = () => {
+      if (dismissTimer) {
+        clearTimeout(dismissTimer);
+        dismissTimer = null;
       }
-      if (transcriber) {
-        try {
-          if (transcriber.isActive()) await transcriber.stop();
-        } catch {
+    };
+    const scheduleDismiss = () => {
+      cancelDismiss();
+      if (isBusy()) return;
+      const delay = options.dismissDelay ?? 4e3;
+      dismissTimer = setTimeout(() => {
+        if (isBusy()) return;
+        fadingOut.value = true;
+        setTimeout(() => {
+          if (isBusy()) {
+            fadingOut.value = false;
+            return;
+          }
+          visible.value = false;
+          fadingOut.value = false;
+          hasOpened.value = false;
+        }, 400);
+      }, delay);
+    };
+    const watchTTSRef = (ttsRef) => {
+      vue.watch(ttsRef, (active) => {
+        if (active && hasOpened.value) {
+          cancelDismiss();
+          if (fadingOut.value) fadingOut.value = false;
+        } else if (!active && hasOpened.value && !isBusy()) {
+          scheduleDismiss();
         }
-        transcriber = null;
-      }
+      });
+    };
+    if (options.isSpeaking) watchTTSRef(options.isSpeaking);
+    if (options.hasPendingAudio) watchTTSRef(options.hasPendingAudio);
+    const hide = () => {
+      cancelDismiss();
+      fadingOut.value = false;
+      visible.value = false;
+      hasOpened.value = false;
+    };
+    const scrollToBottom = () => {
+      vue.nextTick(() => {
+        if (stackRef.value) {
+          stackRef.value.scrollTop = stackRef.value.scrollHeight;
+        }
+      });
+    };
+    const destroy = () => {
+      cancelDismiss();
     };
     return {
-      voiceStatus,
-      isTranscribing,
-      isInitializing,
-      transcriptionText,
-      wakeAnimating,
-      startTranscribing,
-      stopTranscribing,
-      abortTranscription,
-      toggleVoiceMode,
+      visible,
+      fadingOut,
+      show,
+      style,
+      stackRef,
+      open,
+      hide,
+      cancelDismiss,
+      scheduleDismiss,
+      scrollToBottom,
       destroy
     };
   }
 
-  const DATA_STREAM_LINE_RE = /^[0-9a-f]:/;
-  function detectFormat(firstChunk) {
-    const trimmed = firstChunk.trimStart();
-    if (trimmed.startsWith("data:")) {
-      const firstLine = trimmed.split("\n")[0];
-      const payload = firstLine.slice(5).trim();
-      try {
-        const parsed = JSON.parse(payload);
-        if (parsed && typeof parsed.type === "string") {
-          return "ui-message-stream";
-        }
-      } catch {
-      }
-      if (DATA_STREAM_LINE_RE.test(payload)) {
-        return "data-stream";
-      }
-      return "ui-message-stream";
+  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 (DATA_STREAM_LINE_RE.test(trimmed)) {
-      return "data-stream";
+    if (!result) {
+      throw new Error(`Could not resolve ${key.description}`);
     }
-    return "plain-text";
+    return result;
   }
-  function processUIMessageStreamEvent(payload, callbacks) {
-    const trimmed = payload.trim();
-    if (!trimmed || trimmed === "[DONE]") {
-      callbacks.onFinish?.({});
-      return;
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(trimmed);
-    } catch {
-      console.warn("[DataStreamParser] failed to parse UI message stream event:", trimmed.slice(0, 100));
-      return;
-    }
-    const type = parsed?.type;
-    if (!type) return;
-    switch (type) {
-      case "text-delta":
-        if (typeof parsed.delta === "string") {
-          callbacks.onTextDelta?.(parsed.delta);
+
+  const _hoisted_1$1 = { class: "agent-bubble" };
+  const _hoisted_2$1 = {
+    key: 0,
+    class: "tool-steps"
+  };
+  const _hoisted_3$1 = { class: "tool-step__icon" };
+  const _hoisted_4$1 = {
+    key: 0,
+    class: "tool-step__spinner",
+    width: "14",
+    height: "14",
+    viewBox: "0 0 24 24",
+    fill: "none"
+  };
+  const _hoisted_5$1 = {
+    key: 1,
+    width: "14",
+    height: "14",
+    viewBox: "0 0 24 24",
+    fill: "none"
+  };
+  const _hoisted_6$1 = {
+    key: 2,
+    width: "14",
+    height: "14",
+    viewBox: "0 0 24 24",
+    fill: "none"
+  };
+  const _hoisted_7$1 = { class: "tool-step__name" };
+  const _hoisted_8$1 = {
+    key: 0,
+    class: "tool-step__tag tool-step__tag--exec"
+  };
+  const _hoisted_9$1 = {
+    key: 1,
+    class: "thinking-dots"
+  };
+  const _hoisted_10$1 = {
+    key: 2,
+    class: "agent-text"
+  };
+  const _hoisted_11$1 = { class: "input-bar" };
+  const _hoisted_12$1 = ["disabled"];
+  const _hoisted_13$1 = ["disabled"];
+  const _hoisted_14 = {
+    key: 0,
+    class: "btn-spinner",
+    width: "18",
+    height: "18",
+    viewBox: "0 0 24 24",
+    fill: "none"
+  };
+  const _hoisted_15 = {
+    key: 1,
+    width: "18",
+    height: "18",
+    viewBox: "0 0 24 24",
+    fill: "none"
+  };
+  const currentTheme$1 = "dark";
+  const _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
+    __name: "command-test",
+    props: {
+      agentId: {},
+      projectId: {},
+      bubbleSize: {},
+      bubbleDismissDelay: {}
+    },
+    setup(__props) {
+      const props = __props;
+      const aiChatbotX = injectStrict(AiChatbotXKey);
+      const inputText = vue.ref("");
+      const noopTts = {
+        speak: (_text) => {
+        },
+        feed: (_delta) => {
+        },
+        flush: () => {
+        },
+        stop: () => {
         }
-        break;
-      case "tool-input-start":
-        callbacks.onToolCallStart?.(parsed.toolCallId, parsed.toolName);
-        break;
-      case "tool-input-delta":
-        callbacks.onToolCallDelta?.(parsed.toolCallId, parsed.inputTextDelta);
-        break;
-      case "tool-input-available":
-        callbacks.onToolCallComplete?.(parsed.toolCallId, parsed.toolName, parsed.input);
-        break;
-      case "tool-output-available":
-        callbacks.onToolResult?.(parsed.toolCallId, parsed.output);
-        break;
-      case "finish-step":
-        callbacks.onStepFinish?.(parsed);
-        break;
-      case "finish":
-        callbacks.onFinish?.(parsed);
-        break;
-      case "error":
-      case "tool-output-error":
-        callbacks.onError?.(parsed.errorText || parsed.error || "Unknown error", parsed);
-        break;
-      case "start":
-      case "text-start":
-      case "text-end":
-      case "start-step":
-      case "reasoning-start":
-      case "reasoning-delta":
-      case "reasoning-end":
-      case "source-url":
-      case "source-document":
-      case "file":
-      case "abort":
-        break;
-      default:
-        if (type.startsWith("data-")) ; else {
-          console.log("[DataStreamParser] unhandled UI message stream type:", type);
+      };
+      const bubbleBridge = {
+        open: () => {
+        },
+        scheduleDismiss: () => {
+        },
+        scrollToBottom: () => {
         }
-        break;
+      };
+      const endpoint = `/sime/proxy/organizations/${aiChatbotX.organizationId()}/agents/${props.agentId}/stream-invoke`;
+      const agent = useAgentInvoke({
+        endpoint,
+        appToken: aiChatbotX.appToken(),
+        projectId: props.projectId,
+        aiChatbotX,
+        tts: noopTts,
+        bubble: {
+          open: () => bubbleBridge.open(),
+          scheduleDismiss: () => bubbleBridge.scheduleDismiss(),
+          scrollToBottom: () => bubbleBridge.scrollToBottom()
+        }
+      });
+      const bubble = useBubble({
+        dismissDelay: props.bubbleDismissDelay ?? 8e3,
+        isInvoking: agent.isInvoking,
+        bubbleSize: props.bubbleSize
+      });
+      bubbleBridge.open = bubble.open;
+      bubbleBridge.scheduleDismiss = bubble.scheduleDismiss;
+      bubbleBridge.scrollToBottom = bubble.scrollToBottom;
+      const { show: showBubble, style: bubbleStyle, stackRef: bubbleStackRef } = bubble;
+      const handleSubmit = () => {
+        const text = inputText.value.trim();
+        if (!text || agent.isInvoking.value) return;
+        inputText.value = "";
+        agent.invoke(text);
+      };
+      const { isInvoking, currentTextContent, currentToolParts, executingTools, hasAnyContent, toolDisplayName } = agent;
+      vue.onBeforeUnmount(() => {
+        bubble.destroy();
+        agent.abort();
+      });
+      return (_ctx, _cache) => {
+        return vue.openBlock(), vue.createElementBlock("div", {
+          class: "command-test",
+          "data-theme": currentTheme$1
+        }, [
+          vue.createVNode(vue.Transition, { name: "bubble-fade" }, {
+            default: vue.withCtx(() => [
+              vue.unref(showBubble) ? (vue.openBlock(), vue.createElementBlock("div", {
+                key: 0,
+                class: "bubble-stack",
+                ref_key: "bubbleStackRef",
+                ref: bubbleStackRef,
+                style: vue.normalizeStyle(vue.unref(bubbleStyle))
+              }, [
+                vue.createElementVNode("div", _hoisted_1$1, [
+                  vue.unref(currentToolParts).length > 0 ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2$1, [
+                    (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(currentToolParts), (toolPart) => {
+                      return vue.openBlock(), vue.createElementBlock("div", {
+                        key: toolPart.toolCallId,
+                        class: vue.normalizeClass(["tool-step", {
+                          "tool-step--loading": toolPart.state === "partial-call" || toolPart.state === "call",
+                          "tool-step--done": toolPart.state === "result",
+                          "tool-step--error": toolPart.state === "error",
+                          "tool-step--executing": vue.unref(executingTools).has(toolPart.toolCallId)
+                        }])
+                      }, [
+                        vue.createElementVNode("span", _hoisted_3$1, [
+                          toolPart.state === "partial-call" || toolPart.state === "call" ? (vue.openBlock(), vue.createElementBlock("svg", _hoisted_4$1, [..._cache[1] || (_cache[1] = [
+                            vue.createElementVNode("circle", {
+                              cx: "12",
+                              cy: "12",
+                              r: "10",
+                              stroke: "currentColor",
+                              "stroke-width": "2.5",
+                              "stroke-linecap": "round",
+                              "stroke-dasharray": "31.4 31.4"
+                            }, null, -1)
+                          ])])) : toolPart.state === "result" ? (vue.openBlock(), vue.createElementBlock("svg", _hoisted_5$1, [..._cache[2] || (_cache[2] = [
+                            vue.createElementVNode("path", {
+                              d: "M20 6L9 17l-5-5",
+                              stroke: "currentColor",
+                              "stroke-width": "2.5",
+                              "stroke-linecap": "round",
+                              "stroke-linejoin": "round"
+                            }, null, -1)
+                          ])])) : toolPart.state === "error" ? (vue.openBlock(), vue.createElementBlock("svg", _hoisted_6$1, [..._cache[3] || (_cache[3] = [
+                            vue.createElementVNode("circle", {
+                              cx: "12",
+                              cy: "12",
+                              r: "10",
+                              stroke: "currentColor",
+                              "stroke-width": "2"
+                            }, null, -1),
+                            vue.createElementVNode("path", {
+                              d: "M15 9l-6 6M9 9l6 6",
+                              stroke: "currentColor",
+                              "stroke-width": "2",
+                              "stroke-linecap": "round"
+                            }, null, -1)
+                          ])])) : vue.createCommentVNode("", true)
+                        ]),
+                        vue.createElementVNode("span", _hoisted_7$1, vue.toDisplayString(vue.unref(toolDisplayName)(toolPart.toolName)), 1),
+                        vue.unref(executingTools).has(toolPart.toolCallId) ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_8$1, "命令执行中")) : vue.createCommentVNode("", true)
+                      ], 2);
+                    }), 128))
+                  ])) : vue.createCommentVNode("", true),
+                  vue.unref(isInvoking) && !vue.unref(hasAnyContent) ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_9$1, [..._cache[4] || (_cache[4] = [
+                    vue.createElementVNode("span", null, null, -1),
+                    vue.createElementVNode("span", null, null, -1),
+                    vue.createElementVNode("span", null, null, -1)
+                  ])])) : vue.createCommentVNode("", true),
+                  vue.unref(currentTextContent) ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_10$1, vue.toDisplayString(vue.unref(currentTextContent)), 1)) : vue.createCommentVNode("", true)
+                ])
+              ], 4)) : vue.createCommentVNode("", true)
+            ]),
+            _: 1
+          }),
+          vue.createElementVNode("div", _hoisted_11$1, [
+            vue.withDirectives(vue.createElementVNode("input", {
+              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => inputText.value = $event),
+              type: "text",
+              class: "input-field",
+              placeholder: "输入指令...",
+              disabled: vue.unref(isInvoking),
+              onKeydown: vue.withKeys(handleSubmit, ["enter"])
+            }, null, 40, _hoisted_12$1), [
+              [vue.vModelText, inputText.value]
+            ]),
+            vue.createElementVNode("button", {
+              class: "submit-btn",
+              disabled: vue.unref(isInvoking) || !inputText.value.trim(),
+              onClick: handleSubmit
+            }, [
+              vue.unref(isInvoking) ? (vue.openBlock(), vue.createElementBlock("svg", _hoisted_14, [..._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)
+              ])])) : (vue.openBlock(), vue.createElementBlock("svg", _hoisted_15, [..._cache[6] || (_cache[6] = [
+                vue.createElementVNode("path", {
+                  d: "M22 2L11 13",
+                  stroke: "currentColor",
+                  "stroke-width": "2",
+                  "stroke-linecap": "round",
+                  "stroke-linejoin": "round"
+                }, null, -1),
+                vue.createElementVNode("path", {
+                  d: "M22 2L15 22l-4-9-9-4 20-7z",
+                  stroke: "currentColor",
+                  "stroke-width": "2",
+                  "stroke-linecap": "round",
+                  "stroke-linejoin": "round"
+                }, null, -1)
+              ])]))
+            ], 8, _hoisted_13$1)
+          ])
+        ]);
+      };
     }
-  }
-  function parseLegacyProtocolLine(line, callbacks) {
-    if (!line || !DATA_STREAM_LINE_RE.test(line)) return;
-    const code = line[0];
-    const rawValue = line.slice(2);
-    let value;
-    try {
-      value = JSON.parse(rawValue);
-    } catch {
-      value = rawValue;
+  });
+
+  const commandTest = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__scopeId", "data-v-5c7468c4"]]);
+
+  class CommandManager {
+    commands = /* @__PURE__ */ new Map();
+    debug;
+    constructor(options = {}) {
+      this.debug = options.debug ?? false;
     }
-    switch (code) {
-      case "0":
-        callbacks.onTextDelta?.(value);
-        break;
-      case "9":
-        callbacks.onToolCallStart?.(value.toolCallId, value.toolName);
-        break;
-      case "b":
-        callbacks.onToolCallDelta?.(value.toolCallId, value.argsTextDelta);
-        break;
-      case "c":
-        callbacks.onToolCallComplete?.(value.toolCallId, value.toolName, value.args);
-        break;
-      case "a":
-        callbacks.onToolResult?.(value.toolCallId, value.result);
-        break;
-      case "e":
-        callbacks.onStepFinish?.(value);
-        break;
-      case "d":
-        callbacks.onFinish?.(value);
-        break;
-      case "3":
-        callbacks.onError?.(value);
-        break;
+    registerCommand(command) {
+      this.commands.set(command.name, command);
+      this.log("注册命令", `${command.name}: ${command.description}`);
     }
-  }
-  async function readDataStream(response, callbacks) {
-    if (!response.body) return;
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    let format = null;
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) break;
-      const chunk = decoder.decode(value, { stream: true });
-      buffer += chunk;
-      if (format === null && buffer.trim().length > 0) {
-        format = detectFormat(buffer);
-        console.log("[DataStreamParser] detected format:", format, "| first 200 chars:", buffer.slice(0, 200));
-      }
-      if (format === "plain-text") {
-        const text = buffer;
-        buffer = "";
-        if (text) callbacks.onTextDelta?.(text);
-        continue;
-      }
-      if (format === "ui-message-stream") {
-        while (true) {
-          const eventEnd = buffer.indexOf("\n\n");
-          if (eventEnd === -1) break;
-          const eventBlock = buffer.slice(0, eventEnd);
-          buffer = buffer.slice(eventEnd + 2);
-          const dataLines = eventBlock.split(/\r?\n/).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trimStart());
-          for (const dataLine of dataLines) {
-            processUIMessageStreamEvent(dataLine, callbacks);
-          }
-        }
-        continue;
+    unregisterCommand(name) {
+      const deleted = this.commands.delete(name);
+      if (deleted) {
+        this.log("命令已注销", name);
       }
-      if (format === "data-stream") {
-        const isSSEWrapped = buffer.trimStart().startsWith("data:");
-        if (isSSEWrapped) {
-          while (true) {
-            const eventEnd = buffer.indexOf("\n\n");
-            if (eventEnd === -1) break;
-            const eventBlock = buffer.slice(0, eventEnd);
-            buffer = buffer.slice(eventEnd + 2);
-            const dataLines = eventBlock.split(/\r?\n/).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trimStart());
-            for (const dl of dataLines) {
-              const t = dl.trim();
-              if (!t || t === "[DONE]") {
-                if (t === "[DONE]") callbacks.onFinish?.({});
-                continue;
-              }
-              parseLegacyProtocolLine(t, callbacks);
-            }
-          }
-        } else {
-          while (true) {
-            const newlineIdx = buffer.indexOf("\n");
-            if (newlineIdx === -1) break;
-            const line = buffer.slice(0, newlineIdx).trim();
-            buffer = buffer.slice(newlineIdx + 1);
-            if (line) parseLegacyProtocolLine(line, callbacks);
-          }
-        }
-        continue;
+    }
+    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);
     }
-    const tail = decoder.decode();
-    if (tail) buffer += tail;
-    if (buffer.trim()) {
-      if (format === "plain-text") {
-        callbacks.onTextDelta?.(buffer);
-      } else if (format === "ui-message-stream") {
-        const dataLines = buffer.split(/\r?\n/).filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trimStart());
-        for (const dl of dataLines) {
-          processUIMessageStreamEvent(dl, callbacks);
-        }
-      } else if (format === "data-stream") {
-        parseLegacyProtocolLine(buffer.trim(), callbacks);
+    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);
       }
     }
-    callbacks.onFinish?.({});
   }
-  async function parseDataStreamToMessage(response, onUpdate) {
-    let textContent = "";
-    const parts = [];
-    const toolCalls = /* @__PURE__ */ new Map();
-    const ensureTextPart = () => {
-      for (let i = parts.length - 1; i >= 0; i--) {
-        if (parts[i].type === "text") {
-          return parts[i];
+
+  const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
+    __name: "sime-provider",
+    props: {
+      appToken: {},
+      organizationId: {}
+    },
+    setup(__props) {
+      const props = __props;
+      const commandManager = vue.shallowRef(new CommandManager({ debug: false }));
+      const startListeningRef = vue.shallowRef(async () => {
+      });
+      const stopListeningRef = vue.shallowRef(async () => {
+      });
+      const stopBroadcastRef = vue.shallowRef(async () => {
+      });
+      vue.provide(AiChatbotXKey, {
+        appToken: () => props.appToken,
+        organizationId: () => props.organizationId,
+        startListening: () => startListeningRef.value(),
+        stopListening: () => stopListeningRef.value(),
+        stopBroadcast: () => stopBroadcastRef.value(),
+        registerVoiceMethods: (methods) => {
+          if (methods.stopBroadcast) stopBroadcastRef.value = methods.stopBroadcast;
+          if (methods.start) startListeningRef.value = methods.start;
+          if (methods.stop) stopListeningRef.value = methods.stop;
+        },
+        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);
+    const hasPendingAudio = vue.ref(false);
+    let instance = null;
+    let initPromise = null;
+    let audioCtx = null;
+    let sentenceBuffer = "";
+    const sentenceDelimiters = /[。！？；\n.!?;]/;
+    const stripMarkdown = (text) => text.replace(/```[\s\S]*?```/g, "").replace(/\|[^\n]*\|/g, "").replace(/#{1,6}\s*/g, "").replace(/\*\*(.*?)\*\*/g, "$1").replace(/\*(.*?)\*/g, "$1").replace(/`([^`]*)`/g, "$1").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/[-*+]\s+/g, "").replace(/>\s+/g, "").replace(/\n{2,}/g, "。").replace(/\n/g, "，").trim();
+    const warmUpAudio = () => {
+      if (!audioCtx || audioCtx.state === "closed") {
+        try {
+          audioCtx = new AudioContext();
+        } catch {
+          return;
         }
       }
-      const textPart = { type: "text", text: "" };
-      parts.push(textPart);
-      return textPart;
-    };
-    const findToolPartIndex = (toolCallId) => {
-      return parts.findIndex((p) => (p.type === "tool-call" || p.type === "tool-result") && p.toolCallId === toolCallId);
-    };
-    const emitUpdate = () => {
-      onUpdate({ textContent, parts: [...parts], toolCalls: new Map(toolCalls) });
+      if (audioCtx.state === "suspended") {
+        audioCtx.resume();
+      }
     };
-    await readDataStream(response, {
-      onTextDelta(text) {
-        textContent += text;
-        const textPart = ensureTextPart();
-        textPart.text = textContent;
-        emitUpdate();
-      },
-      onToolCallStart(toolCallId, toolName) {
-        const tracker = {
-          toolCallId,
-          toolName,
-          argsText: "",
-          args: void 0,
-          state: "partial-call"
-        };
-        toolCalls.set(toolCallId, tracker);
-        const part = {
-          type: "tool-call",
-          toolCallId,
-          toolName,
-          args: void 0,
-          state: "partial-call"
-        };
-        parts.push(part);
-        emitUpdate();
-      },
-      onToolCallDelta(toolCallId, argsTextDelta) {
-        const tracker = toolCalls.get(toolCallId);
-        if (tracker) {
-          tracker.argsText += argsTextDelta;
-          try {
-            tracker.args = JSON.parse(tracker.argsText);
-          } catch {
-          }
-          const idx = findToolPartIndex(toolCallId);
-          if (idx !== -1 && parts[idx].type === "tool-call") {
-            parts[idx].args = tracker.args;
-          }
-          emitUpdate();
-        }
-      },
-      onToolCallComplete(toolCallId, toolName, args) {
-        const tracker = toolCalls.get(toolCallId);
-        if (tracker) {
-          tracker.state = "call";
-          tracker.args = typeof args === "string" ? safeJsonParse(args) : args;
-        } else {
-          toolCalls.set(toolCallId, {
-            toolCallId,
-            toolName,
-            argsText: typeof args === "string" ? args : JSON.stringify(args),
-            args: typeof args === "string" ? safeJsonParse(args) : args,
-            state: "call"
-          });
-        }
-        const idx = findToolPartIndex(toolCallId);
-        if (idx !== -1) {
-          parts[idx].state = "call";
-          parts[idx].toolName = toolName;
-          parts[idx].args = toolCalls.get(toolCallId).args;
-        } else {
-          parts.push({
-            type: "tool-call",
-            toolCallId,
-            toolName,
-            args: toolCalls.get(toolCallId).args,
-            state: "call"
-          });
-        }
-        emitUpdate();
-      },
-      onToolResult(toolCallId, result) {
-        const tracker = toolCalls.get(toolCallId);
-        if (tracker) {
-          tracker.result = result;
-          tracker.state = "result";
-        }
-        const idx = findToolPartIndex(toolCallId);
-        if (idx !== -1) {
-          const existing = parts[idx];
-          const resultPart = {
-            type: "tool-result",
-            toolCallId,
-            toolName: existing.toolName,
-            args: existing.args,
-            result,
-            state: "result"
-          };
-          parts[idx] = resultPart;
-        } else {
-          parts.push({
-            type: "tool-result",
-            toolCallId,
-            toolName: tracker?.toolName || "unknown",
-            args: tracker?.args,
-            result,
-            state: "result"
-          });
-        }
-        emitUpdate();
-      },
-      onError(error, 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) {
-        emitUpdate();
-      },
-      onFinish(_data) {
-        emitUpdate();
+    let onQueueEmptyCb = null;
+    const ensureInstance = async () => {
+      if (instance) return instance;
+      if (initPromise) return initPromise;
+      const vc = getVoiceConfig();
+      if (!vc || !vc.apiSecret) {
+        console.warn("[TTS] 缺少 voiceConfig 或 apiSecret，语音播报已禁用");
+        return null;
       }
-    });
-    return { textContent, parts, toolCalls };
-  }
-  function safeJsonParse(str) {
-    try {
-      return JSON.parse(str);
-    } catch {
-      return str;
-    }
-  }
-
-  const toolDisplayNames = {
-    generateReport: "生成报告",
-    searchKnowledge: "知识库检索",
-    resolveInstanceTargets: "解析实例目标",
-    getHistoryMetrics: "历史数据查询",
-    getRealtimeMetrics: "实时数据查询",
-    queryBitableData: "多维表格查询",
-    searchUser: "搜索用户",
-    createBitableRecord: "创建表格记录",
-    timeTool: "时间工具",
-    loadSkill: "加载技能",
-    executeCommand: "执行命令",
-    dataAnalyzer: "数据分析",
-    dataPredictor: "数据预测"
-  };
-  function useAgentInvoke(options) {
-    const { aiChatbotX, tts, bubble } = options;
-    const sessionTimeoutMs = options.sessionTimeoutMs ?? 12e4;
-    const maxHistoryTurns = options.maxHistoryTurns ?? 10;
-    const isInvoking = vue.ref(false);
-    const currentTextContent = vue.ref("");
-    const currentToolParts = vue.ref([]);
-    const executingTools = vue.ref(/* @__PURE__ */ new Set());
-    const conversationHistory = vue.ref([]);
-    let lastInteractionTime = 0;
-    const checkSessionTimeout = () => {
-      if (lastInteractionTime > 0 && Date.now() - lastInteractionTime > sessionTimeoutMs) {
-        conversationHistory.value = [];
+      initPromise = (async () => {
+        try {
+          const tts = new webVoiceKit.SpeechSynthesizerStandalone({
+            appId: vc.appId,
+            apiKey: vc.ttsApiKey || vc.apiKey,
+            apiSecret: vc.apiSecret,
+            websocketUrl: vc.ttsWebsocketUrl || "wss://tts-api.xfyun.cn/v2/tts",
+            vcn: vc.ttsVcn || "xiaoyan",
+            speed: vc.speed || 55,
+            volume: vc.volume || 90,
+            pitch: vc.pitch || 50,
+            aue: "raw",
+            auf: "audio/L16;rate=16000",
+            tte: "UTF8",
+            autoPlay: true
+          });
+          tts.onStart(() => {
+            isSpeaking.value = true;
+          });
+          tts.onEnd(() => {
+          });
+          tts.onQueueEmpty(() => {
+            isSpeaking.value = false;
+            hasPendingAudio.value = false;
+            onQueueEmptyCb?.();
+          });
+          tts.onError((err) => {
+            console.error("[TTS] Error:", err);
+            isSpeaking.value = false;
+          });
+          if (audioCtx && audioCtx.state === "running") {
+            tts.audioContext = audioCtx;
+            tts.gainNode = audioCtx.createGain();
+            tts.gainNode.connect(audioCtx.destination);
+          }
+          instance = tts;
+          initPromise = null;
+          return tts;
+        } catch (err) {
+          console.error("[TTS] 初始化失败:", err);
+          initPromise = null;
+          return null;
+        }
+      })();
+      return initPromise;
+    };
+    const speak = async (text) => {
+      const clean = stripMarkdown(text);
+      if (!clean.trim()) return;
+      hasPendingAudio.value = true;
+      const tts = await ensureInstance();
+      if (!tts) return;
+      try {
+        tts.speak(clean);
+      } catch (err) {
+        console.error("[TTS] speak 失败:", err);
       }
     };
-    const appendToHistory = (role, content) => {
-      conversationHistory.value.push({ role, content });
-      const maxLen = maxHistoryTurns * 2;
-      if (conversationHistory.value.length > maxLen) {
-        conversationHistory.value = conversationHistory.value.slice(-maxLen);
+    const feed = (delta) => {
+      sentenceBuffer += delta;
+      while (true) {
+        const match = sentenceBuffer.match(sentenceDelimiters);
+        if (!match || match.index === void 0) break;
+        const sentence = sentenceBuffer.slice(0, match.index + 1).trim();
+        sentenceBuffer = sentenceBuffer.slice(match.index + 1);
+        if (sentence.length > 0) speak(sentence);
       }
     };
-    const clearHistory = () => {
-      conversationHistory.value = [];
+    const flush = () => {
+      const remaining = sentenceBuffer.trim();
+      sentenceBuffer = "";
+      if (remaining.length > 0) speak(remaining);
     };
-    let abortController = null;
-    const hasAnyContent = vue.computed(() => {
-      return !!(currentTextContent.value || currentToolParts.value.length > 0);
-    });
-    const toolDisplayName = (name) => toolDisplayNames[name] || name;
-    const resetState = () => {
-      currentTextContent.value = "";
-      currentToolParts.value = [];
-      executingTools.value = /* @__PURE__ */ new Set();
+    const stop = () => {
+      sentenceBuffer = "";
+      isSpeaking.value = false;
+      hasPendingAudio.value = false;
+      if (instance) {
+        try {
+          instance.stop();
+        } catch {
+        }
+      }
     };
-    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 setOnQueueEmpty = (cb) => {
+      onQueueEmptyCb = cb;
     };
-    const buildCommandDefinitionMap = (commands) => {
-      return new Map(commands.map((command) => [command.name, command]));
+    const destroy = () => {
+      stop();
+      if (instance) {
+        try {
+          instance.destroy();
+        } catch {
+        }
+        instance = null;
+      }
+      if (audioCtx) {
+        try {
+          audioCtx.close();
+        } catch {
+        }
+        audioCtx = null;
+      }
     };
-    const toExecutableCommand = (toolName, payload, commandDefinitions) => {
-      const commandDefinition = commandDefinitions.get(toolName);
-      if (!commandDefinition) {
-        return null;
+    return {
+      isSpeaking,
+      hasPendingAudio,
+      warmUpAudio,
+      speak,
+      feed,
+      flush,
+      stop,
+      destroy,
+      setOnQueueEmpty
+    };
+  }
+
+  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;
       }
-      const parameters = commandDefinition.parameters || [];
-      if (Array.isArray(payload)) {
-        return {
-          name: toolName,
-          args: payload
-        };
+      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);
+        }
       }
-      if (!payload || typeof payload !== "object") {
-        return {
-          name: toolName,
-          args: []
-        };
+      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);
+    const isInitializing = vue.ref(false);
+    const transcriptionText = vue.ref("");
+    const wakeAnimating = vue.ref(false);
+    let detector = null;
+    let transcriber = null;
+    const initTranscriber = () => {
+      if (transcriber) return;
+      const vc = options.getVoiceConfig();
+      if (!vc || !vc.appId || !vc.apiKey || !vc.websocketUrl) {
+        console.error("[VoiceRecognition] 缺少 voiceConfig，无法初始化转写器");
+        return;
+      }
+      transcriber = new webVoiceKit.SpeechTranscriberStandalone({
+        appId: vc.appId,
+        apiKey: vc.apiKey,
+        websocketUrl: vc.websocketUrl,
+        autoStop: {
+          enabled: true,
+          silenceTimeoutMs: 2e3,
+          noSpeechTimeoutMs: 5e3,
+          maxDurationMs: 45e3
+        }
+      });
+      transcriber.onResult((result) => {
+        transcriptionText.value = result.transcript || "";
+      });
+      transcriber.onAutoStop(async () => {
+        const finalText = transcriptionText.value;
+        await stopTranscribing();
+        transcriptionText.value = "";
+        if (finalText.trim()) {
+          options.onTranscriptionDone?.(finalText);
+        }
+      });
+      transcriber.onError((error) => {
+        console.error("[VoiceRecognition] 转写错误:", error);
+        stopTranscribing();
+        transcriptionText.value = "";
+      });
+    };
+    const startTranscribing = async () => {
+      if (isTranscribing.value) return;
+      if (!transcriber) initTranscriber();
+      if (!transcriber) return;
+      try {
+        await transcriber.start();
+        isTranscribing.value = true;
+        transcriptionText.value = "";
+      } catch (error) {
+        console.error("[VoiceRecognition] 启动转写失败:", error);
       }
-      const 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 stopTranscribing = async () => {
+      if (!transcriber || !transcriber.isActive()) {
+        isTranscribing.value = false;
+        return;
+      }
+      try {
+        await transcriber.stop();
+      } catch (error) {
+        console.error("[VoiceRecognition] 停止转写失败:", error);
+      } finally {
+        isTranscribing.value = false;
       }
-      const 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;
+    const initDetector = () => {
+      if (detector || isInitializing.value) return;
+      if (!options.modelPath) {
+        console.error("[VoiceRecognition] 未传入 modelPath，无法启用唤醒词");
+        return;
+      }
+      isInitializing.value = true;
       try {
-        executingTools.value = /* @__PURE__ */ new Set([...executingTools.value, toolCallId]);
-        for (const cmd of commands) {
-          try {
-            await aiChatbotX.executeCommand(cmd.name, cmd.args);
-          } catch (cmdErr) {
-            console.error(`[AgentInvoke] 执行命令 ${cmd.name} 失败:`, cmdErr);
+        detector = new webVoiceKit.WakeWordDetectorStandalone({
+          modelPath: options.modelPath,
+          sampleRate: 16e3,
+          usePartial: true,
+          autoReset: {
+            enabled: true,
+            resetDelayMs: 4e3
           }
-        }
-        return true;
+        });
+        detector.setWakeWords(options.wakeWords || ["你好", "您好"]);
+        detector.onWake(async () => {
+          wakeAnimating.value = true;
+          options.onWake?.();
+          await startTranscribing();
+          setTimeout(() => {
+            wakeAnimating.value = false;
+          }, 1200);
+        });
+        detector.onError((error) => {
+          console.error("[VoiceRecognition] 唤醒监听错误:", error);
+          voiceStatus.value = "standby";
+          stopTranscribing();
+        });
       } finally {
-        const next = new Set(executingTools.value);
-        next.delete(toolCallId);
-        executingTools.value = next;
+        isInitializing.value = false;
       }
     };
-    const parseAssistantText = (payload) => {
-      if (!payload) return "";
-      if (typeof payload === "string") return payload;
-      if (typeof payload === "object") {
-        const data = payload;
-        const directText = data.output || data.answer || data.message || data.result;
-        if (typeof directText === "string" && directText.trim()) return directText;
-        if (data.data && typeof data.data === "object") {
-          const nested = data.data;
-          const nestedText = nested.output || nested.answer || nested.message || nested.result;
-          if (typeof nestedText === "string" && nestedText.trim()) return nestedText;
-        }
-        return JSON.stringify(payload);
+    const toggleVoiceMode = async (targetState) => {
+      const permission = await ensureMicrophonePermission();
+      if (!permission || isInitializing.value) return;
+      if (!detector) {
+        initDetector();
+        if (!detector) return;
       }
-      return String(payload);
-    };
-    const invoke = async (question) => {
-      const content = question.trim();
-      if (!content) return;
-      abort();
-      checkSessionTimeout();
-      resetState();
-      tts.stop();
-      isInvoking.value = true;
-      bubble.open();
-      let prevTextLength = 0;
-      const processedToolResults = /* @__PURE__ */ new Set();
-      const processingToolResults = /* @__PURE__ */ new Set();
-      abortController = new AbortController();
-      const commands = await aiChatbotX.getCommads();
-      const commandDefinitions = buildCommandDefinitionMap(commands);
-      conversationHistory.value.length > 0 ? [...conversationHistory.value] : void 0;
+      const isListening = voiceStatus.value === "listening";
+      const shouldStart = targetState !== void 0 ? targetState : !isListening;
+      if (isListening === shouldStart) return;
       try {
-        const response = await fetch(options.endpoint, {
-          method: "POST",
-          headers: { "Content-Type": "application/json", Authorization: `Bearer ${options.appToken || ""}` },
-          body: JSON.stringify({
-            input: content,
-            projectId: options.projectId || "",
-            commands: commands.length > 0 ? commands : void 0
-            // messages: historyToSend,
-          }),
-          signal: abortController.signal
-        });
-        if (!response.ok) throw new Error(`HTTP ${response.status}`);
-        const contentType = response.headers.get("content-type") || "";
-        const isJsonResponse = contentType.includes("application/json");
-        if (isJsonResponse) {
-          const data = await response.json();
-          const reply = parseAssistantText(data) || "已收到，但没有返回可展示的文本内容。";
-          currentTextContent.value = reply;
-          tts.speak(reply);
-          appendToHistory("user", content);
-          appendToHistory("assistant", reply);
-          if (data.toolResults && Array.isArray(data.toolResults)) {
-            for (const tr of data.toolResults) {
-              const toolPart = {
-                type: "tool-result",
-                toolCallId: `invoke-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-                toolName: tr.toolName,
-                args: tr.args,
-                result: tr.result,
-                state: "result"
-              };
-              currentToolParts.value = [...currentToolParts.value, toolPart];
-              if (commandDefinitions.has(tr.toolName)) {
-                void executeHostCommands(toolPart.toolCallId, tr.toolName, tr.result, commandDefinitions);
-              }
-            }
-          }
+        if (shouldStart) {
+          await detector.start();
+          voiceStatus.value = "listening";
         } else {
-          await parseDataStreamToMessage(response, (result) => {
-            currentTextContent.value = result.textContent;
-            if (result.textContent.length > prevTextLength) {
-              const delta = result.textContent.slice(prevTextLength);
-              prevTextLength = result.textContent.length;
-              tts.feed(delta);
-            }
-            const toolParts = result.parts.filter(
-              (p) => p.type === "tool-call" || p.type === "tool-result"
-            );
-            currentToolParts.value = toolParts;
-            for (const part of toolParts) {
-              if (commandDefinitions.has(part.toolName) && !processedToolResults.has(part.toolCallId) && !processingToolResults.has(part.toolCallId)) {
-                if (part.type === "tool-call" && part.state === "call" && 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) {
-                  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);
-                    }
-                  );
-                }
-              }
-            }
-            bubble.scrollToBottom();
-          });
-          tts.flush();
-          const assistantReply = currentTextContent.value.trim();
-          appendToHistory("user", content);
-          if (assistantReply) {
-            appendToHistory("assistant", assistantReply);
-          }
-          if (!assistantReply && currentToolParts.value.length === 0) {
-            currentTextContent.value = "已收到，但没有返回可展示的文本内容。";
-          }
+          await detector.stop();
+          voiceStatus.value = "standby";
+          transcriptionText.value = "";
+          await stopTranscribing();
         }
       } catch (error) {
-        if (error.name === "AbortError") {
-          return;
-        }
-        console.error("[AgentInvoke] invoke failed:", error);
-        tts.stop();
-        currentTextContent.value = "请求失败，请检查服务地址或稍后重试。";
-      } finally {
-        isInvoking.value = false;
-        abortController = null;
-        lastInteractionTime = Date.now();
-        bubble.scheduleDismiss();
+        console.error("[VoiceRecognition] 监听切换失败:", error);
+        voiceStatus.value = "standby";
       }
     };
-    const abort = () => {
-      if (abortController) {
-        abortController.abort();
-        abortController = null;
+    const abortTranscription = async () => {
+      transcriptionText.value = "";
+      await stopTranscribing();
+    };
+    const destroy = async () => {
+      if (detector) {
+        try {
+          if (detector.isActive()) await detector.stop();
+        } catch {
+        }
+        detector = null;
+      }
+      if (transcriber) {
+        try {
+          if (transcriber.isActive()) await transcriber.stop();
+        } catch {
+        }
+        transcriber = null;
       }
-      tts.stop();
-      isInvoking.value = false;
     };
     return {
-      isInvoking,
-      currentTextContent,
-      currentToolParts,
-      executingTools,
-      hasAnyContent,
-      conversationHistory,
-      toolDisplayName,
-      invoke,
-      abort,
-      resetState,
-      clearHistory
+      voiceStatus,
+      isTranscribing,
+      isInitializing,
+      transcriptionText,
+      wakeAnimating,
+      startTranscribing,
+      stopTranscribing,
+      abortTranscription,
+      toggleVoiceMode,
+      destroy
     };
   }
 
@@ -1961,6 +2205,7 @@
       wakeWords: {},
       wakeResponses: {},
       modelPath: {},
+      agentId: {},
       projectId: {},
       voiceConfig: {},
       bubbleSize: {},
@@ -1974,6 +2219,7 @@
         return null;
       };
       const wakeResponses = vue.computed(() => props.wakeResponses || ["在呢"]);
+      const agentId = vue.computed(() => props.agentId);
       const tts = useTTS(getVoiceConfig);
       const bubbleBridge = {
         open: () => {
@@ -1983,7 +2229,7 @@
         scrollToBottom: () => {
         }
       };
-      const endpoint = `/sime/proxy/agent/${aiChatbotX.agentId()}/stream-invoke`;
+      const endpoint = `/sime/proxy/organizations/${aiChatbotX.organizationId()}/agents/${agentId.value}/stream-invoke`;
       const agent = useAgentInvoke({
         endpoint,
         appToken: aiChatbotX.appToken(),
@@ -2180,7 +2426,7 @@
     }
   });
 
-  const voiceAssistant = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-76f6b7ef"]]);
+  const voiceAssistant = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-59d72f34"]]);
 
   var clientCommandKey = /* @__PURE__ */ ((clientCommandKey2) => {
     clientCommandKey2["SET_THEME"] = "SiMeAgent_setTheme";
@@ -2195,6 +2441,7 @@
 
   exports.AgentChatTransport = AgentChatTransport;
   exports.AiChat = aiChat;
+  exports.AiChatbotCommandTest = commandTest;
   exports.AiChatbotProvider = _sfc_main$1;
   exports.AiChatbotVoiceAssistant = voiceAssistant;
   exports.AiChatbotXKey = AiChatbotXKey;