ibi-ai-talk 1.0.1 → 1.0.3

package/dist/index.umd.js

@@ -61,7 +61,7 @@ if (typeof window !== 'undefined') {
 // 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
+;// 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=70fe37c2
 var render = function render(){var _vm=this,_c=_vm._self._c;return _c("div")
 }
 var staticRenderFns = []
@@ -237,1074 +237,1074 @@ function initOpusEncoder() {
         return false;
     }
 }
-;// CONCATENATED MODULE: ./src/utils/tools.js
-// 全局变量
-let mcpTools = [];
-let mcpEditingIndex = null;
-let mcpProperties = [];
-let websocket = null; // 将从外部设置
+;// CONCATENATED MODULE: ./src/utils/blocking-queue.js
+class BlockingQueue {
+    #items   = [];
+    #waiters = [];          // {resolve, reject, min, timer, onTimeout}
 
-/**
- * 设置 WebSocket 实例
- * @param {WebSocket} ws - WebSocket 连接实例
- */
-function setWebSocket(ws) {
-  websocket = ws;
-}
+    /* 空队列一次性闸门 */
+    #emptyPromise = null;
+    #emptyResolve = null;
 
-/**
- * 初始化 MCP 工具
- */
-async function initMcpTools() {
-  // 加载默认工具数据
-  const defaultMcpTools = await fetch("/default-mcp-tools.json").then((res) =>
-    res.json()
-  );
+    /* 生产者：把数据塞进去 */
+    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;
+        }
 
-  const savedTools = localStorage.getItem("mcpTools");
-  if (savedTools) {
-    try {
-      mcpTools = JSON.parse(savedTools);
-    } catch (e) {
-      console.log("加载MCP工具失败，使用默认工具", "warning");
-      mcpTools = [...defaultMcpTools];
+        // 唤醒所有正在等的 waiter
+        this.#wakeWaiters();
     }
-  } else {
-    mcpTools = [...defaultMcpTools];
-  }
 
-  // renderMcpTools();
-  // setupMcpEventListeners();
+    /* 消费者：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
 
-/**
- * 渲染工具列表
- */
-function renderMcpTools() {
-  const container = document.getElementById("mcpToolsContainer");
-  const countSpan = document.getElementById("mcpToolsCount");
 
-  countSpan.textContent = `${mcpTools.length} 个工具`;
+// 音频流播放上下文类
+class StreamingContext {
+  constructor(
+    opusDecoder,
+    audioContext,
+    sampleRate,
+    channels,
+    minAudioDuration
+  ) {
+    this.opusDecoder = opusDecoder;
+    this.audioContext = audioContext;
 
-  if (mcpTools.length === 0) {
-    container.innerHTML =
-      '<div style="text-align: center; padding: 30px; color: #999;">暂无工具，点击下方按钮添加新工具</div>';
-    return;
+    // 音频参数
+    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; // 上次播放的时间戳
   }
 
-  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;
+  // 缓存音频数组
+  pushAudioBuffer(item) {
+    this.audioBufferQueue.enqueue(...item);
+  }
 
-      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("");
-}
+  // 获取需要处理缓存队列，单线程：在audioBufferQueue一直更新的状态下不会出现安全问题
+  async getPendingAudioBufferQueue() {
+    // 原子交换 + 清空
+    [this.pendingAudioBufferQueue, this.audioBufferQueue] = [
+      await this.audioBufferQueue.dequeue(),
+      new BlockingQueue(),
+    ];
+  }
 
-/**
- * 渲染参数列表
- */
-function renderMcpProperties() {
-  const container = document.getElementById("mcpPropertiesContainer");
+  // 获取正在播放已解码的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);
+  }
 
-  if (mcpProperties.length === 0) {
-    container.innerHTML =
-      '<div style="text-align: center; padding: 20px; color: #999; font-size: 14px;">暂无参数，点击下方按钮添加参数</div>';
-    return;
+  // 将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;
   }
 
-  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("");
-}
+  // 将Opus数据解码为PCM
+  async decodeOpusFrames() {
+    if (!this.opusDecoder) {
+      console.log("Opus解码器未初始化，无法解码", "error");
+      return;
+    } else {
+      console.log("Opus解码器启动", "info");
+    }
 
-/**
- * 添加参数
- */
-function addMcpProperty() {
-  mcpProperties.push({
-    name: `param_${mcpProperties.length + 1}`,
-    type: "string",
-    required: false,
-    description: "",
-  });
-  renderMcpProperties();
-}
+    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");
+        }
+      }
 
-/**
- * 更新参数
- */
-function updateMcpProperty(index, field, value) {
-  if (field === "name") {
-    const isDuplicate = mcpProperties.some(
-      (p, i) => i !== index && p.name === value
-    );
-    if (isDuplicate) {
-      alert("参数名称已存在，请使用不同的名称");
-      renderMcpProperties();
-      return;
+      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();
     }
   }
 
-  mcpProperties[index][field] = value;
+  // 开始播放音频
+  async startPlaying() {
+    let scheduledEndTime = this.audioContext.currentTime; // 跟踪已调度音频的结束时间
 
-  if (field === "type" && value !== "integer" && value !== "number") {
-    delete mcpProperties[index].minimum;
-    delete mcpProperties[index].maximum;
-    renderMcpProperties();
-  }
-}
+    while (true) {
+      // 初始缓冲：等待足够的样本再开始播放
+      const minSamples = this.sampleRate * this.minAudioDuration * 2;
+      if (!this.playing && this.queue.length < minSamples) {
+        await this.getQueue(minSamples);
+      }
+      this.playing = true;
 
-/**
- * 删除参数
- */
-function deleteMcpProperty(index) {
-  mcpProperties.splice(index, 1);
-  renderMcpProperties();
-}
+      // 持续播放队列中的音频，每次播放一个小块
+      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);
 
-/**
- * 设置事件监听
- */
-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");
+        if (actualSamples === 0) break;
 
-  toggleBtn.addEventListener("click", () => {
-    const isExpanded = panel.classList.contains("expanded");
-    panel.classList.toggle("expanded");
-    toggleBtn.textContent = isExpanded ? "展开" : "收起";
-  });
+        const currentSamples = this.queue.splice(0, actualSamples);
+        const audioBuffer = this.audioContext.createBuffer(
+          this.channels,
+          currentSamples.length,
+          this.sampleRate
+        );
+        audioBuffer.copyToChannel(new Float32Array(currentSamples), 0);
 
-  addBtn.addEventListener("click", () => openMcpModal());
-  closeBtn.addEventListener("click", closeMcpModal);
-  cancelBtn.addEventListener("click", closeMcpModal);
-  addPropertyBtn.addEventListener("click", addMcpProperty);
+        // 创建音频源
+        this.source = this.audioContext.createBufferSource();
+        this.source.buffer = audioBuffer;
 
-  modal.addEventListener("click", (e) => {
-    if (e.target === modal) closeMcpModal();
-  });
+        // 精确调度播放时间
+        const currentTime = this.audioContext.currentTime;
+        const startTime = Math.max(scheduledEndTime, currentTime);
 
-  form.addEventListener("submit", handleMcpSubmit);
-}
+        // 直接连接到输出
+        this.source.connect(this.audioContext.destination);
 
-/**
- * 打开模态框
- */
-function openMcpModal(index = null) {
-  const isConnected = websocket && websocket.readyState === WebSocket.OPEN;
-  if (isConnected) {
-    alert("WebSocket 已连接，无法编辑工具");
-    return;
-  }
+        this.source.start(startTime);
 
-  mcpEditingIndex = index;
-  const errorContainer = document.getElementById("mcpErrorContainer");
-  errorContainer.innerHTML = "";
+        // 更新下一个音频块的调度时间
+        const duration = audioBuffer.duration;
+        scheduledEndTime = startTime + duration;
+        this.lastPlayTime = startTime;
 
-  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)
-      : "";
+        // 如果队列中数据不足，等待新数据
+        if (this.queue.length < targetSamples) {
+          break;
+        }
+      }
 
