@spatialwalk/avatarkit 1.0.0-beta.3 → 1.0.0-beta.31

package/README.md

@@ -1,4 +1,4 @@
-# SPAvatarKit SDK
+# SPAvatarSDK SDK
 
 Real-time virtual avatar rendering SDK based on 3D Gaussian Splatting, supporting audio-driven animation rendering and high-quality 3D rendering.
 
@@ -6,6 +6,7 @@ Real-time virtual avatar rendering SDK based on 3D Gaussian Splatting, supportin
 
 - **3D Gaussian Splatting Rendering** - Based on the latest point cloud rendering technology, providing high-quality 3D virtual avatars
 - **Audio-Driven Real-Time Animation Rendering** - Users provide audio data, SDK handles receiving animation data and rendering
+- **Multi-Character Support** - Support multiple avatar instances simultaneously, each with independent state and rendering
 - **WebGPU/WebGL Dual Rendering Backend** - Automatically selects the best rendering backend for compatibility
 - **WASM High-Performance Computing** - Uses C++ compiled WebAssembly modules for geometric calculations
 - **TypeScript Support** - Complete type definitions and IntelliSense
@@ -23,99 +24,234 @@ npm install @spatialwalk/avatarkit
 
 ```typescript
 import { 
-  AvatarKit, 
+  AvatarSDK, 
   AvatarManager, 
   AvatarView,
   Configuration,
-  Environment 
+  Environment,
+  DrivingServiceMode,
+  LogLevel
 } from '@spatialwalk/avatarkit'
 
 // 1. Initialize SDK
+
 const configuration: Configuration = {
-  environment: Environment.test,
+  environment: Environment.cn,
+  drivingServiceMode: DrivingServiceMode.sdk, // Optional, 'sdk' is default
+  // - DrivingServiceMode.sdk: SDK mode - SDK handles WebSocket communication
+  // - DrivingServiceMode.host: Host mode - Host app provides audio and animation data
+  logLevel: LogLevel.off, // Optional, 'off' is default
+  // - LogLevel.off: Disable all logs
+  // - LogLevel.error: Only error logs
+  // - LogLevel.warning: Warning and error logs
+  // - LogLevel.all: All logs (info, warning, error)
 }
 
-await AvatarKit.initialize('your-app-id', configuration)
+await AvatarSDK.initialize('your-app-id', configuration)
 
 // Set sessionToken (if needed, call separately)
-// AvatarKit.setSessionToken('your-session-token')
+// AvatarSDK.setSessionToken('your-session-token')
 
 // 2. Load character
-const avatarManager = new AvatarManager()
+const avatarManager = AvatarManager.shared
 const avatar = await avatarManager.load('character-id', (progress) => {
   console.log(`Loading progress: ${progress.progress}%`)
 })
 
 // 3. Create view (automatically creates Canvas and AvatarController)
+// The playback mode is determined by drivingServiceMode in AvatarSDK configuration
+// - DrivingServiceMode.sdk: SDK mode - SDK handles WebSocket communication
+// - DrivingServiceMode.host: Host mode - Host app provides audio and animation data
 const container = document.getElementById('avatar-container')
 const avatarView = new AvatarView(avatar, container)
 
-// 4. Start real-time communication
+// 4. Start real-time communication (SDK mode only)
 await avatarView.avatarController.start()
 
-// 5. Send audio data
-// If audio is Uint8Array, you can use slice().buffer to convert to ArrayBuffer
-const audioUint8 = new Uint8Array(1024) // Example: audio data
-const audioData = audioUint8.slice().buffer // Simplified conversion, works for ArrayBuffer and SharedArrayBuffer
-avatarView.avatarController.send(audioData, false) // Send audio data, will automatically start playing after accumulating enough data
-avatarView.avatarController.send(audioData, true) // end=true means immediately return animation data, no longer accumulating
+// 5. Send audio data (SDK mode, must be 16kHz mono PCM16 format)
+const audioData = new ArrayBuffer(1024) // Example: 16kHz PCM16 audio data
+avatarView.avatarController.send(audioData, false) // Send audio data
+avatarView.avatarController.send(audioData, true) // end=true marks the end of current conversation round
 ```
 
-### Complete Example
+### Host Mode Example
+
+```typescript
+
+// 1-3. Same as SDK mode (initialize SDK, load character)
 
-Check the example code in the GitHub repository for the complete usage flow.
+// 3. Create view with Host mode
+const container = document.getElementById('avatar-container')
+const avatarView = new AvatarView(avatar, container)
+
+// 4. Host Mode Workflow:
+// Send audio data first to get conversationId, then use it to send animation data
+const conversationId = avatarView.avatarController.yieldAudioData(audioData, false)
+avatarView.avatarController.yieldFramesData(animationData, conversationId)
+```
 
