@newgameplusinc/odyssey-audio-video-sdk-dev 1.0.57 → 1.0.58

package/README.md

@@ -11,69 +11,12 @@ It mirrors the production SDK used by Odyssey V2 and ships ready-to-drop into an
 ## Feature Highlights
 - 🔌 **One class to rule it all** – `OdysseySpatialComms` wires transports, producers, consumers, and room state.
 - 🧭 **Accurate pose propagation** – `updatePosition()` streams listener pose to the SFU while `participant-position-updated` keeps the local store in sync.
-- 🤖 **AI-Powered Noise Suppression** – Deep learning model (TensorFlow.js) runs client-side to remove background noise BEFORE audio reaches MediaSoup. Uses trained LSTM-based mask prediction for superior noise cancellation without affecting voice quality.
 - 🎧 **Studio-grade spatial audio** – each remote participant gets a dedicated Web Audio graph: denoiser → high-pass → low-pass → HRTF `PannerNode` → adaptive gain → master compressor. Uses Web Audio API's HRTF panning model for accurate left/right/front/back positioning based on distance and direction, with custom AudioWorklet processors for noise cancellation and voice tuning.
 - 🎥 **Camera-ready streams** – video tracks are exposed separately so UI layers can render muted `<video>` tags while audio stays inside Web Audio.
 - 🔁 **EventEmitter contract** – subscribe to `room-joined`, `consumer-created`, `participant-position-updated`, etc., without touching Socket.IO directly.
 
 ## Quick Start
 
-### With ML Noise Suppression (Recommended)
-
-```ts
-import {
-	OdysseySpatialComms,
-	Direction,
-	Position,
-} from "@newgameplusinc/odyssey-audio-video-sdk-dev";
-
-const sdk = new OdysseySpatialComms("https://mediasoup-server.example.com");
-
-// 1) Initialize ML noise suppression (place model files in public/models/)
-await sdk.initializeMLNoiseSuppression(
-	'/models/odyssey_noise_suppressor_v1/model.json'
-);
-
-// 2) Join a room
-await sdk.joinRoom({
-	roomId: "demo-room",
-	userId: "user-123",
-	deviceId: "device-123",
-	position: { x: 0, y: 0, z: 0 },
-	direction: { x: 0, y: 1, z: 0 },
-});
-
-// 3) Produce local media (ML cleaning applied automatically to audio)
-const stream = await navigator.mediaDevices.getUserMedia({ 
-	audio: {
-		echoCancellation: true,
-		noiseSuppression: false, // Disable browser NS, use ML instead!
-		autoGainControl: true,
-		sampleRate: 48000,
-	},
-	video: true 
-});
-for (const track of stream.getTracks()) {
-	await sdk.produceTrack(track); // ML processes audio tracks automatically
-}
-
-// 4) Toggle ML noise suppression on/off
-sdk.toggleMLNoiseSuppression(true); // or false
-
-// 5) Handle remote tracks
-sdk.on("consumer-created", async ({ participant, track }) => {
-	if (track.kind === "video") {
-		attachVideo(track, participant.participantId);
-	}
-});
-
-// 6) Keep spatial audio honest
-sdk.updatePosition(currentPos, currentDir);
-sdk.setListenerFromLSD(listenerPos, cameraPos, lookAtPos);
-```
-
-### Without ML Noise Suppression (Legacy)
-
 ```ts
 import {
 	OdysseySpatialComms,
@@ -113,83 +56,23 @@ sdk.setListenerFromLSD(listenerPos, cameraPos, lookAtPos);
 ## Audio Flow (Server ↔ Browser)
 
 ```
