@xmov/avatar 2.0.1 → 2.1.1

package/src/agent/__tests__/agent.test.ts

@@ -1,3787 +0,0 @@
-// @ts-nocheck
-import test from "node:test";
-import assert from "node:assert/strict";
-import XingyunAvatarAgent, {
-  AgentE2EClient,
-  MicrophoneController,
-} from "../index";
-import {
-  AgentAudioUplink,
-  AU_STREAM_FAREND,
-  AU_STREAM_NEAREND,
-  packAuAudioFrame,
-} from "../audio-uplink";
-import {
-  beginWebAudioCaptureSession,
-  configureWebAudioPlaybackSession,
-  endWebAudioCaptureSession,
-  subscribeWebAudioPlaybackSessionRestored,
-} from "../../utils/audio-session";
-import PCMAudioPlayer from "../../baseRender/AudioWorklet";
-import { PcmWebMEncoder } from "../../encoding/pcm-webm-encoder";
-
-class MockWebSocket {
-  static CONNECTING = 0;
-  static OPEN = 1;
-  static CLOSING = 2;
-  static CLOSED = 3;
-  static instances = [];
-  static failedConnections = 0;
-  static autoOpen = true;
-
-  readyState = MockWebSocket.CONNECTING;
-  bufferedAmount = 0;
-  sent = [];
-  closed = false;
-  onopen = null;
-  onmessage = null;
-  onerror = null;
-  onclose = null;
-
-  constructor(url) {
-    this.url = url;
-    MockWebSocket.instances.push(this);
-    if (MockWebSocket.autoOpen) {
-      queueMicrotask(() => this.open());
-    }
-  }
-
-  open() {
-    if (this.readyState !== MockWebSocket.CONNECTING) {
-      return;
-    }
-    if (MockWebSocket.failedConnections > 0) {
-      MockWebSocket.failedConnections -= 1;
-      this.readyState = MockWebSocket.CLOSED;
-      this.onerror?.({});
-      this.onclose?.({ code: 1006, reason: "", wasClean: false });
-      return;
-    }
-    this.readyState = MockWebSocket.OPEN;
-    this.onopen?.({});
-  }
-
-  send(payload) {
-    this.sent.push(payload);
-  }
-
-  close(code, reason) {
-    this.closed = true;
-    this.readyState = MockWebSocket.CLOSED;
-    this.onclose?.({ code, reason });
-  }
-
-  closeRemote(code, reason = "", wasClean = false) {
-    this.readyState = MockWebSocket.CLOSED;
-    this.onclose?.({ code, reason, wasClean });
-  }
-
-  emit(data) {
-    this.onmessage?.({ data: JSON.stringify(data) });
-  }
-
-  emitRaw(data) {
-    this.onmessage?.({ data });
-  }
-}
-
-function createAgent(callbacks = {}, options = {}) {
-  const agent = new XingyunAvatarAgent({
-    containerId: "#sdk",
-    appId: "app",
-    appSecret: "secret",
-    gatewayServer: "https://gateway.example.com/user/v1/ttsa_v2/session",
-    asr_id: 1,
-    llm_id: 1,
-    onMessage() {},
-    e2eServer: "wss://e2e.example.com/ws",
-    authToken: "token-from-nebula",
-    webSocketCtor: MockWebSocket,
-    ...options,
-    agentCallbacks: callbacks,
-  });
-  agent.incompleteInitializationCleanups = [];
-  agent.initializationFailureNotifications = [];
-  agent.cleanupBeforeInitComplete = async (reason) => {
-    agent.incompleteInitializationCleanups.push(reason);
-    agent.destroyed = true;
-  };
-  agent.reportInitializationFailure = (message, cause) => {
-    agent.initializationFailureNotifications.push({ message, cause });
-    agent.avatarOptions.onMessage?.({ code: 10005, message, cause });
-  };
-  return { agent };
-}
-
-function readAuFrame(frame) {
-  assert.equal(frame instanceof ArrayBuffer, true);
-  const bytes = new Uint8Array(frame);
-  const view = new DataView(frame);
-  return {
-    magic: String.fromCharCode(bytes[0], bytes[1]),
-    version: bytes[2],
-    streamId: bytes[3],
-    tsMs: view.getUint32(4, false),
-    payload: new TextDecoder().decode(bytes.subarray(8)),
-  };
-}
-
-function installMicrophoneBrowser({
-  getUserMedia,
-  mediaDevices = true,
-  webmOpus = true,
-  sampleRate = 48000,
-  audioDataFrames = [],
-  trackTransform = true,
-  webAudio = true,
-  audioContextSampleRate = 16000,
-  audioContextState = "running",
-  audioContextResume,
-  audioContextError,
-  mediaRecorderConstructorError,
-  mediaRecorderStartError,
-  audioSession = false,
-  webCodecsOpus = true,
-  webCodecsPreservesOpusConfig = true,
-  audioEncoderSupport,
-  encodedChunkDurations,
-  flushEncodedChunkDurations = [],
-} = {}) {
-  const originalNavigator = Object.getOwnPropertyDescriptor(globalThis, "navigator");
-  const originalMediaRecorder = Object.getOwnPropertyDescriptor(globalThis, "MediaRecorder");
-  const originalMediaStream = Object.getOwnPropertyDescriptor(globalThis, "MediaStream");
-  const originalAudioData = Object.getOwnPropertyDescriptor(globalThis, "AudioData");
-  const originalProcessor = Object.getOwnPropertyDescriptor(globalThis, "MediaStreamTrackProcessor");
-  const originalGenerator = Object.getOwnPropertyDescriptor(globalThis, "MediaStreamTrackGenerator");
-  const originalAudioContext = Object.getOwnPropertyDescriptor(globalThis, "AudioContext");
-  const originalAudioEncoder = Object.getOwnPropertyDescriptor(globalThis, "AudioEncoder");
-  const originalAudioWorkletNode = Object.getOwnPropertyDescriptor(globalThis, "AudioWorkletNode");
-  const getUserMediaCalls = [];
-  const tracks = [];
-  const streams = [];
-  const recorders = [];
-  const processors = [];
-  const generators = [];
-  const audioContexts = [];
-  const audioSources = [];
-  const audioDestinations = [];
-  const audioSessionTypes = [];
-  const audioEncoders = [];
-  const audioWorkletNodes = [];
-  const mockedAudioSession = audioSession
-    ? {
-        currentType: typeof audioSession === "string" ? audioSession : "ambient",
-        get type() {
-          return this.currentType;
-        },
-        set type(value) {
-          this.currentType = value;
-          audioSessionTypes.push(value);
-        },
-      }
-    : undefined;
-
-  function createStream(trackSampleRate = sampleRate, channelCount = 1) {
-    const track = {
-      stopCalls: 0,
-      readyState: "live",
-      getSettings() {
-        return { sampleRate: trackSampleRate, channelCount };
-      },
-      stop() {
-        this.stopCalls += 1;
-        this.readyState = "ended";
-      },
-      clone() {
-        return createStream(trackSampleRate, channelCount).getAudioTracks()[0];
-      },
-    };
-    const stream = {
-      getTracks() {
-        return [track];
-      },
-      getAudioTracks() {
-        return [track];
-      },
-    };
-    tracks.push(track);
-    streams.push(stream);
-    return stream;
-  }
-
-  class MockMediaStream {
-    constructor(inputTracks = []) {
-      this.tracks = [...inputTracks];
-    }
-
-    getTracks() {
-      return this.tracks;
-    }
-
-    getAudioTracks() {
-      return this.tracks.filter((track) => track.kind !== "video");
-    }
-  }
-
-  class MockAudioData {
-    constructor(options) {
-      this.sampleRate = options.sampleRate;
-      this.numberOfFrames = options.numberOfFrames;
-      this.numberOfChannels = options.numberOfChannels;
-      this.timestamp = options.timestamp;
-      this.planes = Array.isArray(options.data) ? options.data : [options.data];
-      this.data = this.planes[0];
-      this.closed = false;
-    }
-
-    copyTo(destination, options = {}) {
-      destination.set(this.planes[options.planeIndex || 0]);
-    }
-
-    close() {
-      this.closed = true;
-    }
-  }
-
-  class MockMediaStreamTrackProcessor {
-    constructor({ track }) {
-      this.track = track;
-      this.cancelCalls = 0;
-      this.releaseCalls = 0;
-      this.readable = new ReadableStream({
-        start: (controller) => {
-          for (const frame of audioDataFrames) {
-            controller.enqueue(new MockAudioData(frame));
-          }
-          controller.close();
-        },
-      });
-      processors.push(this);
-    }
-  }
-
-  class MockMediaStreamTrackGenerator {
-    constructor() {
-      this.kind = "audio";
-      this.readyState = "live";
-      this.stopCalls = 0;
-      this.written = [];
-      this.writable = new WritableStream({
-        write: (audioData) => {
-          this.written.push(audioData);
-        },
-        close: () => {
-          this.writableClosed = true;
-        },
-      });
-      generators.push(this);
-    }
-
-    getSettings() {
-      return { sampleRate: 16000, channelCount: 1 };
-    }
-
-    stop() {
-      this.stopCalls += 1;
-      this.readyState = "ended";
-    }
-  }
-
-  class MockAudioContext {
-    constructor(options = {}) {
-      if (audioContextError) {
-        throw audioContextError;
-      }
-      this.sampleRate = audioContextSampleRate ?? options.sampleRate ?? sampleRate;
-      this.state = audioContextState;
-      this.closeCalls = 0;
-      this.destination = {};
-      this.audioWorklet = {
-        addModule: async () => {},
-      };
-      audioContexts.push(this);
-    }
-
-    createMediaStreamSource(stream) {
-      const source = {
-        stream,
-        connectedTo: null,
-        disconnectCalls: 0,
-        connect: (destination) => {
-          source.connectedTo = destination;
-        },
-        disconnect: () => {
-          source.disconnectCalls += 1;
-          source.connectedTo = null;
-        },
-      };
-      audioSources.push(source);
-      return source;
-    }
-
-    createMediaStreamDestination() {
-      const track = {
-        kind: "audio",
-        readyState: "live",
-        stopCalls: 0,
-        getSettings: () => ({ sampleRate: this.sampleRate, channelCount: 1 }),
-        stop() {
-          this.stopCalls += 1;
-          this.readyState = "ended";
-        },
-      };
-      const destination = {
-        channelCount: 2,
-        channelCountMode: "max",
-        channelInterpretation: "speakers",
-        disconnectCalls: 0,
-        stream: new MockMediaStream([track]),
-        disconnect() {
-          this.disconnectCalls += 1;
-        },
-      };
-      audioDestinations.push(destination);
-      return destination;
-    }
-
-    async resume() {
-      await audioContextResume?.(this);
-      if (this.state !== "closed") {
-        this.state = "running";
-      }
-    }
-
-    async close() {
-      this.closeCalls += 1;
-      this.state = "closed";
-    }
-  }
-
-  class MockEncodedAudioChunk {
-    constructor(timestamp, duration, data) {
-      this.timestamp = timestamp;
-      this.duration = duration;
-      this.data = data;
-      this.byteLength = data.length;
-    }
-
-    copyTo(destination) {
-      destination.set(this.data);
-    }
-  }
-
-  class MockAudioEncoder {
-    static async isConfigSupported(config) {
-      if (audioEncoderSupport) {
-        return audioEncoderSupport(config);
-      }
-      if (!webCodecsPreservesOpusConfig) {
-        const { opus, ...baseConfig } = config;
-        return { supported: webCodecsOpus, config: baseConfig };
-      }
-      return { supported: webCodecsOpus, config };
-    }
-
-    constructor(options) {
-      this.options = options;
-      this.flushCalls = 0;
-      this.nextTimestamp = 0;
-      audioEncoders.push(this);
-    }
-
-    configure(config) {
-      this.config = config;
-    }
-
-    encode(audioData) {
-      let timestamp = audioData.timestamp;
-      const inputDuration = Math.round(
-        (audioData.numberOfFrames * 1_000_000) / audioData.sampleRate,
-      );
-      const frameDuration = this.config?.opus?.frameDuration ?? inputDuration;
-      const durations = encodedChunkDurations
-        ?? new Array(Math.ceil(inputDuration / frameDuration)).fill(frameDuration);
-      for (const duration of durations) {
-        this.options.output(new MockEncodedAudioChunk(
-          timestamp,
-          duration,
-          new Uint8Array([0xf8, 0xff, 0xfe]),
-        ));
-        timestamp += duration;
-      }
-      this.nextTimestamp = timestamp;
-    }
-
-    async flush() {
-      this.flushCalls += 1;
-      for (const duration of flushEncodedChunkDurations) {
-        this.options.output(new MockEncodedAudioChunk(
-          this.nextTimestamp,
-          duration,
-          new Uint8Array([0xf8, 0xff, 0xfe]),
-        ));
-        this.nextTimestamp += duration;
-      }
-    }
-
-    close() {
-      this.closed = true;
-    }
-  }
-
-  class MockAudioWorkletNode {
-    constructor(context, name, options) {
-      this.context = context;
-      this.name = name;
-      this.options = options;
-      this.port = {
-        onmessage: null,
-        postMessage: (message) => {
-          if (message?.type === "flush") {
-            queueMicrotask(() => this.port.onmessage?.({ data: { type: "flushed" } }));
-          }
-        },
-        close() {},
-      };
-      audioWorkletNodes.push(this);
-    }
-
-    connect(destination) {
-      this.connectedTo = destination;
-    }
-
-    disconnect() {
-      this.connectedTo = null;
-    }
-
-    emitPcm(sequence = 0, fill = 1) {
-      const pcm = new Int16Array(1600).fill(fill);
-      this.port.onmessage?.({
-        data: { type: "frame", pcm: pcm.buffer, sequence },
-      });
-    }
-  }
-
-  class MockMediaRecorder {
-    static isTypeSupported(type) {
-      return webmOpus && type === "audio/webm;codecs=opus";
-    }
-
-    state = "inactive";
-    mimeType = "audio/webm;codecs=opus";
-    ondataavailable = null;
-    onerror = null;
-    onstop = null;
-    requestDataCalls = 0;
-
-    constructor(stream, options) {
-      if (mediaRecorderConstructorError) {
-        throw mediaRecorderConstructorError;
-      }
-      this.stream = stream;
-      this.options = options;
-      recorders.push(this);
-    }
-
-    start(timeslice) {
-      if (mediaRecorderStartError) {
-        throw mediaRecorderStartError;
-      }
-      this.state = "recording";
-      this.timeslice = timeslice;
-    }
-
-    requestData() {
-      this.requestDataCalls += 1;
-    }
-
-    stop() {
-      this.ondataavailable?.({
-        data: new Blob(["opus-final"], { type: this.mimeType }),
-        timecode: 200,
-      });
-      this.state = "inactive";
-      this.onstop?.({});
-    }
-  }
-
-  const mockedMediaDevices = mediaDevices
-    ? {
-        async getUserMedia(constraints) {
-          getUserMediaCalls.push(constraints);
-          return getUserMedia ? getUserMedia(constraints, createStream) : createStream();
-        },
-      }
-    : undefined;
-
-  Object.defineProperty(globalThis, "navigator", {
-    configurable: true,
-    value: {
-      mediaDevices: mockedMediaDevices,
-      ...(mockedAudioSession ? { audioSession: mockedAudioSession } : {}),
-    },
-  });
-  Object.defineProperty(globalThis, "MediaRecorder", {
-    configurable: true,
-    value: MockMediaRecorder,
-  });
-  Object.defineProperty(globalThis, "MediaStream", {
-    configurable: true,
-    value: MockMediaStream,
-  });
-  if (trackTransform) {
-    Object.defineProperty(globalThis, "AudioData", {
-      configurable: true,
-      value: MockAudioData,
-    });
-    Object.defineProperty(globalThis, "MediaStreamTrackProcessor", {
-      configurable: true,
-      value: MockMediaStreamTrackProcessor,
-    });
-    Object.defineProperty(globalThis, "MediaStreamTrackGenerator", {
-      configurable: true,
-      value: MockMediaStreamTrackGenerator,
-    });
-  } else {
-    delete globalThis.AudioData;
-    delete globalThis.MediaStreamTrackProcessor;
-    delete globalThis.MediaStreamTrackGenerator;
-  }
-  if (webAudio) {
-    Object.defineProperty(globalThis, "AudioContext", {
-      configurable: true,
-      value: MockAudioContext,
-    });
-  } else {
-    delete globalThis.AudioContext;
-  }
-  Object.defineProperty(globalThis, "AudioEncoder", {
-    configurable: true,
-    value: MockAudioEncoder,
-  });
-  Object.defineProperty(globalThis, "AudioWorkletNode", {
-    configurable: true,
-    value: MockAudioWorkletNode,
-  });
-
-  return {
-    getUserMediaCalls,
-    recorders,
-    processors,
-    generators,
-    audioContexts,
-    audioSources,
-    audioDestinations,
-    audioSessionTypes,
-    audioEncoders,
-    audioWorkletNodes,
-    audioSession: mockedAudioSession,
-    createStream,
-    streams,
-    tracks,
-    restore() {
-      if (originalNavigator) {
-        Object.defineProperty(globalThis, "navigator", originalNavigator);
-      } else {
-        delete globalThis.navigator;
-      }
-      if (originalMediaRecorder) {
-        Object.defineProperty(globalThis, "MediaRecorder", originalMediaRecorder);
-      } else {
-        delete globalThis.MediaRecorder;
-      }
-      if (originalMediaStream) {
-        Object.defineProperty(globalThis, "MediaStream", originalMediaStream);
-      } else {
-        delete globalThis.MediaStream;
-      }
-      if (originalAudioData) {
-        Object.defineProperty(globalThis, "AudioData", originalAudioData);
-      } else {
-        delete globalThis.AudioData;
-      }
-      if (originalProcessor) {
-        Object.defineProperty(globalThis, "MediaStreamTrackProcessor", originalProcessor);
-      } else {
-        delete globalThis.MediaStreamTrackProcessor;
-      }
-      if (originalGenerator) {
-        Object.defineProperty(globalThis, "MediaStreamTrackGenerator", originalGenerator);
-      } else {
-        delete globalThis.MediaStreamTrackGenerator;
-      }
-      if (originalAudioContext) {
-        Object.defineProperty(globalThis, "AudioContext", originalAudioContext);
-      } else {
-        delete globalThis.AudioContext;
-      }
-      if (originalAudioEncoder) {
-        Object.defineProperty(globalThis, "AudioEncoder", originalAudioEncoder);
-      } else {
-        delete globalThis.AudioEncoder;
-      }
-      if (originalAudioWorkletNode) {
-        Object.defineProperty(globalThis, "AudioWorkletNode", originalAudioWorkletNode);
-      } else {
-        delete globalThis.AudioWorkletNode;
-      }
-    },
-  };
-}
-
-function namedError(name, message) {
-  const error = new Error(message);
-  error.name = name;
-  return error;
-}
-
-async function waitFor(predicate, timeoutMs = 1000) {
-  const deadline = Date.now() + timeoutMs;
-  while (!predicate()) {
-    if (Date.now() >= deadline) {
-      throw new Error("Timed out waiting for condition");
-    }
-    await new Promise((resolve) => setTimeout(resolve, 0));
-  }
-}
-
-test("AU v1 packer writes magic, version, stream and big-endian timestamp", () => {
-  const frame = packAuAudioFrame(
-    AU_STREAM_FAREND,
-    12340,
-    new TextEncoder().encode("opus"),
-  );
-
-  assert.deepEqual(readAuFrame(frame), {
-    magic: "AU",
-    version: 1,
-    streamId: AU_STREAM_FAREND,
-    tsMs: 12340,
-    payload: "opus",
-  });
-});
-
-test("AgentAudioUplink sends farend before nearend in the same 100ms bucket", async () => {
-  const sent = [];
-  const uplink = new AgentAudioUplink({ sendBinary: (frame) => sent.push(frame) });
-  uplink.reset(1000);
-
-  uplink.offerFarend({ data: new TextEncoder().encode("far"), timestamp: 1250 });
-  uplink.offerNearend({ data: new Blob(["near"]), timestamp: 1270 });
-  await uplink.drain();
-
-  assert.deepEqual(sent.map(readAuFrame), [
-    { magic: "AU", version: 1, streamId: AU_STREAM_FAREND, tsMs: 250, payload: "far" },
-    { magic: "AU", version: 1, streamId: AU_STREAM_NEAREND, tsMs: 270, payload: "near" },
-  ]);
-});
-
-test("AgentAudioUplink waits for a same-bucket farend that arrives after nearend", async () => {
-  const sent = [];
-  const uplink = new AgentAudioUplink({ sendBinary: (frame) => sent.push(frame) });
-  uplink.reset(1000);
-
-  uplink.offerNearend({ data: new Blob(["near"]), timestamp: 1270 });
-  assert.deepEqual(sent, []);
-  uplink.offerFarend({ data: new TextEncoder().encode("far"), timestamp: 1250 });
-  await uplink.drain();
-
-  assert.deepEqual(sent.map(readAuFrame), [
-    { magic: "AU", version: 1, streamId: AU_STREAM_FAREND, tsMs: 250, payload: "far" },
-    { magic: "AU", version: 1, streamId: AU_STREAM_NEAREND, tsMs: 270, payload: "near" },
-  ]);
-});
-
-test("AgentAudioUplink preserves every nearend fragment in the same 100ms bucket", async () => {
-  const sent = [];
-  const uplink = new AgentAudioUplink({ sendBinary: (frame) => sent.push(frame) });
-  uplink.reset(1000);
-
-  uplink.offerNearend({ data: new Blob(["near-a"]), timestamp: 1150 });
-  uplink.offerFarend({ data: new TextEncoder().encode("far"), timestamp: 1140 });
-  uplink.offerNearend({ data: new Blob(["near-b"]), timestamp: 1170 });
-  uplink.offerNearend({ data: new Blob(["next"]), timestamp: 1250 });
-  await uplink.drain();
-
-  assert.deepEqual(sent.map(readAuFrame), [
-    { magic: "AU", version: 1, streamId: AU_STREAM_FAREND, tsMs: 140, payload: "far" },
-    {
-      magic: "AU",
-      version: 1,
-      streamId: AU_STREAM_NEAREND,
-      tsMs: 150,
-      payload: "near-anear-b",
-    },
-    { magic: "AU", version: 1, streamId: AU_STREAM_NEAREND, tsMs: 250, payload: "next" },
-  ]);
-});
-
-test("AgentAudioUplink matches farend from the preceding 100ms bucket", async () => {
-  const sent = [];
-  const uplink = new AgentAudioUplink({ sendBinary: (frame) => sent.push(frame) });
-  uplink.reset(1000);
-
-  uplink.offerFarend({
-    data: new TextEncoder().encode("far"),
-    timestamp: 1050,
-    isFirstChunk: true,
-  });
-  uplink.offerNearend({ data: new Blob(["near"]), timestamp: 1170 });
-  await uplink.drain();
-
-  assert.deepEqual(sent.map(readAuFrame), [
-    { magic: "AU", version: 1, streamId: AU_STREAM_FAREND, tsMs: 50, payload: "far" },
-    { magic: "AU", version: 1, streamId: AU_STREAM_NEAREND, tsMs: 170, payload: "near" },
-  ]);
-});
-
-test("AgentAudioUplink matches a late preceding-bucket farend", async () => {
-  const sent = [];
-  const uplink = new AgentAudioUplink({ sendBinary: (frame) => sent.push(frame) });
-  uplink.reset(1000);
-
-  uplink.offerNearend({ data: new Blob(["near"]), timestamp: 1170 });
-  uplink.offerFarend({
-    data: new TextEncoder().encode("far"),
-    timestamp: 1050,
-    isFirstChunk: true,
-  });
-  await uplink.drain();
-
-  assert.deepEqual(sent.map(readAuFrame), [
-    { magic: "AU", version: 1, streamId: AU_STREAM_FAREND, tsMs: 50, payload: "far" },
-    { magic: "AU", version: 1, streamId: AU_STREAM_NEAREND, tsMs: 170, payload: "near" },
-  ]);
-});
-
-test("AgentAudioUplink keeps nearend open for a delayed preceding-bucket farend", async () => {
-  const sent = [];
-  const uplink = new AgentAudioUplink({ sendBinary: (frame) => sent.push(frame) });
-  uplink.reset(1000);
-
-  // Playback capture timestamps farend one bucket earlier, while its callback
-  // arrives just after the next nearend block. Keep one extra bucket open so
-  // this stable ordering does not permanently miss the pairing window.
-  uplink.offerNearend({ data: new Blob(["near-0"]), timestamp: 1200 });
-  uplink.offerNearend({ data: new Blob(["near-1"]), timestamp: 1300 });
-  uplink.offerFarend({
-    data: new TextEncoder().encode("far-0"),
-    timestamp: 1100,
-    isFirstChunk: true,
-  });
-  uplink.offerNearend({ data: new Blob(["near-2"]), timestamp: 1400 });
-  uplink.offerFarend({
-    data: new TextEncoder().encode("far-1"),
-    timestamp: 1200,
-    isFirstChunk: false,
-  });
-  uplink.offerNearend({ data: new Blob(["near-3"]), timestamp: 1500 });
-  await uplink.drain();
-
-  assert.deepEqual(sent.map(readAuFrame), [
-    { magic: "AU", version: 1, streamId: AU_STREAM_FAREND, tsMs: 100, payload: "far-0" },
-    { magic: "AU", version: 1, streamId: AU_STREAM_NEAREND, tsMs: 200, payload: "near-0" },
-    { magic: "AU", version: 1, streamId: AU_STREAM_FAREND, tsMs: 200, payload: "far-1" },
-    { magic: "AU", version: 1, streamId: AU_STREAM_NEAREND, tsMs: 300, payload: "near-1" },
-    { magic: "AU", version: 1, streamId: AU_STREAM_NEAREND, tsMs: 400, payload: "near-2" },
-    { magic: "AU", version: 1, streamId: AU_STREAM_NEAREND, tsMs: 500, payload: "near-3" },
-  ]);
-});
-
-test("AgentAudioUplink coalesces a WebM magic split across MediaRecorder blobs", async () => {
-  const sent = [];
-  const uplink = new AgentAudioUplink({ sendBinary: (frame) => sent.push(frame) });
-  uplink.reset(1000);
-
-  uplink.offerNearend({ data: new Uint8Array([0x1a]), timestamp: 1100 });
-  uplink.offerNearend({ data: new Uint8Array([0x45, 0xdf]), timestamp: 1200 });
-  uplink.offerNearend({ data: new Uint8Array([0xa3, 0x9f, 0x42, 0x86]), timestamp: 1300 });
-  await uplink.drain();
-
-  assert.equal(sent.length, 1);
-  const bytes = new Uint8Array(sent[0]);
-  assert.equal(bytes.byteLength, 15);
-  assert.equal(new DataView(sent[0]).getUint32(4, false), 300);
-  assert.deepEqual([...bytes.subarray(8)], [0x1a, 0x45, 0xdf, 0xa3, 0x9f, 0x42, 0x86]);
-});
-
-test("AgentAudioUplink keeps the farend WebM header when it precedes the paired bucket", async () => {
-  const sent = [];
-  const uplink = new AgentAudioUplink({ sendBinary: (frame) => sent.push(frame) });
-  uplink.reset(1000);
-
-  uplink.offerFarend({
-    data: new Uint8Array([0x1a, 0x45, 0xdf, 0xa3, 0x9f]),
-    timestamp: 1100,
-    isFirstChunk: true,
-  });
-  uplink.offerNearend({ data: new Blob(["near"]), timestamp: 1200 });
-  uplink.offerFarend({
-    data: new Uint8Array([0x40, 0xaa, 0x81, 0x00]),
-    timestamp: 1200,
-    isFirstChunk: false,
-  });
-  await uplink.drain();
-
-  assert.equal(sent.length, 2);
-  const farend = new Uint8Array(sent[0]);
-  assert.equal(farend[3], AU_STREAM_FAREND);
-  assert.equal(new DataView(sent[0]).getUint32(4, false), 200);
-  assert.deepEqual(
-    [...farend.subarray(8)],
-    [0x1a, 0x45, 0xdf, 0xa3, 0x9f, 0x40, 0xaa, 0x81, 0x00],
-  );
-  assert.deepEqual(readAuFrame(sent[1]), {
-    magic: "AU",
-    version: 1,
-    streamId: AU_STREAM_NEAREND,
-    tsMs: 200,
-    payload: "near",
-  });
-});
-
-test("AgentAudioUplink drops farend continuation until a WebM header is observed", async () => {
-  const sent = [];
-  const uplink = new AgentAudioUplink({ sendBinary: (frame) => sent.push(frame) });
-  uplink.reset(1000);
-
-  uplink.offerFarend({
-    data: new Uint8Array([0x40, 0xaa, 0x81, 0x00]),
-    timestamp: 1100,
-    isFirstChunk: false,
-  });
-  uplink.offerNearend({ data: new Blob(["near"]), timestamp: 1100 });
-  await uplink.drain();
-
-  assert.deepEqual(sent.map(readAuFrame), [
-    { magic: "AU", version: 1, streamId: AU_STREAM_NEAREND, tsMs: 100, payload: "near" },
-  ]);
-});
-
-test("AgentAudioUplink never sends a delayed timestamp after a newer frame", async () => {
-  const sent = [];
-  const uplink = new AgentAudioUplink({ sendBinary: (frame) => sent.push(frame) });
-  uplink.reset(1000);
-
-  uplink.enqueue([{
-    data: new Blob(["newer"]),
-    timestamp: 1200,
-    streamId: AU_STREAM_NEAREND,
-    tsMs: 200,
-    frameKey: 2,
-  }]);
-  uplink.enqueue([{
-    data: new Blob(["delayed-older"]),
-    timestamp: 1100,
-    streamId: AU_STREAM_NEAREND,
-    tsMs: 100,
-    frameKey: 1,
-  }]);
-  await uplink.drain();
-
-  assert.deepEqual(sent.map(readAuFrame), [
-    { magic: "AU", version: 1, streamId: AU_STREAM_NEAREND, tsMs: 200, payload: "newer" },
-  ]);
-});
-
-test("AgentAudioUplink drops farend-only and stale-connection frames", async () => {
-  const sent = [];
-  const errors = [];
-  let releasePayload;
-  const delayedPayload = new Blob(["stale"]);
-  delayedPayload.arrayBuffer = () => new Promise((_, reject) => {
-    releasePayload = () => reject(new Error("stale payload failed"));
-  });
-  const uplink = new AgentAudioUplink({
-    sendBinary: (frame) => sent.push(frame),
-    onError: (error) => errors.push(error),
-  });
-  uplink.reset(1000);
-  uplink.offerFarend({ data: new TextEncoder().encode("far-only"), timestamp: 1100 });
-  uplink.offerNearend({ data: delayedPayload, timestamp: 1300 });
-  const staleDrain = uplink.drain();
-  await waitFor(() => typeof releasePayload === "function");
-  uplink.reset(2000);
-  releasePayload();
-  await staleDrain;
-  uplink.offerNearend({ data: new Blob(["current"]), timestamp: 2000 });
-  await uplink.drain();
-
-  assert.deepEqual(sent.map(readAuFrame), [
-    { magic: "AU", version: 1, streamId: AU_STREAM_NEAREND, tsMs: 0, payload: "current" },
-  ]);
-  assert.deepEqual(errors, []);
-});
-
-test("AgentAudioUplink fails closed until the next audio-input session", async () => {
-  const sent = [];
-  const errors = [];
-  let sendAttempts = 0;
-  let shouldFail = true;
-  const uplink = new AgentAudioUplink({
-    sendBinary: (frame) => {
-      sendAttempts += 1;
-      if (shouldFail) {
-        throw new Error("backpressure");
-      }
-      sent.push(frame);
-    },
-    onError: (error) => errors.push(error),
-  });
-  uplink.reset(1000);
-
-  uplink.offerNearend({ data: new Blob(["first"]), timestamp: 1000 });
-  uplink.offerNearend({ data: new Blob(["already-queued"]), timestamp: 1100 });
-  await uplink.drain();
-  shouldFail = false;
-  uplink.offerNearend({ data: new Blob(["dropped"]), timestamp: 1200 });
-  await uplink.drain();
-  assert.equal(errors.length, 1);
-  assert.equal(sendAttempts, 1);
-  assert.deepEqual(sent, []);
-
-  uplink.startInput();
-  uplink.offerNearend({ data: new Blob(["next"]), timestamp: 1300 });
-  await uplink.drain();
-  assert.deepEqual(sent.map(readAuFrame), [
-    { magic: "AU", version: 1, streamId: AU_STREAM_NEAREND, tsMs: 300, payload: "next" },
-  ]);
-});
-
-test("AgentE2EClient connects with token, sends JSON, and dispatches events", async () => {
-  MockWebSocket.instances = [];
-  const events = [];
-  const client = new AgentE2EClient({
-    wsUrl: "wss://e2e.example.com/ws",
-    token: "abc",
-    WebSocketCtor: MockWebSocket,
-    onEvent: (event) => events.push(event),
-  });
-
-  await client.connect();
-  const ws = MockWebSocket.instances[0];
-  assert.equal(ws.url, "wss://e2e.example.com/ws?token=abc");
-
-  client.send({ type: "ask", message: { text: "hello" } });
-  assert.deepEqual(JSON.parse(ws.sent[0]), { type: "ask", message: { text: "hello" } });
-
-  ws.emit({ type: "pong" });
-  assert.deepEqual(events, [{ type: "pong" }]);
-});
-
-test("AgentE2EClient serializes concurrent connection attempts", async () => {
-  MockWebSocket.instances = [];
-  MockWebSocket.failedConnections = 0;
-  const client = new AgentE2EClient({
-    wsUrl: "wss://e2e.example.com/ws",
-    token: "token",
-    WebSocketCtor: MockWebSocket,
-  });
-
-  const first = client.connect();
-  const second = client.connect();
-  await Promise.all([first, second]);
-
-  assert.equal(MockWebSocket.instances.length, 1);
-  client.disconnect();
-});
-
-test("AgentE2EClient can reconnect immediately after cancelling a pending connection", async () => {
-  MockWebSocket.instances = [];
-  MockWebSocket.failedConnections = 0;
-  const client = new AgentE2EClient({
-    wsUrl: "wss://e2e.example.com/ws",
-    token: "token",
-    WebSocketCtor: MockWebSocket,
-  });
-
-  const cancelledConnection = client.connect();
-  client.disconnect();
-  const nextConnection = client.connect();
-
-  await assert.rejects(cancelledConnection, /连接已取消/);
-  await nextConnection;
-  assert.equal(MockWebSocket.instances.length, 2);
-  client.disconnect();
-});
-
-test("AgentE2EClient sends ping and dispatches pong", async () => {
-  MockWebSocket.instances = [];
-  const events = [];
-  const client = new AgentE2EClient({
-    wsUrl: "wss://e2e.example.com/ws",
-    token: "token",
-    WebSocketCtor: MockWebSocket,
-    onEvent: (event) => events.push(event),
-  });
-
-  await client.connect();
-  const ws = MockWebSocket.instances[0];
-  client.ping();
-  ws.emit({ type: "pong" });
-
-  assert.deepEqual(JSON.parse(ws.sent[0]), { type: "ping" });
-  assert.deepEqual(events, [{ type: "pong" }]);
-  client.disconnect();
-});
-
-test("AgentE2EClient rejects sends before connecting", () => {
-  const client = new AgentE2EClient({
-    wsUrl: "wss://e2e.example.com/ws",
-    token: "token",
-    WebSocketCtor: MockWebSocket,
-  });
-
-  assert.throws(() => client.send({ type: "ping" }), /E2E WebSocket 未连接/);
-  assert.throws(() => client.sendBinary(new Blob(["audio"])), /E2E WebSocket 未连接/);
-  assert.doesNotThrow(() => client.disconnect());
-});
-
-test("AgentE2EClient reports invalid JSON and ignores non-text messages", async () => {
-  MockWebSocket.instances = [];
-  const events = [];
-  const errors = [];
-  const client = new AgentE2EClient({
-    wsUrl: "wss://e2e.example.com/ws",
-    token: "token",
-    WebSocketCtor: MockWebSocket,
-    onEvent: (event) => events.push(event),
-    onError: (error) => errors.push(error),
-  });
-
-  await client.connect();
-  const ws = MockWebSocket.instances[0];
-  ws.emitRaw("not-json");
-  ws.emitRaw(new Blob(["binary"]));
-  ws.emitRaw(JSON.stringify({ message: "missing type" }));
-
-  assert.deepEqual(events, []);
-  assert.equal(errors.length, 1);
-  assert.match(errors[0].message, /不是合法 JSON/);
-  client.disconnect();
-});
-
-test("AgentE2EClient rejects Binary frames when the socket buffer is over limit", async () => {
-  MockWebSocket.instances = [];
-  const client = new AgentE2EClient({
-    wsUrl: "wss://e2e.example.com/ws",
-    token: "token",
-    WebSocketCtor: MockWebSocket,
-  });
-
-  await client.connect();
-  const ws = MockWebSocket.instances[0];
-  ws.bufferedAmount = 2 * 1024 * 1024 + 1;
-
-  assert.throws(
-    () => client.sendBinary(new Blob(["audio"])),
-    (error) => error.name === "WebSocketBackpressureError" && /缓冲区超限/.test(error.message),
-  );
-  assert.deepEqual(ws.sent, []);
-  client.disconnect();
-});
-
-test("AgentE2EClient can drop JSON frames when the socket buffer is over limit", async () => {
-  MockWebSocket.instances = [];
-  const client = new AgentE2EClient({
-    wsUrl: "wss://e2e.example.com/ws",
-    token: "token",
-    WebSocketCtor: MockWebSocket,
-  });
-
-  await client.connect();
-  const ws = MockWebSocket.instances[0];
-  ws.bufferedAmount = 2 * 1024 * 1024 + 1;
-
-  assert.equal(client.trySend({ type: "telemetry" }), false);
-  assert.deepEqual(ws.sent, []);
-  client.disconnect();
-});
-
-test("AgentE2EClient preserves a server URL that already contains its token", async () => {
-  MockWebSocket.instances = [];
-  const wsUrl = "ws://test-e2emp.xingyun3d.com:8000/ws/session?session_id=test&token=server-token";
-  const client = new AgentE2EClient({
-    wsUrl,
-    token: "separate-token",
-    WebSocketCtor: MockWebSocket,
-  });
-
-  await client.connect();
-  assert.equal(MockWebSocket.instances[0].url, wsUrl);
-  client.disconnect();
-});
-
-test("AgentE2EClient adds audio_input_off for a disabled initial audio input", async () => {
-  MockWebSocket.instances = [];
-  const client = new AgentE2EClient({
-    wsUrl: "wss://e2e.example.com/ws/session?session_id=test&token=server-token",
-    token: "separate-token",
-    audioInputEnabled: false,
-    WebSocketCtor: MockWebSocket,
-  });
-
-  await client.connect();
-  assert.equal(
-    MockWebSocket.instances[0].url,
-    "wss://e2e.example.com/ws/session?session_id=test&token=server-token&audio_input_off=1",
-  );
-  client.disconnect();
-});
-
-test("AgentE2EClient removes stale audio_input_off for an enabled initial audio input", async () => {
-  MockWebSocket.instances = [];
-  const client = new AgentE2EClient({
-    wsUrl: "wss://e2e.example.com/ws/session?session_id=test&audio_input_off=1",
-    token: "token",
-    audioInputEnabled: true,
-    WebSocketCtor: MockWebSocket,
-  });
-
-  await client.connect();
-  assert.equal(MockWebSocket.instances[0].url, "wss://e2e.example.com/ws/session?session_id=test&token=token");
-  client.disconnect();
-});
-
-test("AgentE2EClient uses the latest audio input state when reconnecting", async () => {
-  MockWebSocket.instances = [];
-  const client = new AgentE2EClient({
-    wsUrl: "wss://e2e.example.com/ws/session?session_id=test",
-    token: "token",
-    audioInputEnabled: false,
-    WebSocketCtor: MockWebSocket,
-  });
-
-  await client.connect();
-  assert.match(MockWebSocket.instances[0].url, /[?&]audio_input_off=1(?:&|$)/);
-  client.setAudioInputEnabled(true);
-  client.disconnect();
-  await client.connect();
-  assert.equal(MockWebSocket.instances[1].url, "wss://e2e.example.com/ws/session?session_id=test&token=token");
-  client.disconnect();
-});
-
-test("XingyunAvatarAgent initializes E2E from the unified session e2e_resp", async () => {
-  MockWebSocket.instances = [];
-  const { agent } = createAgent();
-  agent.sessionInfo = {
-    session_id: "gateway-session",
-    room: "gateway-room",
-    token: "gateway-token",
-    socket_io_url: "wss://gateway.example.com/socket.io",
-    e2e_resp: {
-      ws_url: "wss://e2e.example.com/ws/session?session_id=gateway-session",
-      e2e_token: "unified-e2e-token",
-    },
-  };
-
-  try {
-    const sessionInfo = await agent.init();
-    assert.equal(sessionInfo, agent.sessionInfo);
-    assert.equal(
-      MockWebSocket.instances[0].url,
-      "wss://e2e.example.com/ws/session?session_id=gateway-session&token=unified-e2e-token&audio_input_off=1",
-    );
-  } finally {
-    await agent.destroy("test");
-  }
-});
-
-test("XingyunAvatarAgent enables dual audio from the returned AEC feature", async () => {
-  MockWebSocket.instances = [];
-  const { agent } = createAgent();
-  agent.sessionInfo = {
-    ...agent.sessionInfo,
-    features: {
-      speech_frontend: { enable_aec: false },
-    },
-    e2e_resp: {
-      ...agent.sessionInfo.e2e_resp,
-      features: {
-        speech_frontend: { enable_aec: true },
-      },
-    },
-  };
-
-  try {
-    await agent.init();
-    assert.equal(typeof agent.avatarOptions.onAudioPlaybackData, "function");
-    assert.equal(agent.audioCaptureEnableCalls, 1);
-
-    const callback = agent.avatarOptions.onAudioPlaybackData;
-    const timestamp = agent.audioUplink.connectionStartedAt;
-    agent.microphone = { isRecording: true, async stop() {} };
-    callback({
-      data: new TextEncoder().encode("feature-enabled").buffer,
-      codec: "opus",
-      isFirstChunk: true,
-      sampleRate: 16000,
-      samples: 1600,
-      timestamp,
-      speech_id: 1,
-    });
-    agent.sendAudioFrame({ data: new Blob(["nearend"]), timestamp });
-    await agent.audioUplink.drain();
-    assert.deepEqual(MockWebSocket.instances[0].sent.map(readAuFrame), [
-      { magic: "AU", version: 1, streamId: AU_STREAM_FAREND, tsMs: 0, payload: "feature-enabled" },
-      { magic: "AU", version: 1, streamId: AU_STREAM_NEAREND, tsMs: 0, payload: "nearend" },
-    ]);
-  } finally {
-    await agent.destroy("test");
-  }
-});
-
-test("XingyunAvatarAgent keeps requested AEC when the session does not echo features", async () => {
-  MockWebSocket.instances = [];
-  const { agent } = createAgent({}, {
-    features: {
-      speech_frontend: { enable_aec: true },
-    },
-  });
-
-  try {
-    await agent.init();
-    assert.equal(typeof agent.avatarOptions.onAudioPlaybackData, "function");
-    const timestamp = Date.now();
-    agent.microphone = { isRecording: true, async stop() {} };
-    agent.sendAudioFrame({ data: new Blob(["nearend"]), timestamp });
-    await agent.audioUplink.drain();
-
-    assert.deepEqual(readAuFrame(MockWebSocket.instances[0].sent[0]), {
-      magic: "AU",
-      version: 1,
-      streamId: AU_STREAM_NEAREND,
-      tsMs: 0,
-      payload: "nearend",
-    });
-  } finally {
-    await agent.destroy("test");
-  }
-});
-
-test("XingyunAvatarAgent lets the returned false AEC feature disable the legacy audio option", async () => {
-  MockWebSocket.instances = [];
-  const { agent } = createAgent({}, {
-    audio: { echoCancellationEnabled: true },
-    features: {
-      speech_frontend: { enable_aec: true },
-    },
-  });
-  agent.sessionInfo = {
-    ...agent.sessionInfo,
-    features: {
-      speech_frontend: { enable_aec: false },
-    },
-  };
-
-  try {
-    await agent.init();
-    assert.equal(agent.avatarOptions.onAudioPlaybackData, undefined);
-    assert.equal(agent.audioCaptureEnableCalls, 0);
-    const rawNearend = new Blob(["raw-nearend"], { type: "audio/webm;codecs=opus" });
-    agent.sendAudioFrame({ data: rawNearend, timestamp: Date.now() });
-    assert.equal(MockWebSocket.instances[0].sent[0], rawNearend);
-  } finally {
-    await agent.destroy("test");
-  }
-});
-
-test("XingyunAvatarAgent init starts exactly once when TTSA is ready before E2E", async () => {
-  MockWebSocket.instances = [];
-  const states = [];
-  const { agent } = createAgent({
-    onAgentStateChange: (state) => states.push(state),
-  });
-
-  await agent.init();
-
-  assert.equal(agent.getAgentState(), "running");
-  assert.equal(agent.started, true);
-  assert.equal(agent.startCalls, 1);
-  assert.deepEqual(states, ["initializing", "ready", "running"]);
-  await agent.destroy("test");
-});
-
-test("XingyunAvatarAgent init waits for TTSA when E2E is ready first", async () => {
-  MockWebSocket.instances = [];
-  const { agent } = createAgent();
-  agent.autoTtsaReady = false;
-  let initSettled = false;
-
-  const initPromise = agent.init().finally(() => {
-    initSettled = true;
-  });
-  await waitFor(() => MockWebSocket.instances[0]?.readyState === MockWebSocket.OPEN);
-
-  assert.equal(initSettled, false);
-  assert.equal(agent.getAgentState(), "initializing");
-  agent.onTtsaReady();
-  await initPromise;
-
-  assert.equal(agent.getAgentState(), "running");
-  assert.equal(agent.started, true);
-  assert.equal(agent.startCalls, 1);
-  await agent.destroy("test");
-});
-
-test("XingyunAvatarAgent shares one in-flight initialization", async () => {
-  MockWebSocket.instances = [];
-  const { agent } = createAgent();
-  agent.autoTtsaReady = false;
-
-  const firstInit = agent.init();
-  const secondInit = agent.init();
-
-  assert.equal(secondInit, firstInit);
-  await waitFor(() => MockWebSocket.instances[0]?.readyState === MockWebSocket.OPEN);
-  assert.equal(MockWebSocket.instances.length, 1);
-  agent.onTtsaReady();
-  await firstInit;
-  assert.equal(agent.startCalls, 1);
-  await agent.destroy("test");
-});
-
-test("XingyunAvatarAgent keeps initial init pending across a TTSA session reload", async () => {
-  MockWebSocket.instances = [];
-  const { agent } = createAgent();
-  agent.autoTtsaReady = false;
-  const initPromise = agent.init();
-
-  await waitFor(() => MockWebSocket.instances[0]?.readyState === MockWebSocket.OPEN);
-  await agent.onSessionReloaded({
-    session_id: "reloaded-session",
-    e2e_resp: {
-      ws_url: "wss://e2e.example.com/ws/session?session_id=reloaded-session",
-      e2e_token: "reloaded-token",
-    },
-  });
-  assert.equal(agent.getAgentState(), "initializing");
-  assert.equal(MockWebSocket.instances.length, 2);
-
-  agent.onTtsaReady();
-  const sessionInfo = await initPromise;
-  assert.equal(sessionInfo.session_id, "reloaded-session");
-  assert.equal(agent.getAgentState(), "running");
-  assert.equal(agent.startCalls, 1);
-  await agent.destroy("test");
-});
-
-test("XingyunAvatarAgent requires TTSA readiness from the latest initial session", async () => {
-  MockWebSocket.instances = [];
-  const { agent } = createAgent();
-  agent.autoTtsaReady = false;
-  let initSettled = false;
-  const initPromise = agent.init().finally(() => {
-    initSettled = true;
-  });
-
-  await waitFor(() => MockWebSocket.instances[0]?.readyState === MockWebSocket.OPEN);
-  agent.onTtsaReady({ session_id: "test-session" });
-  await agent.onSessionReloaded({
-    session_id: "replacement-session",
-    e2e_resp: {
-      ws_url: "wss://e2e.example.com/ws/session?session_id=replacement-session",
-      e2e_token: "replacement-token",
-    },
-  });
-  await new Promise((resolve) => setTimeout(resolve, 0));
-
-  assert.equal(initSettled, false);
-  agent.onTtsaReady({ session_id: "test-session" });
-  await new Promise((resolve) => setTimeout(resolve, 0));
-  assert.equal(initSettled, false);
-
-  agent.onTtsaReady({ session_id: "replacement-session" });
-  const sessionInfo = await initPromise;
-  assert.equal(sessionInfo.session_id, "replacement-session");
-  assert.equal(agent.getAgentState(), "running");
-  assert.equal(agent.startCalls, 1);
-  await agent.destroy("test");
-});
-
-test("XingyunAvatarAgent rejects init when the latest TTSA session reload is exhausted", async () => {
-  MockWebSocket.instances = [];
-  const { agent } = createAgent();
-  agent.autoTtsaReady = false;
-  const initPromise = agent.init();
-
-  await waitFor(() => MockWebSocket.instances[0]?.readyState === MockWebSocket.OPEN);
-  agent.onTtsaReady({ session_id: "test-session" });
-  await agent.onSessionReloaded({
-    session_id: "replacement-session",
-    e2e_resp: {
-      ws_url: "wss://e2e.example.com/ws/session?session_id=replacement-session",
-      e2e_token: "replacement-token",
-    },
-  });
-  agent.onSessionReloadExhausted(new Error("TTSA reload exhausted"));
-
-  await assert.rejects(initPromise, /TTSA reload exhausted/);
-  assert.equal(agent.getAgentState(), "failed");
-  assert.equal(agent.startCalls, 0);
-});
-
-test("XingyunAvatarAgent supersedes an in-flight E2E attempt during initial session reload", async () => {
-  MockWebSocket.instances = [];
-  MockWebSocket.autoOpen = false;
-  const { agent } = createAgent();
-  agent.autoTtsaReady = false;
-  const initPromise = agent.init();
-
-  try {
-    await waitFor(() => MockWebSocket.instances.length === 1);
-    const reloadPromise = agent.onSessionReloaded({
-      session_id: "replacement-session",
-      e2e_resp: {
-        ws_url: "wss://e2e.example.com/ws/session?session_id=replacement-session",
-        e2e_token: "replacement-token",
-      },
-    });
-    await waitFor(() => MockWebSocket.instances.length === 2);
-    MockWebSocket.instances[1].open();
-    await reloadPromise;
-    agent.onTtsaReady();
-
-    const sessionInfo = await initPromise;
-    assert.equal(sessionInfo.session_id, "replacement-session");
-    assert.equal(agent.getAgentState(), "running");
-    assert.equal(agent.startCalls, 1);
-  } finally {
-    MockWebSocket.autoOpen = true;
-    await agent.destroy("test");
-  }
-});
-
-test("XingyunAvatarAgent init rejects if E2E closes while waiting for TTSA", async () => {
-  MockWebSocket.instances = [];
-  const { agent } = createAgent();
-  agent.autoTtsaReady = false;
-  const initPromise = agent.init();
-
-  try {
-    await waitFor(() => MockWebSocket.instances[0]?.readyState === MockWebSocket.OPEN);
-    MockWebSocket.instances[0].closeRemote(4001, "invalid token", true);
-
-    await assert.rejects(
-      Promise.race([
-        initPromise,
-        new Promise((_, reject) => setTimeout(() => reject(new Error("init timeout")), 50)),
-      ]),
-      /Agent 初始化期间 E2E WebSocket 已关闭/,
-    );
-  } finally {
-    await agent.destroy("test");
-  }
-});
-
-test("XingyunAvatarAgent funnels an initial E2E connection failure through shared initialization cleanup", async () => {
-  MockWebSocket.instances = [];
-  MockWebSocket.failedConnections = 1;
-  const legacyErrors = [];
-  const agentErrors = [];
-  const { agent } = createAgent(
-    { onError: (error) => agentErrors.push(error) },
-    { onMessage: (error) => legacyErrors.push(error) },
-  );
-
-  try {
-    await assert.rejects(agent.init(), /E2E WebSocket/);
-
-    assert.equal(agent.getAgentState(), "failed");
-    assert.deepEqual(agent.incompleteInitializationCleanups, ["agent_init_failed"]);
-    assert.equal(agent.initializationFailureNotifications.length, 1);
-    assert.equal(legacyErrors.length, 1);
-    assert.equal(legacyErrors[0].code, 10005);
-    assert.deepEqual(agentErrors.map((error) => error.code), ["AGENT_INIT_FAILED"]);
-  } finally {
-    MockWebSocket.failedConnections = 0;
-    await agent.destroy("test");
-  }
-});
-
-test("XingyunAvatarAgent funnels a unified session failure through shared initialization cleanup", async () => {
-  const legacyErrors = [];
-  const agentErrors = [];
-  const { agent } = createAgent(
-    { onError: (error) => agentErrors.push(error) },
-    { onMessage: (error) => legacyErrors.push(error) },
-  );
-  agent.sessionInfo = null;
-
-  await assert.rejects(agent.init(), /未返回 sessionInfo/);
-
-  assert.equal(agent.getAgentState(), "failed");
-  assert.deepEqual(agent.incompleteInitializationCleanups, ["agent_init_failed"]);
-  assert.equal(agent.initializationFailureNotifications.length, 1);
-  assert.equal(legacyErrors.length, 1);
-  assert.equal(legacyErrors[0].code, 10005);
-  assert.deepEqual(agentErrors.map((error) => error.code), ["AGENT_INIT_FAILED"]);
-
-  await agent.destroy("test");
-  assert.equal(agent.getAgentState(), "destroyed");
-});
-
-test("XingyunAvatarAgent preserves parent diagnostics during initialization", async () => {
-  const agentErrors = [];
-  const { agent } = createAgent({ onError: (error) => agentErrors.push(error) });
-  Object.defineProperty(agent, "sessionInfo", {
-    configurable: true,
-    get() {
-      agent.avatarOptions.onMessage({ code: "SESSION_DETAIL", message: "session detail" });
-      return null;
-    },
-  });
-
-  await assert.rejects(agent.init(), /未返回 sessionInfo/);
-
-  assert.deepEqual(agentErrors.map((error) => error.code), [
-    "SESSION_DETAIL",
-    "AGENT_INIT_FAILED",
-  ]);
-});
-
-test("XingyunAvatarAgent preserves its initialization failure when callbacks throw", async () => {
-  const agentErrors = [];
-  const { agent } = createAgent(
-    {
-      onAgentStateChange(state) {
-        if (state === "failed") {
-          throw new Error("state callback failed");
-        }
-      },
-      onError(error) {
-        agentErrors.push(error);
-        throw new Error("error callback failed");
-      },
-    },
-    {
-      onMessage() {
-        throw new Error("legacy callback failed");
-      },
-    },
-  );
-  agent.sessionInfo = null;
-
-  await assert.rejects(agent.init(), /未返回 sessionInfo/);
-
-  assert.equal(agent.getAgentState(), "failed");
-  assert.deepEqual(agentErrors.map((error) => error.code), ["AGENT_INIT_FAILED"]);
-});
-
-test("XingyunAvatarAgent rejects a partial unified session response", async () => {
-  const { agent } = createAgent();
-  agent.sessionInfo = {
-    session_id: "gateway-session",
-    room: "gateway-room",
-    token: "gateway-token",
-    socket_io_url: "wss://gateway.example.com/socket.io",
-    e2e_resp: {
-      ws_url: "wss://e2e.example.com/ws/session?session_id=gateway-session",
-    },
-  };
-
-  await assert.rejects(agent.init(), /e2e_resp 必须同时返回 ws_url 和 e2e_token/);
-  assert.equal(agent.destroyed, true);
-  assert.deepEqual(agent.incompleteInitializationCleanups, ["agent_init_failed"]);
-});
-
-test("XingyunAvatarAgent rejects e2e_resp with only an E2E token", async () => {
-  const { agent } = createAgent();
-  agent.sessionInfo = {
-    session_id: "gateway-session",
-    room: "gateway-room",
-    token: "gateway-token",
-    socket_io_url: "wss://gateway.example.com/socket.io",
-    e2e_resp: {
-      e2e_token: "unified-e2e-token",
-    },
-  };
-
-  await assert.rejects(agent.init(), /e2e_resp 必须同时返回 ws_url 和 e2e_token/);
-  assert.equal(agent.destroyed, true);
-  assert.deepEqual(agent.incompleteInitializationCleanups, ["agent_init_failed"]);
-});
-
-test("XingyunAvatarAgent rejects an incomplete direct E2E fallback", async () => {
-  const { agent } = createAgent({}, { e2eServer: undefined });
-
-  await assert.rejects(agent.init(), /e2eServer 和 authToken 必须同时配置/);
-  assert.equal(agent.destroyed, true);
-});
-
-test("XingyunAvatarAgent fails when unified session and fallbacks are unavailable", async () => {
-  const { agent } = createAgent({}, { e2eServer: undefined, authToken: undefined });
-
-  await assert.rejects(agent.init(), /未返回 e2e_resp\.ws_url，且未配置 e2eServer/);
-  assert.equal(agent.destroyed, true);
-});
-
-test("XingyunAvatarAgent defaults session_speak_req_id without overwriting zero", () => {
-  const { agent: defaultAgent } = createAgent();
-  const { agent: zeroAgent } = createAgent({}, { session_speak_req_id: 0 });
-
-  assert.equal(defaultAgent.avatarOptions.session_speak_req_id, 1);
-  assert.equal(zeroAgent.avatarOptions.session_speak_req_id, 0);
-});
-
-test("XingyunAvatarAgent accepts JSON Config sources", () => {
-  const { agent } = createAgent({}, {
-    asr_id: undefined,
-    asr_config: { provider: "asr-custom" },
-    tts_config: { provider: "tts-custom" },
-    features: {
-      anti_interference: { semantic_judge_enabled: false },
-      speech_frontend: {
-        enabled: false,
-        enable_aec: false,
-        enable_speech_separation: false,
-      },
-      vad_merge_mode: true,
-    },
-    extras: { trace_context: "agent-test" },
-    llm_id: undefined,
-    brain_config: { provider: "brain-custom" },
-  });
-
-  assert.deepEqual(agent.avatarOptions.sessionRequestData, {
-    asr_config: { provider: "asr-custom" },
-    tts_config: { provider: "tts-custom" },
-    features: {
-      anti_interference: { semantic_judge_enabled: false },
-      speech_frontend: {
-        enabled: false,
-        enable_aec: false,
-        enable_speech_separation: false,
-      },
-      vad_merge_mode: true,
-    },
-    extras: { trace_context: "agent-test" },
-    brain_config: { provider: "brain-custom" },
-    session_speak_req_id: 1,
-  });
-});
-
-test("XingyunAvatarAgent omits empty ASR, TTS, Features, Extras and Brain configs", () => {
-  const { agent } = createAgent({}, {
-    asr_id: undefined,
-    asr_config: {},
-    tts_config: {},
-    features: {},
-    extras: {},
-    llm_id: undefined,
-    brain_config: {},
-  });
-
-  assert.deepEqual(agent.avatarOptions.sessionRequestData, {
-    session_speak_req_id: 1,
-  });
-});
-
-test("XingyunAvatarAgent treats configs without serializable fields as empty", () => {
-  const { agent } = createAgent({}, {
-    asr_id: 3,
-    asr_config: { provider: undefined },
-    tts_config: { provider: undefined },
-    features: { vad_merge_mode: undefined },
-    extras: { trace_context: undefined },
-    llm_id: 4,
-    brain_config: { extra_body: undefined },
-  });
-
-  assert.deepEqual(agent.avatarOptions.sessionRequestData, {
-    asr_id: 3,
-    llm_id: 4,
-    session_speak_req_id: 1,
-  });
-});
-
-test("XingyunAvatarAgent rejects non-object features", () => {
-  assert.throws(
-    () => createAgent({}, { features: [] as never }),
-    /Agent features 必须是对象/,
-  );
-});
-
-test("XingyunAvatarAgent rejects non-object TTS config", () => {
-  assert.throws(
-    () => createAgent({}, { tts_config: [] as never }),
-    /Agent TTS JSON Config 必须是对象/,
-  );
-});
-
-test("XingyunAvatarAgent rejects non-object extras", () => {
-  assert.throws(
-    () => createAgent({}, { extras: [] as never }),
-    /Agent extras 必须是对象/,
-  );
-});
-
-test("XingyunAvatarAgent preserves Brain extra_body", () => {
-  const { agent } = createAgent({}, {
-    asr_id: undefined,
-    asr_config: { provider: "asr-custom" },
-    llm_id: undefined,
-    brain_config: {
-      provider: "openai-compatible",
-      extra_body: { thinking: { type: "disabled" } },
-    },
-  });
-
-  assert.deepEqual(agent.avatarOptions.sessionRequestData, {
-    asr_config: { provider: "asr-custom" },
-    brain_config: {
-      provider: "openai-compatible",
-      extra_body: { thinking: { type: "disabled" } },
-    },
-    session_speak_req_id: 1,
-  });
-});
-
-test("XingyunAvatarAgent only captures playback audio when AEC or a caller callback needs it", async () => {
-  const playbackFrames = [];
-  const { agent: defaultAgent } = createAgent();
-  const { agent: callbackAgent } = createAgent({}, {
-    onAudioPlaybackData: (data) => playbackFrames.push(data),
-  });
-  const { agent: aecAgent } = createAgent({}, {
-    audio: { echoCancellationEnabled: true },
-  });
-
-  assert.equal(defaultAgent.avatarOptions.onAudioPlaybackData, undefined);
-  assert.equal(typeof callbackAgent.avatarOptions.onAudioPlaybackData, "function");
-  assert.equal(aecAgent.avatarOptions.onAudioPlaybackData, undefined);
-  await aecAgent.init();
-  assert.equal(typeof aecAgent.avatarOptions.onAudioPlaybackData, "function");
-
-  const frame = { data: new TextEncoder().encode("AAE=").buffer, codec: "opus", isFirstChunk: false, sampleRate: 16000, samples: 2, timestamp: 1, speech_id: 3 };
-  callbackAgent.avatarOptions.onAudioPlaybackData(frame);
-  assert.deepEqual(playbackFrames, [frame]);
-  await aecAgent.destroy("test");
-});
-
-test("XingyunAvatarAgent forwards paired playback and microphone audio as ordered AU frames", async () => {
-  MockWebSocket.instances = [];
-  const { agent } = createAgent({}, {
-    audio: { echoCancellationEnabled: true },
-  });
-
-  const toBuffer = (s: string) => new TextEncoder().encode(s).buffer;
-  await agent.init();
-  const callback = agent.avatarOptions.onAudioPlaybackData;
-  const ws = MockWebSocket.instances[0];
-  agent.microphone = { isRecording: true, async stop() {} };
-  const connectionStartedAt = agent.audioUplink.connectionStartedAt;
-  const timestamp = connectionStartedAt + 100;
-  callback({ data: toBuffer("farend"), codec: "opus", isFirstChunk: true, sampleRate: 16000, samples: 1600, timestamp, speech_id: 1 });
-  agent.sendAudioFrame({ data: new Blob(["nearend"]), timestamp });
-  await agent.audioUplink.drain();
-
-  assert.deepEqual(ws.sent.map(readAuFrame), [
-    { magic: "AU", version: 1, streamId: AU_STREAM_FAREND, tsMs: 100, payload: "farend" },
-    { magic: "AU", version: 1, streamId: AU_STREAM_NEAREND, tsMs: 100, payload: "nearend" },
-  ]);
-  await agent.destroy("test");
-});
-
-test("XingyunAvatarAgent restarts playback capture when dual-audio ASR starts", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser();
-  const { agent } = createAgent({}, {
-    audio: { echoCancellationEnabled: true },
-  });
-
-  try {
-    await agent.init();
-    await agent.startASR();
-    assert.equal(agent.audioCaptureRestartCalls, 1);
-    await agent.stopASR();
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent uses a cloned explicit ASR input stream", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser();
-  const inputStream = browser.createStream(16_000, 1);
-  const sourceTrack = inputStream.getAudioTracks()[0];
-  const { agent } = createAgent();
-
-  try {
-    await agent.init();
-    await agent.startASR({ inputStream });
-
-    assert.equal(browser.getUserMediaCalls.length, 0);
-    assert.equal(sourceTrack.stopCalls, 0);
-    assert.equal(browser.recorders.length, 1);
-
-    await agent.stopASR();
-
-    assert.equal(sourceTrack.stopCalls, 0);
-    assert.equal(browser.tracks[1].stopCalls, 1);
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent skips ended tracks when cloning an explicit ASR input stream", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser();
-  const endedTrack = browser.createStream(16_000, 1).getAudioTracks()[0];
-  const liveTrack = browser.createStream(16_000, 1).getAudioTracks()[0];
-  endedTrack.stop();
-  const inputStream = new MediaStream([endedTrack, liveTrack]);
-  const { agent } = createAgent();
-
-  try {
-    await agent.init();
-    await agent.startASR({ inputStream });
-    await agent.stopASR();
-
-    assert.equal(endedTrack.stopCalls, 1);
-    assert.equal(liveTrack.stopCalls, 0);
-    assert.equal(browser.tracks[2].stopCalls, 1);
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent uses an explicit ASR input stream in dual-audio mode", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser();
-  const inputStream = browser.createStream(16_000, 1);
-  const sourceTrack = inputStream.getAudioTracks()[0];
-  const { agent } = createAgent({}, {
-    audio: { echoCancellationEnabled: true },
-  });
-
-  try {
-    await agent.init();
-    await agent.startASR({ inputStream });
-
-    assert.equal(browser.getUserMediaCalls.length, 0);
-    assert.equal(browser.recorders.length, 0);
-    assert.equal(browser.audioWorkletNodes.length, 1);
-
-    await agent.stopASR();
-
-    assert.equal(sourceTrack.stopCalls, 0);
-    assert.equal(browser.tracks[1].stopCalls, 1);
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent does not request the microphone after a pending explicit-input start is cancelled", async () => {
-  MockWebSocket.instances = [];
-  let resolveAudioEncoderSupport;
-  let supportCheckStarted = false;
-  const audioEncoderSupportResult = new Promise((resolve) => {
-    resolveAudioEncoderSupport = resolve;
-  });
-  const browser = installMicrophoneBrowser({
-    audioEncoderSupport: async (config) => {
-      supportCheckStarted = true;
-      await audioEncoderSupportResult;
-      return { supported: true, config };
-    },
-  });
-  const inputStream = browser.createStream(16_000, 1);
-  const sourceTrack = inputStream.getAudioTracks()[0];
-  const { agent } = createAgent({}, {
-    audio: { echoCancellationEnabled: true },
-  });
-
-  try {
-    await agent.init();
-    const startPromise = agent.startASR({ inputStream });
-    await waitFor(() => supportCheckStarted);
-
-    await agent.stopASR();
-    resolveAudioEncoderSupport();
-
-    await assert.rejects(startPromise, (error) => (
-      error?.agentCode === "AUDIO_FIXED_TRACK_CANCELLED"
-    ));
-    assert.equal(browser.getUserMediaCalls.length, 0);
-    assert.equal(sourceTrack.stopCalls, 0);
-    assert.equal(browser.tracks[1].stopCalls, 1);
-    assert.equal(browser.audioWorkletNodes.length, 0);
-  } finally {
-    resolveAudioEncoderSupport?.();
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent releases explicit input and restores server state when a startup callback throws", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser();
-  const inputStream = browser.createStream(16_000, 1);
-  const sourceTrack = inputStream.getAudioTracks()[0];
-  const { agent } = createAgent({
-    onConversationChange() {
-      throw new Error("conversation callback failed");
-    },
-  });
-
-  try {
-    await agent.init();
-    const ws = MockWebSocket.instances[0];
-
-    await assert.rejects(
-      agent.startASR({ inputStream }),
-      /conversation callback failed/,
-    );
-
-    assert.equal(sourceTrack.stopCalls, 0);
-    assert.equal(browser.tracks[1].stopCalls, 1);
-    assert.equal(agent.microphone, null);
-    assert.deepEqual(
-      ws.sent.map((payload) => JSON.parse(payload).message),
-      ["audio_input_on", "audio_input_off"],
-    );
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent does not continue an explicit-input start stopped from a startup callback", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser();
-  const inputStream = browser.createStream(16_000, 1);
-  const sourceTrack = inputStream.getAudioTracks()[0];
-  let agent;
-  ({ agent } = createAgent({
-    onConversationChange(event) {
-      if (event.state === "asking") {
-        void agent.stopASR();
-      }
-    },
-  }));
-
-  try {
-    await agent.init();
-
-    await assert.rejects(
-      agent.startASR({ inputStream }),
-      (error) => error?.agentCode === "AUDIO_FIXED_TRACK_CANCELLED",
-    );
-
-    await agent.stopASR();
-    assert.equal(browser.getUserMediaCalls.length, 0);
-    assert.equal(browser.recorders.length, 0);
-    assert.equal(sourceTrack.stopCalls, 0);
-    assert.equal(browser.tracks[1].stopCalls, 1);
-    assert.equal(agent.microphone, null);
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent returns to idle when ASR state callbacks stop a pending explicit-input start", async () => {
-  for (const stopState of ["requesting-permission", "starting"]) {
-    MockWebSocket.instances = [];
-    const browser = installMicrophoneBrowser();
-    const inputStream = browser.createStream(16_000, 1);
-    let agent;
-    ({ agent } = createAgent({
-      onASRStateChange(state) {
-        if (state === stopState) {
-          void agent.stopASR();
-        }
-      },
-    }));
-
-    try {
-      await agent.init();
-      await assert.rejects(
-        agent.startASR({ inputStream }),
-        (error) => error?.agentCode === "AUDIO_FIXED_TRACK_CANCELLED",
-      );
-      await agent.stopASR();
-
-      assert.equal(agent.getASRState(), "idle", stopState);
-      assert.equal(browser.getUserMediaCalls.length, 0, stopState);
-      assert.equal(browser.recorders.length, 0, stopState);
-    } finally {
-      await agent.destroy("test");
-      browser.restore();
-    }
-  }
-});
-
-test("XingyunAvatarAgent releases a cloned explicit input when ASR startup fails", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser({ webmOpus: false });
-  const inputStream = browser.createStream(16_000, 1);
-  const sourceTrack = inputStream.getAudioTracks()[0];
-  const { agent } = createAgent();
-
-  try {
-    await agent.init();
-    await assert.rejects(
-      agent.startASR({ inputStream }),
-      /当前浏览器不支持 audio\/webm;codecs=opus/,
-    );
-
-    assert.equal(sourceTrack.stopCalls, 0);
-    assert.equal(browser.tracks[1].stopCalls, 1);
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent releases a cloned explicit input when enabling ASR transport fails", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser();
-  const inputStream = browser.createStream(16_000, 1);
-  const sourceTrack = inputStream.getAudioTracks()[0];
-  const { agent } = createAgent();
-
-  try {
-    await agent.init();
-    MockWebSocket.instances[0].send = () => {
-      throw new Error("transport send failed");
-    };
-
-    await assert.rejects(
-      agent.startASR({ inputStream }),
-      /transport send failed/,
-    );
-
-    assert.equal(sourceTrack.stopCalls, 0);
-    assert.equal(browser.tracks[1].stopCalls, 1);
-    assert.equal(agent.microphone, null);
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent stops the current ASR after an AU send failure", async () => {
-  MockWebSocket.instances = [];
-  const errors = [];
-  const { agent } = createAgent(
-    { onError: (error) => errors.push(error) },
-    { audio: { echoCancellationEnabled: true } },
-  );
-
-  await agent.init();
-  const ws = MockWebSocket.instances[0];
-  let stopCalls = 0;
-  agent.microphone = {
-    isRecording: true,
-    async stop() {
-      stopCalls += 1;
-    },
-  };
-  agent.audioUplink.startInput();
-  agent.enableAudioInput();
-  ws.sent = [];
-  ws.bufferedAmount = 2 * 1024 * 1024 + 1;
-
-  agent.sendAudioFrame({
-    data: new Blob(["nearend"]),
-    timestamp: agent.audioUplink.connectionStartedAt,
-  });
-  await agent.audioUplink.drain();
-  await waitFor(() => stopCalls === 1 && agent.stopASRPromise === null);
-
-  assert.equal(agent.microphone, null);
-  assert.equal(agent.getASRState(), "failed");
-  assert.equal(errors.at(-1).code, "E2E_AUDIO_SEND_FAILED");
-  assert.deepEqual(ws.sent.map((payload) => JSON.parse(payload)), [
-    { type: "event", message: "audio_input_off" },
-  ]);
-  await agent.destroy("test");
-});
-
-test("XingyunAvatarAgent resets the AU timeline for each E2E connection", async () => {
-  MockWebSocket.instances = [];
-  const { agent } = createAgent({}, {
-    audio: { echoCancellationEnabled: true },
-    reconnect: { initialDelayMs: 0, maxDelayMs: 0, maxAttempts: 2 },
-  });
-  await agent.init();
-  const toBuffer = (s: string) => new TextEncoder().encode(s).buffer;
-  const callback = agent.avatarOptions.onAudioPlaybackData;
-  agent.microphone = { isRecording: true, async stop() {} };
-  const firstWs = MockWebSocket.instances[0];
-  let timestamp = agent.audioUplink.connectionStartedAt;
-  callback({ data: toBuffer("first-far"), codec: "opus", isFirstChunk: true, sampleRate: 16000, samples: 1600, timestamp, speech_id: 1 });
-  agent.sendAudioFrame({ data: new Blob(["first-near"]), timestamp });
-  await agent.audioUplink.drain();
-
-  firstWs.closeRemote(1006);
-  await waitFor(() => MockWebSocket.instances.length === 2 && agent.getAgentState() === "running");
-  const secondWs = MockWebSocket.instances[1];
-  agent.microphone = { isRecording: true, async stop() {} };
-  timestamp = agent.audioUplink.connectionStartedAt;
-  callback({ data: toBuffer("second-far"), codec: "opus", isFirstChunk: true, sampleRate: 16000, samples: 1600, timestamp, speech_id: 2 });
-  agent.sendAudioFrame({ data: new Blob(["second-near"]), timestamp });
-  await agent.audioUplink.drain();
-
-  assert.equal(readAuFrame(firstWs.sent[0]).tsMs, 0);
-  assert.equal(readAuFrame(secondWs.sent[0]).tsMs, 0);
-  await agent.destroy("test");
-});
-
-test("XingyunAvatarAgent rejects non-object Brain extra_body", () => {
-  assert.throws(
-    () => createAgent({}, {
-      asr_id: undefined,
-      asr_config: { provider: "asr-custom" },
-      llm_id: undefined,
-      brain_config: { provider: "brain-custom", extra_body: [] as never },
-    }),
-    /Agent Brain extra_body 必须是 JSON 对象/,
-  );
-});
-
-test("XingyunAvatarAgent rejects ambiguous non-empty config sources", () => {
-  assert.throws(
-    () => createAgent({}, { asr_config: { provider: "asr-custom" } }),
-    /Agent ASR 配置不能同时提供 ID 和 JSON Config/,
-  );
-});
-
-test("XingyunAvatarAgent extends XmovAvatar and preserves base speak", async () => {
-  MockWebSocket.instances = [];
-  const { agent } = createAgent();
-  const XmovAvatar = require("../../index");
-
-  await agent.init();
-  const ws = MockWebSocket.instances[0];
-  assert.equal(ws.url, "wss://e2e.example.com/ws?token=token-from-nebula&audio_input_off=1");
-  assert.equal(agent instanceof XmovAvatar, true);
-  assert.equal(agent.started, true);
-  assert.equal(agent.startCalls, 1);
-
-  agent.start();
-  assert.equal(agent.startCalls, 1);
-  agent.speak("legacy TTSA speak");
-  assert.deepEqual(agent.speeches, [["legacy TTSA speak"]]);
-  assert.deepEqual(ws.sent, []);
-  agent.avatarOptions.onVoiceStateChange("end");
-  assert.deepEqual(ws.sent, []);
-});
-
-test("XingyunAvatarAgent restarts TTSA after same-session ready without leaving stopped state", async () => {
-  MockWebSocket.instances = [];
-  const { agent } = createAgent();
-
-  await agent.init();
-  assert.equal(agent.startCalls, 1);
-
-  agent.onTtsaReady({ session_id: "test-session" });
-  assert.equal(agent.startCalls, 2);
-  assert.equal(agent.getAgentState(), "running");
-
-  await agent.stop();
-  agent.onTtsaReady({ session_id: "test-session" });
-  assert.equal(agent.startCalls, 2);
-  assert.equal(agent.getAgentState(), "stopped");
-  await agent.destroy("test");
-});
-
-test("XingyunAvatarAgent ignores an explicit start while init is pending", () => {
-  const { agent } = createAgent();
-  agent.agentState = "initializing";
-
-  assert.doesNotThrow(() => agent.start());
-  assert.equal(agent.started, false);
-});
-
-test("XingyunAvatarAgent sends frozen ask and speak payloads without client IDs or providers", async () => {
-  MockWebSocket.instances = [];
-  const conversations = [];
-  const { agent } = createAgent({
-    onConversationChange: (event) => conversations.push(event),
-  });
-
-  await agent.init();
-  const ws = MockWebSocket.instances[0];
-
-  await agent.ask("hello");
-  const askPayload = JSON.parse(ws.sent[0]);
-  assert.deepEqual(askPayload, { type: "ask", message: { text: "hello" } });
-  assert.deepEqual(conversations.at(-1), { state: "asking", text: "hello" });
-
-  await agent.speakByE2E("welcome");
-  const speakPayload = JSON.parse(ws.sent.at(-1));
-  assert.deepEqual(speakPayload, {
-    type: "speak",
-    message: { text: "welcome", is_start: true, is_end: true },
-  });
-});
-
-test("XingyunAvatarAgent interrupts E2E and local playback without client IDs", async () => {
-  MockWebSocket.instances = [];
-  const { agent } = createAgent();
-
-  await agent.init();
-  const ws = MockWebSocket.instances[0];
-  await agent.ask("cancel me");
-
-  await agent.interruptConversation("user");
-  assert.deepEqual(agent.interrupts, ["speak"]);
-  assert.deepEqual(JSON.parse(ws.sent.at(-1)), { type: "interrupt" });
-});
-
-test("XingyunAvatarAgent keeps ASR listening when interrupting a conversation", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser();
-  const { agent } = createAgent();
-
-  try {
-    await agent.init();
-    await agent.startASR();
-    const ws = MockWebSocket.instances[0];
-    const recorder = browser.recorders[0];
-    ws.sent = [];
-
-    await agent.interruptConversation("user");
-    const audioAfterInterrupt = new Blob(["audio-after-interrupt"], {
-      type: "audio/webm;codecs=opus",
-    });
-    recorder.ondataavailable?.({ data: audioAfterInterrupt, timecode: 100 });
-
-    assert.equal(agent.getASRState(), "listening");
-    assert.equal(agent.microphone?.isRecording, true);
-    assert.equal(recorder.state, "recording");
-    assert.equal(browser.tracks[0].readyState, "live");
-    assert.equal(ws.sent.at(-1), audioAfterInterrupt);
-    assert.deepEqual(
-      ws.sent
-        .filter((payload) => typeof payload === "string")
-        .map((payload) => JSON.parse(payload)),
-      [{ type: "interrupt" }],
-    );
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent forwards TTSA voice_end to E2E while running", async () => {
-  MockWebSocket.instances = [];
-  const voiceStates = [];
-  const { agent } = createAgent({}, {
-    onVoiceStateChange: (state, duration) => voiceStates.push({ state, duration }),
-  });
-
-  await agent.init();
-  const ws = MockWebSocket.instances[0];
-  agent.avatarOptions.onVoiceStateChange("end", 1200);
-  assert.deepEqual(JSON.parse(ws.sent.at(-1)), { type: "event", message: "voice_end" });
-  assert.deepEqual(voiceStates, [
-    { state: "end", duration: 1200 },
-  ]);
-
-  await agent.destroy("test");
-  agent.avatarOptions.onVoiceStateChange("end", 1200);
-  const voiceEndMessages = ws.sent
-    .filter((payload) => typeof payload === "string")
-    .map((payload) => JSON.parse(payload))
-    .filter((payload) => payload.message === "voice_end");
-  assert.equal(voiceEndMessages.length, 1);
-});
-
-test("XingyunAvatarAgent stops callbacks after destroy", async () => {
-  MockWebSocket.instances = [];
-  const conversations = [];
-  const states = [];
-  const { agent } = createAgent({
-    onConversationChange: (event) => conversations.push(event),
-    onAgentStateChange: (state) => states.push(state),
-  });
-
-  await agent.init();
-  const ws = MockWebSocket.instances[0];
-  await agent.ask("hello");
-  await agent.destroy("test");
-
-  ws.emit({ type: "asr_result", text: "ignored", is_final: true });
-  assert.equal(conversations.length, 1);
-  assert.equal(states.at(-1), "destroyed");
-  assert.equal(agent.destroyed, true);
-});
-
-test("XingyunAvatarAgent cleans up a pending microphone start after destroy", async () => {
-  MockWebSocket.instances = [];
-  let resolveStream;
-  const browser = installMicrophoneBrowser({
-    getUserMedia: (_constraints, createStream) => new Promise((resolve) => {
-      resolveStream = () => resolve(createStream());
-    }),
-  });
-  const { agent } = createAgent();
-
-  try {
-    await agent.init();
-
-    const startPromise = agent.startASR();
-    await Promise.resolve();
-    await agent.destroy("test");
-    resolveStream();
-
-    await assert.rejects(startPromise, /Agent 已销毁/);
-    assert.equal(agent.getAgentState(), "destroyed");
-    assert.notEqual(agent.getASRState(), "listening");
-    assert.equal(agent.microphone, null);
-    assert.equal(browser.tracks[0].stopCalls, 1);
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent cancels a pending microphone permission request on stop", async () => {
-  MockWebSocket.instances = [];
-  let resolveStream;
-  const errors = [];
-  const browser = installMicrophoneBrowser({
-    getUserMedia: (_constraints, createStream) => new Promise((resolve) => {
-      resolveStream = () => resolve(createStream());
-    }),
-  });
-  const { agent } = createAgent({ onError: (error) => errors.push(error) });
-
-  try {
-    await agent.init();
-
-    const startPromise = agent.startASR();
-    await Promise.resolve();
-    await agent.stopASR();
-    assert.equal(agent.getASRState(), "idle");
-    assert.equal(agent.microphone, null);
-
-    resolveStream();
-    await assert.rejects(
-      startPromise,
-      (error) => error.agentCode === "AUDIO_FIXED_TRACK_CANCELLED",
-    );
-    assert.equal(agent.getASRState(), "idle");
-    assert.equal(errors.length, 0);
-    assert.equal(browser.recorders.length, 0);
-    assert.equal(browser.tracks[0].stopCalls, 1);
-  } finally {
-    resolveStream?.();
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent ignores a stale microphone start after a new start succeeds", async () => {
-  MockWebSocket.instances = [];
-  const pendingStreams = [];
-  const errors = [];
-  const browser = installMicrophoneBrowser({
-    getUserMedia: (_constraints, createStream) => new Promise((resolve, reject) => {
-      pendingStreams.push({
-        resolve: () => resolve(createStream()),
-        reject,
-      });
-    }),
-  });
-  const { agent } = createAgent({ onError: (error) => errors.push(error) });
-
-  try {
-    await agent.init();
-
-    const firstStart = agent.startASR();
-    await Promise.resolve();
-    await agent.stopASR();
-
-    const secondStart = agent.startASR();
-    await Promise.resolve();
-    pendingStreams[1].resolve();
-    await secondStart;
-    assert.equal(agent.getASRState(), "listening");
-
-    const staleError = new Error("stale permission rejection");
-    staleError.name = "NotAllowedError";
-    pendingStreams[0].reject(staleError);
-    await assert.rejects(
-      firstStart,
-      (error) => error.agentCode === "AUDIO_FIXED_TRACK_CANCELLED",
-    );
-
-    assert.equal(agent.getASRState(), "listening");
-    assert.equal(errors.length, 0);
-    const messages = MockWebSocket.instances[0].sent
-      .filter((payload) => typeof payload === "string")
-      .map((payload) => JSON.parse(payload).message)
-      .filter(Boolean);
-    assert.deepEqual(messages, ["audio_input_on", "audio_input_off", "audio_input_on"]);
-  } finally {
-    pendingStreams.forEach(({ resolve }) => resolve());
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent serializes concurrent ASR stops and sends audio_input_off once", async () => {
-  MockWebSocket.instances = [];
-  const { agent } = createAgent({}, { audio: { inputEnabled: true } });
-  await agent.init();
-  const ws = MockWebSocket.instances[0];
-  let releaseStop;
-  const microphone = {
-    isRecording: true,
-    stopCalls: 0,
-    stop() {
-      this.stopCalls += 1;
-      return new Promise((resolve) => {
-        releaseStop = resolve;
-      });
-    },
-  };
-  agent.microphone = microphone;
-
-  const firstStop = agent.stopASR();
-  const secondStop = agent.stopASR();
-  assert.equal(firstStop, secondStop);
-  assert.equal(microphone.stopCalls, 1);
-
-  releaseStop();
-  await Promise.all([firstStop, secondStop]);
-  const audioInputOffMessages = ws.sent
-    .filter((payload) => typeof payload === "string")
-    .map((payload) => JSON.parse(payload))
-    .filter((payload) => payload.message === "audio_input_off");
-  assert.equal(audioInputOffMessages.length, 1);
-  assert.deepEqual(audioInputOffMessages[0], { type: "event", message: "audio_input_off" });
-  assert.equal(agent.getASRState(), "idle");
-  await agent.destroy("test");
-});
-
-test("XingyunAvatarAgent fails closed when MediaRecorder reports an asynchronous error", async () => {
-  MockWebSocket.instances = [];
-  const errors = [];
-  let errorCallbackState;
-  const { agent } = createAgent({
-    onError: (error) => {
-      errors.push(error);
-      if (error.code === "MEDIA_RECORDER_ERROR") {
-        errorCallbackState = {
-          microphone: agent.microphone,
-          stopASRPromise: agent.stopASRPromise,
-        };
-      }
-    },
-  }, { audio: { inputEnabled: true } });
-  await agent.init();
-  const ws = MockWebSocket.instances[0];
-  let releaseStop;
-  const microphone = {
-    isRecording: true,
-    stopCalls: 0,
-    stop() {
-      this.stopCalls += 1;
-      agent.sendAudioFrame({ data: new Blob(["final-opus"]), timestamp: Date.now() });
-      return new Promise((resolve) => {
-        releaseStop = resolve;
-      });
-    },
-  };
-  agent.microphone = microphone;
-  const recorderError = new Error("encoder failed");
-  recorderError.name = "MediaRecorderError";
-
-  agent.handleMicrophoneError(microphone, recorderError);
-
-  assert.equal(agent.getASRState(), "failed");
-  assert.equal(agent.microphone, null);
-  assert.equal(microphone.stopCalls, 1);
-  assert.notEqual(agent.stopASRPromise, null);
-  assert.equal(errorCallbackState.microphone, null);
-  assert.notEqual(errorCallbackState.stopASRPromise, null);
-  assert.equal(errors.at(-1).domain, "asr");
-  assert.equal(errors.at(-1).code, "MEDIA_RECORDER_ERROR");
-  assert.equal(ws.sent.filter((payload) => typeof payload === "string").length, 0);
-
-  releaseStop();
-  await agent.stopASRPromise;
-  const audioInputOffMessages = ws.sent
-    .filter((payload) => typeof payload === "string")
-    .map((payload) => JSON.parse(payload))
-    .filter((payload) => payload.message === "audio_input_off");
-  assert.equal(audioInputOffMessages.length, 1);
-  assert.deepEqual(audioInputOffMessages[0], { type: "event", message: "audio_input_off" });
-  assert.equal(ws.sent[0] instanceof Blob, true);
-  assert.equal(await ws.sent[0].text(), "final-opus");
-  assert.equal(JSON.parse(ws.sent[1]).message, "audio_input_off");
-  await agent.destroy("test");
-});
-
-test("XingyunAvatarAgent uploads raw WebM Opus when dual audio is disabled", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser();
-  const { agent } = createAgent();
-
-  try {
-    await agent.init();
-    const ws = MockWebSocket.instances[0];
-
-    await agent.startASR();
-    assert.equal(agent.audioCaptureRestartCalls, 0);
-    const firstFragment = new Blob(["webm-header-and-cluster-prefix"], { type: "audio/webm;codecs=opus" });
-    const secondFragment = new Blob(["cluster-tail-and-opus-payload"], { type: "audio/webm;codecs=opus" });
-    browser.recorders[0].ondataavailable?.({ data: firstFragment, timecode: 0 });
-    browser.recorders[0].ondataavailable?.({ data: secondFragment, timecode: 100 });
-    await agent.stopASR();
-
-    const controlMessages = ws.sent
-      .filter((payload) => typeof payload === "string")
-      .map((payload) => JSON.parse(payload));
-    const audioFrames = ws.sent.filter((payload) => payload instanceof Blob);
-    assert.equal(audioFrames.length, 3);
-    assert.deepEqual(
-      await Promise.all(audioFrames.map((frame) => frame.text())),
-      ["webm-header-and-cluster-prefix", "cluster-tail-and-opus-payload", "opus-final"],
-    );
-    assert.deepEqual(controlMessages, [
-      { type: "event", message: "audio_input_on" },
-      { type: "event", message: "audio_input_off" },
-    ]);
-    assert.equal(controlMessages.some((payload) => payload.message === "audio_start"), false);
-    assert.equal(controlMessages.some((payload) => payload.message === "voice_end"), false);
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent enables its default-off audio input before uploading and disables it after stop", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser();
-  const { agent } = createAgent();
-
-  try {
-    await agent.init();
-    const ws = MockWebSocket.instances[0];
-    assert.match(ws.url, /[?&]audio_input_off=1(?:&|$)/);
-
-    await agent.startASR();
-    browser.recorders[0].ondataavailable?.({
-      data: new Blob(["opus"], { type: "audio/webm;codecs=opus" }),
-      timecode: 0,
-    });
-    await agent.stopASR();
-
-    const messages = ws.sent.map((payload) => (
-      typeof payload === "string" ? JSON.parse(payload).message : "binary"
-    ));
-    assert.deepEqual(messages, ["audio_input_on", "binary", "binary", "audio_input_off"]);
-    assert.equal(messages.includes("voice_end"), false);
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent reports a capability error when WebM Opus is unavailable", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser({ webmOpus: false });
-  const errors = [];
-  const { agent } = createAgent({ onError: (error) => errors.push(error) });
-
-  try {
-    await agent.init();
-    await assert.rejects(agent.startASR(), /当前浏览器不支持 audio\/webm;codecs=opus/);
-    assert.equal(errors.at(-1).domain, "sdk");
-    assert.equal(errors.at(-1).code, "AUDIO_WEBM_OPUS_UNSUPPORTED");
-    assert.equal(browser.getUserMediaCalls.length, 0);
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent distinguishes an unavailable fixed audio transform from WebM Opus support", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser({ trackTransform: false, webAudio: false });
-  const errors = [];
-  const { agent } = createAgent({ onError: (error) => errors.push(error) });
-
-  try {
-    await agent.init();
-    await assert.rejects(agent.startASR(), /当前浏览器不支持 16 kHz mono 音频处理/);
-    assert.equal(errors.at(-1).domain, "sdk");
-    assert.equal(errors.at(-1).code, "AUDIO_FIXED_TRACK_UNSUPPORTED");
-    assert.equal(errors.at(-1).retryable, false);
-    assert.equal(browser.getUserMediaCalls.length, 1);
-    assert.equal(browser.recorders.length, 0);
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent normalizes a MediaRecorder constructor capability failure", async () => {
-  MockWebSocket.instances = [];
-  const nativeError = new Error("constructor rejected mime type");
-  nativeError.name = "NotSupportedError";
-  const browser = installMicrophoneBrowser({ mediaRecorderConstructorError: nativeError });
-  const errors = [];
-  const { agent } = createAgent({ onError: (error) => errors.push(error) });
-
-  try {
-    await agent.init();
-    await assert.rejects(agent.startASR(), /当前浏览器不支持 audio\/webm;codecs=opus/);
-    assert.equal(errors.at(-1).domain, "sdk");
-    assert.equal(errors.at(-1).code, "AUDIO_WEBM_OPUS_UNSUPPORTED");
-    assert.equal(errors.at(-1).retryable, false);
-    assert.equal(browser.tracks[0].stopCalls, 1);
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent restores a default-off audio input when ASR start fails", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser({ webmOpus: false });
-  const { agent } = createAgent({}, { audio: { inputEnabled: false } });
-
-  try {
-    await agent.init();
-    const ws = MockWebSocket.instances[0];
-
-    await assert.rejects(agent.startASR(), /当前浏览器不支持 audio\/webm;codecs=opus/);
-    const messages = ws.sent.map((payload) => JSON.parse(payload).message);
-    assert.deepEqual(messages, ["audio_input_on", "audio_input_off"]);
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent handles frozen E2E downlink events", async () => {
-  MockWebSocket.instances = [];
-  const asrResults = [];
-  const conversations = [];
-  const speakStates = [];
-  const errors = [];
-  const llmResponses = [];
-  const semanticResults = [];
-  const { agent } = createAgent({
-    onASRResult: (result) => asrResults.push(result),
-    onConversationChange: (event) => conversations.push(event),
-    onSpeakStateChange: (event) => speakStates.push(event),
-    onLLMResponse: (response) => llmResponses.push(response),
-    onSemanticJudgeResult: (result) => semanticResults.push(result),
-    onError: (error) => errors.push(error),
-  });
-
-  await agent.init();
-  const ws = MockWebSocket.instances[0];
-  const microphone = {
-    isRecording: true,
-    stopCalls: 0,
-    async stop() {
-      this.stopCalls += 1;
-    },
-  };
-  agent.microphone = microphone;
-
-  ws.emit({ type: "asr_result", text: "你好", is_final: false });
-  ws.emit({ type: "asr_result", text: "你好世界", is_final: true });
-  ws.emit({ type: "llm_response", event: "chunk", text: "今天", is_first: true });
-  ws.emit({
-    type: "llm_response",
-    event: "done",
-    usage: {
-      prompt_tokens: 150,
-      completion_tokens: 80,
-      total_tokens: 230,
-      cached_tokens: 10,
-    },
-  });
-  ws.emit({
-    type: "semantic_judge_round_result",
-    message: { query: "今天天气怎么样", meaningful: true, action: "release" },
-  });
-  ws.emit({ type: "speak_state_change", state: "ignored" });
-  agent.avatarOptions.onSpeakStateChange("speak_start", "speak-1");
-  agent.avatarOptions.onSpeakStateChange("speak_end", "speak-1");
-  ws.emit({ type: "error", domain: "asr", code: 5101, message: "ASR initialization failed" });
-  await agent.stopASRPromise;
-
-  assert.deepEqual(asrResults.map(({ text, isFinal }) => ({ text, isFinal })), [
-    { text: "你好", isFinal: false },
-    { text: "你好世界", isFinal: true },
-  ]);
-  assert.deepEqual(conversations, [{ state: "speaking" }, { state: "completed" }, { state: "failed" }]);
-  assert.deepEqual(speakStates, [
-    { state: "speak_start", clientSpeakId: "speak-1" },
-    { state: "speak_end", clientSpeakId: "speak-1" },
-  ]);
-  assert.deepEqual(llmResponses.map(({ raw, ...response }) => response), [
-    { event: "chunk", text: "今天", isFirst: true },
-    {
-      event: "done",
-      usage: { promptTokens: 150, completionTokens: 80, totalTokens: 230, cachedTokens: 10 },
-    },
-  ]);
-  assert.deepEqual(semanticResults.map(({ raw, ...result }) => result), [
-    { query: "今天天气怎么样", meaningful: true, action: "release" },
-  ]);
-  assert.deepEqual({ domain: errors[0].domain, code: errors[0].code, message: errors[0].message }, {
-    domain: "asr",
-    code: "5101",
-    message: "ASR initialization failed",
-  });
-  assert.equal(errors[0].retryable, true);
-  assert.equal(microphone.stopCalls, 1);
-  assert.equal(agent.microphone, null);
-  assert.equal(agent.getASRState(), "failed");
-  await agent.destroy("test");
-});
-
-test("XingyunAvatarAgent does not reconnect terminal WebSocket close codes", async () => {
-  for (const code of [1000, 4000, 4001, 4002, 4009, 4010]) {
-    MockWebSocket.instances = [];
-    const errors = [];
-    const { agent } = createAgent({ onError: (error) => errors.push(error) }, {
-      reconnect: { initialDelayMs: 0, maxDelayMs: 0 },
-    });
-    await agent.init();
-    const ws = MockWebSocket.instances[0];
-
-    ws.closeRemote(code, code === 1000 ? "normal" : "");
-
-    assert.equal(agent.getAgentState(), "failed");
-    assert.deepEqual(errors.map((error) => error.code), [`E2E_CLOSE_${code}`]);
-    assert.equal(MockWebSocket.instances.length, 1);
-    if (code === 4009) {
-      assert.equal(errors[0].domain, "quota");
-      assert.equal(errors[0].retryable, false);
-    }
-    await agent.destroy("test");
-  }
-});
-
-test("XingyunAvatarAgent reconnects an abnormal E2E close and leaves ASR stopped", async () => {
-  MockWebSocket.instances = [];
-  MockWebSocket.failedConnections = 0;
-  const states = [];
-  const errors = [];
-  const { agent } = createAgent({
-    onAgentStateChange: (state) => states.push(state),
-    onError: (error) => errors.push(error),
-  }, {
-    reconnect: { initialDelayMs: 0, maxDelayMs: 0, maxAttempts: 2 },
-  });
-  await agent.init();
-  const ws = MockWebSocket.instances[0];
-  const microphone = {
-    isRecording: true,
-    stopCalls: 0,
-    async stop() {
-      this.stopCalls += 1;
-    },
-  };
-  agent.microphone = microphone;
-
-  ws.closeRemote(1006);
-  await agent.stopASRPromise;
-  await waitFor(() => MockWebSocket.instances.length === 2 && agent.getAgentState() === "running");
-
-  assert.deepEqual(states.slice(-2), ["reconnecting", "running"]);
-  assert.deepEqual(errors.map((error) => error.code), ["E2E_RECONNECTING"]);
-  assert.equal(agent.getASRState(), "idle");
-  assert.equal(microphone.stopCalls, 1);
-  assert.equal(agent.microphone, null);
-  assert.match(MockWebSocket.instances[1].url, /audio_input_off=1/);
-  assert.equal(ws.sent.length, 0);
-  await agent.destroy("test");
-});
-
-test("XingyunAvatarAgent falls back to a fresh unified session after E2E retries are exhausted", async () => {
-  MockWebSocket.instances = [];
-  MockWebSocket.failedConnections = 0;
-  const states = [];
-  const { agent } = createAgent({
-    onAgentStateChange: (state) => states.push(state),
-  }, {
-    reconnect: { initialDelayMs: 0, maxDelayMs: 0, maxAttempts: 2 },
-  });
-  agent.reloadSessionInfo = {
-    session_id: "fresh-session",
-    room: "fresh-room",
-    token: "fresh-ttsa-token",
-    socket_io_url: "wss://gateway.example.com/fresh",
-    e2e_resp: {
-      ws_url: "wss://e2e.example.com/ws/session?session_id=fresh-session",
-      e2e_token: "fresh-e2e-token",
-    },
-  };
-
-  await agent.init();
-  MockWebSocket.failedConnections = 2;
-  MockWebSocket.instances[0].closeRemote(1006);
-
-  await waitFor(() => agent.restartReasons.length === 1 && agent.getAgentState() === "running");
-  assert.deepEqual(agent.restartReasons, ["e2e_reconnect_exhausted"]);
-  assert.equal(agent.reloadSuccessCalls, 1);
-  assert.match(MockWebSocket.instances.at(-1).url, /session_id=fresh-session/);
-  assert.match(MockWebSocket.instances.at(-1).url, /token=fresh-e2e-token/);
-  assert.deepEqual(states.slice(-2), ["reconnecting", "running"]);
-  await agent.destroy("test");
-});
-
-test("XingyunAvatarAgent waits for TTSA before completing a unified session reconnect", async () => {
-  MockWebSocket.instances = [];
-  MockWebSocket.failedConnections = 0;
-  const { agent } = createAgent({}, {
-    reconnect: { initialDelayMs: 0, maxDelayMs: 0, maxAttempts: 2 },
-  });
-  await agent.init();
-
-  await agent.onSessionReloaded({
-    e2e_resp: {
-      ws_url: "wss://e2e.example.com/ws/session?session_id=fresh-session",
-      e2e_token: "fresh-e2e-token",
-    },
-  });
-  assert.equal(agent.getAgentState(), "reconnecting");
-  agent.reloadSuccess();
-  assert.equal(agent.getAgentState(), "reconnecting");
-  agent.started = false;
-  agent.onTtsaReady();
-  assert.equal(agent.started, true);
-  assert.equal(agent.getAgentState(), "running");
-  await agent.destroy("test");
-});
-
-test("XingyunAvatarAgent preserves a stopped state after a unified session reconnect", async () => {
-  MockWebSocket.instances = [];
-  MockWebSocket.failedConnections = 0;
-  const { agent } = createAgent({}, {
-    reconnect: { initialDelayMs: 0, maxDelayMs: 0, maxAttempts: 2 },
-  });
-  agent.reloadSessionInfo = {
-    session_id: "fresh-session",
-    room: "fresh-room",
-    token: "fresh-ttsa-token",
-    socket_io_url: "wss://gateway.example.com/fresh",
-    e2e_resp: {
-      ws_url: "wss://e2e.example.com/ws/session?session_id=fresh-session",
-      e2e_token: "fresh-e2e-token",
-    },
-  };
-
-  await agent.init();
-  await agent.stop();
-  agent.started = false;
-  MockWebSocket.failedConnections = 2;
-  MockWebSocket.instances[0].closeRemote(1006);
-
-  await waitFor(() => agent.restartReasons.length === 1 && agent.getAgentState() === "stopped");
-  assert.equal(agent.started, false);
-  await agent.destroy("test");
-});
-
-test("XingyunAvatarAgent cancels a scheduled reconnect when destroyed", async () => {
-  MockWebSocket.instances = [];
-  MockWebSocket.failedConnections = 0;
-  const { agent } = createAgent({}, {
-    reconnect: { initialDelayMs: 50, maxDelayMs: 50, maxAttempts: 2 },
-  });
-  await agent.init();
-
-  MockWebSocket.instances[0].closeRemote(1006);
-  await agent.destroy("test");
-  await new Promise((resolve) => setTimeout(resolve, 70));
-
-  assert.equal(agent.getAgentState(), "destroyed");
-  assert.equal(MockWebSocket.instances.length, 1);
-});
-
-test("XingyunAvatarAgent cancels a pending unified session restart when destroyed", async () => {
-  MockWebSocket.instances = [];
-  MockWebSocket.failedConnections = 0;
-  const { agent } = createAgent({}, {
-    reconnect: { initialDelayMs: 0, maxDelayMs: 0, maxAttempts: 1 },
-  });
-  agent.reloadSessionInfo = {
-    e2e_resp: {
-      ws_url: "wss://e2e.example.com/ws/session?session_id=late-session",
-      e2e_token: "late-e2e-token",
-    },
-  };
-  agent.restartDelayMs = 50;
-  await agent.init();
-
-  MockWebSocket.failedConnections = 1;
-  MockWebSocket.instances[0].closeRemote(1006);
-  await waitFor(() => agent.restartReasons.length === 1);
-  await agent.destroy("test");
-  await new Promise((resolve) => setTimeout(resolve, 70));
-
-  assert.equal(agent.getAgentState(), "destroyed");
-  assert.equal(MockWebSocket.instances.length, 2);
-});
-
-test("XingyunAvatarAgent rejects a pending microphone start after an abnormal WebSocket close", async () => {
-  MockWebSocket.instances = [];
-  let resolveStream;
-  const browser = installMicrophoneBrowser({
-    getUserMedia: (_constraints, createStream) => new Promise((resolve) => {
-      resolveStream = () => resolve(createStream());
-    }),
-  });
-  const { agent } = createAgent();
-
-  try {
-    await agent.init();
-    const ws = MockWebSocket.instances[0];
-    const startPromise = agent.startASR();
-    await Promise.resolve();
-
-    ws.closeRemote(1006);
-    resolveStream();
-
-    await assert.rejects(startPromise, /E2E WebSocket|Agent 尚未启动/);
-    await waitFor(() => agent.getAgentState() === "running");
-    assert.equal(agent.getASRState(), "idle");
-    assert.equal(browser.tracks[0].stopCalls, 1);
-    assert.equal(agent.microphone, null);
-    assert.deepEqual(ws.sent.map((payload) => JSON.parse(payload)), [
-      { type: "event", message: "audio_input_on" },
-    ]);
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("MicrophoneController uses WebM Opus and flushes its final Blob before stop resolves", async () => {
-  const browser = installMicrophoneBrowser({ sampleRate: 48000 });
-  const metadata = [];
-  const frames = [];
-  const audioBlocks = [];
-  const microphone = new MicrophoneController({
-    onMetadata: (value) => metadata.push(value),
-    onFrame: (frame, timestamp) => {
-      frames.push(frame);
-      audioBlocks.push({ data: frame, timestamp });
-    },
-  });
-
-  try {
-    await microphone.start();
-    assert.equal(browser.recorders.length, 1);
-    assert.equal(browser.recorders[0].timeslice, 100);
-    assert.deepEqual(browser.recorders[0].options, {
-      mimeType: "audio/webm;codecs=opus",
-      audioBitsPerSecond: 24000,
-    });
-    assert.equal(browser.generators.length, 1);
-    assert.equal(browser.recorders[0].stream.getAudioTracks()[0], browser.generators[0]);
-    assert.deepEqual(browser.recorders[0].stream.getAudioTracks()[0].getSettings(), {
-      sampleRate: 16000,
-      channelCount: 1,
-    });
-    assert.deepEqual(metadata, [{
-      format: "webm_opus",
-      mimeType: "audio/webm;codecs=opus",
-      sampleRate: 16000,
-      channels: 1,
-      chunkMs: 100,
-    }]);
-
-    await microphone.stop();
-    assert.equal(frames.length, 1);
-    assert.equal(frames[0] instanceof Blob, true);
-    assert.equal(audioBlocks[0].data, frames[0]);
-    assert.equal(Number.isFinite(audioBlocks[0].timestamp), true);
-    assert.equal(browser.tracks[0].stopCalls, 1);
-    assert.equal(browser.generators[0].writableClosed, true);
-  } finally {
-    await microphone.stop();
-    browser.restore();
-  }
-});
-
-test("MicrophoneController normalizes Safari second-based timecodes to 100ms timestamps", async () => {
-  const browser = installMicrophoneBrowser();
-  const timestamps = [];
-  const microphone = new MicrophoneController({
-    onFrame: (_frame, timestamp) => timestamps.push(timestamp),
-  });
-
-  try {
-    await microphone.start();
-    const recorder = browser.recorders[0];
-    recorder.ondataavailable?.({ data: new Blob(["a"]), timecode: 12.5 });
-    recorder.ondataavailable?.({ data: new Blob(["b"]), timecode: 12.6 });
-    recorder.ondataavailable?.({ data: new Blob(["c"]), timecode: 12.7 });
-
-    const firstTimestamp = timestamps[0];
-    assert.deepEqual(
-      timestamps.map((timestamp) => Math.round(timestamp - firstTimestamp)),
-      [0, 100, 200],
-    );
-  } finally {
-    await microphone.stop();
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent rejects non-100ms AU chunks before requesting permission", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser();
-  const errors = [];
-  const { agent } = createAgent(
-    { onError: (error) => errors.push(error) },
-    { audio: { chunkMs: 200, echoCancellationEnabled: true } },
-  );
-
-  try {
-    await agent.init();
-    await assert.rejects(
-      agent.startASR(),
-      (error) => error.agentCode === "AUDIO_CHUNK_DURATION_UNSUPPORTED",
-    );
-    assert.equal(browser.getUserMediaCalls.length, 0);
-    assert.equal(errors[0].code, "AUDIO_CHUNK_DURATION_UNSUPPORTED");
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent uses PCM WebCodecs instead of MediaRecorder for dual-audio nearend", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser({ webmOpus: false });
-  const { agent } = createAgent({}, {
-    audio: { echoCancellationEnabled: true },
-  });
-
-  try {
-    await agent.init();
-    await agent.startASR();
-
-    assert.equal(browser.recorders.length, 0);
-    assert.equal(browser.audioEncoders.length, 1);
-    assert.equal(browser.audioWorkletNodes.length, 1);
-    browser.audioWorkletNodes[0].emitPcm(0);
-    browser.audioWorkletNodes[0].emitPcm(1);
-    browser.audioWorkletNodes[0].emitPcm(2);
-    browser.audioWorkletNodes[0].emitPcm(3);
-
-    const ws = MockWebSocket.instances[0];
-    await waitFor(() => ws.sent.filter((payload) => payload instanceof ArrayBuffer).length >= 2);
-    const auFrames = ws.sent.filter((payload) => payload instanceof ArrayBuffer);
-    const bytes = new Uint8Array(auFrames[0]);
-    assert.equal(bytes[3], AU_STREAM_NEAREND);
-    assert.deepEqual([...bytes.slice(8, 12)], [0x1a, 0x45, 0xdf, 0xa3]);
-    const firstTimestamp = new DataView(auFrames[0]).getUint32(4, false);
-    const secondTimestamp = new DataView(auFrames[1]).getUint32(4, false);
-    assert.equal(secondTimestamp - firstTimestamp, 100);
-    await agent.stopASR();
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("XingyunAvatarAgent fails before microphone permission when dual-audio WebCodecs Opus is unavailable", async () => {
-  MockWebSocket.instances = [];
-  const browser = installMicrophoneBrowser({ webCodecsOpus: false });
-  const errors = [];
-  const { agent } = createAgent(
-    { onError: (error) => errors.push(error) },
-    { audio: { echoCancellationEnabled: true } },
-  );
-
-  try {
-    await agent.init();
-    await assert.rejects(
-      agent.startASR(),
-      (error) => error.agentCode === "AUDIO_WEBCODECS_OPUS_UNSUPPORTED",
-    );
-    assert.equal(browser.getUserMediaCalls.length, 0);
-    assert.equal(browser.recorders.length, 0);
-    assert.equal(errors.at(-1).code, "AUDIO_WEBCODECS_OPUS_UNSUPPORTED");
-  } finally {
-    await agent.destroy("test");
-    browser.restore();
-  }
-});
-
-test("PcmWebMEncoder preserves every 20ms WebCodecs Opus packet as a WebM block", async () => {
-  const browser = installMicrophoneBrowser({
-    encodedChunkDurations: [20000, 20000, 20000, 20000, 20000],
-  });
-  const encoder = new PcmWebMEncoder();
-
-  try {
-    await encoder.init();
-    const webm = new Uint8Array(await encoder.encode(new Int16Array(1600).fill(1)));
-    let clusterCount = 0;
-    for (let index = 0; index <= webm.length - 4; index += 1) {
-      if (
-        webm[index] === 0x1f
-        && webm[index + 1] === 0x43
-        && webm[index + 2] === 0xb6
-        && webm[index + 3] === 0x75
-      ) {
-        clusterCount += 1;
-      }
-    }
-    assert.equal(clusterCount, 5);
-  } finally {
-    await encoder.destroy();
-    browser.restore();
-  }
-});
-
-test("PcmWebMEncoder emits a standards-compliant WebM Opus track header", async () => {
-  const browser = installMicrophoneBrowser();
-  const encoder = new PcmWebMEncoder();
-  const includesBytes = (data, expected) => {
-    for (let offset = 0; offset <= data.length - expected.length; offset += 1) {
-      if (expected.every((byte, index) => data[offset + index] === byte)) {
-        return true;
-      }
-    }
-    return false;
-  };
-
-  try {
-    await encoder.init();
-    const webm = new Uint8Array(await encoder.encode(new Int16Array(1600).fill(1)));
-
-    assert.equal(
-      includesBytes(webm, [0x42, 0x87, 0x81, 0x04]),
-      true,
-      "Opus WebM must declare DocTypeVersion 4",
-    );
-    assert.equal(
-      includesBytes(webm, [0x83, 0x81, 0x02]),
-      true,
-      "TrackEntry must declare TrackType 2 (audio)",
-    );
-    assert.equal(
-      includesBytes(webm, [0xa3, 0x87, 0x81, 0x00, 0x00, 0x80]),
-      true,
-      "Opus SimpleBlock must be marked as a key block",
-    );
-  } finally {
-    await encoder.destroy();
-    browser.restore();
-  }
-});
-
-test("PcmWebMEncoder pins Opus packets to 20ms inside each 100ms AU payload", async () => {
-  const browser = installMicrophoneBrowser();
-  const encoder = new PcmWebMEncoder();
-
-  try {
-    await encoder.init();
-    const webm = new Uint8Array(await encoder.encode(new Int16Array(1600).fill(1)));
-    let clusterCount = 0;
-    for (let index = 0; index <= webm.length - 4; index += 1) {
-      if (
-        webm[index] === 0x1f
-        && webm[index + 1] === 0x43
-        && webm[index + 2] === 0xb6
-        && webm[index + 3] === 0x75
-      ) {
-        clusterCount += 1;
-      }
-    }
-
-    assert.equal(browser.audioEncoders[0].config.opus.format, "opus");
-    assert.equal(browser.audioEncoders[0].config.opus.frameDuration, 20000);
-    assert.equal(clusterCount, 5);
-  } finally {
-    await encoder.destroy();
-    browser.restore();
-  }
-});
-
-test("PcmWebMEncoder keeps Opus continuous and flushes only when destroyed", async () => {
-  const browser = installMicrophoneBrowser({
-    flushEncodedChunkDurations: [20000],
-  });
-  const encoder = new PcmWebMEncoder();
-
-  try {
-    await encoder.init();
-    const webm = new Uint8Array(await encoder.encode(new Int16Array(1600).fill(1)));
-    let clusterCount = 0;
-    for (let index = 0; index <= webm.length - 4; index += 1) {
-      if (
-        webm[index] === 0x1f
-        && webm[index + 1] === 0x43
-        && webm[index + 2] === 0xb6
-        && webm[index + 3] === 0x75
-      ) {
-        clusterCount += 1;
-      }
-    }
-
-    assert.equal(clusterCount, 5);
-    assert.equal(browser.audioEncoders[0].flushCalls, 0);
-  } finally {
-    await encoder.destroy();
-    assert.equal(browser.audioEncoders[0].flushCalls, 1);
-    browser.restore();
-  }
-});
-
-test("PcmWebMEncoder starts a fresh Opus and WebM stream after reset", async () => {
-  const browser = installMicrophoneBrowser();
-  const encoder = new PcmWebMEncoder();
-
-  try {
-    await encoder.init();
-    await encoder.encode(new Int16Array(1600).fill(1));
-    encoder.reset();
-    const webm = new Uint8Array(await encoder.encode(new Int16Array(1600).fill(2)));
-
-    assert.equal(browser.audioEncoders.length, 2);
-    assert.equal(browser.audioEncoders[0].closed, true);
-    assert.deepEqual([...webm.subarray(0, 4)], [0x1a, 0x45, 0xdf, 0xa3]);
-  } finally {
-    await encoder.destroy();
-    browser.restore();
-  }
-});
-
-test("PcmWebMEncoder rejects browsers that ignore the 20ms Opus extension", async () => {
-  const browser = installMicrophoneBrowser({ webCodecsPreservesOpusConfig: false });
-
-  try {
-    assert.equal(await PcmWebMEncoder.isSupported(), false);
-  } finally {
-    browser.restore();
-  }
-});
-
-test("PcmWebMEncoder rejects non-20ms Opus packets at runtime", async () => {
-  const browser = installMicrophoneBrowser({ encodedChunkDurations: [100000] });
-  const encoder = new PcmWebMEncoder();
-
-  try {
-    await encoder.init();
-    await assert.rejects(
-      encoder.encode(new Int16Array(1600).fill(1)),
-      /WebCodecs Opus 未按 20ms 分包/,
-    );
-  } finally {
-    await encoder.destroy();
-    browser.restore();
-  }
-});
-
-test("MicrophoneController keeps custom chunk duration for raw nearend uploads", async () => {
-  const browser = installMicrophoneBrowser();
-  const microphone = new MicrophoneController({
-    audio: { chunkMs: 200 },
-    onFrame() {},
-  });
-
-  try {
-    await microphone.start();
-    assert.equal(browser.recorders[0].timeslice, 200);
-  } finally {
-    await microphone.stop();
-    browser.restore();
-  }
-});
-
-test("MicrophoneController resamples continuous input to 16 kHz mono before MediaRecorder", async () => {
-  const browser = installMicrophoneBrowser({
-    sampleRate: 48000,
-    audioDataFrames: [
-      {
-        sampleRate: 48000,
-        numberOfFrames: 480,
-        numberOfChannels: 2,
-        timestamp: 123,
-        data: [new Float32Array(480).fill(1), new Float32Array(480).fill(0)],
-      },
-      {
-        sampleRate: 48000,
-        numberOfFrames: 480,
-        numberOfChannels: 2,
-        timestamp: 10123,
-        data: [new Float32Array(480).fill(1), new Float32Array(480).fill(0)],
-      },
-    ],
-  });
-  const microphone = new MicrophoneController({ onFrame() {} });
-
-  try {
-    await microphone.start();
-    await microphone.stop();
-
-    assert.equal(browser.generators.length, 1);
-    assert.equal(browser.generators[0].written.length, 1);
-    assert.equal(browser.generators[0].written[0].sampleRate, 16000);
-    assert.equal(browser.generators[0].written[0].numberOfChannels, 1);
-    assert.equal(browser.generators[0].written[0].numberOfFrames, 320);
-    assert.equal(browser.generators[0].written[0].data[0], 0.5);
-  } finally {
-    await microphone.stop();
-    browser.restore();
-  }
-});
-
-test("MicrophoneController releases tracks when MediaRecorder never dispatches stop", async () => {
-  const microphone = new MicrophoneController({ onFrame() {} });
-  const track = {
-    stopCalls: 0,
-    stop() {
-      this.stopCalls += 1;
-    },
-  };
-  microphone.stream = {
-    getTracks: () => [track],
-  };
-  const recorder = {
-    state: "recording",
-    ondataavailable: () => {},
-    onerror: null,
-    onstop: null,
-    stop() {},
-  };
-  microphone.mediaRecorder = recorder;
-
-  const startedAt = Date.now();
-  await microphone.stop();
-
-  assert.equal(track.stopCalls, 1);
-  assert.equal(microphone.isRecording, false);
-  assert.equal(recorder.ondataavailable, null);
-  assert.ok(Date.now() - startedAt < 1500);
-});
-
-test("MicrophoneController waits for the final Blob when an errored recorder is already inactive", async () => {
-  const events = [];
-  const microphone = new MicrophoneController({
-    onFrame: () => events.push("blob"),
-  });
-  const track = { stop: () => events.push("track-stop") };
-  const recorder = {
-    state: "inactive",
-    ondataavailable: (event) => microphone.options.onFrame(event.data),
-    onerror: null,
-    onstop: null,
-    stopCalls: 0,
-    stop() {
-      this.stopCalls += 1;
-    },
-  };
-  microphone.stream = { getTracks: () => [track] };
-  microphone.mediaRecorder = recorder;
-
-  const stopPromise = microphone.stop().then(() => events.push("stop-resolved"));
-  queueMicrotask(() => {
-    recorder.ondataavailable?.({ data: new Blob(["final-opus"]) });
-    recorder.onstop?.({});
-  });
-  await stopPromise;
-
-  assert.equal(recorder.stopCalls, 0);
-  assert.deepEqual(events, ["blob", "track-stop", "stop-resolved"]);
-});
-
-test("MicrophoneController starts with browser audio constraints and releases its track", async () => {
-  const browser = installMicrophoneBrowser({ audioSession: "ambient" });
-  const metadata = [];
-  const microphone = new MicrophoneController({
-    onMetadata: (value) => metadata.push(value),
-    onFrame() {},
-  });
-
-  try {
-    await microphone.start();
-
-    assert.equal(microphone.isRecording, true);
-    assert.deepEqual(browser.getUserMediaCalls, [
-      {
-        audio: {
-          sampleRate: { ideal: 16000 },
-          channelCount: { ideal: 1 },
-          echoCancellation: true,
-          noiseSuppression: true,
-          autoGainControl: true,
-        },
-      },
-    ]);
-    assert.deepEqual(metadata, [microphone.getAudioMetadata()]);
-    assert.equal(browser.recorders.length, 1);
-    assert.equal(browser.recorders[0].options.mimeType, "audio/webm;codecs=opus");
-    assert.deepEqual(browser.audioSessionTypes, ["play-and-record"]);
-
-    await microphone.stop();
-
-    assert.equal(microphone.isRecording, false);
-    assert.equal(browser.tracks[0].stopCalls, 1);
-    assert.deepEqual(browser.audioSessionTypes, ["play-and-record", "playback"]);
-  } finally {
-    await microphone.stop();
-    browser.restore();
-  }
-});
-
-test("Web Audio session stays capture-safe until all microphone users stop", () => {
-  const audioSession = { type: "ambient" };
-  const browserNavigator = { audioSession };
-
-  assert.equal(configureWebAudioPlaybackSession(browserNavigator), true);
-  assert.equal(audioSession.type, "playback");
-  assert.equal(beginWebAudioCaptureSession(browserNavigator), true);
-  assert.equal(beginWebAudioCaptureSession(browserNavigator), true);
-  assert.equal(audioSession.type, "play-and-record");
-  assert.equal(configureWebAudioPlaybackSession(browserNavigator), true);
-  assert.equal(audioSession.type, "play-and-record");
-  assert.equal(endWebAudioCaptureSession(browserNavigator), true);
-  assert.equal(audioSession.type, "play-and-record");
-  assert.equal(endWebAudioCaptureSession(browserNavigator), true);
-  assert.equal(audioSession.type, "playback");
-  assert.equal(configureWebAudioPlaybackSession({}), false);
-});
-
-test("Web Audio playback route refresh waits for the final capture session", () => {
-  const audioSession = { type: "playback" };
-  const browserNavigator = { audioSession };
-  const restoredTypes = [];
-  const unsubscribe = subscribeWebAudioPlaybackSessionRestored(
-    () => restoredTypes.push(audioSession.type),
-    browserNavigator,
-  );
-
-  beginWebAudioCaptureSession(browserNavigator);
-  beginWebAudioCaptureSession(browserNavigator);
-  endWebAudioCaptureSession(browserNavigator);
-  assert.deepEqual(restoredTypes, []);
-
-  endWebAudioCaptureSession(browserNavigator);
-  assert.deepEqual(restoredTypes, ["playback"]);
-
-  unsubscribe();
-  beginWebAudioCaptureSession(browserNavigator);
-  endWebAudioCaptureSession(browserNavigator);
-  assert.deepEqual(restoredTypes, ["playback"]);
-});
-
-test("Web Audio playback restoration listeners cannot break capture cleanup", () => {
-  const audioSession = { type: "playback" };
-  const browserNavigator = { audioSession };
-  const unsubscribe = subscribeWebAudioPlaybackSessionRestored(() => {
-    throw new Error("route refresh failed");
-  }, browserNavigator);
-
-  beginWebAudioCaptureSession(browserNavigator);
-  assert.equal(endWebAudioCaptureSession(browserNavigator), true);
-  assert.equal(audioSession.type, "playback");
-  unsubscribe();
-});
-
-test("Web Audio playback route is not refreshed for a pre-existing capture session", () => {
-  const audioSession = { type: "play-and-record" };
-  const browserNavigator = { audioSession };
-  let restoreCalls = 0;
-  const unsubscribe = subscribeWebAudioPlaybackSessionRestored(
-    () => {
-      restoreCalls += 1;
-    },
-    browserNavigator,
-  );
-
-  beginWebAudioCaptureSession(browserNavigator);
-  endWebAudioCaptureSession(browserNavigator);
-
-  assert.equal(audioSession.type, "play-and-record");
-  assert.equal(restoreCalls, 0);
-  unsubscribe();
-});
-
-test("PCMAudioPlayer reconnects a running graph when playback routing is restored", () => {
-  const hadWindow = "window" in globalThis;
-  const previousWindow = globalThis.window;
-  globalThis.window = { avatarSDKLogger: { log() {}, warn() {} } };
-  const destination = {};
-  const connections = [];
-  const node = {
-    disconnectCalls: 0,
-    disconnect() {
-      this.disconnectCalls += 1;
-    },
-    connect(target) {
-      connections.push(target);
-    },
-  };
-  const player = new PCMAudioPlayer();
-  player.isInitialized = true;
-  player.isPlaying = true;
-  player.audioCtx = { state: "running", destination };
-  player.audioWorkletNode = node;
-
-  try {
-    assert.equal(player.refreshPlaybackRoute(), true);
-    assert.equal(node.disconnectCalls, 1);
-    assert.deepEqual(connections, [destination]);
-  } finally {
-    if (hadWindow) {
-      globalThis.window = previousWindow;
-    } else {
-      delete globalThis.window;
-    }
-  }
-});
-
-test("MicrophoneController restores playback session when audio drain fails", async () => {
-  const browser = installMicrophoneBrowser({ audioSession: "ambient" });
-  const microphone = new MicrophoneController({ onFrame() {} });
-  const drainError = new Error("drain failed");
-
-  try {
-    microphone.hasAudioSessionCapture = beginWebAudioCaptureSession();
-    microphone.audioTransformer = {
-      async drain() {
-        throw drainError;
-      },
-      async stop() {},
-    };
-
-    await assert.rejects(microphone.stop(), (error) => error === drainError);
-    assert.equal(browser.audioSession.type, "playback");
-  } finally {
-    await microphone.stop();
-    browser.restore();
-  }
-});
-
-test("MicrophoneController preserves permission rejection and reports it through onError", async () => {
-  const permissionError = namedError("NotAllowedError", "Permission denied");
-  const browser = installMicrophoneBrowser({
-    getUserMedia: async () => {
-      throw permissionError;
-    },
-  });
-  const errors = [];
-  const microphone = new MicrophoneController({
-    onFrame() {},
-    onError: (error) => errors.push(error),
-  });
-
-  try {
-    await assert.rejects(microphone.start(), (error) => error === permissionError);
-    assert.deepEqual(errors, [permissionError]);
-    assert.equal(microphone.isRecording, false);
-  } finally {
-    await microphone.stop();
-    browser.restore();
-  }
-});
-
-test("MicrophoneController preserves the no-device error", async () => {
-  const noDeviceError = namedError("NotFoundError", "Requested device not found");
-  const browser = installMicrophoneBrowser({
-    getUserMedia: async () => {
-      throw noDeviceError;
-    },
-  });
-  const errors = [];
-  const microphone = new MicrophoneController({
-    onFrame() {},
-    onError: (error) => errors.push(error),
-  });
-
-  try {
-    await assert.rejects(microphone.start(), (error) => error === noDeviceError);
-    assert.deepEqual(errors, [noDeviceError]);
-    assert.equal(microphone.isRecording, false);
-  } finally {
-    await microphone.stop();
-    browser.restore();
-  }
-});
-
-test("MicrophoneController rejects browsers without getUserMedia", async () => {
-  const browser = installMicrophoneBrowser({ mediaDevices: false });
-  const microphone = new MicrophoneController({ onFrame() {} });
-
-  try {
-    await assert.rejects(microphone.start(), /当前浏览器不支持麦克风采集/);
-    assert.equal(microphone.isRecording, false);
-  } finally {
-    await microphone.stop();
-    browser.restore();
-  }
-});
-
-test("MicrophoneController rejects browsers without WebM Opus instead of falling back to PCM", async () => {
-  const browser = installMicrophoneBrowser({ webmOpus: false });
-  const microphone = new MicrophoneController({ onFrame() {} });
-
-  try {
-    await assert.rejects(microphone.start(), /当前浏览器不支持 audio\/webm;codecs=opus/);
-    assert.equal(microphone.isRecording, false);
-    assert.equal(browser.getUserMediaCalls.length, 0);
-    assert.equal(browser.recorders.length, 0);
-  } finally {
-    await microphone.stop();
-    browser.restore();
-  }
-});
-
-test("MicrophoneController falls back to Web Audio without track processor APIs", async () => {
-  const browser = installMicrophoneBrowser({ trackTransform: false });
-  const microphone = new MicrophoneController({ onFrame() {} });
-
-  try {
-    await microphone.start();
-
-    assert.equal(browser.audioContexts.length, 1);
-    assert.equal(browser.audioContexts[0].sampleRate, 16000);
-    assert.equal(browser.audioDestinations[0].channelCount, 1);
-    assert.equal(browser.audioDestinations[0].channelCountMode, "explicit");
-    assert.equal(browser.recorders[0].stream, browser.audioDestinations[0].stream);
-
-    await microphone.stop();
-
-    assert.equal(browser.tracks[0].stopCalls, 1);
-    assert.equal(browser.audioDestinations[0].stream.getAudioTracks()[0].stopCalls, 1);
-    assert.equal(browser.audioSources[0].disconnectCalls, 1);
-    assert.equal(browser.audioContexts[0].closeCalls, 1);
-  } finally {
-    await microphone.stop();
-    browser.restore();
-  }
-});
-
-test("MicrophoneController rejects a Web Audio fallback that cannot provide 16 kHz", async () => {
-  const browser = installMicrophoneBrowser({
-    trackTransform: false,
-    audioContextSampleRate: 48000,
-  });
-  const microphone = new MicrophoneController({ onFrame() {} });
-
-  try {
-    await assert.rejects(microphone.start(), /浏览器无法创建 16 kHz AudioContext/);
-    assert.equal(browser.recorders.length, 0);
-    assert.equal(browser.tracks[0].stopCalls, 1);
-    assert.equal(browser.audioContexts[0].closeCalls, 1);
-  } finally {
-    await microphone.stop();
-    browser.restore();
-  }
-});
-
-test("MicrophoneController closes a pending Web Audio fallback when stopped", async () => {
-  let releaseResume;
-  const resumeGate = new Promise((resolve) => {
-    releaseResume = resolve;
-  });
-  const browser = installMicrophoneBrowser({
-    trackTransform: false,
-    audioContextState: "suspended",
-    audioContextResume: () => resumeGate,
-  });
-  const microphone = new MicrophoneController({ onFrame() {} });
-
-  try {
-    const startPromise = microphone.start();
-    await Promise.resolve();
-    await Promise.resolve();
-    assert.equal(browser.audioContexts.length, 1);
-
-    await microphone.stop();
-    assert.equal(browser.audioContexts[0].closeCalls, 1);
-
-    releaseResume();
-    await assert.rejects(startPromise, (error) => error.agentCode === "AUDIO_FIXED_TRACK_CANCELLED");
-    assert.equal(browser.recorders.length, 0);
-    assert.equal(browser.tracks[0].stopCalls, 1);
-  } finally {
-    releaseResume?.();
-    await microphone.stop();
-    browser.restore();
-  }
-});
-
-test("MicrophoneController normalizes native Web Audio capability failures", async () => {
-  const nativeError = new Error("sample rate is unsupported");
-  nativeError.name = "NotSupportedError";
-  const browser = installMicrophoneBrowser({
-    trackTransform: false,
-    audioContextError: nativeError,
-  });
-  const microphone = new MicrophoneController({ onFrame() {} });
-
-  try {
-    await assert.rejects(
-      microphone.start(),
-      (error) => error.agentCode === "AUDIO_FIXED_TRACK_UNSUPPORTED" && error.retryable === false,
-    );
-    assert.equal(browser.recorders.length, 0);
-    assert.equal(browser.tracks[0].stopCalls, 1);
-  } finally {
-    await microphone.stop();
-    browser.restore();
-  }
-});
-
-test("MicrophoneController makes repeated start and stop calls idempotent", async () => {
-  const browser = installMicrophoneBrowser();
-  const microphone = new MicrophoneController({ onFrame() {} });
-
-  try {
-    await microphone.start();
-    await microphone.start();
-    assert.equal(browser.getUserMediaCalls.length, 1);
-    assert.equal(browser.recorders.length, 1);
-
-    await microphone.stop();
-    await microphone.stop();
-    assert.equal(browser.tracks[0].stopCalls, 1);
-
-    await microphone.start();
-    assert.equal(browser.getUserMediaCalls.length, 2);
-    assert.equal(browser.recorders.length, 2);
-    await microphone.stop();
-    assert.equal(browser.tracks[1].stopCalls, 1);
-  } finally {
-    await microphone.stop();
-    browser.restore();
-  }
-});
-
-test("MicrophoneController emits no frames after stop", async () => {
-  const browser = installMicrophoneBrowser();
-  const frames = [];
-  const microphone = new MicrophoneController({ onFrame: (frame) => frames.push(frame) });
-
-  try {
-    await microphone.start();
-    const recorder = browser.recorders[0];
-    recorder.ondataavailable?.({ data: new Blob(["opus"]) });
-    assert.equal(frames.length, 1);
-
-    await microphone.stop();
-    assert.equal(frames.length, 2);
-    recorder.ondataavailable?.({ data: new Blob(["late-opus"]) });
-    assert.equal(frames.length, 2);
-  } finally {
-    await microphone.stop();
-    browser.restore();
-  }
-});