-    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),
-        });
-      });
+      // 等待新数据
+      await this.getQueue(minSamples);
     }
-  } 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 = "";
+// 创建streamingContext实例的工厂函数
+function createStreamingContext(
+  opusDecoder,
+  audioContext,
+  sampleRate,
+  channels,
+  minAudioDuration
+) {
+  return new StreamingContext(
+    opusDecoder,
+    audioContext,
+    sampleRate,
+    channels,
+    minAudioDuration
+  );
 }
 
-/**
- * 处理表单提交
- */
-function handleMcpSubmit(e) {
-  e.preventDefault();
-  const errorContainer = document.getElementById("mcpErrorContainer");
-  errorContainer.innerHTML = "";
+;// CONCATENATED MODULE: ./src/utils/player.js
+// 音频播放模块
 
-  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;
+// 音频播放器类
+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;
   }
 
-  // 解析模拟返回结果
-  let mockResponse = null;
-  if (mockResponseText) {
-    try {
-      mockResponse = JSON.parse(mockResponseText);
-    } catch (e) {
-      showMcpError("模拟返回结果不是有效的 JSON 格式: " + e.message);
-      return;
+  // 获取或创建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;
   }
 
-  // 构建 inputSchema
-  const inputSchema = {
-    type: "object",
-    properties: {},
-    required: [],
-  };
+  // 初始化Opus解码器
+  async initOpusDecoder() {
+    if (this.opusDecoder) return this.opusDecoder;
 
-  mcpProperties.forEach((prop) => {
-    const propSchema = { type: prop.type };
+    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对象都不存在");
+        }
+      }
 
-    if (prop.description) {
-      propSchema.description = prop.description;
-    }
+      const mod = window.ModuleInstance;
 
-    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;
-      }
-    }
+      this.opusDecoder = {
+        channels: this.CHANNELS,
+        rate: this.SAMPLE_RATE,
+        frameSize: this.FRAME_SIZE,
+        module: mod,
+        decoderPtr: null,
 
-    inputSchema.properties[prop.name] = propSchema;
+        init: function () {
+          if (this.decoderPtr) return true;
 
-    if (prop.required) {
-      inputSchema.required.push(prop.name);
-    }
-  });
+          const decoderSize = mod._opus_decoder_get_size(this.channels);
+          console.log(`Opus解码器大小: ${decoderSize}字节`, "debug");
 