-                          ┌─────────────────────────────────────────────┐
-                          │         CLIENT-SIDE PROCESSING              │
-                          └─────────────────────────────────────────────┘
-
-┌──────────────┐   getUserMedia    ┌──────────────────────┐   ML Processing   ┌──────────────────┐
-│ Microphone   │ ────────────────▶ │ Vue: produceTrack()  │ ───────────────▶ │ SDK: ML Noise    │
-│ (Raw Audio)  │                   │ (SDK method call)    │                  │ Suppressor       │
-└──────────────┘                   └──────────────────────┘                  │ (TF.js Model)    │
-                                                                             │ • Load model.json │
-                                                                             │ • Mel-spectrogram │
-                                                                             │ • LSTM inference  │
-                                                                             │ • Mask apply      │
-                                                                             └────────┬─────────┘
-                                                                                      │
-                                                                                Clean Audio
-                                                                                      ▼
-                                                      ┌──────────────────────────────────────────┐
-                                                      │ SDK: mediasoupManager.produce()          │
-                                                      │ (Sends clean track to server)            │
-                                                      └────────┬─────────────────────────────────┘
-                                                               │
-                                                               │ WebRTC/RTP
-                                                               ▼
-                          ┌─────────────────────────────────────────────┐
-                          │         SERVER-SIDE ROUTING                 │
-                          └─────────────────────────────────────────────┘
-
-┌──────────────┐   update-position   ┌──────────────┐   route clean audio   ┌──────────────────┐
-│ Browser LSD  │ ──────────────────▶ │ MediaSoup SFU│ ───────────────────▶ │ Other Clients    │
-│ (Unreal data)│                     │ + Socket.IO  │                       │ (Receive RTP)    │
-└──────────────┘                     └──────┬───────┘                       └──────┬───────────┘
-                                            │                                       │
-                                            │ consumer-created event                │
-                                            ▼                                       ▼
-                          ┌─────────────────────────────────────────────┐
-                          │         REMOTE AUDIO PLAYBACK               │
-                          └─────────────────────────────────────────────┘
-
-                                     ┌──────────────────┐
-                                     │ SDK Event Bus    │
-                                     │ (EventManager)   │
-                                     └────────┬─────────┘
-                                              │ track + pose
-                                              ▼
-                                     ┌──────────────────┐
-                                     │ SpatialAudioMgr  │
-                                     │ (Web Audio API)  │
-                                     │ • Denoiser       │◀─── Traditional noise reduction
-                                     │ • HP/LP Filters  │     (runs on received audio)
-                                     │ • HRTF Panner    │
-                                     │ • Distance Gain  │
-                                     │ • Compressor     │
-                                     └────────┬─────────┘
-                                              │
-                                              ▼
-                                     ┌──────────────────┐
-                                     │ Web Audio Graph  │
-                                     └────────┬─────────┘
-                                              │
-                                              ▼
-                                  Listener ears (Left/Right)
-                                              │
-                                              ▼
-                                        System Output
-```
-
-### ML Noise Suppression Pipeline (Client-Side)
-```
-Mic → getUserMedia() 
-      ↓
-Vue: sdk.produceTrack(audioTrack)
-      ↓
-SDK: mlNoiseSuppressor.processMediaStream() [TensorFlow.js runs here]
-      ↓
-SDK: mediasoupManager.produce(cleanTrack)
-      ↓
-MediaSoup Server → Other participants hear clean audio ✅
+┌──────────────┐   update-position   ┌──────────────┐   pose + tracks   ┌──────────────────┐
+│ Browser LSD  │ ──────────────────▶ │ MediaSoup SFU│ ────────────────▶ │ SDK Event Bus     │
+│ (Unreal data)│                     │ + Socket.IO  │                   │ (EventManager)    │
+└──────┬───────┘                     └──────┬───────┘                   └──────────┬────────┘
+	│                                    │                                  track + pose
+	│                                    │                                       ▼
+	│                           ┌────────▼────────┐                      ┌──────────────────┐
+	│ audio RTP                 │  consumer-created│                      │ SpatialAudioMgr   │
+	└──────────────────────────▶│  setup per-user │◀──────────────────────│  (Web Audio API)  │
+					└────────┬────────┘                      │  - Denoiser       │
+						  │                               │  - HP / LP        │
+						  │                               │  - HRTF Panner    │
+						  ▼                               │  - Gain + Comp    │
+					 Web Audio Graph                         └──────────┬───────┘
+						  │                                          │
+						  ▼                                          ▼
+				      Listener ears (Left/Right)                  System Output
 ```
 
 ### Web Audio Algorithms
@@ -236,121 +119,7 @@ These layers run entirely in Web Audio, so you can ship “AirPods-style” back
 3. **Position + direction updates** – every `participant-position-updated` event calls `updateSpatialAudio(participantId, position, direction)`. The position feeds the panner’s XYZ, while the direction vector sets the source orientation so voices project forward relative to avatar facing.
 4. **Distance-aware gain** – the manager stores the latest listener pose and computes the Euclidean distance to each remote participant on every update. A custom rolloff curve adjusts gain before the compressor, giving the “someone on my left / far away” perception without blowing out master levels.
 5. **Left/right rendering** – because the panner uses `panningModel = "HRTF"`, browsers feed the processed signal into the user’s audio hardware with head-related transfer functions, producing natural interaural time/intensity differences.
-## ML Noise Suppression (Deep Learning Pre-Processing)
-
-**NEW:** The SDK now includes an optional **AI-powered noise suppression** layer that runs **BEFORE** audio reaches MediaSoup, using a trained TensorFlow.js model.
-
-### Why ML Noise Suppression?
-- **Superior noise removal** – Deep learning models learn complex noise patterns that traditional DSP can't handle (keyboard typing, paper rustling, traffic, etc.)
-- **Voice preservation** – LSTM-based mask prediction preserves natural voice quality while removing background noise
-- **Client-side processing** – Runs entirely in the browser using TensorFlow.js (WebGL/WebAssembly acceleration)
-- **Privacy-first** – Audio never leaves the user's device; processing happens locally
-- **Zero latency** – <10ms processing time per frame, suitable for real-time communication
-
-### Architecture
-```
-Raw Mic Audio → ML Model (TF.js) → Clean Audio → MediaSoup → Traditional Denoiser → Spatial Audio
-```
-
-The ML model applies **mask-based spectral subtraction** trained on diverse noise datasets:
-1. Extracts mel-spectrogram from raw audio
-2. Predicts a noise mask (0-1 per frequency bin) using Bidirectional LSTM
-3. Applies mask to remove noise while preserving speech
-4. Reconstructs clean audio waveform
-
-### Setup ML Noise Suppression
-
-**1. Place Model Files:**
-```
-YourApp/public/models/odyssey_noise_suppressor_v1/
-├── model.json                    # TF.js model architecture
-├── group1-shard*.bin             # Model weights (multiple files)
-├── normalization_stats.json      # Preprocessing parameters
-└── model_config.json             # Audio config (48kHz, n_mels, etc.)
-```
-
-**2. Initialize in Code:**
-```ts
-const sdk = new OdysseySpatialComms('wss://your-server.com');
-
-// Initialize ML noise suppression
-try {
-	await sdk.initializeMLNoiseSuppression(
-		'/models/odyssey_noise_suppressor_v1/model.json'
-	);
-	console.log('✅ ML Noise Suppression enabled');
-} catch (error) {
-	console.error('ML initialization failed:', error);
-	// Graceful degradation - SDK continues without ML
-}
-
-// Produce audio tracks (ML cleaning applied automatically)
-const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
-await sdk.produceTrack(stream.getAudioTracks()[0]);
-
-// Toggle ML on/off at runtime
-sdk.toggleMLNoiseSuppression(false); // Disable
-sdk.toggleMLNoiseSuppression(true);  // Re-enable
-
-// Check ML status
-if (sdk.isMLNoiseSuppressionEnabled()) {
-	console.log('ML is active');
-}
-```
-
-**3. Recommended Audio Constraints:**
-```ts
-const stream = await navigator.mediaDevices.getUserMedia({
-	audio: {
-		echoCancellation: true,        // Keep echo cancellation
-		noiseSuppression: false,       // Disable browser NS (ML replaces it)
-		autoGainControl: true,         // Keep AGC
-		sampleRate: 48000,             // Match model training (48kHz)
-	},
-});
-```
-
-### ML Model Details
-- **Architecture:** Bidirectional LSTM (2 layers, 256 units) + Dense layers
-- **Input:** 48kHz audio → Mel-spectrogram (128 bins, 8-frame sequences)
-- **Output:** Time-frequency mask (0-1 values per bin)
-- **Latency:** ~5-8ms per chunk (AudioWorklet processing)
-- **Model Size:** ~2-3 MB (quantized to uint8)
-- **Training:** LibriSpeech (clean speech) + AudioSet (noise) datasets
-
-### When to Use ML vs Traditional Denoiser
-
-| Feature | ML Noise Suppression | Traditional Denoiser (AudioWorklet) |
-|---------|---------------------|-------------------------------------|
-| **Noise Types** | Complex (keyboard, traffic, music) | Stationary (fan, HVAC, hiss) |
-| **Voice Quality** | Excellent (learned patterns) | Good (spectral shaping) |
-| **CPU Usage** | Medium (TF.js optimized) | Low (simple DSP) |
-| **Latency** | ~5-8ms | ~1-2ms |
-| **Use Case** | Noisy environments | Quiet rooms with constant noise |
-
-**Best Practice:** Enable **both** for maximum quality:
-- ML suppresses complex noise (pre-MediaSoup)
-- Traditional denoiser handles residual stationary noise (post-receive)
-
-### Troubleshooting
-
-**Model fails to load:**
-- Ensure model files are served as static assets (check browser Network tab)
-- Verify CORS headers if serving from CDN
-- Check browser console for TensorFlow.js errors
-
-**High CPU usage:**
-- TF.js automatically uses WebGL when available (much faster)
-- Disable ML on low-end devices: `sdk.toggleMLNoiseSuppression(false)`
-
-**Voice sounds muffled:**
-- Model trained on 48kHz audio; ensure mic uses same sample rate
-- Check if browser is downsampling to 16kHz (some mobile browsers do this)
 
-**Doesn't remove all noise:**
-- ML works best on noise types seen during training
-- Combine with traditional denoiser for residual cleanup
-- Extremely loud noise (>30 dB SNR) may leak through
 ## Video Flow (Capture ↔ Rendering)
 
 ```