-**Example Project:** [Avatarkit-web-demo](https://github.com/spatialwalk/Avatarkit-web-demo)
+### Complete Examples
 
-This repository contains complete examples for Vanilla JS, Vue 3, and React, demonstrating how to integrate and use SPAvatarKit SDK in different frameworks.
+Check the example code in the GitHub repository for complete usage flows for both modes.
+
+**Example Project:** [AvatarSDK-Web-Demo](https://github.com/spatialwalk/AvatarSDK-Web-Demo)
+
+This repository contains complete examples for Vanilla JS, Vue 3, and React, demonstrating:
+- SDK mode: Real-time audio input with automatic animation data reception
+- Host mode: Custom data sources with manual audio/animation data management
 
 ## 🏗️ Architecture Overview
 
+### Three-Layer Architecture
+
+The SDK uses a three-layer architecture for clear separation of concerns:
+
+1. **Rendering Layer (AvatarView)** - Responsible for 3D rendering only
+2. **Playback Layer (AvatarController)** - Manages audio/animation synchronization and playback
+3. **Network Layer** - Handles WebSocket communication (only in SDK mode, internal implementation)
+
 ### Core Components
 
-- **AvatarKit** - SDK initialization and management
+- **AvatarSDK** - SDK initialization and management
 - **AvatarManager** - Character resource loading and management
-- **AvatarView** - 3D rendering view (internally contains AvatarController)
-- **AvatarController** - Real-time communication and data processing
-- **AvatarCoreAdapter** - WASM module adapter
+- **AvatarView** - 3D rendering view (rendering layer)
+- **AvatarController** - Audio/animation playback controller (playback layer)
+
+### Playback Modes
+
+The SDK supports two playback modes, configured in `AvatarSDK.initialize()`:
+
+#### 1. SDK Mode (Default)
+- Configured via `drivingServiceMode: DrivingServiceMode.sdk` in `AvatarSDK.initialize()`
+- SDK handles WebSocket communication automatically
+- Send audio data via `AvatarController.send()`
+- SDK receives animation data from backend and synchronizes playback
+- Best for: Real-time audio input scenarios
+
+#### 2. Host Mode
+- Configured via `drivingServiceMode: DrivingServiceMode.host` in `AvatarSDK.initialize()`
+- Host application manages its own network/data fetching
+- Host application provides both audio and animation data
+- SDK only handles synchronized playback
+- Best for: Custom data sources, pre-recorded content, or custom network implementations
+
+**Note:** The playback mode is determined by `drivingServiceMode` in `AvatarSDK.initialize()` configuration.
+
+### Fallback Mechanism
+
+The SDK includes a fallback mechanism to ensure audio playback continues even when animation data is unavailable:
+
+- **SDK Mode Connection Failure**: If WebSocket connection fails to establish within 15 seconds, the SDK automatically enters fallback mode. In this mode, audio data can still be sent and will play normally, even though no animation data will be received from the server. This ensures that audio playback is not interrupted even when the service connection fails.
+- **SDK Mode Server Error**: If the server returns an error after connection is established, the SDK automatically enters audio-only mode for that session and continues playing audio independently.
+- **Host Mode**: If empty animation data is provided (empty array or undefined), the SDK automatically enters audio-only mode.
+- Once in audio-only mode, any subsequent animation data for that session will be ignored, and only audio will continue playing.
+- The fallback mode is interruptible, just like normal playback mode.
+- Connection state callbacks (`onConnectionState`) will notify you when connection fails or times out, allowing you to handle the fallback state appropriately.
 
 ### Data Flow
 
+#### SDK Mode Flow
+
 ```
-User audio input (16kHz mono PCM) → AvatarController → WebSocket → Backend processing
-                                              ↓
-Backend returns animation data (FLAME keyframes) → AvatarController → AnimationPlayer
-                                              ↓
+User audio input (16kHz mono PCM16) 
+    ↓
+AvatarController.send() 
+    ↓
+WebSocket → Backend processing
+    ↓
+Backend returns animation data (FLAME keyframes) 
+    ↓
+AvatarController → AnimationPlayer
+    ↓
 FLAME parameters → AvatarCore.computeFrameFlatFromParams() → Splat data
-                                              ↓
-Splat data → RenderSystem → WebGPU/WebGL → Canvas rendering
+    ↓
+AvatarController (playback loop) → AvatarView.renderRealtimeFrame()
+    ↓
+RenderSystem → WebGPU/WebGL → Canvas rendering
 ```
 
-**Note:** Users need to provide audio data themselves (16kHz mono PCM), SDK handles receiving animation data and rendering.
+#### Host Mode Flow
+
+```
+External data source (audio + animation)
+    ↓
+AvatarController.yieldAudioData(audioChunk) // Returns conversationId
+    ↓
+AvatarController.yieldFramesData(keyframes, conversationId)
+    ↓
+AvatarController → AnimationPlayer (synchronized playback)
+    ↓
+FLAME parameters → AvatarCore.computeFrameFlatFromParams() → Splat data
+    ↓
+AvatarController (playback loop) → AvatarView.renderRealtimeFrame()
+    ↓
+RenderSystem → WebGPU/WebGL → Canvas rendering
+```
+
+### Audio Format Requirements
+
+**⚠️ Important:** The SDK requires audio data to be in **16kHz mono PCM16** format:
+
+- **Sample Rate**: 16kHz (16000 Hz) - This is a backend requirement
+- **Channels**: Mono (single channel)
+- **Format**: PCM16 (16-bit signed integer, little-endian)
+- **Byte Order**: Little-endian
+
+**Audio Data Format:**
+- Each sample is 2 bytes (16-bit)
+- Audio data should be provided as `ArrayBuffer` or `Uint8Array`
+- For example: 1 second of audio = 16000 samples × 2 bytes = 32000 bytes
+
+**Resampling:**
+- If your audio source is at a different sample rate (e.g., 24kHz, 48kHz), you must resample it to 16kHz before sending to the SDK
+- For high-quality resampling, we recommend using Web Audio API's `OfflineAudioContext` with anti-aliasing filtering
+- See example projects for resampling implementation
 
 ## 📚 API Reference
 
-### AvatarKit
+### AvatarSDK
 
 The core management class of the SDK, responsible for initialization and global configuration.
 
 ```typescript
 // Initialize SDK
-await AvatarKit.initialize(appId: string, configuration: Configuration)
+await AvatarSDK.initialize(appId: string, configuration: Configuration)
 
 // Check initialization status
-const isInitialized = AvatarKit.isInitialized
+const isInitialized = AvatarSDK.isInitialized
+
+// Get initialized app ID
+const appId = AvatarSDK.appId
+
+// Get configuration
+const config = AvatarSDK.configuration
+
+// Set sessionToken (if needed, call separately)
+AvatarSDK.setSessionToken('your-session-token')
+
+// Set userId (optional, for telemetry)
+AvatarSDK.setUserId('user-id')
+
+// Get sessionToken
+const sessionToken = AvatarSDK.sessionToken
+
+// Get userId
+const userId = AvatarSDK.userId
+
+// Get SDK version
+const version = AvatarSDK.version
 
 // Cleanup resources (must be called when no longer in use)
-AvatarKit.cleanup()
+AvatarSDK.cleanup()
 ```
 
 ### AvatarManager
 
-Character resource manager, responsible for downloading, caching, and loading character data.
+Character resource manager, responsible for downloading, caching, and loading character data. Use the singleton instance via `AvatarManager.shared`.
 
 ```typescript
-const manager = new AvatarManager()
+// Get singleton instance
+const manager = AvatarManager.shared
 
 // Load character
 const avatar = await manager.load(
@@ -129,23 +265,32 @@ manager.clearCache()
 
 ### AvatarView
 
-3D rendering view, internally automatically creates and manages AvatarController.
-
-**⚠️ Important Limitation:** Currently, the SDK only supports one AvatarView instance at a time. If you need to switch characters, you must first call the `dispose()` method to clean up the current AvatarView, then create a new instance.
+3D rendering view (rendering layer), responsible for 3D rendering only. Internally automatically creates and manages `AvatarController`.
 
 ```typescript
-// Create view (Canvas is automatically added to container)
-const avatarView = new AvatarView(avatar: Avatar, container?: HTMLElement)
+constructor(avatar: Avatar, container: HTMLElement)
+```
+
+**Parameters:**
+- `avatar`: Avatar instance
+- `container`: Canvas container element (required)
+  - Canvas automatically uses the full size of the container (width and height)
+  - Canvas aspect ratio adapts to container size - set container size to control aspect ratio
+  - Canvas will be automatically added to the container
+  - SDK automatically handles resize events via ResizeObserver
 
-// Get Canvas element
-const canvas = avatarView.getCanvas()
+**Playback Mode:**
+- The playback mode is determined by `drivingServiceMode` in `AvatarSDK.initialize()` configuration
+- The playback mode is fixed when creating `AvatarView` and persists throughout its lifecycle
+- Cannot be changed after creation
 
-// Set background
-avatarView.setBackgroundImage('path/to/image.jpg')
-avatarView.setBackgroundOpaque(true)
+```typescript
+// Create view (Canvas is automatically added to container)
+const container = document.getElementById('avatar-container')
+const avatarView = new AvatarView(avatar, container)
 
-// Update camera configuration
-avatarView.updateCameraConfig(cameraConfig: CameraConfig)
+// Wait for first frame to render
+await avatarView.ready // Promise that resolves when the first frame is rendered
 
 // Cleanup resources (must be called before switching characters)
 avatarView.dispose()
@@ -154,10 +299,9 @@ avatarView.dispose()
 **Character Switching Example:**
 
 ```typescript
-// Before switching characters, must clean up old AvatarView first
+// To switch characters, simply dispose the old view and create a new one
 if (currentAvatarView) {
   currentAvatarView.dispose()
-  currentAvatarView = null
 }
 
 // Load new character
@@ -165,37 +309,92 @@ const newAvatar = await avatarManager.load('new-character-id')
 
 // Create new AvatarView
 currentAvatarView = new AvatarView(newAvatar, container)
-await currentAvatarView.avatarController.start()
+
+// SDK mode: start connection (will throw error if not in SDK mode)
+  await currentAvatarView.controller.start()
 ```
 
 ### AvatarController
 
-Real-time communication controller, handles WebSocket connections and animation data.
+Audio/animation playback controller (playback layer), manages synchronized playback of audio and animation. Automatically handles WebSocket communication in SDK mode.
+
+**Two Usage Patterns:**
+
+#### SDK Mode Methods
 
 ```typescript
-// Start connection
+// Start WebSocket service
 await avatarView.avatarController.start()
 
-// Send audio data
-avatarView.avatarController.send(audioData: ArrayBuffer, end: boolean)
-// audioData: Audio data (ArrayBuffer format)
-// end: false (default) - Normal audio data sending, server will accumulate audio data, automatically returns animation data and starts synchronized playback of animation and audio after accumulating enough data
-// end: true - Immediately return animation data, no longer accumulating, used for ending current conversation or scenarios requiring immediate response
+// Send audio data (must be 16kHz mono PCM16 format)
+const conversationId = avatarView.avatarController.send(audioData: ArrayBuffer, end: boolean)
+// Returns: conversationId - Conversation ID for this conversation session
+// end: false (default) - Continue sending audio data for current conversation
+// end: true - Mark the end of current conversation round. After end=true, sending new audio data will interrupt any ongoing playback from the previous conversation round
+
+// Close WebSocket service
+avatarView.avatarController.close()
+```
+
+#### Host Mode Methods
+
+```typescript
+// Stream audio chunks (must be 16kHz mono PCM16 format)
+const conversationId = avatarView.avatarController.yieldAudioData(
+  data: Uint8Array,               // Audio chunk data
+  isLast: boolean = false         // Whether this is the last chunk
+)
+// Returns: conversationId - Conversation ID for this audio session
+
+// Stream animation keyframes (requires conversationId from audio data)
+avatarView.avatarController.yieldFramesData(
+  keyframes: any[],                // Animation keyframes (obtained from your service)
+  conversationId: string          // Conversation ID (required)
+)
+```
+
+**⚠️ Important: Conversation ID (conversationId) Management**
 
-// Interrupt conversation
+**SDK Mode:**
+- `send()` returns a conversationId to distinguish each conversation round
+- `end=true` marks the end of a conversation round
+
+**Host Mode:**
+- `yieldAudioData()` returns a conversationId (automatically generates if starting new session)
+   - `yieldFramesData()` requires a valid conversationId parameter
+   - Animation data with mismatched conversationId will be **discarded**
+   - Use `getCurrentConversationId()` to retrieve the current active conversationId
+
+#### Common Methods (Both Modes)
+
+```typescript
+
+// Interrupt current playback (stops and clears data)
 avatarView.avatarController.interrupt()
 
-// Close connection
-avatarView.avatarController.close()
+// Clear all data and resources
+avatarView.avatarController.clear()
+
+// Get current conversation ID (for Host mode)
+const conversationId = avatarView.avatarController.getCurrentConversationId()
+// Returns: Current conversationId for the active audio session, or null if no active session
+
+// Volume control (affects only avatar audio player, not system volume)
+avatarView.avatarController.setVolume(0.5)  // Set volume to 50% (0.0 to 1.0)
+const currentVolume = avatarView.avatarController.getVolume()  // Get current volume (0.0 to 1.0)
 
 // Set event callbacks
-avatarView.avatarController.onConnectionState = (state: ConnectionState) => {}
-avatarView.avatarController.onAvatarState = (state: AvatarState) => {}
+avatarView.avatarController.onConnectionState = (state: ConnectionState) => {} // SDK mode only
+avatarView.avatarController.onConversationState = (state: ConversationState) => {}
 avatarView.avatarController.onError = (error: Error) => {}
-
-// Note: sendText() method is not supported, calling it will throw an error
 ```
 
+**Important Notes:**
+- `start()` and `close()` are only available in SDK mode
+- `yieldAudioData()` and `yieldFramesData()` are only available in Host mode
+- `pause()`, `resume()`, `interrupt()`, `clear()`, `getCurrentConversationId()`, `setVolume()`, and `getVolume()` are available in both modes
+- The playback mode is determined when creating `AvatarView` and cannot be changed
+
 ## 🔧 Configuration
 
 ### Configuration
@@ -203,18 +402,42 @@ avatarView.avatarController.onError = (error: Error) => {}
 ```typescript
 interface Configuration {
   environment: Environment
+  drivingServiceMode?: DrivingServiceMode  // Optional, default is 'sdk' (SDK mode)
+  logLevel?: LogLevel  // Optional, default is 'off' (no logs)
 }
 ```
 
+### LogLevel
+
+Control the verbosity of SDK logs:
+
+```typescript
+enum LogLevel {
+  off = 'off',        // Disable all logs
+  error = 'error',    // Only error logs
+  warning = 'warning', // Warning and error logs
+  all = 'all'         // All logs (info, warning, error) - default
+}
+```
+
+**Note:** `LogLevel.off` completely disables all logging, including error logs. Use with caution in production environments.
+
 **Description:**
-- `environment`: Specifies the environment (cn/us/test), SDK will automatically use the corresponding API address and WebSocket address based on the environment
-- `sessionToken`: Set separately via `AvatarKit.setSessionToken()`, not in Configuration
+- `environment`: Specifies the environment (cn/intl), SDK will automatically use the corresponding API address and WebSocket address based on the environment
+- `drivingServiceMode`: Specifies the driving service mode
+  - `DrivingServiceMode.sdk` (default): SDK mode - SDK handles WebSocket communication automatically
+  - `DrivingServiceMode.host`: Host mode - Host application provides audio and animation data
+- `logLevel`: Controls the verbosity of SDK logs
+  - `LogLevel.off` (default): Disable all logs
+  - `LogLevel.error`: Only error logs
+  - `LogLevel.warning`: Warning and error logs
+  - `LogLevel.all`: All logs (info, warning, error)
+- `sessionToken`: Set separately via `AvatarSDK.setSessionToken()`, not in Configuration
 
 ```typescript
 enum Environment {
   cn = 'cn',    // China region
-  us = 'us',    // US region
-  test = 'test' // Test environment
+  intl = 'intl',    // International region
 }
 ```
 
@@ -245,16 +468,23 @@ enum ConnectionState {
 }
 ```
 
-### AvatarState
+### ConversationState
 
 ```typescript
-enum AvatarState {
-  idle = 'idle',      // Idle state, showing breathing animation
-  active = 'active',  // Active, waiting for playable content
-  playing = 'playing' // Playing
+enum ConversationState {
+  idle = 'idle',      // Idle state (breathing animation)
+  playing = 'playing' // Playing state (active conversation)
 }
 ```
 
+**State Description:**
+- `idle`: Avatar is in idle state (breathing animation), waiting for conversation to start
+- `playing`: Avatar is playing conversation content (including during transition animations)
+
+**Note:** During transition animations, the target state is notified immediately:
+- When transitioning from `idle` to `playing`, the `playing` state is notified immediately
+- When transitioning from `playing` to `idle`, the `idle` state is notified immediately
+
 ## 🎨 Rendering System
 
 The SDK supports two rendering backends:
@@ -264,57 +494,6 @@ The SDK supports two rendering backends:
 
 The rendering system automatically selects the best backend, no manual configuration needed.
 
-## 🔍 Debugging and Monitoring
-
-### Logging System
-
-The SDK has a built-in complete logging system, supporting different levels of log output:
-
-```typescript
-import { logger } from '@spatialwalk/avatarkit'
-
-// Set log level
-logger.setLevel('verbose') // 'basic' | 'verbose'
-
-// Manual log output
-logger.log('Info message')
-logger.warn('Warning message')
-logger.error('Error message')
-```
-
-### Performance Monitoring
-
-The SDK provides performance monitoring interfaces to monitor rendering performance:
-
-```typescript
-// Get rendering performance statistics
-const stats = avatarView.getPerformanceStats()
-
-if (stats) {
-  console.log(`Render time: ${stats.renderTime.toFixed(2)}ms`)
-  console.log(`Sort time: ${stats.sortTime.toFixed(2)}ms`)
-  console.log(`Rendering backend: ${stats.backend}`)
-  
-  // Calculate frame rate
-  const fps = 1000 / stats.renderTime
-  console.log(`Frame rate: ${fps.toFixed(2)} FPS`)
-}
-
-// Regular performance monitoring
-setInterval(() => {
-  const stats = avatarView.getPerformanceStats()
-  if (stats) {
-    // Send to monitoring service or display on UI
-    console.log('Performance:', stats)
-  }
-}, 1000)
-```
-
-**Performance Statistics Description:**
-- `renderTime`: Total rendering time (milliseconds), includes sorting and GPU rendering
-- `sortTime`: Sorting time (milliseconds), uses Radix Sort algorithm to depth-sort point cloud
-- `backend`: Currently used rendering backend (`'webgpu'` | `'webgl'` | `null`)
-
 ## 🚨 Error Handling
 
 ### SPAvatarError
@@ -348,22 +527,43 @@ avatarView.avatarController.onError = (error: Error) => {
 
 ### Lifecycle Management
 
+#### SDK Mode Lifecycle
+
 ```typescript
 // Initialize
+const container = document.getElementById('avatar-container')
 const avatarView = new AvatarView(avatar, container)
 await avatarView.avatarController.start()
 
 // Use
 avatarView.avatarController.send(audioData, false)
 
-// Cleanup (must be called before switching characters)
+// Cleanup
+avatarView.avatarController.close()
+avatarView.dispose() // Automatically cleans up all resources
+```
+
+#### Host Mode Lifecycle
+
+```typescript
+// Initialize
+const container = document.getElementById('avatar-container')
+const avatarView = new AvatarView(avatar, container)
+
+// Use
+const conversationId = avatarView.avatarController.yieldAudioData(audioChunk, false)
+avatarView.avatarController.yieldFramesData(keyframes, conversationId)
+
+// Cleanup
+avatarView.avatarController.clear() // Clear all data and resources
 avatarView.dispose() // Automatically cleans up all resources
 ```
 
 **⚠️ Important Notes:** 
-- SDK currently only supports one AvatarView instance at a time
-- When switching characters, must first call `dispose()` to clean up old AvatarView, then create new instance
+- When disposing AvatarView instances, must call `dispose()` to properly clean up resources
 - Not properly cleaning up may cause resource leaks and rendering errors
+- In SDK mode, call `close()` before `dispose()` to properly close WebSocket connections
+- In Host mode, call `clear()` before `dispose()` to clear all playback data
 
 ### Memory Optimization
 
@@ -371,16 +571,6 @@ avatarView.dispose() // Automatically cleans up all resources
 - Supports dynamic loading/unloading of character and animation resources
 - Provides memory usage monitoring interface
 
-### Audio Data Sending
-
-The `send()` method receives audio data in `ArrayBuffer` format:
-
-**Usage:**
-- `audioData`: Audio data (ArrayBuffer format)
-- `end=false` (default) - Normal audio data sending, server will accumulate audio data, automatically returns animation data and starts synchronized playback of animation and audio after accumulating enough data
-- `end=true` - Immediately return animation data, no longer accumulating, used for ending current conversation or scenarios requiring immediate response
-- **Important**: No need to wait for `end=true` to start playing, it will automatically start playing after accumulating enough audio data
-
 ## 🌐 Browser Compatibility
 
 - **Chrome/Edge** 90+ (WebGPU recommended)
@@ -400,5 +590,5 @@ Issues and Pull Requests are welcome!
 
 For questions, please contact:
 - Email: support@spavatar.com
-- Documentation: https://docs.spavatar.com
+- Documentation: https://docs.spatialreal.ai
 - GitHub: https://github.com/spavatar/sdk