-  if (inputSchema.required.length === 0) {
-    delete inputSchema.required;
-  }
+          this.decoderPtr = mod._malloc(decoderSize);
+          if (!this.decoderPtr) {
+            throw new Error("无法分配解码器内存");
+          }
 
-  const tool = { name, description, inputSchema, mockResponse };
+          const err = mod._opus_decoder_init(
+            this.decoderPtr,
+            this.rate,
+            this.channels
+          );
 
-  if (mcpEditingIndex !== null) {
-    mcpTools[mcpEditingIndex] = tool;
-    console.log(`已更新工具: ${name}`, "success");
-  } else {
-    mcpTools.push(tool);
-    console.log(`已添加工具: ${name}`, "success");
-  }
+          if (err < 0) {
+            this.destroy();
+            throw new Error(`Opus解码器初始化失败: ${err}`);
+          }
 
-  saveMcpTools();
-  renderMcpTools();
-  closeMcpModal();
-}
+          console.log("Opus解码器初始化成功", "success");
+          return true;
+        },
 
-/**
- * 显示错误
- */
-function showMcpError(message) {
-  const errorContainer = document.getElementById("mcpErrorContainer");
-  errorContainer.innerHTML = `<div class="mcp-error">${message}</div>`;
-}
+        decode: function (opusData) {
+          if (!this.decoderPtr) {
+            if (!this.init()) {
+              throw new Error("解码器未初始化且无法初始化");
+            }
+          }
 
-/**
- * 编辑工具
- */
-function editMcpTool(index) {
-  openMcpModal(index);
-}
+          try {
+            const mod = this.module;
 
-/**
- * 删除工具
- */
-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");
-  }
-}
+            const opusPtr = mod._malloc(opusData.length);
+            mod.HEAPU8.set(opusData, opusPtr);
 