@@ -368,19 +137,17 @@ const stream = await navigator.mediaDevices.getUserMedia({
 ```
 
 ## Core Classes
-- `src/index.ts` – `OdysseySpatialComms` (socket lifecycle, producers/consumers, event surface, ML noise suppression integration).
+- `src/index.ts` – `OdysseySpatialComms` (socket lifecycle, producers/consumers, event surface).
 - `src/MediasoupManager.ts` – transport helpers for produce/consume/resume.
 - `src/SpatialAudioManager.ts` – Web Audio orchestration (listener transforms, per-participant chains, denoiser, distance math).
-- `src/MLNoiseSuppressor.ts` – TensorFlow.js-based deep learning noise suppression (mel-spectrogram extraction, LSTM inference, mask application).
 - `src/EventManager.ts` – lightweight EventEmitter used by the entire SDK.
 
 ## Integration Checklist
 1. **Instantiate once** per page/tab and keep it in a store (Vuex, Redux, Zustand, etc.).
-2. **(Optional) Initialize ML noise suppression** – Call `await sdk.initializeMLNoiseSuppression('/models/odyssey_noise_suppressor_v1/model.json')` after instantiation for AI-powered noise cancellation.
-3. **Pipe LSD/Lap data** from your rendering engine into `updatePosition()` + `setListenerFromLSD()` at ~10 Hz.
-4. **Render videos muted** – never attach remote audio tracks straight to DOM; let `SpatialAudioManager` own playback.
-5. **Push avatar telemetry back to Unreal** so `remoteSpatialData` can render minimaps/circles (see Odyssey V2 `sendMediaSoupParticipantsToUnreal`).
-6. **Monitor logs** – browser console shows `🎧 SDK`, `📍 SDK`, `🎚️ [Spatial Audio]`, and `🎤 ML` statements for every critical hop.
+2. **Pipe LSD/Lap data** from your rendering engine into `updatePosition()` + `setListenerFromLSD()` at ~10 Hz.
+3. **Render videos muted** – never attach remote audio tracks straight to DOM; let `SpatialAudioManager` own playback.
+4. **Push avatar telemetry back to Unreal** so `remoteSpatialData` can render minimaps/circles (see Odyssey V2 `sendMediaSoupParticipantsToUnreal`).
+5. **Monitor logs** – browser console shows `🎧 SDK`, `📍 SDK`, and `🎚️ [Spatial Audio]` statements for every critical hop.
 
 ## Server Contract (Socket.IO events)
 | Event | Direction | Payload |

package/dist/MediasoupManager.js

@@ -41,7 +41,7 @@ class MediasoupManager {
         this.recvTransport = null;
         this.producers = new Map();
         this.consumers = new Map();
-        this.participantId = "";
+        this.participantId = '';
         this.socket = socket;
         this.device = new mediasoupClient.Device();
     }
@@ -100,7 +100,7 @@ class MediasoupManager {
                 // Emit event so parent SDK can recreate producers
                 this.socket.emit("transport-failed", {
                     participantId: this.participantId,
-                    direction: "send",
+                    direction: "send"
                 });
             }
         });
@@ -126,46 +126,30 @@ class MediasoupManager {
     async produce(track, appData) {
         if (!this.sendTransport)
             throw new Error("Send transport not initialized");
-        console.log(`📤 [MediaSoup] Producing ${track.kind} track (transport state: ${this.sendTransport.connectionState})`);
         // Configure simulcast for video tracks for adaptive bitrate
         const produceOptions = { track, appData };
-        if (track.kind === "video") {
+        if (track.kind === 'video') {
             produceOptions.encodings = [
                 // Low quality layer - 100 kbps, good for poor connections
-                {
-                    rid: "r0",
-                    active: true,
-                    maxBitrate: 100000,
-                    scaleResolutionDownBy: 4,
-                },
+                { rid: 'r0', active: true, maxBitrate: 100000, scaleResolutionDownBy: 4 },
                 // Medium quality layer - 300 kbps, balanced
-                {
-                    rid: "r1",
-                    active: true,
-                    maxBitrate: 300000,
-                    scaleResolutionDownBy: 2,
-                },
+                { rid: 'r1', active: true, maxBitrate: 300000, scaleResolutionDownBy: 2 },
                 // High quality layer - 900 kbps, full resolution
-                {
-                    rid: "r2",
-                    active: true,
-                    maxBitrate: 900000,
-                    scaleResolutionDownBy: 1,
-                },
+                { rid: 'r2', active: true, maxBitrate: 900000, scaleResolutionDownBy: 1 }
             ];
             // VP8 codec for simulcast support
             produceOptions.codecOptions = {
-                videoGoogleStartBitrate: 1000,
+                videoGoogleStartBitrate: 1000
             };
         }
         const producer = await this.sendTransport.produce(produceOptions);
         // Handle producer events
-        producer.on("transportclose", () => {
+        producer.on('transportclose', () => {
             console.warn(`⚠️ [MediaSoup] Producer ${producer.id.substring(0, 8)} transport closed`);
             this.producers.delete(producer.id);
             // The main SDK (index.ts) should handle recreation
         });
-        producer.on("trackended", () => {
+        producer.on('trackended', () => {
             console.warn(`⚠️ [MediaSoup] Producer ${producer.id.substring(0, 8)} track ended`);
             producer.close();
             this.producers.delete(producer.id);
@@ -183,12 +167,12 @@ class MediasoupManager {
             rtpParameters: data.rtpParameters,
         });
         // Handle consumer events
-        consumer.on("transportclose", () => {
+        consumer.on('transportclose', () => {
             console.warn(`⚠️ [MediaSoup] Consumer ${consumer.id.substring(0, 8)} transport closed`);
             this.consumers.delete(consumer.id);
             // The main SDK (index.ts) should handle recreation
         });
-        consumer.on("trackended", () => {
+        consumer.on('trackended', () => {
             console.warn(`⚠️ [MediaSoup] Consumer ${consumer.id.substring(0, 8)} track ended`);
             consumer.close();
             this.consumers.delete(consumer.id);

package/dist/index.d.ts

@@ -10,8 +10,6 @@ export declare class OdysseySpatialComms extends EventManager {
     private localParticipant;
     private mediasoupManager;
     private spatialAudioManager;
-    private mlNoiseSuppressor;
-    private mlNoiseSuppressionEnabled;
     constructor(serverUrl: string, spatialOptions?: SpatialAudioOptions);
     on(event: OdysseyEvent, listener: (...args: any[]) => void): this;
     emit(event: OdysseyEvent, ...args: any[]): boolean;
@@ -30,19 +28,6 @@ export declare class OdysseySpatialComms extends EventManager {
     leaveRoom(): void;
     resumeAudio(): Promise<void>;
     getAudioContextState(): AudioContextState;
-    /**
-     * Initialize ML noise suppression
-     * @param modelUrl - URL to model.json (e.g., '/models/odyssey_noise_suppressor_v1/model.json')
-     */
-    initializeMLNoiseSuppression(modelUrl: string): Promise<void>;
-    /**
-     * Toggle ML noise suppression on/off
-     */
-    toggleMLNoiseSuppression(enabled: boolean): void;
-    /**
-     * Check if ML noise suppression is enabled
-     */
-    isMLNoiseSuppressionEnabled(): boolean;
     produceTrack(track: MediaStreamTrack, appData?: {
         isScreenshare?: boolean;
     }): Promise<any>;

package/dist/index.js

@@ -5,14 +5,11 @@ const socket_io_client_1 = require("socket.io-client");
 const EventManager_1 = require("./EventManager");
 const MediasoupManager_1 = require("./MediasoupManager");
 const SpatialAudioManager_1 = require("./SpatialAudioManager");
-const MLNoiseSuppressor_1 = require("./MLNoiseSuppressor");
 class OdysseySpatialComms extends EventManager_1.EventManager {
     constructor(serverUrl, spatialOptions) {
         super(); // Initialize the EventEmitter base class
         this.room = null;
         this.localParticipant = null;
-        this.mlNoiseSuppressor = null;
-        this.mlNoiseSuppressionEnabled = false;
         this.socket = (0, socket_io_client_1.io)(serverUrl, {
             transports: ["websocket"],
         });
@@ -104,71 +101,8 @@ class OdysseySpatialComms extends EventManager_1.EventManager {
     getAudioContextState() {
         return this.spatialAudioManager.getAudioContextState();
     }
-    /**
-     * Initialize ML noise suppression
-     * @param modelUrl - URL to model.json (e.g., '/models/odyssey_noise_suppressor_v1/model.json')
-     */
-    async initializeMLNoiseSuppression(modelUrl) {
-        if (this.mlNoiseSuppressor) {
-            console.log('ML Noise Suppression already initialized');
-            return;
-        }
-        try {
-            console.log('🎤 Initializing ML Noise Suppression...');
-            this.mlNoiseSuppressor = new MLNoiseSuppressor_1.MLNoiseSuppressor();
-            await this.mlNoiseSuppressor.initialize(modelUrl, this.spatialAudioManager.getAudioContext());
-            this.mlNoiseSuppressionEnabled = true;
-            console.log('✅ ML Noise Suppression enabled');
-        }
-        catch (error) {
-            console.error('❌ Failed to initialize ML Noise Suppression:', error);
-            this.mlNoiseSuppressor = null;
-            this.mlNoiseSuppressionEnabled = false;
-            throw error;
-        }
-    }
-    /**
-     * Toggle ML noise suppression on/off
-     */
-    toggleMLNoiseSuppression(enabled) {
-        if (!this.mlNoiseSuppressor) {
-            console.warn('ML Noise Suppression not initialized. Call initializeMLNoiseSuppression() first.');
-            return;
-        }
-        this.mlNoiseSuppressionEnabled = enabled;
-        console.log(`🎤 ML Noise Suppression: ${enabled ? 'ON' : 'OFF'}`);
-    }
-    /**
-     * Check if ML noise suppression is enabled
-     */
-    isMLNoiseSuppressionEnabled() {
-        return this.mlNoiseSuppressionEnabled && this.mlNoiseSuppressor !== null;
-    }
     async produceTrack(track, appData) {
-        console.log(`🎬 [SDK] produceTrack called - kind: ${track.kind}, enabled: ${track.enabled}, readyState: ${track.readyState}`);
-        let processedTrack = track;
-        // Apply ML noise suppression to audio BEFORE sending to MediaSoup
-        if (track.kind === 'audio' && this.mlNoiseSuppressionEnabled && this.mlNoiseSuppressor) {
-            try {
-                console.log('🎤 [SDK] Applying ML noise suppression to audio...');
-                const inputStream = new MediaStream([track]);
-                console.log('🎤 [SDK] Created input stream with track');
-                const cleanedStream = await this.mlNoiseSuppressor.processMediaStream(inputStream);
-                console.log('🎤 [SDK] Got cleaned stream from ML');
-                processedTrack = cleanedStream.getAudioTracks()[0];
-                console.log(`✅ [SDK] ML noise suppression applied - processed track state: ${processedTrack.readyState}`);
-            }
-            catch (error) {
-                console.error('❌ [SDK] ML noise suppression failed, using original track:', error);
-                processedTrack = track; // Fallback to original track
-            }
-        }
-        else {
-            console.log(`ℹ️  [SDK] Skipping ML - kind: ${track.kind}, ML enabled: ${this.mlNoiseSuppressionEnabled}`);
-        }
-        console.log(`📤 [SDK] Producing track to MediaSoup - kind: ${processedTrack.kind}, state: ${processedTrack.readyState}`);
-        const producer = await this.mediasoupManager.produce(processedTrack, appData);
-        console.log(`✅ [SDK] Producer created - id: ${producer.id}, kind: ${producer.kind}`);
+        const producer = await this.mediasoupManager.produce(track, appData);
         if (this.localParticipant) {
             const isFirstProducer = this.localParticipant.producers.size === 0;
             this.localParticipant.producers.set(producer.id, producer);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@newgameplusinc/odyssey-audio-video-sdk-dev",
-  "version": "1.0.57",
-  "description": "Odyssey Spatial Audio & Video SDK using MediaSoup for real-time communication with AI-powered noise suppression",
+  "version": "1.0.58",
+  "description": "Odyssey Spatial Audio & Video SDK using MediaSoup for real-time communication",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -31,8 +31,7 @@
     "socket.io-client": "^4.7.2",
     "webrtc-adapter": "^8.2.3",
     "mediasoup-client": "^3.6.90",
-    "events": "^3.3.0",
-    "@tensorflow/tfjs": "^4.22.0"
+    "events": "^3.3.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/dist/MLNoiseSuppressor.d.ts

@@ -1,76 +0,0 @@
-/**
- * ML-Based Noise Suppressor for Odyssey MediaSoup SDK
- * Uses trained TensorFlow.js BiLSTM model for real-time noise suppression
- *
- * Architecture: BiLSTM (256 units x 2) + Dense layers
- * Input: Mel-spectrogram features (16 frames x 128 mels)
- * Output: Noise suppression mask (0-1 per frequency bin)
- *
- * Trained on: LibriSpeech + UrbanSound8K + MS-SNSD datasets
- * Performance: val_loss=0.038, SNR improvement ~12dB
- */
-export declare class MLNoiseSuppressor {
-    private model;
-    private config;
-    private normStats;
-    private audioContext;
-    private isInitialized;
-    private processingNode;
-    private highPassFilter;
-    private frameBuffer;
-    private prevMask;
-    private readonly SMOOTHING_ALPHA;
-    private melFilterbank;
-    private fftSize;
-    private hannWindow;
-    /**
-     * Initialize the ML noise suppressor
-     * @param modelUrl URL to the model.json file
-     * @param audioContext Web Audio API AudioContext
-     */
-    initialize(modelUrl: string, audioContext: AudioContext): Promise<void>;
-    /**
-     * Create Hann window for FFT
-     */
-    private createHannWindow;
-    /**
-     * Create mel filterbank matrix
-     */
-    private createMelFilterbank;
-    /**
-     * Compute FFT magnitude spectrum (optimized DFT for real-time)
-     */
-    private computeFFT;
-    /**
-     * Compute mel-spectrogram features from audio frame
-     */
-    private computeMelFeatures;
-    /**
-     * Process audio buffer with ML noise suppression
-     * @param inputBuffer Audio buffer to process (Float32Array)
-     * @returns Processed audio buffer
-     */
-    processAudio(inputBuffer: Float32Array): Promise<Float32Array>;
-    /**
-     * Apply temporal smoothing to reduce artifacts (Apple-style)
-     */
-    private applyTemporalSmoothing;
-    /**
-     * Apply mask with voice frequency preservation
-     */
-    private applyMaskWithVoicePreservation;
-    /**
-     * Process MediaStream with ML noise suppression
-     * @param inputStream MediaStream to process
-     * @returns Cleaned MediaStream
-     */
-    processMediaStream(inputStream: MediaStream): Promise<MediaStream>;
-    /**
-     * Cleanup resources
-     */
-    dispose(): void;
-    /**
-     * Check if initialized
-     */
-    isReady(): boolean;
-}