ibi-ai-talk 1.0.0

package/dist/index.umd.js

@@ -0,0 +1,2665 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory();
+	else if(typeof define === 'function' && define.amd)
+		define([], factory);
+	else if(typeof exports === 'object')
+		exports["index"] = factory();
+	else
+		root["index"] = factory();
+})((typeof self !== 'undefined' ? self : this), () => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	// The require scope
+/******/ 	var __webpack_require__ = {};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/publicPath */
+/******/ 	(() => {
+/******/ 		__webpack_require__.p = "";
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (/* binding */ entry_lib)
+});
+
+;// CONCATENATED MODULE: ./node_modules/@vue/cli-service/lib/commands/build/setPublicPath.js
+/* eslint-disable no-var */
+// This file is imported into lib/wc client bundles.
+
+if (typeof window !== 'undefined') {
+  var currentScript = window.document.currentScript
+  if (false) { var getCurrentScript; }
+
+  var src = currentScript && currentScript.src.match(/(.+\/)[^/]+\.js(\?.*)?$/)
+  if (src) {
+    __webpack_require__.p = src[1] // eslint-disable-line
+  }
+}
+
+// Indicate to webpack that this file can be concatenated
+/* harmony default export */ const setPublicPath = (null);
+
+;// CONCATENATED MODULE: ./node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[2]!./node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/index.vue?vue&type=template&id=71334dec
+var render = function render(){var _vm=this,_c=_vm._self._c;return _c("div")
+}
+var staticRenderFns = []
+
+
+;// CONCATENATED MODULE: ./src/utils/opus-codec.js
+// 检查Opus库是否已加载
+function checkOpusLoaded() {
+    try {
+        // 检查Module是否存在（本地库导出的全局变量）
+        if (typeof Module === 'undefined') {
+            throw new Error('Opus库未加载，Module对象不存在');
+        }
+
+        // 尝试先使用Module.instance（libopus.js最后一行导出方式）
+        if (typeof Module.instance !== 'undefined' && typeof Module.instance._opus_decoder_get_size === 'function') {
+            // 使用Module.instance对象替换全局Module对象
+            window.ModuleInstance = Module.instance;
+            console.log('Opus库加载成功（使用Module.instance）', 'success');
+        }
+
+        // 如果没有Module.instance，检查全局Module函数
+        if (typeof Module._opus_decoder_get_size === 'function') {
+            window.ModuleInstance = Module;
+            console.log('Opus库加载成功（使用全局Module）', 'success');
+        }
+
+        throw new Error('Opus解码函数未找到，可能Module结构不正确');
+    } catch (err) {
+        console.log(`Opus库加载失败，请检查libopus.js文件是否存在且正确: ${err.message}`, 'error');
+    }
+}
+
+
+// 创建一个Opus编码器
+let opusEncoder = null;
+function initOpusEncoder() {
+    try {
+        if (opusEncoder) {
+            return opusEncoder; // 已经初始化过
+        }
+
+        if (!window.ModuleInstance) {
+            console.log('无法创建Opus编码器：ModuleInstance不可用', 'error');
+            return;
+        }
+
+        // 初始化一个Opus编码器
+        const mod = window.ModuleInstance;
+        const sampleRate = 16000; // 16kHz采样率
+        const channels = 1;       // 单声道
+        const application = 2048; // OPUS_APPLICATION_VOIP = 2048
+
+        // 创建编码器
+        opusEncoder = {
+            channels: channels,
+            sampleRate: sampleRate,
+            frameSize: 960, // 60ms @ 16kHz = 60 * 16 = 960 samples
+            maxPacketSize: 4000, // 最大包大小
+            module: mod,
+
+            // 初始化编码器
+            init: function () {
+                try {
+                    // 获取编码器大小
+                    const encoderSize = mod._opus_encoder_get_size(this.channels);
+                    console.log(`Opus编码器大小: ${encoderSize}字节`, 'info');
+
+                    // 分配内存
+                    this.encoderPtr = mod._malloc(encoderSize);
+                    if (!this.encoderPtr) {
+                        throw new Error("无法分配编码器内存");
+                    }
+
+                    // 初始化编码器
+                    const err = mod._opus_encoder_init(
+                        this.encoderPtr,
+                        this.sampleRate,
+                        this.channels,
+                        application
+                    );
+
+                    if (err < 0) {
+                        throw new Error(`Opus编码器初始化失败: ${err}`);
+                    }
+
+                    // 设置位率 (16kbps)
+                    mod._opus_encoder_ctl(this.encoderPtr, 4002, 16000); // OPUS_SET_BITRATE
+
+                    // 设置复杂度 (0-10, 越高质量越好但CPU使用越多)
+                    mod._opus_encoder_ctl(this.encoderPtr, 4010, 5);     // OPUS_SET_COMPLEXITY
+
+                    // 设置使用DTX (不传输静音帧)
+                    mod._opus_encoder_ctl(this.encoderPtr, 4016, 1);     // OPUS_SET_DTX
+
+                    console.log("Opus编码器初始化成功", 'success');
+                    return true;
+                } catch (error) {
+                    if (this.encoderPtr) {
+                        mod._free(this.encoderPtr);
+                        this.encoderPtr = null;
+                    }
+                    console.log(`Opus编码器初始化失败: ${error.message}`, 'error');
+                    return false;
+                }
+            },
+
+            // 编码PCM数据为Opus
+            encode: function (pcmData) {
+                if (!this.encoderPtr) {
+                    if (!this.init()) {
+                        return null;
+                    }
+                }
+
+                try {
+                    const mod = this.module;
+
+                    // 为PCM数据分配内存
+                    const pcmPtr = mod._malloc(pcmData.length * 2); // 2字节/int16
+
+                    // 将PCM数据复制到HEAP
+                    for (let i = 0; i < pcmData.length; i++) {
+                        mod.HEAP16[(pcmPtr >> 1) + i] = pcmData[i];
+                    }
+
+                    // 为输出分配内存
+                    const outPtr = mod._malloc(this.maxPacketSize);
+
+                    // 进行编码
+                    const encodedLen = mod._opus_encode(
+                        this.encoderPtr,
+                        pcmPtr,
+                        this.frameSize,
+                        outPtr,
+                        this.maxPacketSize
+                    );
+
+                    if (encodedLen < 0) {
+                        throw new Error(`Opus编码失败: ${encodedLen}`);
+                    }
+
+                    // 复制编码后的数据
+                    const opusData = new Uint8Array(encodedLen);
+                    for (let i = 0; i < encodedLen; i++) {
+                        opusData[i] = mod.HEAPU8[outPtr + i];
+                    }
+
+                    // 释放内存
+                    mod._free(pcmPtr);
+                    mod._free(outPtr);
+
+                    return opusData;
+                } catch (error) {
+                    console.log(`Opus编码出错: ${error.message}`, 'error');
+                    return null;
+                }
+            },
+
+            // 销毁编码器
+            destroy: function () {
+                if (this.encoderPtr) {
+                    this.module._free(this.encoderPtr);
+                    this.encoderPtr = null;
+                }
+            }
+        };
+
+        opusEncoder.init();
+        return opusEncoder;
+    } catch (error) {
+        console.log(`创建Opus编码器失败: ${error.message}`, 'error');
+        return false;
+    }
+}
+;// CONCATENATED MODULE: ./src/utils/tools.js
+// 全局变量
+let mcpTools = [];
+let mcpEditingIndex = null;
+let mcpProperties = [];
+let websocket = null; // 将从外部设置
+
+/**
+ * 设置 WebSocket 实例
+ * @param {WebSocket} ws - WebSocket 连接实例
+ */
+function setWebSocket(ws) {
+  websocket = ws;
+}
+
+/**
+ * 初始化 MCP 工具
+ */
+async function initMcpTools() {
+  // 加载默认工具数据
+  const defaultMcpTools = await fetch("/default-mcp-tools.json").then((res) =>
+    res.json()
+  );
+
+  const savedTools = localStorage.getItem("mcpTools");
+  if (savedTools) {
+    try {
+      mcpTools = JSON.parse(savedTools);
+    } catch (e) {
+      console.log("加载MCP工具失败，使用默认工具", "warning");
+      mcpTools = [...defaultMcpTools];
+    }
+  } else {
+    mcpTools = [...defaultMcpTools];
+  }
+
+  // renderMcpTools();
+  // setupMcpEventListeners();
+}
+
+/**
+ * 渲染工具列表
+ */
+function renderMcpTools() {
+  const container = document.getElementById("mcpToolsContainer");
+  const countSpan = document.getElementById("mcpToolsCount");
+
+  countSpan.textContent = `${mcpTools.length} 个工具`;
+
+  if (mcpTools.length === 0) {
+    container.innerHTML =
+      '<div style="text-align: center; padding: 30px; color: #999;">暂无工具，点击下方按钮添加新工具</div>';
+    return;
+  }
+
+  container.innerHTML = mcpTools
+    .map((tool, index) => {
+      const paramCount = tool.inputSchema.properties
+        ? Object.keys(tool.inputSchema.properties).length
+        : 0;
+      const requiredCount = tool.inputSchema.required
+        ? tool.inputSchema.required.length
+        : 0;
+      const hasMockResponse =
+        tool.mockResponse && Object.keys(tool.mockResponse).length > 0;
+
+      return `
+            <div class="mcp-tool-card">
+                <div class="mcp-tool-header">
+                    <div class="mcp-tool-name">${tool.name}</div>
+                    <div class="mcp-tool-actions">
+                        <button onclick="window.mcpModule.editMcpTool(${index})"
+                            style="padding: 4px 10px; border: none; border-radius: 4px; background-color: #2196f3; color: white; cursor: pointer; font-size: 12px;">
+                            ✏️ 编辑
+                        </button>
+                        <button onclick="window.mcpModule.deleteMcpTool(${index})"
+                            style="padding: 4px 10px; border: none; border-radius: 4px; background-color: #f44336; color: white; cursor: pointer; font-size: 12px;">
+                            🗑️ 删除
+                        </button>
+                    </div>
+                </div>
+                <div class="mcp-tool-description">${tool.description}</div>
+                <div class="mcp-tool-info">
+                    <div class="mcp-tool-info-row">
+                        <span class="mcp-tool-info-label">参数数量:</span>
+                        <span class="mcp-tool-info-value">${paramCount} 个 ${
+        requiredCount > 0 ? `(${requiredCount} 个必填)` : ""
+      }</span>
+                    </div>
+                    <div class="mcp-tool-info-row">
+                        <span class="mcp-tool-info-label">模拟返回:</span>
+                        <span class="mcp-tool-info-value">${
+                          hasMockResponse
+                            ? "✅ 已配置: " + JSON.stringify(tool.mockResponse)
+                            : "⚪ 使用默认"
+                        }</span>
+                    </div>
+                </div>
+            </div>
+        `;
+    })
+    .join("");
+}
+
+/**
+ * 渲染参数列表
+ */
+function renderMcpProperties() {
+  const container = document.getElementById("mcpPropertiesContainer");
+
+  if (mcpProperties.length === 0) {
+    container.innerHTML =
+      '<div style="text-align: center; padding: 20px; color: #999; font-size: 14px;">暂无参数，点击下方按钮添加参数</div>';
+    return;
+  }
+
+  container.innerHTML = mcpProperties
+    .map(
+      (prop, index) => `
+        <div class="mcp-property-item">
+            <div class="mcp-property-header">
+                <span class="mcp-property-name">${prop.name}</span>
+                <button type="button" onclick="window.mcpModule.deleteMcpProperty(${index})"
+                    style="padding: 3px 8px; border: none; border-radius: 3px; background-color: #f44336; color: white; cursor: pointer; font-size: 11px;">
+                    删除
+                </button>
+            </div>
+            <div class="mcp-property-row">
+                <div>
+                    <label class="mcp-small-label">参数名称 *</label>
+                    <input type="text" class="mcp-small-input" value="${
+                      prop.name
+                    }"
+                        onchange="window.mcpModule.updateMcpProperty(${index}, 'name', this.value)" required>
+                </div>
+                <div>
+                    <label class="mcp-small-label">数据类型 *</label>
+                    <select class="mcp-small-input" onchange="window.mcpModule.updateMcpProperty(${index}, 'type', this.value)">
+                        <option value="string" ${
+                          prop.type === "string" ? "selected" : ""
+                        }>字符串</option>
+                        <option value="integer" ${
+                          prop.type === "integer" ? "selected" : ""
+                        }>整数</option>
+                        <option value="number" ${
+                          prop.type === "number" ? "selected" : ""
+                        }>数字</option>
+                        <option value="boolean" ${
+                          prop.type === "boolean" ? "selected" : ""
+                        }>布尔值</option>
+                        <option value="array" ${
+                          prop.type === "array" ? "selected" : ""
+                        }>数组</option>
+                        <option value="object" ${
+                          prop.type === "object" ? "selected" : ""
+                        }>对象</option>
+                    </select>
+                </div>
+            </div>
+            ${
+              prop.type === "integer" || prop.type === "number"
+                ? `
+            <div class="mcp-property-row">
+                <div>
+                    <label class="mcp-small-label">最小值</label>
+                    <input type="number" class="mcp-small-input" value="${
+                      prop.minimum !== undefined ? prop.minimum : ""
+                    }"
+                        placeholder="可选" onchange="window.mcpModule.updateMcpProperty(${index}, 'minimum', this.value ? parseFloat(this.value) : undefined)">
+                </div>
+                <div>
+                    <label class="mcp-small-label">最大值</label>
+                    <input type="number" class="mcp-small-input" value="${
+                      prop.maximum !== undefined ? prop.maximum : ""
+                    }"
+                        placeholder="可选" onchange="window.mcpModule.updateMcpProperty(${index}, 'maximum', this.value ? parseFloat(this.value) : undefined)">
+                </div>
+            </div>
+            `
+                : ""
+            }
+            <div class="mcp-property-row-full">
+                <label class="mcp-small-label">参数描述</label>
+                <input type="text" class="mcp-small-input" value="${
+                  prop.description || ""
+                }"
+                    placeholder="可选" onchange="window.mcpModule.updateMcpProperty(${index}, 'description', this.value)">
+            </div>
+            <label class="mcp-checkbox-label">
+                <input type="checkbox" ${prop.required ? "checked" : ""}
+                    onchange="window.mcpModule.updateMcpProperty(${index}, 'required', this.checked)">
+                必填参数
+            </label>
+        </div>
+    `
+    )
+    .join("");
+}
+
+/**
+ * 添加参数
+ */
+function addMcpProperty() {
+  mcpProperties.push({
+    name: `param_${mcpProperties.length + 1}`,
+    type: "string",
+    required: false,
+    description: "",
+  });
+  renderMcpProperties();
+}
+
+/**
+ * 更新参数
+ */
+function updateMcpProperty(index, field, value) {
+  if (field === "name") {
+    const isDuplicate = mcpProperties.some(
+      (p, i) => i !== index && p.name === value
+    );
+    if (isDuplicate) {
+      alert("参数名称已存在，请使用不同的名称");
+      renderMcpProperties();
+      return;
+    }
+  }
+
+  mcpProperties[index][field] = value;
+
+  if (field === "type" && value !== "integer" && value !== "number") {
+    delete mcpProperties[index].minimum;
+    delete mcpProperties[index].maximum;
+    renderMcpProperties();
+  }
+}
+
+/**
+ * 删除参数
+ */
+function deleteMcpProperty(index) {
+  mcpProperties.splice(index, 1);
+  renderMcpProperties();
+}
+
+/**
+ * 设置事件监听
+ */
+function setupMcpEventListeners() {
+  const toggleBtn = document.getElementById("toggleMcpTools");
+  const panel = document.getElementById("mcpToolsPanel");
+  const addBtn = document.getElementById("addMcpToolBtn");
+  const modal = document.getElementById("mcpToolModal");
+  const closeBtn = document.getElementById("closeMcpModalBtn");
+  const cancelBtn = document.getElementById("cancelMcpBtn");
+  const form = document.getElementById("mcpToolForm");
+  const addPropertyBtn = document.getElementById("addMcpPropertyBtn");
+
+  toggleBtn.addEventListener("click", () => {
+    const isExpanded = panel.classList.contains("expanded");
+    panel.classList.toggle("expanded");
+    toggleBtn.textContent = isExpanded ? "展开" : "收起";
+  });
+
+  addBtn.addEventListener("click", () => openMcpModal());
+  closeBtn.addEventListener("click", closeMcpModal);
+  cancelBtn.addEventListener("click", closeMcpModal);
+  addPropertyBtn.addEventListener("click", addMcpProperty);
+
+  modal.addEventListener("click", (e) => {
+    if (e.target === modal) closeMcpModal();
+  });
+
+  form.addEventListener("submit", handleMcpSubmit);
+}
+
+/**
+ * 打开模态框
+ */
+function openMcpModal(index = null) {
+  const isConnected = websocket && websocket.readyState === WebSocket.OPEN;
+  if (isConnected) {
+    alert("WebSocket 已连接，无法编辑工具");
+    return;
+  }
+
+  mcpEditingIndex = index;
+  const errorContainer = document.getElementById("mcpErrorContainer");
+  errorContainer.innerHTML = "";
+
+  if (index !== null) {
+    document.getElementById("mcpModalTitle").textContent = "编辑工具";
+    const tool = mcpTools[index];
+    document.getElementById("mcpToolName").value = tool.name;
+    document.getElementById("mcpToolDescription").value = tool.description;
+    document.getElementById("mcpMockResponse").value = tool.mockResponse
+      ? JSON.stringify(tool.mockResponse, null, 2)
+      : "";
+
+    mcpProperties = [];
+    const schema = tool.inputSchema;
+    if (schema.properties) {
+      Object.keys(schema.properties).forEach((key) => {
+        const prop = schema.properties[key];
+        mcpProperties.push({
+          name: key,
+          type: prop.type || "string",
+          minimum: prop.minimum,
+          maximum: prop.maximum,
+          description: prop.description || "",
+          required: schema.required && schema.required.includes(key),
+        });
+      });
+    }
+  } else {
+    document.getElementById("mcpModalTitle").textContent = "添加工具";
+    document.getElementById("mcpToolForm").reset();
+    mcpProperties = [];
+  }
+
+  renderMcpProperties();
+  document.getElementById("mcpToolModal").style.display = "block";
+}
+
+/**
+ * 关闭模态框
+ */
+function closeMcpModal() {
+  document.getElementById("mcpToolModal").style.display = "none";
+  mcpEditingIndex = null;
+  document.getElementById("mcpToolForm").reset();
+  mcpProperties = [];
+  document.getElementById("mcpErrorContainer").innerHTML = "";
+}
+
+/**
+ * 处理表单提交
+ */
+function handleMcpSubmit(e) {
+  e.preventDefault();
+  const errorContainer = document.getElementById("mcpErrorContainer");
+  errorContainer.innerHTML = "";
+
+  const name = document.getElementById("mcpToolName").value.trim();
+  const description = document
+    .getElementById("mcpToolDescription")
+    .value.trim();
+  const mockResponseText = document
+    .getElementById("mcpMockResponse")
+    .value.trim();
+
+  // 检查名称重复
+  const isDuplicate = mcpTools.some(
+    (tool, index) => tool.name === name && index !== mcpEditingIndex
+  );
+
+  if (isDuplicate) {
+    showMcpError("工具名称已存在，请使用不同的名称");
+    return;
+  }
+
+  // 解析模拟返回结果
+  let mockResponse = null;
+  if (mockResponseText) {
+    try {
+      mockResponse = JSON.parse(mockResponseText);
+    } catch (e) {
+      showMcpError("模拟返回结果不是有效的 JSON 格式: " + e.message);
+      return;
+    }
+  }
+
+  // 构建 inputSchema
+  const inputSchema = {
+    type: "object",
+    properties: {},
+    required: [],
+  };
+
+  mcpProperties.forEach((prop) => {
+    const propSchema = { type: prop.type };
+
+    if (prop.description) {
+      propSchema.description = prop.description;
+    }
+
+    if (prop.type === "integer" || prop.type === "number") {
+      if (prop.minimum !== undefined && prop.minimum !== "") {
+        propSchema.minimum = prop.minimum;
+      }
+      if (prop.maximum !== undefined && prop.maximum !== "") {
+        propSchema.maximum = prop.maximum;
+      }
+    }
+
+    inputSchema.properties[prop.name] = propSchema;
+
+    if (prop.required) {
+      inputSchema.required.push(prop.name);
+    }
+  });
+
+  if (inputSchema.required.length === 0) {
+    delete inputSchema.required;
+  }
+
+  const tool = { name, description, inputSchema, mockResponse };
+
+  if (mcpEditingIndex !== null) {
+    mcpTools[mcpEditingIndex] = tool;
+    console.log(`已更新工具: ${name}`, "success");
+  } else {
+    mcpTools.push(tool);
+    console.log(`已添加工具: ${name}`, "success");
+  }
+
+  saveMcpTools();
+  renderMcpTools();
+  closeMcpModal();
+}
+
+/**
+ * 显示错误
+ */
+function showMcpError(message) {
+  const errorContainer = document.getElementById("mcpErrorContainer");
+  errorContainer.innerHTML = `<div class="mcp-error">${message}</div>`;
+}
+
+/**
+ * 编辑工具
+ */
+function editMcpTool(index) {
+  openMcpModal(index);
+}
+
+/**
+ * 删除工具
+ */
+function deleteMcpTool(index) {
+  const isConnected = websocket && websocket.readyState === WebSocket.OPEN;
+  if (isConnected) {
+    alert("WebSocket 已连接，无法编辑工具");
+    return;
+  }
+  if (confirm(`确定要删除工具 "${mcpTools[index].name}" 吗？`)) {
+    const toolName = mcpTools[index].name;
+    mcpTools.splice(index, 1);
+    saveMcpTools();
+    renderMcpTools();
+    console.log(`已删除工具: ${toolName}`, "info");
+  }
+}
+
+/**
+ * 保存工具
+ */
+function saveMcpTools() {
+  localStorage.setItem("mcpTools", JSON.stringify(mcpTools));
+}
+
+/**
+ * 获取工具列表
+ */
+function getMcpTools() {
+  return mcpTools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+  }));
+}
+
+/**
+ * 执行工具调用
+ */
+function executeMcpTool(toolName, toolArgs) {
+  const tool = mcpTools.find((t) => t.name === toolName);
+  if (!tool) {
+    console.log(`未找到工具: ${toolName}`, "error");
+    return {
+      success: false,
+      error: `未知工具: ${toolName}`,
+    };
+  }
+
+  if (tool.name == "self.drink_car_list") {
+    console.log("准备触发 gotoOrderEvent 事件"); // 增加此日志
+    const event = new CustomEvent("gotoOrderEvent");
+    window.dispatchEvent(event);
+    return {
+      success: true,
+      message: `工具 ${toolName} 执行成功`,
+      data: sessionStorage.getItem('cartList') || [],
+    };
+  } else if (tool.name == "self.drink_car_reset") {
+    console.log("准备触发 resetOrderEvent 事件"); // 增加此日志
+    const event = new CustomEvent("resetOrderEvent", {
+      detail: toolArgs,
+    });
+    window.dispatchEvent(event);
+    return {
+        success: true,
+        message: `工具 ${toolName} 执行成功`,
+        data: sessionStorage.getItem('cartList') || [],
+    }
+  } else if (tool.name == "self.drink_order") {
+    console.log("准备触发 orderEvent 事件"); // 增加此日志
+    const event = new CustomEvent("orderEvent");
+    window.dispatchEvent(event);
+  }
+}
+
+// 暴露全局方法供 HTML 内联事件调用
+window.mcpModule = {
+  updateMcpProperty,
+  deleteMcpProperty,
+  editMcpTool,
+  deleteMcpTool,
+};
+
+;// CONCATENATED MODULE: ./src/utils/blocking-queue.js
+class BlockingQueue {
+    #items   = [];
+    #waiters = [];          // {resolve, reject, min, timer, onTimeout}
+
+    /* 空队列一次性闸门 */
+    #emptyPromise = null;
+    #emptyResolve = null;
+
+    /* 生产者：把数据塞进去 */
+    enqueue(item, ...restItems) {
+        if (restItems.length === 0) {
+            this.#items.push(item);
+        }
+        // 如果有额外参数，批量处理所有项
+        else {
+            const items = [item, ...restItems].filter(i => i);
+            if (items.length === 0) return;
+            this.#items.push(...items);
+        }
+        // 若有空队列闸门，一次性放行所有等待者
+        if (this.#emptyResolve) {
+            this.#emptyResolve();
+            this.#emptyResolve = null;
+            this.#emptyPromise = null;
+        }
+
+        // 唤醒所有正在等的 waiter
+        this.#wakeWaiters();
+    }
+
+    /* 消费者：min 条或 timeout ms 先到谁 */
+    async dequeue(min = 1, timeout = Infinity, onTimeout = null) {
+        // 1. 若空，等第一次数据到达（所有调用共享同一个 promise）
+        if (this.#items.length === 0) {
+            await this.#waitForFirstItem();
+        }
+
+        // 立即满足
+        if (this.#items.length >= min) {
+            return this.#flush();
+        }
+
+        // 需要等待
+        return new Promise((resolve, reject) => {
+            let timer = null;
+            const waiter = { resolve, reject, min, onTimeout, timer };
+
+            // 超时逻辑
+            if (Number.isFinite(timeout)) {
+                waiter.timer = setTimeout(() => {
+                    this.#removeWaiter(waiter);
+                    if (onTimeout) onTimeout(this.#items.length);
+                    resolve(this.#flush());
+                }, timeout);
+            }
+
+            this.#waiters.push(waiter);
+        });
+    }
+
+    /* 空队列闸门生成器 */
+    #waitForFirstItem() {
+        if (!this.#emptyPromise) {
+            this.#emptyPromise = new Promise(r => (this.#emptyResolve = r));
+        }
+        return this.#emptyPromise;
+    }
+
+    /* 内部：每次数据变动后，检查哪些 waiter 已满足 */
+    #wakeWaiters() {
+        for (let i = this.#waiters.length - 1; i >= 0; i--) {
+            const w = this.#waiters[i];
+            if (this.#items.length >= w.min) {
+                this.#removeWaiter(w);
+                w.resolve(this.#flush());
+            }
+        }
+    }
+
+    #removeWaiter(waiter) {
+        const idx = this.#waiters.indexOf(waiter);
+        if (idx !== -1) {
+            this.#waiters.splice(idx, 1);
+            if (waiter.timer) clearTimeout(waiter.timer);
+        }
+    }
+
+    #flush() {
+        const snapshot = [...this.#items];
+        this.#items.length = 0;
+        return snapshot;
+    }
+
+    /* 当前缓存长度（不含等待者） */
+    get length() {
+        return this.#items.length;
+    }
+}
+;// CONCATENATED MODULE: ./src/utils/stream-context.js
+
+
+// 音频流播放上下文类
+class StreamingContext {
+  constructor(
+    opusDecoder,
+    audioContext,
+    sampleRate,
+    channels,
+    minAudioDuration
+  ) {
+    this.opusDecoder = opusDecoder;
+    this.audioContext = audioContext;
+
+    // 音频参数
+    this.sampleRate = sampleRate;
+    this.channels = channels;
+    this.minAudioDuration = minAudioDuration;
+
+    // 初始化队列和状态
+    this.queue = []; // 已解码的PCM队列。正在播放
+    this.activeQueue = new BlockingQueue(); // 已解码的PCM队列。准备播放
+    this.pendingAudioBufferQueue = []; // 待处理的缓存队列
+    this.audioBufferQueue = new BlockingQueue(); // 缓存队列
+    this.playing = false; // 是否正在播放
+    this.endOfStream = false; // 是否收到结束信号
+    this.source = null; // 当前音频源
+    this.totalSamples = 0; // 累积的总样本数
+    this.lastPlayTime = 0; // 上次播放的时间戳
+  }
+
+  // 缓存音频数组
+  pushAudioBuffer(item) {
+    this.audioBufferQueue.enqueue(...item);
+  }
+
+  // 获取需要处理缓存队列，单线程：在audioBufferQueue一直更新的状态下不会出现安全问题
+  async getPendingAudioBufferQueue() {
+    // 原子交换 + 清空
+    [this.pendingAudioBufferQueue, this.audioBufferQueue] = [
+      await this.audioBufferQueue.dequeue(),
+      new BlockingQueue(),
+    ];
+  }
+
+  // 获取正在播放已解码的PCM队列，单线程：在activeQueue一直更新的状态下不会出现安全问题
+  async getQueue(minSamples) {
+    let TepArray = [];
+    const num =
+      minSamples - this.queue.length > 0 ? minSamples - this.queue.length : 1;
+    // 原子交换 + 清空
+    [TepArray, this.activeQueue] = [
+      await this.activeQueue.dequeue(num),
+      new BlockingQueue(),
+    ];
+    this.queue.push(...TepArray);
+  }
+
+  // 将Int16音频数据转换为Float32音频数据
+  convertInt16ToFloat32(int16Data) {
+    const float32Data = new Float32Array(int16Data.length);
+    for (let i = 0; i < int16Data.length; i++) {
+      // 将[-32768,32767]范围转换为[-1,1]，统一使用32768.0避免不对称失真
+      float32Data[i] = int16Data[i] / 32768.0;
+    }
+    return float32Data;
+  }
+
+  // 将Opus数据解码为PCM
+  async decodeOpusFrames() {
+    if (!this.opusDecoder) {
+      console.log("Opus解码器未初始化，无法解码", "error");
+      return;
+    } else {
+      console.log("Opus解码器启动", "info");
+    }
+
+    while (true) {
+      let decodedSamples = [];
+      for (const frame of this.pendingAudioBufferQueue) {
+        try {
+          // 使用Opus解码器解码
+          const frameData = this.opusDecoder.decode(frame);
+          if (frameData && frameData.length > 0) {
+            // 转换为Float32
+            const floatData = this.convertInt16ToFloat32(frameData);
+            // 使用循环替代展开运算符
+            for (let i = 0; i < floatData.length; i++) {
+              decodedSamples.push(floatData[i]);
+            }
+          }
+        } catch (error) {
+          console.log("Opus解码失败: " + error.message, "error");
+        }
+      }
+
+      if (decodedSamples.length > 0) {
+        // 使用循环替代展开运算符
+        for (let i = 0; i < decodedSamples.length; i++) {
+          this.activeQueue.enqueue(decodedSamples[i]);
+        }
+        this.totalSamples += decodedSamples.length;
+      } else {
+        console.log("没有成功解码的样本", "warning");
+      }
+      await this.getPendingAudioBufferQueue();
+    }
+  }
+
+  // 开始播放音频
+  async startPlaying() {
+    let scheduledEndTime = this.audioContext.currentTime; // 跟踪已调度音频的结束时间
+
+    while (true) {
+      // 初始缓冲：等待足够的样本再开始播放
+      const minSamples = this.sampleRate * this.minAudioDuration * 2;
+      if (!this.playing && this.queue.length < minSamples) {
+        await this.getQueue(minSamples);
+      }
+      this.playing = true;
+
+      // 持续播放队列中的音频，每次播放一个小块
+      while (this.playing && this.queue.length > 0) {
+        // 每次播放120ms的音频（2个Opus包）
+        const playDuration = 0.12;
+        const targetSamples = Math.floor(this.sampleRate * playDuration);
+        const actualSamples = Math.min(this.queue.length, targetSamples);
+
+        if (actualSamples === 0) break;
+
+        const currentSamples = this.queue.splice(0, actualSamples);
+        const audioBuffer = this.audioContext.createBuffer(
+          this.channels,
+          currentSamples.length,
+          this.sampleRate
+        );
+        audioBuffer.copyToChannel(new Float32Array(currentSamples), 0);
+
+        // 创建音频源
+        this.source = this.audioContext.createBufferSource();
+        this.source.buffer = audioBuffer;
+
+        // 精确调度播放时间
+        const currentTime = this.audioContext.currentTime;
+        const startTime = Math.max(scheduledEndTime, currentTime);
+
+        // 直接连接到输出
+        this.source.connect(this.audioContext.destination);
+
+        this.source.start(startTime);
+
+        // 更新下一个音频块的调度时间
+        const duration = audioBuffer.duration;
+        scheduledEndTime = startTime + duration;
+        this.lastPlayTime = startTime;
+
+        // 如果队列中数据不足，等待新数据
+        if (this.queue.length < targetSamples) {
+          break;
+        }
+      }
+
+      // 等待新数据
+      await this.getQueue(minSamples);
+    }
+  }
+}
+
+// 创建streamingContext实例的工厂函数
+function createStreamingContext(
+  opusDecoder,
+  audioContext,
+  sampleRate,
+  channels,
+  minAudioDuration
+) {
+  return new StreamingContext(
+    opusDecoder,
+    audioContext,
+    sampleRate,
+    channels,
+    minAudioDuration
+  );
+}
+
+;// CONCATENATED MODULE: ./src/utils/player.js
+// 音频播放模块
+
+
+
+// 音频播放器类
+class AudioPlayer {
+  constructor() {
+    // 音频参数
+    this.SAMPLE_RATE = 16000;
+    this.CHANNELS = 1;
+    this.FRAME_SIZE = 960;
+    this.MIN_AUDIO_DURATION = 0.12;
+
+    // 状态
+    this.audioContext = null;
+    this.opusDecoder = null;
+    this.streamingContext = null;
+    this.queue = new BlockingQueue();
+    this.isPlaying = false;
+  }
+
+  // 获取或创建AudioContext
+  getAudioContext() {
+    if (!this.audioContext) {
+      this.audioContext = new (window.AudioContext ||
+        window.webkitAudioContext)({
+        sampleRate: this.SAMPLE_RATE,
+        latencyHint: "interactive",
+      });
+      console.log(
+        "创建音频上下文，采样率: " + this.SAMPLE_RATE + "Hz",
+        "debug"
+      );
+    }
+    return this.audioContext;
+  }
+
+  // 初始化Opus解码器
+  async initOpusDecoder() {
+    if (this.opusDecoder) return this.opusDecoder;
+
+    try {
+      if (typeof window.ModuleInstance === "undefined") {
+        if (typeof Module !== "undefined") {
+          window.ModuleInstance = Module;
+          console.log("使用全局Module作为ModuleInstance", "info");
+        } else {
+          throw new Error("Opus库未加载，ModuleInstance和Module对象都不存在");
+        }
+      }
+
+      const mod = window.ModuleInstance;
+
+      this.opusDecoder = {
+        channels: this.CHANNELS,
+        rate: this.SAMPLE_RATE,
+        frameSize: this.FRAME_SIZE,
+        module: mod,
+        decoderPtr: null,
+
+        init: function () {
+          if (this.decoderPtr) return true;
+
+          const decoderSize = mod._opus_decoder_get_size(this.channels);
+          console.log(`Opus解码器大小: ${decoderSize}字节`, "debug");
+
+          this.decoderPtr = mod._malloc(decoderSize);
+          if (!this.decoderPtr) {
+            throw new Error("无法分配解码器内存");
+          }
+
+          const err = mod._opus_decoder_init(
+            this.decoderPtr,
+            this.rate,
+            this.channels
+          );
+
+          if (err < 0) {
+            this.destroy();
+            throw new Error(`Opus解码器初始化失败: ${err}`);
+          }
+
+          console.log("Opus解码器初始化成功", "success");
+          return true;
+        },
+
+        decode: function (opusData) {
+          if (!this.decoderPtr) {
+            if (!this.init()) {
+              throw new Error("解码器未初始化且无法初始化");
+            }
+          }
+
+          try {
+            const mod = this.module;
+
+            const opusPtr = mod._malloc(opusData.length);
+            mod.HEAPU8.set(opusData, opusPtr);
+
+            const pcmPtr = mod._malloc(this.frameSize * 2);
+
+            const decodedSamples = mod._opus_decode(
+              this.decoderPtr,
+              opusPtr,
+              opusData.length,
+              pcmPtr,
+              this.frameSize,
+              0
+            );
+
+            if (decodedSamples < 0) {
+              mod._free(opusPtr);
+              mod._free(pcmPtr);
+              throw new Error(`Opus解码失败: ${decodedSamples}`);
+            }
+
+            const decodedData = new Int16Array(decodedSamples);
+            for (let i = 0; i < decodedSamples; i++) {
+              decodedData[i] = mod.HEAP16[(pcmPtr >> 1) + i];
+            }
+
+            mod._free(opusPtr);
+            mod._free(pcmPtr);
+
+            return decodedData;
+          } catch (error) {
+            console.log(`Opus解码错误: ${error.message}`, "error");
+            return new Int16Array(0);
+          }
+        },
+
+        destroy: function () {
+          if (this.decoderPtr) {
+            this.module._free(this.decoderPtr);
+            this.decoderPtr = null;
+          }
+        },
+      };
+
+      if (!this.opusDecoder.init()) {
+        throw new Error("Opus解码器初始化失败");
+      }
+
+      return this.opusDecoder;
+    } catch (error) {
+      console.log(`Opus解码器初始化失败: ${error.message}`, "error");
+      this.opusDecoder = null;
+      throw error;
+    }
+  }
+
+  // 启动音频缓冲
+  async startAudioBuffering() {
+    console.log("开始音频缓冲...", "info");
+
+    this.initOpusDecoder().catch((error) => {
+      console.log(`预初始化Opus解码器失败: ${error.message}`, "warning");
+    });
+
+    const timeout = 400;
+    while (true) {
+      const packets = await this.queue.dequeue(6, timeout, (count) => {
+        console.log(`缓冲超时，当前缓冲包数: ${count}，开始播放`, "info");
+      });
+      if (packets.length) {
+        console.log(`已缓冲 ${packets.length} 个音频包，开始播放`, "info");
+        this.streamingContext.pushAudioBuffer(packets);
+      }
+
+      while (true) {
+        const data = await this.queue.dequeue(99, 30);
+        if (data.length) {
+          this.streamingContext.pushAudioBuffer(data);
+        } else {
+          break;
+        }
+      }
+    }
+  }
+
+  // 播放已缓冲的音频
+  async playBufferedAudio() {
+    try {
+      this.audioContext = this.getAudioContext();
+
+      if (!this.opusDecoder) {
+        console.log("初始化Opus解码器...", "info");
+        try {
+          this.opusDecoder = await this.initOpusDecoder();
+          if (!this.opusDecoder) {
+            throw new Error("解码器初始化失败");
+          }
+          console.log("Opus解码器初始化成功", "success");
+        } catch (error) {
+          console.log("Opus解码器初始化失败: " + error.message, "error");
+          this.isPlaying = false;
+          return;
+        }
+      }
+
+      if (!this.streamingContext) {
+        this.streamingContext = createStreamingContext(
+          this.opusDecoder,
+          this.audioContext,
+          this.SAMPLE_RATE,
+          this.CHANNELS,
+          this.MIN_AUDIO_DURATION
+        );
+      }
+
+      this.streamingContext.decodeOpusFrames();
+      this.streamingContext.startPlaying();
+    } catch (error) {
+      console.log(`播放已缓冲的音频出错: ${error.message}`, "error");
+      this.isPlaying = false;
+      this.streamingContext = null;
+    }
+  }
+
+  // 添加音频数据到队列
+  enqueueAudioData(opusData) {
+    if (opusData.length > 0) {
+      this.queue.enqueue(opusData);
+    } else {
+      console.log("收到空音频数据帧，可能是结束标志", "warning");
+      if (this.isPlaying && this.streamingContext) {
+        this.streamingContext.endOfStream = true;
+      }
+    }
+  }
+
+  // 预加载解码器
+  async preload() {
+    console.log("预加载Opus解码器...", "info");
+    try {
+      await this.initOpusDecoder();
+      console.log("Opus解码器预加载成功", "success");
+    } catch (error) {
+      console.log(
+        `Opus解码器预加载失败: ${error.message}，将在需要时重试`,
+        "warning"
+      );
+    }
+  }
+
+  // 启动播放系统
+  async start() {
+    await this.preload();
+    this.playBufferedAudio();
+    this.startAudioBuffering();
+  }
+}
+
+// 创建单例
+let audioPlayerInstance = null;
+
+function player_getAudioPlayer() {
+  if (!audioPlayerInstance) {
+    audioPlayerInstance = new AudioPlayer();
+  }
+  return audioPlayerInstance;
+}
+
+;// CONCATENATED MODULE: ./src/utils/recorder.js
+// 音频录制模块
+
+
+
+// 音频录制器类
+class AudioRecorder {
+  constructor() {
+    this.isRecording = false;
+    this.audioContext = null;
+    this.analyser = null;
+    this.audioProcessor = null;
+    this.audioProcessorType = null;
+    this.audioSource = null;
+    this.opusEncoder = null;
+    this.pcmDataBuffer = new Int16Array();
+    this.audioBuffers = [];
+    this.totalAudioSize = 0;
+    this.visualizationRequest = null;
+    this.recordingTimer = null;
+    this.websocket = null;
+
+    // 回调函数
+    this.onRecordingStart = null;
+    this.onRecordingStop = null;
+    this.onVisualizerUpdate = null;
+  }
+
+  // 设置WebSocket实例
+  setWebSocket(ws) {
+    this.websocket = ws;
+  }
+
+  // 获取AudioContext实例
+  getAudioContext() {
+    const audioPlayer = player_getAudioPlayer();
+    return audioPlayer.getAudioContext();
+  }
+
+  // 初始化编码器
+  initEncoder() {
+    if (!this.opusEncoder) {
+      this.opusEncoder = initOpusEncoder();
+    }
+    return this.opusEncoder;
+  }
+
+  // PCM处理器代码
+  getAudioProcessorCode() {
+    return `
+            class AudioRecorderProcessor extends AudioWorkletProcessor {
+                constructor() {
+                    super();
+                    this.buffers = [];
+                    this.frameSize = 960;
+                    this.buffer = new Int16Array(this.frameSize);
+                    this.bufferIndex = 0;
+                    this.isRecording = false;
+
+                    this.port.onmessage = (event) => {
+                        if (event.data.command === 'start') {
+                            this.isRecording = true;
+                            this.port.postMessage({ type: 'status', status: 'started' });
+                        } else if (event.data.command === 'stop') {
+                            this.isRecording = false;
+
+                            if (this.bufferIndex > 0) {
+                                const finalBuffer = this.buffer.slice(0, this.bufferIndex);
+                                this.port.postMessage({
+                                    type: 'buffer',
+                                    buffer: finalBuffer
+                                });
+                                this.bufferIndex = 0;
+                            }
+
+                            this.port.postMessage({ type: 'status', status: 'stopped' });
+                        }
+                    };
+                }
+
+                process(inputs, outputs, parameters) {
+                    if (!this.isRecording) return true;
+
+                    const input = inputs[0][0];
+                    if (!input) return true;
+
+                    for (let i = 0; i < input.length; i++) {
+                        if (this.bufferIndex >= this.frameSize) {
+                            this.port.postMessage({
+                                type: 'buffer',
+                                buffer: this.buffer.slice(0)
+                            });
+                            this.bufferIndex = 0;
+                        }
+
+                        this.buffer[this.bufferIndex++] = Math.max(-32768, Math.min(32767, Math.floor(input[i] * 32767)));
+                    }
+
+                    return true;
+                }
+            }
+
+            registerProcessor('audio-recorder-processor', AudioRecorderProcessor);
+        `;
+  }
+
+  // 创建音频处理器
+  async createAudioProcessor() {
+    this.audioContext = this.getAudioContext();
+
+    try {
+      if (this.audioContext.audioWorklet) {
+        const blob = new Blob([this.getAudioProcessorCode()], {
+          type: "application/javascript",
+        });
+        const url = URL.createObjectURL(blob);
+        await this.audioContext.audioWorklet.addModule(url);
+        URL.revokeObjectURL(url);
+
+        const audioProcessor = new AudioWorkletNode(
+          this.audioContext,
+          "audio-recorder-processor"
+        );
+
+        audioProcessor.port.onmessage = (event) => {
+          if (event.data.type === "buffer") {
+            this.processPCMBuffer(event.data.buffer);
+          }
+        };
+
+        console.log("使用AudioWorklet处理音频", "success");
+
+        const silent = this.audioContext.createGain();
+        silent.gain.value = 0;
+        audioProcessor.connect(silent);
+        silent.connect(this.audioContext.destination);
+        return { node: audioProcessor, type: "worklet" };
+      } else {
+        console.log(
+          "AudioWorklet不可用，使用ScriptProcessorNode作为回退方案",
+          "warning"
+        );
+        return this.createScriptProcessor();
+      }
+    } catch (error) {
+      console.log(
+        `创建音频处理器失败: ${error.message}，尝试回退方案`,
+        "error"
+      );
+      return this.createScriptProcessor();
+    }
+  }
+
+  // 创建ScriptProcessor作为回退
+  createScriptProcessor() {
+    try {
+      const frameSize = 4096;
+      const scriptProcessor = this.audioContext.createScriptProcessor(
+        frameSize,
+        1,
+        1
+      );
+
+      scriptProcessor.onaudioprocess = (event) => {
+        if (!this.isRecording) return;
+
+        const input = event.inputBuffer.getChannelData(0);
+        const buffer = new Int16Array(input.length);
+
+        for (let i = 0; i < input.length; i++) {
+          buffer[i] = Math.max(
+            -32768,
+            Math.min(32767, Math.floor(input[i] * 32767))
+          );
+        }
+
+        this.processPCMBuffer(buffer);
+      };
+
+      const silent = this.audioContext.createGain();
+      silent.gain.value = 0;
+      scriptProcessor.connect(silent);
+      silent.connect(this.audioContext.destination);
+
+      console.log("使用ScriptProcessorNode作为回退方案成功", "warning");
+      return { node: scriptProcessor, type: "processor" };
+    } catch (fallbackError) {
+      console.log(`回退方案也失败: ${fallbackError.message}`, "error");
+      return null;
+    }
+  }
+
+  // 处理PCM缓冲数据
+  processPCMBuffer(buffer) {
+    if (!this.isRecording) return;
+
+    const newBuffer = new Int16Array(this.pcmDataBuffer.length + buffer.length);
+    newBuffer.set(this.pcmDataBuffer);
+    newBuffer.set(buffer, this.pcmDataBuffer.length);
+    this.pcmDataBuffer = newBuffer;
+
+    const samplesPerFrame = 960;
+
+    while (this.pcmDataBuffer.length >= samplesPerFrame) {
+      const frameData = this.pcmDataBuffer.slice(0, samplesPerFrame);
+      this.pcmDataBuffer = this.pcmDataBuffer.slice(samplesPerFrame);
+
+      this.encodeAndSendOpus(frameData);
+    }
+  }
+
+  // 编码并发送Opus数据
+  encodeAndSendOpus(pcmData = null) {
+    if (!this.opusEncoder) {
+      console.log("Opus编码器未初始化", "error");
+      return;
+    }
+
+    try {
+      if (pcmData) {
+        const opusData = this.opusEncoder.encode(pcmData);
+        if (opusData && opusData.length > 0) {
+          this.audioBuffers.push(opusData.buffer);
+          this.totalAudioSize += opusData.length;
+
+          if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
+            try {
+              this.websocket.send(opusData.buffer);
+            } catch (error) {
+              console.log(`WebSocket发送错误: ${error.message}`, "error");
+            }
+          }
+        } else {
+          log("Opus编码失败，无有效数据返回", "error");
+        }
+      } else {
+        if (this.pcmDataBuffer.length > 0) {
+          const samplesPerFrame = 960;
+          if (this.pcmDataBuffer.length < samplesPerFrame) {
+            const paddedBuffer = new Int16Array(samplesPerFrame);
+            paddedBuffer.set(this.pcmDataBuffer);
+            this.encodeAndSendOpus(paddedBuffer);
+          } else {
+            this.encodeAndSendOpus(
+              this.pcmDataBuffer.slice(0, samplesPerFrame)
+            );
+          }
+          this.pcmDataBuffer = new Int16Array(0);
+        }
+      }
+    } catch (error) {
+      console.log(`Opus编码错误: ${error.message}`, "error");
+    }
+  }
+
+  // 开始录音
+  async start() {
+    try {
+      if (!this.initEncoder()) {
+        console.log("无法启动录音: Opus编码器初始化失败", "error");
+        return false;
+      }
+
+      const stream = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          echoCancellation: true,
+          noiseSuppression: true,
+          sampleRate: 16000,
+          channelCount: 1,
+          latency: { ideal: 0.02, max: 0.05 },
+          // Chrome 扩展参数（非标准，可能变动）
+          googNoiseSuppression: true, // 启用 Chrome 噪声抑制
+          googNoiseSuppression2: 3, // 级别设置（1-3，数值越高抑制越强，不同版本可能有差异）
+          googAutoGainControl: true, // 自动增益控制
+          googHighpassFilter: true, // 高通滤波器（过滤低频噪声）
+        },
+      });
+
+      this.audioContext = this.getAudioContext();
+
+      if (this.audioContext.state === "suspended") {
+        await this.audioContext.resume();
+      }
+
+      const processorResult = await this.createAudioProcessor();
+      if (!processorResult) {
+        console.log("无法创建音频处理器", "error");
+        return false;
+      }
+
+      this.audioProcessor = processorResult.node;
+      this.audioProcessorType = processorResult.type;
+
+      this.audioSource = this.audioContext.createMediaStreamSource(stream);
+      this.analyser = this.audioContext.createAnalyser();
+      this.analyser.fftSize = 2048;
+
+      this.audioSource.connect(this.analyser);
+      this.audioSource.connect(this.audioProcessor);
+
+      this.pcmDataBuffer = new Int16Array();
+      this.audioBuffers = [];
+      this.totalAudioSize = 0;
+      this.isRecording = true;
+
+      if (this.audioProcessorType === "worklet" && this.audioProcessor.port) {
+        this.audioProcessor.port.postMessage({ command: "start" });
+      }
+
+      // 发送监听开始消息
+      if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
+        const listenMessage = {
+          type: "listen",
+          mode: localStorage.getItem("listenMode") || "wakeup",
+          state: "start",
+        };
+
+        console.log(
+          `发送录音开始消息: ${JSON.stringify(listenMessage)}`,
+          "info"
+        );
+        this.websocket.send(JSON.stringify(listenMessage));
+      } else {
+        console.log("WebSocket未连接，无法发送开始消息", "error");
+        return false;
+      }
+
+      // 启动录音计时器
+      let recordingSeconds = 0;
+      this.recordingTimer = setInterval(() => {
+        recordingSeconds += 0.1;
+        if (this.onRecordingStart) {
+          this.onRecordingStart(recordingSeconds);
+        }
+      }, 100);
+
+      console.log("开始PCM直接录音", "success");
+      return true;
+    } catch (error) {
+      console.log(`直接录音启动错误: ${error.message}`, "error");
+      this.isRecording = false;
+      return false;
+    }
+  }
+
+  // 停止录音
+  stop() {
+    if (!this.isRecording) return false;
+
+    try {
+      this.isRecording = false;
+
+      if (this.audioProcessor) {
+        if (this.audioProcessorType === "worklet" && this.audioProcessor.port) {
+          this.audioProcessor.port.postMessage({ command: "stop" });
+        }
+
+        this.audioProcessor.disconnect();
+        this.audioProcessor = null;
+      }
+
+      if (this.audioSource) {
+        this.audioSource.disconnect();
+        this.audioSource = null;
+      }
+
+      if (this.visualizationRequest) {
+        cancelAnimationFrame(this.visualizationRequest);
+        this.visualizationRequest = null;
+      }
+
+      if (this.recordingTimer) {
+        clearInterval(this.recordingTimer);
+        this.recordingTimer = null;
+      }
+
+      // 编码并发送剩余的数据
+      this.encodeAndSendOpus();
+
+      // 发送结束信号
+      if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
+        const emptyOpusFrame = new Uint8Array(0);
+        this.websocket.send(emptyOpusFrame);
+
+        const stopMessage = {
+          type: "listen",
+          mode: localStorage.getItem("listenMode") || "wakeup",
+          state: "stop",
+        };
+
+        this.websocket.send(JSON.stringify(stopMessage));
+        console.log("已发送录音停止信号", "info");
+      }
+
+      if (this.onRecordingStop) {
+        this.onRecordingStop();
+      }
+
+      console.log("停止PCM直接录音", "success");
+      return true;
+    } catch (error) {
+      console.log(`直接录音停止错误: ${error.message}`, "error");
+      return false;
+    }
+  }
+
+  // 获取分析器
+  getAnalyser() {
+    return this.analyser;
+  }
+}
+
+// 创建单例
+let audioRecorderInstance = null;
+
+function recorder_getAudioRecorder() {
+  if (!audioRecorderInstance) {
+    audioRecorderInstance = new AudioRecorder();
+  }
+  return audioRecorderInstance;
+}
+
+;// CONCATENATED MODULE: ./src/utils/ota-connector.js
+// WebSocket 连接
+async function webSocketConnect(otaUrl, config) {
+
+    if (!validateConfig(config)) {
+        return;
+    }
+
+    // 发送OTA请求并获取返回的websocket信息
+    const otaResult = await sendOTA(otaUrl, config);
+    if (!otaResult) {
+        console.log('无法从OTA服务器获取信息', 'error');
+        return;
+    }
+
+    // 从OTA响应中提取websocket信息
+    const { websocket } = otaResult;
+    if (!websocket || !websocket.url) {
+        console.log('OTA响应中缺少websocket信息', 'error');
+        return;
+    }
+
+    // 使用OTA返回的websocket URL
+    let connUrl = new URL(websocket.url);
+
+    // 添加token参数（从OTA响应中获取）
+    if (websocket.token) {
+        if (websocket.token.startsWith("Bearer ")) {
+            connUrl.searchParams.append('authorization', websocket.token);
+        } else {
+            connUrl.searchParams.append('authorization', 'Bearer ' + websocket.token);
+        }
+    }
+
+    // 添加认证参数（保持原有逻辑）
+    connUrl.searchParams.append('device-id', config.deviceId);
+    connUrl.searchParams.append('client-id', config.clientId);
+
+    const wsurl = connUrl.toString()
+
+    console.log(`正在连接: ${wsurl}`, 'info');
+
+    return new WebSocket(connUrl.toString());
+}
+
+// 验证配置
+function validateConfig(config) {
+    if (!config.deviceMac) {
+        console.log('设备MAC地址不能为空', 'error');
+        return false;
+    }
+    if (!config.clientId) {
+        console.log('客户端ID不能为空', 'error');
+        return false;
+    }
+    return true;
+}
+
+// 判断wsUrl路径是否存在错误
+function validateWsUrl(wsUrl) {
+    if (wsUrl === '') return false;
+    // 检查URL格式
+    if (!wsUrl.startsWith('ws://') && !wsUrl.startsWith('wss://')) {
+        console.log('URL格式错误，必须以ws://或wss://开头', 'error');
+        return false;
+    }
+    return true
+}
+
+
+// OTA发送请求，验证状态，并返回响应数据
+async function sendOTA(otaUrl, config) {
+    try {
+        const res = await fetch(otaUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Device-Id': config.deviceId,
+                'Client-Id': config.clientId
+            },
+            body: JSON.stringify({
+                version: 0,
+                uuid: '',
+                application: {
+                    name: 'xiaozhi-web-test',
+                    version: '1.0.0',
+                    compile_time: '2025-04-16 10:00:00',
+                    idf_version: '4.4.3',
+                    elf_sha256: '1234567890abcdef1234567890abcdef1234567890abcdef'
+                },
+                ota: { label: 'xiaozhi-web-test' },
+                board: {
+                    type: 'xiaozhi-web-test',
+                    ssid: 'xiaozhi-web-test',
+                    rssi: 0,
+                    channel: 0,
+                    ip: '192.168.1.1',
+                    mac: config.deviceMac
+                },
+                flash_size: 0,
+                minimum_free_heap_size: 0,
+                mac_address: config.deviceMac,
+                chip_model_name: '',
+                chip_info: { model: 0, cores: 0, revision: 0, features: 0 },
+                partition_table: [{ label: '', type: 0, subtype: 0, address: 0, size: 0 }]
+            })
+        });
+
+        if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
+
+        const result = await res.json();
+        return result; // 返回完整的响应数据
+    } catch (err) {
+        return null; // 失败返回null
+    }
+}
+;// CONCATENATED MODULE: ./src/utils/manager.js
+// 生成随机MAC地址
+function generateRandomMac() {
+  const hexDigits = "0123456789ABCDEF";
+  let mac = "";
+  for (let i = 0; i < 6; i++) {
+    if (i > 0) mac += ":";
+    for (let j = 0; j < 2; j++) {
+      mac += hexDigits.charAt(Math.floor(Math.random() * 16));
+    }
+  }
+  return mac;
+}
+
+// 加载配置
+function loadConfig() {
+  // 从localStorage加载MAC地址，如果没有则生成新的
+  let savedMac = localStorage.getItem("xz_tester_deviceMac");
+  if (!savedMac) {
+    savedMac = generateRandomMac();
+    localStorage.setItem("xz_tester_deviceMac", savedMac);
+  }
+}
+
+// 获取配置值
+function getConfig() {
+  return {
+    deviceId: localStorage.getItem("MAC"), // 使用MAC地址作为deviceId
+    deviceName: "测试设备",
+    deviceMac: localStorage.getItem("MAC"),
+    clientId: "web_test_client",
+    token: "your-token1",
+  };
+}
+
+// 保存连接URL
+function saveConnectionUrls() {
+  const otaUrl = localStorage.getItem("otaUrl");
+  localStorage.setItem("xz_tester_otaUrl", otaUrl);
+}
+
+;// CONCATENATED MODULE: ./src/utils/websocket.js
+// WebSocket消息处理模块
+
+
+
+
+
+
+// WebSocket处理器类
+class WebSocketHandler {
+  constructor() {
+    this.websocket = null;
+    this.onConnectionStateChange = null;
+    this.onRecordButtonStateChange = null;
+    this.onSessionStateChange = null;
+    this.onSessionEmotionChange = null;
+    this.currentSessionId = null;
+    this.isRemoteSpeaking = false;
+    this.heartbeatTimer = null;
+
+    // 重连相关配置
+    this.reconnectConfig = {
+      maxRetries: 10, // 最大重连次数
+      baseDelay: 1000, // 基础重连延迟(ms)
+      maxDelay: 30000, // 最大重连延迟(ms)
+      retryCount: 0, // 当前重连次数
+      reconnectTimer: null, // 重连定时器
+      isReconnecting: false, // 是否正在重连中
+      manualDisconnect: false, // 是否手动断开连接
+    };
+  }
+
+  // 在 WebSocketHandler 类中添加
+  startHeartbeat() {
+    this.stopHeartbeat(); // 先清除之前的定时器
+    this.sendHeartbeat();
+  }
+
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearTimeout(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+
+  sendHeartbeat() {
+    if (this.websocket?.readyState === WebSocket.OPEN) {
+      try {
+        this.websocket.send("1");
+      } catch (error) {
+        console.error("心跳发送失败:", error);
+      }
+    }
+
+    this.heartbeatTimer = setTimeout(() => {
+      this.sendHeartbeat();
+    }, 5000);
+  }
+
+  // 发送hello握手消息
+  async sendHelloMessage() {
+    if (!this.websocket || this.websocket.readyState !== WebSocket.OPEN)
+      return false;
+
+    this.startHeartbeat(); // 启动心跳
+    try {
+      const config = getConfig();
+
+      const helloMessage = {
+        type: "hello",
+        device_id: config.deviceId,
+        device_name: config.deviceName,
+        device_mac: config.deviceMac,
+        token: config.token,
+        seat: localStorage.getItem("SEAT"),
+        features: {
+          mcp: true,
+        },
+      };
+
+      console.log("发送hello握手消息", "info");
+      this.websocket.send(JSON.stringify(helloMessage));
+
+      return new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          console.log("等待hello响应超时", "error");
+          console.log('提示: 请尝试点击"测试认证"按钮进行连接排查', "info");
+          resolve(false);
+        }, 5000);
+
+        const onMessageHandler = (event) => {
+          try {
+            const response = JSON.parse(event.data);
+            if (response.type === "hello" && response.session_id) {
+              console.log(
+                `服务器握手成功，会话ID: ${response.session_id}`,
+                "success"
+              );
+              // 握手成功后重置重连计数器
+              this.reconnectConfig.retryCount = 0;
+              clearTimeout(timeout);
+              this.websocket.removeEventListener("message", onMessageHandler);
+              resolve(true);
+            }
+          } catch (e) {
+            // 忽略非JSON消息
+          }
+        };
+
+        this.websocket.addEventListener("message", onMessageHandler);
+      });
+    } catch (error) {
+      console.log(`发送hello消息错误: ${error.message}`, "error");
+      return false;
+    }
+  }
+
+  // 处理文本消息
+  handleTextMessage(message) {
+    if (message.type === "hello") {
+    } else if (message.type === "tts") {
+      this.handleTTSMessage(message);
+    } else if (message.type === "audio") {
+    } else if (message.type === "stt") {
+      const event = new CustomEvent("wsSendMessage", {
+        detail: message,
+      });
+      window.dispatchEvent(event);
+    } else if (message.type === "llm") {
+    } else if (message.type === "mcp") {
+      this.handleMCPMessage(message);
+    } else if (message.type === "json_data") {
+      if (message.state === "drinks") {
+        const event = new CustomEvent("drinkListEvent", {
+          detail: message.data,
+        });
+        window.dispatchEvent(event);
+      } else if (message.state === "book") {
+        const event = new CustomEvent("bookListEvent", {
+          detail: message
+        });
+        window.dispatchEvent(event);
+      }
+    } else if (message.type === "view_action") {
+      const event = new CustomEvent("viewActionEvent", {
+        detail: message.state,
+      });
+      window.dispatchEvent(event);
+    } else {
+      console.log(`未知消息类型: ${message.type}`, "warning");
+    }
+  }
+
+  // 处理TTS消息
+  handleTTSMessage(message) {
+    if (message.state === "start") {
+      console.log("服务器开始发送语音", "info");
+      this.currentSessionId = message.session_id;
+      const event = new CustomEvent("startThink");
+      window.dispatchEvent(event);
+      this.isRemoteSpeaking = true;
+      if (this.onSessionStateChange) {
+        this.onSessionStateChange(true);
+      }
+    } else if (message.state === "sentence_start") {
+      const event = new CustomEvent("startVolic", {
+        detail: message.text,
+      });
+      window.dispatchEvent(event);
+      console.log(`服务器发送语音段: ${message.text}`, "info");
+    } else if (message.state === "sentence_end") {
+      console.log(`语音段结束: ${message.text}`, "info");
+    } else if (message.state === "stop") {
+      const event = new CustomEvent("stopVolic");
+      window.dispatchEvent(event);
+      console.log("服务器语音传输结束", "info");
+      this.isRemoteSpeaking = false;
+      if (this.onRecordButtonStateChange) {
+        this.onRecordButtonStateChange(false);
+      }
+      if (this.onSessionStateChange) {
+        this.onSessionStateChange(false);
+      }
+    }
+  }
+
+  // 处理MCP消息
+  handleMCPMessage(message) {
+    const payload = message.payload || {};
+    console.log(`服务器下发: ${JSON.stringify(message)}`, "info");
+
+    if (payload.method === "tools/list") {
+      const tools = getMcpTools();
+      const replyMessage = JSON.stringify({
+        session_id: message.session_id || "",
+        type: "mcp",
+        payload: {
+          jsonrpc: "2.0",
+          id: payload.id,
+          result: {
+            tools: tools,
+          },
+        },
+      });
+      console.log(`客户端上报: ${replyMessage}`, "info");
+      this.websocket.send(replyMessage);
+      console.log(`回复MCP工具列表: ${tools.length} 个工具`, "info");
+    } else if (payload.method === "tools/call") {
+      const toolName = payload.params?.name;
+      const toolArgs = payload.params?.arguments;
+
+      console.log(
+        `调用工具: ${toolName} 参数: ${JSON.stringify(toolArgs)}`,
+        "info"
+      );
+
+      const result = executeMcpTool(toolName, toolArgs);
+
+      const replyMessage = JSON.stringify({
+        session_id: message.session_id || "",
+        type: "mcp",
+        payload: {
+          jsonrpc: "2.0",
+          id: payload.id,
+          result: {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result),
+              },
+            ],
+            isError: false,
+          },
+        },
+      });
+
+      console.log(`客户端上报: ${replyMessage}`, "info");
+      this.websocket.send(replyMessage);
+    } else if (payload.method === "initialize") {
+      console.log(
+        `收到工具初始化请求: ${JSON.stringify(payload.params)}`,
+        "info"
+      );
+    } else {
+      console.log(`未知的MCP方法: ${payload.method}`, "warning");
+    }
+  }
+
+  // 处理二进制消息
+  async handleBinaryMessage(data) {
+    try {
+      let arrayBuffer;
+      if (data instanceof ArrayBuffer) {
+        arrayBuffer = data;
+      } else if (data instanceof Blob) {
+        arrayBuffer = await data.arrayBuffer();
+        console.log(
+          `收到Blob音频数据，大小: ${arrayBuffer.byteLength}字节`,
+          "debug"
+        );
+      } else {
+        console.log(`收到未知类型的二进制数据: ${typeof data}`, "warning");
+        return;
+      }
+
+      const opusData = new Uint8Array(arrayBuffer);
+      const audioPlayer = player_getAudioPlayer();
+      audioPlayer.enqueueAudioData(opusData);
+    } catch (error) {
+      console.log(`处理二进制消息出错: ${error.message}`, "error");
+    }
+  }
+
+  // 计算重连延迟（指数退避策略）
+  calculateReconnectDelay() {
+    // 指数退避 + 随机抖动，避免多个客户端同时重连
+    const delay = Math.min(
+      this.reconnectConfig.baseDelay *
+        Math.pow(2, this.reconnectConfig.retryCount),
+      this.reconnectConfig.maxDelay
+    );
+    // 添加±20%的随机抖动
+    const jitter = delay * 0.2 * (Math.random() - 0.5);
+    return Math.round(delay + jitter);
+  }
+
+  // 触发自动重连
+  triggerReconnect() {
+    // 如果是手动断开连接，不进行重连
+    if (this.reconnectConfig.manualDisconnect) {
+      console.log("手动断开连接，不进行自动重连", "info");
+      return;
+    }
+
+    // 检查是否达到最大重连次数
+    if (this.reconnectConfig.retryCount >= this.reconnectConfig.maxRetries) {
+      console.log(
+        `已达到最大重连次数(${this.reconnectConfig.maxRetries})，停止重连`,
+        "error"
+      );
+      this.reconnectConfig.isReconnecting = false;
+      if (this.onConnectionStateChange) {
+        this.onConnectionStateChange(false);
+      }
+      return;
+    }
+
+    // 计算重连延迟
+    const delay = this.calculateReconnectDelay();
+    this.reconnectConfig.retryCount++;
+
+    console.log(
+      `准备进行第${this.reconnectConfig.retryCount}次重连，延迟${delay}ms`,
+      "info"
+    );
+
+    // 设置重连定时器
+    this.reconnectConfig.reconnectTimer = setTimeout(async () => {
+      console.log(`开始第${this.reconnectConfig.retryCount}次重连`, "info");
+      try {
+        const success = await this.connect();
+        if (success) {
+          console.log("重连成功", "success");
+          this.reconnectConfig.isReconnecting = false;
+        } else {
+          console.log(
+            `第${this.reconnectConfig.retryCount}次重连失败`,
+            "error"
+          );
+          this.triggerReconnect();
+        }
+      } catch (error) {
+        console.log(`重连出错: ${error.message}`, "error");
+        this.triggerReconnect();
+      }
+    }, delay);
+  }
+
+  // 停止自动重连
+  stopReconnect() {
+    if (this.reconnectConfig.reconnectTimer) {
+      clearTimeout(this.reconnectConfig.reconnectTimer);
+      this.reconnectConfig.reconnectTimer = null;
+    }
+    this.reconnectConfig.isReconnecting = false;
+    this.reconnectConfig.retryCount = 0;
+  }
+
+  // 连接WebSocket服务器
+  async connect() {
+    // 如果正在重连中，先停止之前的重连
+    this.stopReconnect();
+
+    const config = getConfig();
+    console.log("正在检查OTA状态...", "info");
+    saveConnectionUrls();
+
+    try {
+      const otaUrl = localStorage.getItem("xz_tester_otaUrl");
+      const ws = await webSocketConnect(otaUrl, config);
+      if (ws === undefined) {
+        // 连接失败，触发重连
+        if (
+          !this.reconnectConfig.isReconnecting &&
+          !this.reconnectConfig.manualDisconnect
+        ) {
+          this.reconnectConfig.isReconnecting = true;
+          this.triggerReconnect();
+        }
+        return false;
+      }
+
+      this.websocket = ws;
+
+      // 设置接收二进制数据的类型为ArrayBuffer
+      this.websocket.binaryType = "arraybuffer";
+
+      // 设置 MCP 模块的 WebSocket 实例
+      setWebSocket(this.websocket);
+
+      // 设置录音器的WebSocket
+      const audioRecorder = recorder_getAudioRecorder();
+      audioRecorder.setWebSocket(this.websocket);
+
+      this.setupEventHandlers();
+
+      return true;
+    } catch (error) {
+      console.log(`连接错误: ${error.message}`, "error");
+      if (this.onConnectionStateChange) {
+        this.onConnectionStateChange(false);
+      }
+
+      // 连接出错，触发重连
+      if (
+        !this.reconnectConfig.isReconnecting &&
+        !this.reconnectConfig.manualDisconnect
+      ) {
+        this.reconnectConfig.isReconnecting = true;
+        this.triggerReconnect();
+      }
+
+      return false;
+    }
+  }
+
+  // 设置事件处理器
+  setupEventHandlers() {
+    this.websocket.onopen = async () => {
+      const url = localStorage.getItem("xz_tester_wsUrl");
+      console.log(`已连接到服务器: ${url}`, "success");
+
+      if (this.onConnectionStateChange) {
+        this.onConnectionStateChange(true);
+      }
+
+      // 连接成功后，默认状态为聆听中
+      this.isRemoteSpeaking = false;
+      if (this.onSessionStateChange) {
+        this.onSessionStateChange(false);
+      }
+
+      await this.sendHelloMessage();
+    };
+
+    this.websocket.onclose = (event) => {
+      console.log(
+        `已断开连接，代码: ${event.code}, 原因: ${event.reason}`,
+        "info"
+      );
+      this.stopHeartbeat();
+
+      // 清除MCP的WebSocket引用
+      setWebSocket(null);
+
+      // 停止录音
+      const audioRecorder = recorder_getAudioRecorder();
+      audioRecorder.stop();
+
+      if (this.onConnectionStateChange) {
+        this.onConnectionStateChange(false);
+      }
+
+      // 如果不是手动断开连接，触发自动重连
+      if (
+        !this.reconnectConfig.manualDisconnect &&
+        !this.reconnectConfig.isReconnecting
+      ) {
+        // 1000: 正常关闭, 1001: 客户端离开, 这两种情况不自动重连
+        if (event.code !== 1000 && event.code !== 1001) {
+          console.log("检测到异常断开连接，准备自动重连", "warning");
+          this.reconnectConfig.isReconnecting = true;
+          this.triggerReconnect();
+        }
+      }
+
+      // 重置手动断开标记（以便下次可以重连）
+      this.reconnectConfig.manualDisconnect = false;
+    };
+
+    this.websocket.onerror = (error) => {
+      console.log(`WebSocket错误: ${error.message || "未知错误"}`, "error");
+
+      if (this.onConnectionStateChange) {
+        this.onConnectionStateChange(false);
+      }
+    };
+
+    this.websocket.onmessage = (event) => {
+      try {
+        if (typeof event.data === "string") {
+          const message = JSON.parse(event.data);
+          this.handleTextMessage(message);
+        } else {
+          this.handleBinaryMessage(event.data);
+        }
+      } catch (error) {
+        console.log(`WebSocket消息处理错误: ${error.message}`, "error");
+      }
+    };
+  }
+
+  // 断开连接
+  disconnect() {
+    // 标记为手动断开连接
+    this.reconnectConfig.manualDisconnect = true;
+    this.stopReconnect();
+
+    if (!this.websocket) return;
+
+    // 正常关闭连接
+    this.websocket.close(1000, "Manual disconnect");
+    const audioRecorder = recorder_getAudioRecorder();
+    audioRecorder.stop();
+  }
+
+  // 发送文本消息
+  sendTextMessage(text) {
+    try {
+      // 如果对方正在说话，先发送打断消息
+      const abortMessage = {
+        session_id: this.currentSessionId,
+        type: "abort",
+        reason: "wake_word_detected",
+      };
+      this.websocket.send(JSON.stringify(abortMessage));
+      console.log("发送打断消息", "info");
+
+      const listenMessage = {
+        type: "listen",
+        mode: localStorage.getItem("listenMode") || "wakeup",
+        state: "detect",
+        text: text,
+      };
+
+      this.websocket.send(JSON.stringify(listenMessage));
+      console.log(`发送文本消息: ${text}`, "info6666");
+
+      return true;
+    } catch (error) {
+      console.log(`发送消息错误: ${error.message}`, "error");
+      return false;
+    }
+  }
+
+  // 获取WebSocket实例
+  getWebSocket() {
+    return this.websocket;
+  }
+
+  // 检查是否已连接
+  isConnected() {
+    return this.websocket && this.websocket.readyState === WebSocket.OPEN;
+  }
+
+  // 获取重连状态
+  getReconnectStatus() {
+    return {
+      isReconnecting: this.reconnectConfig.isReconnecting,
+      retryCount: this.reconnectConfig.retryCount,
+      maxRetries: this.reconnectConfig.maxRetries,
+    };
+  }
+
+  // 重置重连配置
+  resetReconnectConfig() {
+    this.stopReconnect();
+    this.reconnectConfig.retryCount = 0;
+    this.reconnectConfig.isReconnecting = false;
+    this.reconnectConfig.manualDisconnect = false;
+  }
+}
+
+// 创建单例
+let wsHandlerInstance = null;
+
+function getWebSocketHandler() {
+  if (!wsHandlerInstance) {
+    wsHandlerInstance = new WebSocketHandler();
+  }
+  return wsHandlerInstance;
+}
+
+;// CONCATENATED MODULE: ./src/utils/controller.js
+// UI控制模块
+
+
+
+// ws连接事件监听
+async function wsConnectEventListeners() {
+  const wsHandler = getWebSocketHandler();
+  await wsHandler.connect();
+}
+
+// ws关闭事件监听
+async function wsCloseEventListeners() {
+  const wsHandler = getWebSocketHandler();
+  await wsHandler.disconnect();
+}
+
+// 语音播放
+async function startEventAudioPlayer() {
+  const audioRecorder = recorder_getAudioRecorder();
+  await audioRecorder.start();
+}
+
+// 语音暂停
+async function stopEventAudioPlayer() {
+  const audioRecorder = getAudioRecorder();
+  await audioRecorder.stop();
+}
+
+
+// 判断ws是否连接
+function isWsConnected() {
+  const wsHandler = getWebSocketHandler();
+  return wsHandler.isConnected();
+}
+;// CONCATENATED MODULE: ./node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/index.vue?vue&type=script&lang=js
+
+
+
+
+/* harmony default export */ const lib_vue_loader_options_srcvue_type_script_lang_js = ({
+  name: "ibiAiTalk",
+  data() {
+    return {
+      audioPlayer: null,
+    };
+  },
+  props: {
+    listenMode: {
+      type: String,
+      default: "wakeup",
+    },
+    otaUrl: {
+      type: String,
+      default: "",
+    },
+    macAddress: {
+      type: String,
+      default: "",
+    },
+  },
+  async mounted() {
+    localStorage.setItem("MAC", this.macAddress);
+    localStorage.setItem("otaUrl", this.otaUrl);
+    localStorage.setItem("listenMode", this.listenMode);
+    checkOpusLoaded();
+    initOpusEncoder();
+    initMcpTools();
+    if (!isWsConnected()) {
+      await wsConnectEventListeners();
+    }
+    this.audioPlayer = getAudioPlayer();
+    await this.audioPlayer.start();
+    await startEventAudioPlayer();
+  },
+  beforeDestroy() {
+    this.audioPlayer.stop().catch(() => {});
+    // 关闭WebSocket连接
+    if (isWsConnected()) {
+      wsCloseEventListeners().catch(() => {});
+    }
+  },
+});
+
+;// CONCATENATED MODULE: ./src/index.vue?vue&type=script&lang=js
+ /* harmony default export */ const srcvue_type_script_lang_js = (lib_vue_loader_options_srcvue_type_script_lang_js); 
+;// CONCATENATED MODULE: ./node_modules/@vue/vue-loader-v15/lib/runtime/componentNormalizer.js
+/* globals __VUE_SSR_CONTEXT__ */
+
+// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
+// This module is a runtime utility for cleaner component module output and will
+// be included in the final webpack user bundle.
+
+function normalizeComponent(
+  scriptExports,
+  render,
+  staticRenderFns,
+  functionalTemplate,
+  injectStyles,
+  scopeId,
+  moduleIdentifier /* server only */,
+  shadowMode /* vue-cli only */
+) {
+  // Vue.extend constructor export interop
+  var options =
+    typeof scriptExports === 'function' ? scriptExports.options : scriptExports
+
+  // render functions
+  if (render) {
+    options.render = render
+    options.staticRenderFns = staticRenderFns
+    options._compiled = true
+  }
+
+  // functional template
+  if (functionalTemplate) {
+    options.functional = true
+  }
+
+  // scopedId
+  if (scopeId) {
+    options._scopeId = 'data-v-' + scopeId
+  }
+
+  var hook
+  if (moduleIdentifier) {
+    // server build
+    hook = function (context) {
+      // 2.3 injection
+      context =
+        context || // cached call
+        (this.$vnode && this.$vnode.ssrContext) || // stateful
+        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
+      // 2.2 with runInNewContext: true
+      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
+        context = __VUE_SSR_CONTEXT__
+      }
+      // inject component styles
+      if (injectStyles) {
+        injectStyles.call(this, context)
+      }
+      // register component module identifier for async chunk inferrence
+      if (context && context._registeredComponents) {
+        context._registeredComponents.add(moduleIdentifier)
+      }
+    }
+    // used by ssr in case component is cached and beforeCreate
+    // never gets called
+    options._ssrRegister = hook
+  } else if (injectStyles) {
+    hook = shadowMode
+      ? function () {
+          injectStyles.call(
+            this,
+            (options.functional ? this.parent : this).$root.$options.shadowRoot
+          )
+        }
+      : injectStyles
+  }
+
+  if (hook) {
+    if (options.functional) {
+      // for template-only hot-reload because in that case the render fn doesn't
+      // go through the normalizer
+      options._injectStyles = hook
+      // register for functional component in vue file
+      var originalRender = options.render
+      options.render = function renderWithStyleInjection(h, context) {
+        hook.call(context)
+        return originalRender(h, context)
+      }
+    } else {
+      // inject component registration as beforeCreate hook
+      var existing = options.beforeCreate
+      options.beforeCreate = existing ? [].concat(existing, hook) : [hook]
+    }
+  }
+
+  return {
+    exports: scriptExports,
+    options: options
+  }
+}
+
+;// CONCATENATED MODULE: ./src/index.vue
+
+
+
+
+
+/* normalize component */
+;
+var component = normalizeComponent(
+  srcvue_type_script_lang_js,
+  render,
+  staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ const src_0 = (component.exports);
+;// CONCATENATED MODULE: ./node_modules/@vue/cli-service/lib/commands/build/entry-lib.js
+
+
+/* harmony default export */ const entry_lib = (src_0);
+
+
+__webpack_exports__ = __webpack_exports__["default"];
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});
+//# sourceMappingURL=index.umd.js.map