-/**
- * 保存工具
- */
-function saveMcpTools() {
-  localStorage.setItem("mcpTools", JSON.stringify(mcpTools));
-}
+            const pcmPtr = mod._malloc(this.frameSize * 2);
 
-/**
- * 获取工具列表
- */
-function getMcpTools() {
-  return mcpTools.map((tool) => ({
-    name: tool.name,
-    description: tool.description,
-    inputSchema: tool.inputSchema,
-  }));
-}
+            const decodedSamples = mod._opus_decode(
+              this.decoderPtr,
+              opusPtr,
+              opusData.length,
+              pcmPtr,
+              this.frameSize,
+              0
+            );
 
-/**
- * 执行工具调用
- */
-function executeMcpTool(toolName, toolArgs) {
-  const tool = mcpTools.find((t) => t.name === toolName);
-  if (!tool) {
-    console.log(`未找到工具: ${toolName}`, "error");
-    return {
-      success: false,
-      error: `未知工具: ${toolName}`,
-    };
-  }
+            if (decodedSamples < 0) {
+              mod._free(opusPtr);
+              mod._free(pcmPtr);
+              throw new Error(`Opus解码失败: ${decodedSamples}`);
+            }
 
-  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);
-  }
-}
+            const decodedData = new Int16Array(decodedSamples);
+            for (let i = 0; i < decodedSamples; i++) {
+              decodedData[i] = mod.HEAP16[(pcmPtr >> 1) + i];
+            }
 
-// 暴露全局方法供 HTML 内联事件调用
-window.mcpModule = {
-  updateMcpProperty,
-  deleteMcpProperty,
-  editMcpTool,
-  deleteMcpTool,
-};
+            mod._free(opusPtr);
+            mod._free(pcmPtr);
 
-;// CONCATENATED MODULE: ./src/utils/blocking-queue.js
-class BlockingQueue {
-    #items   = [];
-    #waiters = [];          // {resolve, reject, min, timer, onTimeout}
+            return decodedData;
+          } catch (error) {
+            console.log(`Opus解码错误: ${error.message}`, "error");
+            return new Int16Array(0);
+          }
+        },
 
-    /* 空队列一次性闸门 */
-    #emptyPromise = null;
-    #emptyResolve = null;
+        destroy: function () {
+          if (this.decoderPtr) {
+            this.module._free(this.decoderPtr);
+            this.decoderPtr = 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;
-        }
+      if (!this.opusDecoder.init()) {
+        throw new Error("Opus解码器初始化失败");
+      }
 
-        // 唤醒所有正在等的 waiter
-        this.#wakeWaiters();
+      return this.opusDecoder;
+    } catch (error) {
+      console.log(`Opus解码器初始化失败: ${error.message}`, "error");
+      this.opusDecoder = null;
+      throw error;
     }
+  }
 
-    /* 消费者：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 };
+  // 启动音频缓冲
+  async startAudioBuffering() {
+    console.log("开始音频缓冲...", "info");
 
-            // 超时逻辑
-            if (Number.isFinite(timeout)) {
-                waiter.timer = setTimeout(() => {
-                    this.#removeWaiter(waiter);
-                    if (onTimeout) onTimeout(this.#items.length);
-                    resolve(this.#flush());
-                }, timeout);
-            }
+    this.initOpusDecoder().catch((error) => {
+      console.log(`预初始化Opus解码器失败: ${error.message}`, "warning");
+    });
 
-            this.#waiters.push(waiter);
-        });
-    }
+    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);
+      }
 
-    /* 空队列闸门生成器 */
-    #waitForFirstItem() {
-        if (!this.#emptyPromise) {
-            this.#emptyPromise = new Promise(r => (this.#emptyResolve = r));
+      while (true) {
+        const data = await this.queue.dequeue(99, 30);
+        if (data.length) {
+          this.streamingContext.pushAudioBuffer(data);
+        } else {
+          break;
         }
-        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());
-            }
-        }
-    }
+  // 播放已缓冲的音频
+  async playBufferedAudio() {
+    try {
+      this.audioContext = this.getAudioContext();
 
-    #removeWaiter(waiter) {
-        const idx = this.#waiters.indexOf(waiter);
-        if (idx !== -1) {
-            this.#waiters.splice(idx, 1);
-            if (waiter.timer) clearTimeout(waiter.timer);
+      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;
         }
-    }
+      }
 
