@spatialwalk/avatarkit 1.0.0-beta.7 → 1.0.0-beta.70

package/dist/StreamingAudioPlayer-Bi2685bX.js

@@ -0,0 +1,633 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { A as APP_CONFIG, l as logger, e as errorToMessage, a as logEvent } from "./index-CvW_c7G-.js";
+class StreamingAudioPlayer {
+  // 标记是否正在恢复 AudioContext，避免并发恢复请求
+  constructor(options) {
+    // AudioContext is managed internally
+    __publicField(this, "audioContext", null);
+    __publicField(this, "sampleRate");
+    __publicField(this, "channelCount");
+    __publicField(this, "debug");
+    // Session-level state
+    __publicField(this, "sessionId");
+    __publicField(this, "sessionStartTime", 0);
+    // AudioContext time when session started
+    __publicField(this, "pausedTimeOffset", 0);
+    // Accumulated paused time
+    __publicField(this, "pausedAt", 0);
+    // Time when paused
+    __publicField(this, "pausedAudioContextTime", 0);
+    // audioContext.currentTime when paused (for resume calculation)
+    __publicField(this, "scheduledTime", 0);
+    // Next chunk schedule time in AudioContext time
+    // Playback state
+    __publicField(this, "isPlaying", false);
+    __publicField(this, "isPaused", false);
+    __publicField(this, "autoStartEnabled", true);
+    // Control whether to auto-start when buffer is ready
+    __publicField(this, "autoContinue", false);
+    // 标记是否应该自动继续播放（当 end=false 且无数据时自动暂停后使用）
+    // Audio buffer queue
+    __publicField(this, "audioChunks", []);
+    __publicField(this, "scheduledChunks", 0);
+    // Number of chunks already scheduled
+    __publicField(this, "activeSources", /* @__PURE__ */ new Set());
+    __publicField(this, "lastScheduledChunkEndTime", 0);
+    // 最后一个已调度 chunk 的结束时间（相对时间）
+    __publicField(this, "lastGetCurrentTimeLog", 0);
+    // 上次记录 getCurrentTime 日志的时间戳（用于节流）
+    // 跟踪每个已调度的 chunk 的开始时间（绝对时间）和持续时间，用于准确计算当前播放时间
+    __publicField(this, "scheduledChunkInfo", []);
+    // Volume control
+    __publicField(this, "gainNode", null);
+    __publicField(this, "volume", 1);
+    // Default volume 1.0 (0.0 - 1.0)
+    // Event callbacks
+    __publicField(this, "onEndedCallback");
+    // AudioContext state management
+    __publicField(this, "stateChangeHandler");
+    __publicField(this, "isResuming", false);
+    this.sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    this.sampleRate = (options == null ? void 0 : options.sampleRate) ?? APP_CONFIG.audio.sampleRate;
+    this.channelCount = (options == null ? void 0 : options.channelCount) ?? 1;
+    this.debug = (options == null ? void 0 : options.debug) ?? false;
+  }
+  /**
+   * Initialize audio context (create and ensure it's ready)
+   */
+  async initialize() {
+    if (this.audioContext) {
+      return;
+    }
+    try {
+      this.audioContext = new AudioContext({
+        sampleRate: this.sampleRate
+      });
+      this.gainNode = this.audioContext.createGain();
+      this.gainNode.gain.value = this.volume;
+      this.gainNode.connect(this.audioContext.destination);
+      if (this.audioContext.state === "suspended") {
+        await this.audioContext.resume();
+      }
+      this.stateChangeHandler = (event) => {
+        const context = event.target;
+        if (context.state === "suspended" && this.isPlaying && !this.isPaused) {
+          this.ensureAudioContextRunning().catch((err) => {
+            logger.errorWithError("[StreamingAudioPlayer] Failed to auto-resume AudioContext after external suspend:", err);
+          });
+        }
+      };
+      this.audioContext.addEventListener("statechange", this.stateChangeHandler);
+      this.log("AudioContext initialized", {
+        sessionId: this.sessionId,
+        sampleRate: this.audioContext.sampleRate,
+        state: this.audioContext.state
+      });
+    } catch (error) {
+      const message = errorToMessage(error);
+      logEvent("activeAudioSessionFailed", "warning", {
+        sessionId: this.sessionId,
+        reason: message
+      });
+      logger.error("Failed to initialize AudioContext:", message);
+      throw error instanceof Error ? error : new Error(message);
+    }
+  }
+  /**
+   * 确保 AudioContext 正在运行（如果被暂停则自动恢复）
+   * 只在正在播放且未暂停时自动恢复，避免干扰正常的暂停/恢复逻辑
+   * 
+   * 优化：
+   * - 快速路径：如果已经是 running 状态，直接返回
+   * - 避免并发恢复：使用 isResuming 标志防止重复恢复请求
+   * - 处理 closed 状态：如果 AudioContext 已关闭，无法恢复
+   */
+  async ensureAudioContextRunning() {
+    if (!this.audioContext) {
+      return;
+    }
+    const state = this.audioContext.state;
+    if (state === "running") {
+      return;
+    }
+    if (state === "closed") {
+      this.log("AudioContext is closed, cannot resume", {
+        sessionId: this.sessionId,
+        state
+      });
+      return;
+    }
+    if (state === "suspended" && this.isPlaying && !this.isPaused) {
+      if (this.isResuming) {
+        this.log("AudioContext resume already in progress, skipping duplicate request", {
+          sessionId: this.sessionId,
+          state
+        });
+        return;
+      }
+      this.isResuming = true;
+      try {
+        this.log("AudioContext is suspended during playback, resuming...", {
+          sessionId: this.sessionId,
+          state,
+          isPlaying: this.isPlaying,
+          isPaused: this.isPaused
+        });
+        await this.audioContext.resume();
+        this.log("AudioContext resumed successfully", {
+          sessionId: this.sessionId,
+          state: this.audioContext.state
+        });
+      } catch (err) {
+        logger.errorWithError("[StreamingAudioPlayer] Failed to resume AudioContext:", err);
+        logEvent("character_player", "error", {
+          sessionId: this.sessionId,
+          event: "audio_context_resume_failed",
+          reason: err instanceof Error ? err.message : String(err)
+        });
+      } finally {
+        this.isResuming = false;
+      }
+    }
+  }
+  /**
+   * Add audio chunk (16-bit PCM)
+   */
+  addChunk(pcmData, isLast = false) {
+    if (!this.audioContext) {
+      logger.error("AudioContext not initialized");
+      return;
+    }
+    if (this.isPlaying && !this.isPaused && this.audioContext.state === "suspended") {
+      this.ensureAudioContextRunning().catch((err) => {
+        logger.errorWithError("[StreamingAudioPlayer] Failed to ensure AudioContext running in addChunk:", err);
+      });
+    }
+    this.audioChunks.push({ data: pcmData, isLast });
+    this.log(`Added chunk ${this.audioChunks.length}`, {
+      size: pcmData.length,
+      totalChunks: this.audioChunks.length,
+      isLast,
+      isPlaying: this.isPlaying,
+      scheduledChunks: this.scheduledChunks
+    });
+    if (this.autoContinue && this.isPaused) {
+      this.log("[StreamingAudioPlayer] autoContinue=true, auto-resuming playback");
+      this.autoContinue = false;
+      this.resume().catch((err) => {
+        logger.errorWithError("Failed to auto-resume playback:", err);
+      });
+    }
+    if (!this.isPlaying && this.autoStartEnabled && this.audioChunks.length > 0) {
+      this.log("[StreamingAudioPlayer] Auto-starting playback from addChunk");
+      this.startPlayback().catch((err) => {
+        logger.errorWithError("[StreamingAudioPlayer] Failed to start playback from addChunk:", err);
+      });
+    } else if (this.isPlaying && !this.isPaused) {
+      this.log("[StreamingAudioPlayer] Already playing, scheduling next chunk");
+      this.scheduleNextChunk();
+    } else {
+      this.log("[StreamingAudioPlayer] Not playing and no chunks, waiting for more chunks");
+    }
+  }
+  /**
+   * Start new session (stop current and start fresh)
+   */
+  async startNewSession(audioChunks) {
+    this.stop();
+    this.sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    this.audioChunks = [];
+    this.scheduledChunks = 0;
+    this.pausedTimeOffset = 0;
+    this.pausedAt = 0;
+    this.pausedAudioContextTime = 0;
+    this.autoContinue = false;
+    this.log("Starting new session", {
+      chunks: audioChunks.length
+    });
+    for (const chunk of audioChunks) {
+      this.addChunk(chunk.data, chunk.isLast);
+    }
+  }
+  /**
+   * Start playback
+   */
+  async startPlayback() {
+    if (!this.audioContext) {
+      this.log("[StreamingAudioPlayer] Cannot start playback: AudioContext not initialized");
+      return;
+    }
+    if (this.isPlaying) {
+      this.log("[StreamingAudioPlayer] Cannot start playback: Already playing");
+      return;
+    }
+    await this.ensureAudioContextRunning();
+    this.isPlaying = true;
+    this.sessionStartTime = this.audioContext.currentTime;
+    this.scheduledTime = this.sessionStartTime;
+    this.lastScheduledChunkEndTime = 0;
+    this.scheduledChunkInfo = [];
+    this.autoContinue = false;
+    this.log("[StreamingAudioPlayer] Starting playback", {
+      sessionStartTime: this.sessionStartTime,
+      bufferedChunks: this.audioChunks.length,
+      scheduledChunks: this.scheduledChunks,
+      activeSources: this.activeSources.size,
+      audioContextState: this.audioContext.state
+    });
+    this.scheduleAllChunks();
+  }
+  /**
+   * Schedule all pending chunks
+   */
+  scheduleAllChunks() {
+    while (this.scheduledChunks < this.audioChunks.length) {
+      this.scheduleNextChunk();
+    }
+  }
+  /**
+   * Schedule next audio chunk
+   */
+  scheduleNextChunk() {
+    if (!this.audioContext) {
+      this.log("[StreamingAudioPlayer] Cannot schedule chunk: AudioContext not initialized");
+      return;
+    }
+    if (!this.isPlaying || this.isPaused) {
+      this.log("[StreamingAudioPlayer] Cannot schedule chunk: Not playing or paused");
+      return;
+    }
+    if (this.audioContext.state === "suspended") {
+      this.ensureAudioContextRunning().catch((err) => {
+        logger.errorWithError("[StreamingAudioPlayer] Failed to ensure AudioContext running in scheduleNextChunk:", err);
+      });
+    }
+    const chunkIndex = this.scheduledChunks;
+    if (chunkIndex >= this.audioChunks.length) {
+      this.log(`[StreamingAudioPlayer] No more chunks to schedule (chunkIndex: ${chunkIndex}, totalChunks: ${this.audioChunks.length})`);
+      return;
+    }
+    const chunk = this.audioChunks[chunkIndex];
+    if (chunk.data.length === 0 && !chunk.isLast) {
+      this.scheduledChunks++;
+      return;
+    }
+    const pcmData = chunk.data;
+    const isLast = chunk.isLast;
+    const audioBuffer = this.pcmToAudioBuffer(pcmData);
+    if (!audioBuffer) {
+      const errorMessage = "Failed to create AudioBuffer from PCM data";
+      logger.error(errorMessage);
+      logEvent("character_player", "error", {
+        sessionId: this.sessionId,
+        event: "audio_buffer_creation_failed"
+      });
+      return;
+    }
+    try {
+      const source = this.audioContext.createBufferSource();
+      source.buffer = audioBuffer;
+      source.connect(this.gainNode);
+      const chunkStartTime = this.scheduledTime;
+      source.start(chunkStartTime);
+      const actualStartTime = Math.max(chunkStartTime, this.audioContext.currentTime);
+      this.scheduledChunkInfo.push({
+        startTime: actualStartTime,
+        duration: audioBuffer.duration
+      });
+      this.activeSources.add(source);
+      source.onended = () => {
+        this.activeSources.delete(source);
+        if (this.activeSources.size === 0) {
+          const lastChunk = this.audioChunks[this.scheduledChunks - 1];
+          if (lastChunk && !lastChunk.isLast) {
+            this.log("All audio chunks ended but end=false, pausing and setting autoContinue");
+            this.autoContinue = true;
+            this.pause();
+          } else if (isLast) {
+            this.log("Last audio chunk ended, marking playback as ended");
+            this.markEnded();
+          }
+        }
+      };
+      this.scheduledTime += audioBuffer.duration;
+      this.lastScheduledChunkEndTime = this.scheduledTime - this.sessionStartTime - this.pausedTimeOffset;
+      this.scheduledChunks++;
+      this.log(`[StreamingAudioPlayer] Scheduled chunk ${chunkIndex + 1}/${this.audioChunks.length}`, {
+        startTime: this.scheduledTime - audioBuffer.duration,
+        duration: audioBuffer.duration,
+        nextScheduleTime: this.scheduledTime,
+        isLast,
+        activeSources: this.activeSources.size
+      });
+    } catch (err) {
+      logger.errorWithError("Failed to schedule audio chunk:", err);
+      logEvent("character_player", "error", {
+        sessionId: this.sessionId,
+        event: "schedule_chunk_failed",
+        reason: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  /**
+   * Convert PCM data to AudioBuffer
+   * Input: 16-bit PCM (int16), Output: AudioBuffer (float32 [-1, 1])
+   */
+  pcmToAudioBuffer(pcmData) {
+    if (!this.audioContext) {
+      return null;
+    }
+    if (pcmData.length === 0) {
+      const silenceDuration = 0.01;
+      const numSamples2 = Math.floor(this.sampleRate * silenceDuration);
+      const audioBuffer2 = this.audioContext.createBuffer(
+        this.channelCount,
+        numSamples2,
+        this.sampleRate
+      );
+      for (let channel = 0; channel < this.channelCount; channel++) {
+        const channelData = audioBuffer2.getChannelData(channel);
+        channelData.fill(0);
+      }
+      return audioBuffer2;
+    }
+    const alignedData = new Uint8Array(pcmData);
+    const int16Array = new Int16Array(alignedData.buffer, 0, alignedData.length / 2);
+    const numSamples = int16Array.length / this.channelCount;
+    const audioBuffer = this.audioContext.createBuffer(
+      this.channelCount,
+      numSamples,
+      this.sampleRate
+    );
+    for (let channel = 0; channel < this.channelCount; channel++) {
+      const channelData = audioBuffer.getChannelData(channel);
+      for (let i = 0; i < numSamples; i++) {
+        const sampleIndex = i * this.channelCount + channel;
+        channelData[i] = int16Array[sampleIndex] / 32768;
+      }
+    }
+    return audioBuffer;
+  }
+  /**
+   * Get current playback time (seconds)
+   * 返回实际播放的音频总时长
+   */
+  getCurrentTime() {
+    if (!this.audioContext || !this.isPlaying) {
+      return 0;
+    }
+    if (this.isPaused) {
+      return this.pausedAt;
+    }
+    const currentAudioTime = this.audioContext.currentTime;
+    if (this.activeSources.size === 0 && this.scheduledChunks > 0) {
+      return Math.max(0, this.lastScheduledChunkEndTime);
+    }
+    let totalPlayedDuration = 0;
+    for (let i = 0; i < this.scheduledChunkInfo.length; i++) {
+      const chunkInfo = this.scheduledChunkInfo[i];
+      const chunkEndTime = chunkInfo.startTime + chunkInfo.duration;
+      if (currentAudioTime < chunkInfo.startTime) {
+        break;
+      } else if (chunkEndTime <= currentAudioTime) {
+        totalPlayedDuration += chunkInfo.duration;
+      } else {
+        const playedTime = currentAudioTime - chunkInfo.startTime;
+        totalPlayedDuration += playedTime;
+        break;
+      }
+    }
+    return Math.max(0, totalPlayedDuration);
+  }
+  /**
+   * Get total duration of buffered audio (seconds)
+   * 计算所有已缓冲 chunk 的总时长
+   */
+  getBufferedDuration() {
+    if (!this.audioContext) {
+      return 0;
+    }
+    let totalDuration = 0;
+    for (const chunk of this.audioChunks) {
+      const chunkDuration = chunk.data.length / (this.sampleRate * this.channelCount * 2);
+      totalDuration += chunkDuration;
+    }
+    return totalDuration;
+  }
+  /**
+   * Get current AudioContext time
+   * @returns Current AudioContext time in seconds, or 0 if AudioContext is not initialized
+   */
+  getAudioContextTime() {
+    var _a;
+    return ((_a = this.audioContext) == null ? void 0 : _a.currentTime) ?? 0;
+  }
+  /**
+   * Pause playback
+   */
+  pause() {
+    if (!this.isPlaying || this.isPaused || !this.audioContext) {
+      return;
+    }
+    this.pausedAt = this.getCurrentTime();
+    this.pausedAudioContextTime = this.audioContext.currentTime;
+    this.isPaused = true;
+    if (this.audioContext.state === "running") {
+      this.audioContext.suspend().catch((err) => {
+        logger.errorWithError("Failed to suspend AudioContext:", err);
+        this.isPaused = false;
+      });
+    }
+    this.log("Playback paused", {
+      pausedAt: this.pausedAt,
+      pausedAudioContextTime: this.pausedAudioContextTime,
+      audioContextState: this.audioContext.state
+    });
+  }
+  /**
+   * Resume playback
+   */
+  async resume() {
+    if (!this.isPaused || !this.audioContext || !this.isPlaying) {
+      return;
+    }
+    this.autoContinue = false;
+    if (this.audioContext.state === "suspended") {
+      try {
+        await this.audioContext.resume();
+      } catch (err) {
+        logger.errorWithError("Failed to resume AudioContext:", err);
+        throw err;
+      }
+    }
+    const currentAudioTime = this.audioContext.currentTime;
+    this.sessionStartTime = this.pausedAudioContextTime - this.pausedAt - this.pausedTimeOffset;
+    this.isPaused = false;
+    if (this.scheduledChunks < this.audioChunks.length) {
+      this.scheduleAllChunks();
+    }
+    this.log("Playback resumed", {
+      pausedAt: this.pausedAt,
+      pausedAudioContextTime: this.pausedAudioContextTime,
+      currentAudioContextTime: currentAudioTime,
+      adjustedSessionStartTime: this.sessionStartTime,
+      audioContextState: this.audioContext.state
+    });
+  }
+  /**
+   * Stop playback
+   */
+  stop() {
+    if (!this.audioContext) {
+      return;
+    }
+    if (this.isPaused && this.audioContext.state === "suspended") {
+      this.audioContext.resume().catch(() => {
+      });
+      this.isPaused = false;
+    }
+    this.isPlaying = false;
+    this.isPaused = false;
+    this.isResuming = false;
+    this.sessionStartTime = 0;
+    this.scheduledTime = 0;
+    for (const source of this.activeSources) {
+      source.onended = null;
+      try {
+        source.stop(0);
+      } catch {
+      }
+      try {
+        source.disconnect();
+      } catch {
+      }
+    }
+    this.activeSources.clear();
+    this.audioChunks = [];
+    this.scheduledChunks = 0;
+    this.autoContinue = false;
+    this.log("[StreamingAudioPlayer] Playback stopped, state reset");
+  }
+  /**
+   * Enable or disable auto-start (for delayed start scenarios)
+   */
+  setAutoStart(enabled) {
+    this.autoStartEnabled = enabled;
+    this.log(`Auto-start ${enabled ? "enabled" : "disabled"}`);
+  }
+  /**
+   * Start playback manually (for delayed start scenarios)
+   * This allows starting playback after transition animation completes
+   */
+  play() {
+    if (this.isPlaying) {
+      return;
+    }
+    this.autoStartEnabled = true;
+    this.startPlayback().catch((err) => {
+      logger.errorWithError("[StreamingAudioPlayer] Failed to start playback from play():", err);
+    });
+  }
+  /**
+   * Mark playback as ended
+   */
+  markEnded() {
+    var _a;
+    this.log("Playback ended");
+    this.isPlaying = false;
+    (_a = this.onEndedCallback) == null ? void 0 : _a.call(this);
+  }
+  /**
+   * Set ended callback
+   */
+  onEnded(callback) {
+    this.onEndedCallback = callback;
+  }
+  /**
+   * Check if playing
+   */
+  isPlayingNow() {
+    return this.isPlaying && !this.isPaused;
+  }
+  /**
+   * Dispose and cleanup
+   */
+  dispose() {
+    this.stop();
+    if (this.audioContext && this.stateChangeHandler) {
+      this.audioContext.removeEventListener("statechange", this.stateChangeHandler);
+      this.stateChangeHandler = void 0;
+    }
+    if (this.audioContext) {
+      this.audioContext.close();
+      this.audioContext = null;
+      this.gainNode = null;
+    }
+    this.audioChunks = [];
+    this.scheduledChunks = 0;
+    this.sessionStartTime = 0;
+    this.pausedTimeOffset = 0;
+    this.pausedAt = 0;
+    this.pausedAudioContextTime = 0;
+    this.scheduledTime = 0;
+    this.onEndedCallback = void 0;
+    this.log("StreamingAudioPlayer disposed");
+  }
+  /**
+   * Flush buffered audio
+   * - hard: stops all playing sources and clears all chunks
+   * - soft (default): clears UNSCHEDULED chunks only
+   */
+  flush(options) {
+    const hard = (options == null ? void 0 : options.hard) === true;
+    if (hard) {
+      this.stop();
+      this.audioChunks = [];
+      this.scheduledChunks = 0;
+      this.sessionStartTime = 0;
+      this.pausedAt = 0;
+      this.scheduledTime = 0;
+      this.log("Flushed (hard)");
+      return;
+    }
+    if (this.scheduledChunks < this.audioChunks.length) {
+      this.audioChunks.splice(this.scheduledChunks);
+    }
+    this.log("Flushed (soft)", { remainingScheduled: this.scheduledChunks });
+  }
+  /**
+   * 设置音量 (0.0 - 1.0)
+   * 注意：这仅控制数字人音频播放器的音量，不影响系统音量
+   * @param volume 音量值，范围 0.0 到 1.0（0.0 为静音，1.0 为最大音量）
+   */
+  setVolume(volume) {
+    if (volume < 0 || volume > 1) {
+      logger.warn(`[StreamingAudioPlayer] Volume out of range: ${volume}, clamping to [0, 1]`);
+      volume = Math.max(0, Math.min(1, volume));
+    }
+    this.volume = volume;
+    if (this.gainNode) {
+      this.gainNode.gain.value = volume;
+    }
+  }
+  /**
+   * 获取当前音量
+   * @returns 当前音量值 (0.0 - 1.0)
+   */
+  getVolume() {
+    return this.volume;
+  }
+  /**
+   * Debug logging
+   */
+  log(message, data) {
+    if (this.debug) {
+      logger.log(`[StreamingAudioPlayer] ${message}`, data || "");
+    }
+  }
+}
+export {
+  StreamingAudioPlayer
+};

package/dist/animation/AnimationWebSocketClient.d.ts

@@ -2,20 +2,23 @@ import { EventEmitter } from './utils/eventEmitter';
 export interface AnimationWebSocketClientOptions {
     wsUrl: string;
     reconnectAttempts?: number;
-    debug?: boolean;
     jwtToken?: string;
+    appId?: string;
+    clientId?: string;
 }
 export declare class AnimationWebSocketClient extends EventEmitter {
     private wsUrl;
     private reconnectAttempts;
-    private debug;
     private jwtToken?;
+    private appId?;
+    private clientId?;
     private ws;
     private currentCharacterId;
     private currentRetryCount;
     private isConnecting;
     private isManuallyDisconnected;
     private reconnectTimer;
+    private sessionConfigured;
     constructor(options: AnimationWebSocketClientOptions);
     /**
      * 连接WebSocket
@@ -27,13 +30,14 @@ export declare class AnimationWebSocketClient extends EventEmitter {
     disconnect(): void;
     /**
      * 发送音频数据
+     * @param conversationId - 会话ID（在 protobuf 协议中映射为 reqId 字段）
      */
-    sendAudioData(reqId: string, audioData: ArrayBuffer, end: boolean): boolean;
+    sendAudioData(conversationId: string, audioData: ArrayBuffer, end: boolean): boolean;
     /**
-     * 生成请求ID
-     * 使用统一的 ReqID 生成规则：YYYYMMDDHHmmss_nanoid
+     * 生成会话ID
+     * 使用统一的会话ID生成规则：YYYYMMDDHHmmss_nanoid
      */
-    generateReqId(): string;
+    generateConversationId(): string;
     /**
      * 获取连接状态
      */
@@ -44,7 +48,14 @@ export declare class AnimationWebSocketClient extends EventEmitter {
     getCurrentCharacterId(): string;
     private buildWebSocketUrl;
     private connectWebSocket;
+    /**
+     * 清理 URL 用于日志记录（隐藏敏感信息）
+     */
+    private sanitizeUrlForLog;
+    /**
+     * v2 协议：配置会话（发送采样率等参数）
+     */
+    private configureSession;
     private handleMessage;
     private scheduleReconnect;
 }
-//# sourceMappingURL=AnimationWebSocketClient.d.ts.map

package/dist/animation/utils/eventEmitter.d.ts

@@ -10,4 +10,3 @@ export declare class EventEmitter {
     removeAllListeners(event?: string): void;
 }
 export {};
-//# sourceMappingURL=eventEmitter.d.ts.map

package/dist/animation/utils/flameConverter.d.ts

@@ -23,4 +23,3 @@ export declare function convertWasmParamsToProtoFlame(wasmParams: FlameParams):
  * Create a neutral proto Flame (zero pose)
  */
 export declare function createNeutralFlameProto(): Flame;
-//# sourceMappingURL=flameConverter.d.ts.map