-    #flush() {
-        const snapshot = [...this.#items];
-        this.#items.length = 0;
-        return snapshot;
+      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;
     }
+  }
 
-    /* 当前缓存长度（不含等待者） */
-    get length() {
-        return this.#items.length;
+  // 添加音频数据到队列
+  enqueueAudioData(opusData) {
+    if (opusData.length > 0) {
+      this.queue.enqueue(opusData);
+    } else {
+      console.log("收到空音频数据帧，可能是结束标志", "warning");
+      if (this.isPlaying && this.streamingContext) {
+        this.streamingContext.endOfStream = true;
+      }
     }
-}
-;// CONCATENATED MODULE: ./src/utils/stream-context.js
+  }
 
+  // 预加载解码器
+  async preload() {
+    console.log("预加载Opus解码器...", "info");
+    try {
+      await this.initOpusDecoder();
+      console.log("Opus解码器预加载成功", "success");
+    } catch (error) {
+      console.log(
+        `Opus解码器预加载失败: ${error.message}，将在需要时重试`,
+        "warning"
+      );
+    }
+  }
 
-// 音频流播放上下文类
-class StreamingContext {
-  constructor(
-    opusDecoder,
-    audioContext,
-    sampleRate,
-    channels,
-    minAudioDuration
-  ) {
-    this.opusDecoder = opusDecoder;
-    this.audioContext = audioContext;
+  // 启动播放系统
+  async start() {
+    await this.preload();
+    this.playBufferedAudio();
+    this.startAudioBuffering();
+  }
+}
 
-    // 音频参数
-    this.sampleRate = sampleRate;
-    this.channels = channels;
-    this.minAudioDuration = minAudioDuration;
+// 创建单例
+let audioPlayerInstance = null;
 
-    // 初始化队列和状态
-    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; // 上次播放的时间戳
+function getAudioPlayer() {
+  if (!audioPlayerInstance) {
+    audioPlayerInstance = new AudioPlayer();
   }
+  return audioPlayerInstance;
+}
 
-  // 缓存音频数组
-  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;
-  }
+;// CONCATENATED MODULE: ./src/utils/tools.js
+// 全局变量
+let mcpTools = [];
+let mcpEditingIndex = null;
+let mcpProperties = [];
+let websocket = null; // 将从外部设置
 
-  // 将Opus数据解码为PCM
-  async decodeOpusFrames() {
-    if (!this.opusDecoder) {
-      console.log("Opus解码器未初始化，无法解码", "error");
-      return;
-    } else {
-      console.log("Opus解码器启动", "info");
-    }
+/**
+ * 设置 WebSocket 实例
+ * @param {WebSocket} ws - WebSocket 连接实例
+ */
+function setWebSocket(ws) {
+  websocket = ws;
+}
 
-    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");
-        }
-      }
+/**
+ * 初始化 MCP 工具
+ */
+async function initMcpTools() {
+  // 加载默认工具数据
+  const defaultMcpTools = await fetch("/default-mcp-tools.json").then((res) =>
+    res.json()
+  );
 
-      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();
+  const savedTools = localStorage.getItem("mcpTools");
+  if (savedTools) {
+    try {
+      mcpTools = JSON.parse(savedTools);
+    } catch (e) {
+      console.log("加载MCP工具失败，使用默认工具", "warning");
+      mcpTools = [...defaultMcpTools];
     }
+  } else {
+    mcpTools = [...defaultMcpTools];
   }
 
-  // 开始播放音频
-  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);
+  // renderMcpTools();
+  // setupMcpEventListeners();
+}
 
-        // 创建音频源
-        this.source = this.audioContext.createBufferSource();
-        this.source.buffer = audioBuffer;
+/**
+ * 渲染工具列表
+ */
+function renderMcpTools() {
+  const container = document.getElementById("mcpToolsContainer");
+  const countSpan = document.getElementById("mcpToolsCount");
 
-        // 精确调度播放时间
-        const currentTime = this.audioContext.currentTime;
-        const startTime = Math.max(scheduledEndTime, currentTime);
+  countSpan.textContent = `${mcpTools.length} 个工具`;
 
-        // 直接连接到输出
-        this.source.connect(this.audioContext.destination);
+  if (mcpTools.length === 0) {
+    container.innerHTML =
+      '<div style="text-align: center; padding: 30px; color: #999;">暂无工具，点击下方按钮添加新工具</div>';
+    return;
+  }
 
-        this.source.start(startTime);
+  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;
 
-        // 更新下一个音频块的调度时间
-        const duration = audioBuffer.duration;
-        scheduledEndTime = startTime + duration;
-        this.lastPlayTime = startTime;
+      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("");
+}
 
-        // 如果队列中数据不足，等待新数据
-        if (this.queue.length < targetSamples) {
-          break;
-        }
-      }
+/**
+ * 渲染参数列表
+ */
+function renderMcpProperties() {
+  const container = document.getElementById("mcpPropertiesContainer");
 
-      // 等待新数据
-      await this.getQueue(minSamples);
-    }
+  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("");
 }
 
-// 创建streamingContext实例的工厂函数
-function createStreamingContext(
-  opusDecoder,
-  audioContext,
-  sampleRate,
-  channels,
-  minAudioDuration
-) {
-  return new StreamingContext(
-    opusDecoder,
-    audioContext,
-    sampleRate,
-    channels,
-    minAudioDuration
-  );
+/**
+ * 添加参数
+ */
+function addMcpProperty() {
+  mcpProperties.push({
+    name: `param_${mcpProperties.length + 1}`,
+    type: "string",
+    required: false,
+    description: "",
+  });
+  renderMcpProperties();
 }
 
-;// 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"
-      );
+/**
+ * 更新参数
+ */
+function updateMcpProperty(index, field, value) {
+  if (field === "name") {
+    const isDuplicate = mcpProperties.some(
+      (p, i) => i !== index && p.name === value
+    );
+    if (isDuplicate) {
+      alert("参数名称已存在，请使用不同的名称");
+      renderMcpProperties();
+      return;
     }
-    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,
+  mcpProperties[index][field] = value;
 
-        init: function () {
-          if (this.decoderPtr) return true;
+  if (field === "type" && value !== "integer" && value !== "number") {
+    delete mcpProperties[index].minimum;
+    delete mcpProperties[index].maximum;
+    renderMcpProperties();
+  }
+}
 
-          const decoderSize = mod._opus_decoder_get_size(this.channels);
-          console.log(`Opus解码器大小: ${decoderSize}字节`, "debug");
+/**
+ * 删除参数
+ */
+function deleteMcpProperty(index) {
+  mcpProperties.splice(index, 1);
+  renderMcpProperties();
+}
 
-          this.decoderPtr = mod._malloc(decoderSize);
-          if (!this.decoderPtr) {
-            throw new Error("无法分配解码器内存");
-          }
+/**
+ * 设置事件监听
+ */
+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");
 
-          const err = mod._opus_decoder_init(
-            this.decoderPtr,
-            this.rate,
-            this.channels
-          );
+  toggleBtn.addEventListener("click", () => {
+    const isExpanded = panel.classList.contains("expanded");
+    panel.classList.toggle("expanded");
+    toggleBtn.textContent = isExpanded ? "展开" : "收起";
+  });
 
-          if (err < 0) {
-            this.destroy();
-            throw new Error(`Opus解码器初始化失败: ${err}`);
-          }
+  addBtn.addEventListener("click", () => openMcpModal());
+  closeBtn.addEventListener("click", closeMcpModal);
+  cancelBtn.addEventListener("click", closeMcpModal);
+  addPropertyBtn.addEventListener("click", addMcpProperty);
 
-          console.log("Opus解码器初始化成功", "success");
-          return true;
-        },
+  modal.addEventListener("click", (e) => {
+    if (e.target === modal) closeMcpModal();
+  });
 
-        decode: function (opusData) {
-          if (!this.decoderPtr) {
-            if (!this.init()) {
-              throw new Error("解码器未初始化且无法初始化");
-            }
-          }
+  form.addEventListener("submit", handleMcpSubmit);
+}
 
-          try {
-            const mod = this.module;
+/**
+ * 打开模态框
+ */
+function openMcpModal(index = null) {
+  const isConnected = websocket && websocket.readyState === WebSocket.OPEN;
+  if (isConnected) {
+    alert("WebSocket 已连接，无法编辑工具");
+    return;
+  }
 
-            const opusPtr = mod._malloc(opusData.length);
-            mod.HEAPU8.set(opusData, opusPtr);
+  mcpEditingIndex = index;
+  const errorContainer = document.getElementById("mcpErrorContainer");
+  errorContainer.innerHTML = "";
 
-            const pcmPtr = mod._malloc(this.frameSize * 2);
+  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)
+      : "";
 
-            const decodedSamples = mod._opus_decode(
-              this.decoderPtr,
-              opusPtr,
-              opusData.length,
-              pcmPtr,
-              this.frameSize,
-              0
-            );
+    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 = [];
+  }
 
-            if (decodedSamples < 0) {
-              mod._free(opusPtr);
-              mod._free(pcmPtr);
-              throw new Error(`Opus解码失败: ${decodedSamples}`);
-            }
+  renderMcpProperties();
+  document.getElementById("mcpToolModal").style.display = "block";
+}
 
-            const decodedData = new Int16Array(decodedSamples);
-            for (let i = 0; i < decodedSamples; i++) {
-              decodedData[i] = mod.HEAP16[(pcmPtr >> 1) + i];
-            }
+/**
+ * 关闭模态框
+ */
+function closeMcpModal() {
+  document.getElementById("mcpToolModal").style.display = "none";
+  mcpEditingIndex = null;
+  document.getElementById("mcpToolForm").reset();
+  mcpProperties = [];
+  document.getElementById("mcpErrorContainer").innerHTML = "";
+}
 
-            mod._free(opusPtr);
-            mod._free(pcmPtr);
+/**
+ * 处理表单提交
+ */
+function handleMcpSubmit(e) {
+  e.preventDefault();
+  const errorContainer = document.getElementById("mcpErrorContainer");
+  errorContainer.innerHTML = "";
 
-            return decodedData;
-          } catch (error) {
-            console.log(`Opus解码错误: ${error.message}`, "error");
-            return new Int16Array(0);
-          }
-        },
+  const name = document.getElementById("mcpToolName").value.trim();
+  const description = document
+    .getElementById("mcpToolDescription")
+    .value.trim();
+  const mockResponseText = document
+    .getElementById("mcpMockResponse")
+    .value.trim();
 
-        destroy: function () {
-          if (this.decoderPtr) {
-            this.module._free(this.decoderPtr);
-            this.decoderPtr = null;
-          }
-        },
-      };
+  // 检查名称重复
+  const isDuplicate = mcpTools.some(
+    (tool, index) => tool.name === name && index !== mcpEditingIndex
+  );
 
-      if (!this.opusDecoder.init()) {
-        throw new Error("Opus解码器初始化失败");
-      }
+  if (isDuplicate) {
+    showMcpError("工具名称已存在，请使用不同的名称");
+    return;
+  }
 
-      return this.opusDecoder;
-    } catch (error) {
-      console.log(`Opus解码器初始化失败: ${error.message}`, "error");
-      this.opusDecoder = null;
-      throw error;
+  // 解析模拟返回结果
+  let mockResponse = null;
+  if (mockResponseText) {
+    try {
+      mockResponse = JSON.parse(mockResponseText);
+    } catch (e) {
+      showMcpError("模拟返回结果不是有效的 JSON 格式: " + e.message);
+      return;
     }
   }
 
-  // 启动音频缓冲
-  async startAudioBuffering() {
-    console.log("开始音频缓冲...", "info");
-
-    this.initOpusDecoder().catch((error) => {
-      console.log(`预初始化Opus解码器失败: ${error.message}`, "warning");
-    });
+  // 构建 inputSchema
+  const inputSchema = {
+    type: "object",
+    properties: {},
+    required: [],
+  };
 
-    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);
-      }
+  mcpProperties.forEach((prop) => {
+    const propSchema = { type: prop.type };
 
-      while (true) {
-        const data = await this.queue.dequeue(99, 30);
-        if (data.length) {
-          this.streamingContext.pushAudioBuffer(data);
-        } else {
-          break;
-        }
-      }
+    if (prop.description) {
+      propSchema.description = prop.description;
     }
-  }
-
-  // 播放已缓冲的音频
-  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 (prop.type === "integer" || prop.type === "number") {
+      if (prop.minimum !== undefined && prop.minimum !== "") {
+        propSchema.minimum = prop.minimum;
       }
-
-      if (!this.streamingContext) {
-        this.streamingContext = createStreamingContext(
-          this.opusDecoder,
-          this.audioContext,
-          this.SAMPLE_RATE,
-          this.CHANNELS,
-          this.MIN_AUDIO_DURATION
-        );
+      if (prop.maximum !== undefined && prop.maximum !== "") {
+        propSchema.maximum = prop.maximum;
       }
-
-      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;
-      }
+    inputSchema.properties[prop.name] = propSchema;
+
+    if (prop.required) {
+      inputSchema.required.push(prop.name);
     }
+  });
+
+  if (inputSchema.required.length === 0) {
+    delete inputSchema.required;
   }
 
-  // 预加载解码器
-  async preload() {
-    console.log("预加载Opus解码器...", "info");
-    try {
-      await this.initOpusDecoder();
-      console.log("Opus解码器预加载成功", "success");
-    } catch (error) {
-      console.log(
-        `Opus解码器预加载失败: ${error.message}，将在需要时重试`,
-        "warning"
-      );
-    }
+  const tool = { name, description, inputSchema, mockResponse };
+
+  if (mcpEditingIndex !== null) {
+    mcpTools[mcpEditingIndex] = tool;
+    console.log(`已更新工具: ${name}`, "success");
+  } else {
+    mcpTools.push(tool);
+    console.log(`已添加工具: ${name}`, "success");
   }
 
-  // 启动播放系统
-  async start() {
-    await this.preload();
-    this.playBufferedAudio();
-    this.startAudioBuffering();
+  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");
   }
 }
 
-// 创建单例
-let audioPlayerInstance = null;
+/**
+ * 保存工具
+ */
+function saveMcpTools() {
+  localStorage.setItem("mcpTools", JSON.stringify(mcpTools));
+}
 
-function player_getAudioPlayer() {
-  if (!audioPlayerInstance) {
-    audioPlayerInstance = new AudioPlayer();
+/**
+ * 获取工具列表
+ */
+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);
   }
-  return audioPlayerInstance;
 }
 
+// 暴露全局方法供 HTML 内联事件调用
+window.mcpModule = {
+  updateMcpProperty,
+  deleteMcpProperty,
+  editMcpTool,
+  deleteMcpTool,
+};
+
 ;// CONCATENATED MODULE: ./src/utils/recorder.js
 // 音频录制模块
 
@@ -1340,7 +1340,7 @@ class AudioRecorder {
 
   // 获取AudioContext实例
   getAudioContext() {
-    const audioPlayer = player_getAudioPlayer();
+    const audioPlayer = getAudioPlayer();
     return audioPlayer.getAudioContext();
   }
 
@@ -2150,7 +2150,7 @@ class WebSocketHandler {
       }
 
       const opusData = new Uint8Array(arrayBuffer);
-      const audioPlayer = player_getAudioPlayer();
+      const audioPlayer = getAudioPlayer();
       audioPlayer.enqueueAudioData(opusData);
     } catch (error) {
       console.log(`处理二进制消息出错: ${error.message}`, "error");
@@ -2487,6 +2487,7 @@ function isWsConnected() {
 
 
 
+
 /* harmony default export */ const lib_vue_loader_options_srcvue_type_script_lang_js = ({
   name: "ibiAiTalk",
   data() {