@mentra/sdk 2.1.13 → 2.1.14

package/dist/app/session/index.js

@@ -26,11 +26,11 @@ const node_fetch_1 = __importDefault(require("node-fetch"));
 const cloud_to_app_1 = require("../../types/messages/cloud-to-app");
 // List of event types that should never be subscribed to as streams
 const APP_TO_APP_EVENT_TYPES = [
-    'app_message_received',
-    'app_user_joined',
-    'app_user_left',
-    'app_room_updated',
-    'app_direct_message_response'
+    "app_message_received",
+    "app_user_joined",
+    "app_user_left",
+    "app_room_updated",
+    "app_direct_message_response",
 ];
 /**
  * 🚀 App Session Implementation
@@ -95,18 +95,21 @@ class AppSession {
             autoReconnect: true, // Enable auto-reconnection by default for better reliability
             maxReconnectAttempts: 3, // Default to 3 reconnection attempts for better resilience
             reconnectDelay: 1000, // Start with 1 second delay (uses exponential backoff)
-            ...config
+            ...config,
         };
         this.appServer = this.config.appServer;
-        this.logger = this.appServer.logger.child({ userId: this.config.userId, service: 'app-session' });
+        this.logger = this.appServer.logger.child({
+            userId: this.config.userId,
+            service: "app-session",
+        });
         this.userId = this.config.userId;
         // Make sure the URL is correctly formatted to prevent double protocol issues
         if (this.config.mentraOSWebsocketUrl) {
             try {
                 const url = new URL(this.config.mentraOSWebsocketUrl);
-                if (!['ws:', 'wss:'].includes(url.protocol)) {
+                if (!["ws:", "wss:"].includes(url.protocol)) {
                     // Fix URLs with incorrect protocol (e.g., 'ws://http://host')
-                    const fixedUrl = this.config.mentraOSWebsocketUrl.replace(/^ws:\/\/http:\/\//, 'ws://');
+                    const fixedUrl = this.config.mentraOSWebsocketUrl.replace(/^ws:\/\/http:\/\//, "ws://");
                     this.config.mentraOSWebsocketUrl = fixedUrl;
                     this.logger.warn(`⚠️ [${this.config.packageName}] Fixed malformed WebSocket URL: ${fixedUrl}`);
                 }
@@ -123,7 +126,7 @@ class AppSession {
         if (this.config.mentraOSWebsocketUrl) {
             try {
                 const url = new URL(this.config.mentraOSWebsocketUrl);
-                if (!['ws:', 'wss:'].includes(url.protocol)) {
+                if (!["ws:", "wss:"].includes(url.protocol)) {
                     this.logger.error({ config: this.config }, `⚠️ [${this.config.packageName}] Invalid WebSocket URL protocol: ${url.protocol}. Should be ws: or wss:`);
                 }
             }
@@ -156,14 +159,14 @@ class AppSession {
         });
         // Initialize dashboard API with this session instance
         // Import DashboardManager dynamically to avoid circular dependency
-        const { DashboardManager } = require('./dashboard');
+        const { DashboardManager } = require("./dashboard");
         this.dashboard = new DashboardManager(this, this.send.bind(this));
         // Initialize camera module with session reference
-        this.camera = new camera_1.CameraModule(this.config.packageName, this.sessionId || 'unknown-session-id', this.send.bind(this), this, // Pass session reference
-        this.logger.child({ module: 'camera' }));
+        this.camera = new camera_1.CameraModule(this.config.packageName, this.sessionId || "unknown-session-id", this.send.bind(this), this, // Pass session reference
+        this.logger.child({ module: "camera" }));
         // Initialize audio module with session reference
-        this.audio = new audio_1.AudioManager(this.config.packageName, this.sessionId || 'unknown-session-id', this.send.bind(this), this, // Pass session reference
-        this.logger.child({ module: 'audio' }));
+        this.audio = new audio_1.AudioManager(this.config.packageName, this.sessionId || "unknown-session-id", this.send.bind(this), this, // Pass session reference
+        this.logger.child({ module: "audio" }));
         this.location = new location_1.LocationManager(this, this.send.bind(this));
     }
     /**
@@ -171,7 +174,7 @@ class AppSession {
      * @returns The current session ID or 'unknown-session-id' if not connected
      */
     getSessionId() {
-        return this.sessionId || 'unknown-session-id';
+        return this.sessionId || "unknown-session-id";
     }
     /**
      * Get the package name for this App
@@ -197,8 +200,8 @@ class AppSession {
      * @throws Error if language code is invalid
      * @deprecated Use session.events.onTranscriptionForLanguage() instead
      */
-    onTranscriptionForLanguage(language, handler) {
-        return this.events.onTranscriptionForLanguage(language, handler);
+    onTranscriptionForLanguage(language, handler, disableLanguageIdentification = false) {
+        return this.events.onTranscriptionForLanguage(language, handler, disableLanguageIdentification);
     }
     /**
      * 🌐 Listen for speech translation events for a specific language pair
@@ -278,7 +281,7 @@ class AppSession {
     subscribe(sub) {
         let type;
         let rate;
-        if (typeof sub === 'string') {
+        if (typeof sub === "string") {
             type = sub;
         }
         else {
@@ -304,7 +307,7 @@ class AppSession {
      */
     unsubscribe(sub) {
         let type;
-        if (typeof sub === 'string') {
+        if (typeof sub === "string") {
             type = sub;
         }
         else {
@@ -340,7 +343,7 @@ class AppSession {
         this.sessionId = sessionId;
         // Configure settings API client with the WebSocket URL and session ID
         // This allows settings to be fetched from the correct server
-        this.settings.configureApiClient(this.config.packageName, this.config.mentraOSWebsocketUrl || '', sessionId);
+        this.settings.configureApiClient(this.config.packageName, this.config.mentraOSWebsocketUrl || "", sessionId);
         // Update the sessionId in the camera module
         if (this.camera) {
             this.camera.updateSessionId(sessionId);
@@ -354,15 +357,16 @@ class AppSession {
                 // Clear previous resources if reconnecting
                 if (this.ws) {
                     // Don't call full dispose() as that would clear subscriptions
-                    if (this.ws.readyState !== 3) { // 3 = CLOSED
+                    if (this.ws.readyState !== 3) {
+                        // 3 = CLOSED
                         this.ws.close();
                     }
                     this.ws = null;
                 }
                 // Validate WebSocket URL before attempting connection
                 if (!this.config.mentraOSWebsocketUrl) {
-                    this.logger.error('WebSocket URL is missing or undefined');
-                    reject(new Error('WebSocket URL is required'));
+                    this.logger.error("WebSocket URL is missing or undefined");
+                    reject(new Error("WebSocket URL is required"));
                     return;
                 }
                 // Add debug logging for connection attempts
@@ -371,18 +375,19 @@ class AppSession {
                 this.ws = new ws_1.WebSocket(this.config.mentraOSWebsocketUrl);
                 // Track WebSocket for automatic cleanup
                 this.resources.track(() => {
-                    if (this.ws && this.ws.readyState !== 3) { // 3 = CLOSED
+                    if (this.ws && this.ws.readyState !== 3) {
+                        // 3 = CLOSED
                         this.ws.close();
                     }
                 });
-                this.ws.on('open', () => {
+                this.ws.on("open", () => {
                     try {
                         this.sendConnectionInit();
                     }
                     catch (error) {
-                        this.logger.error(error, 'Error during connection initialization');
+                        this.logger.error(error, "Error during connection initialization");
                         const errorMessage = error instanceof Error ? error.message : String(error);
-                        this.events.emit('error', new Error(`Connection initialization failed: ${errorMessage}`));
+                        this.events.emit("error", new Error(`Connection initialization failed: ${errorMessage}`));
                         reject(error);
                     }
                 });
@@ -394,7 +399,7 @@ class AppSession {
                             try {
                                 // Validate buffer before processing
                                 if (data.length === 0) {
-                                    this.events.emit('error', new Error('Received empty binary data'));
+                                    this.events.emit("error", new Error("Received empty binary data"));
                                     return;
                                 }
                                 // Convert Node.js Buffer to ArrayBuffer safely
@@ -403,15 +408,15 @@ class AppSession {
                                 const audioChunk = {
                                     type: types_1.StreamType.AUDIO_CHUNK,
                                     arrayBuffer: arrayBuf,
-                                    timestamp: new Date() // Ensure timestamp is present
+                                    timestamp: new Date(), // Ensure timestamp is present
                                 };
                                 this.handleMessage(audioChunk);
                                 return;
                             }
                             catch (error) {
-                                this.logger.error(error, 'Error processing binary message:');
+                                this.logger.error(error, "Error processing binary message:");
                                 const errorMessage = error instanceof Error ? error.message : String(error);
-                                this.events.emit('error', new Error(`Failed to process binary message: ${errorMessage}`));
+                                this.events.emit("error", new Error(`Failed to process binary message: ${errorMessage}`));
                                 return;
                             }
                         }
@@ -423,59 +428,61 @@ class AppSession {
                         try {
                             // Convert string data to JSON safely
                             let jsonData;
-                            if (typeof data === 'string') {
+                            if (typeof data === "string") {
                                 jsonData = data;
                             }
                             else if (Buffer.isBuffer(data)) {
-                                jsonData = data.toString('utf8');
+                                jsonData = data.toString("utf8");
                             }
                             else {
-                                throw new Error('Unknown message format');
+                                throw new Error("Unknown message format");
                             }
                             // Validate JSON before parsing
-                            if (!jsonData || jsonData.trim() === '') {
-                                this.events.emit('error', new Error('Received empty JSON message'));
+                            if (!jsonData || jsonData.trim() === "") {
+                                this.events.emit("error", new Error("Received empty JSON message"));
                                 return;
                             }
                             // Parse JSON with error handling
                             const message = JSON.parse(jsonData);
                             // Basic schema validation
-                            if (!message || typeof message !== 'object' || !('type' in message)) {
-                                this.events.emit('error', new Error('Malformed message: missing type property'));
+                            if (!message ||
+                                typeof message !== "object" ||
+                                !("type" in message)) {
+                                this.events.emit("error", new Error("Malformed message: missing type property"));
                                 return;
                             }
                             // Process the validated message
                             this.handleMessage(message);
                         }
                         catch (error) {
-                            this.logger.error(error, 'JSON parsing error');
+                            this.logger.error(error, "JSON parsing error");
                             const errorMessage = error instanceof Error ? error.message : String(error);
-                            this.events.emit('error', new Error(`Failed to parse JSON message: ${errorMessage}`));
+                            this.events.emit("error", new Error(`Failed to parse JSON message: ${errorMessage}`));
                         }
                     }
                     catch (error) {
                         // Final catch - should never reach here if individual handlers work correctly
-                        this.logger.error({ error }, 'Unhandled message processing error');
+                        this.logger.error({ error }, "Unhandled message processing error");
                         const errorMessage = error instanceof Error ? error.message : String(error);
-                        this.events.emit('error', new Error(`Unhandled message error: ${errorMessage}`));
+                        this.events.emit("error", new Error(`Unhandled message error: ${errorMessage}`));
                     }
                 };
-                this.ws.on('message', messageHandler);
+                this.ws.on("message", messageHandler);
                 // Track event handler removal for automatic cleanup
                 this.resources.track(() => {
                     if (this.ws) {
-                        this.ws.off('message', messageHandler);
+                        this.ws.off("message", messageHandler);
                     }
                 });
                 // Connection closure handler
                 const closeHandler = (code, reason) => {
-                    const reasonStr = reason ? `: ${reason}` : '';
+                    const reasonStr = reason ? `: ${reason}` : "";
                     const closeInfo = `Connection closed (code: ${code})${reasonStr}`;
                     // Emit the disconnected event with structured data for better handling
-                    this.events.emit('disconnected', {
+                    this.events.emit("disconnected", {
                         message: closeInfo,
                         code: code,
-                        reason: reason || '',
+                        reason: reason || "",
                         wasClean: code === 1000 || code === 1001,
                     });
                     // Only attempt reconnection for abnormal closures
@@ -483,8 +490,8 @@ class AppSession {
                     // 1000 (Normal Closure) and 1001 (Going Away) are normal
                     // 1002-1015 are abnormal, and reason "App stopped" means intentional closure
                     // 1008 usually when the userSession no longer exists on server. i.e user disconnected from cloud.
-                    const isNormalClosure = (code === 1000 || code === 1001 || code === 1008);
-                    const isManualStop = reason && reason.includes('App stopped');
+                    const isNormalClosure = code === 1000 || code === 1001 || code === 1008;
+                    const isManualStop = reason && reason.includes("App stopped");
                     // Log closure details for diagnostics
                     this.logger.debug(`🔌 [${this.config.packageName}] WebSocket closed with code ${code}${reasonStr}`);
                     this.logger.debug(`🔌 [${this.config.packageName}] isNormalClosure: ${isNormalClosure}, isManualStop: ${isManualStop}`);
@@ -496,27 +503,27 @@ class AppSession {
                         this.logger.debug(`🔌 [${this.config.packageName}] Normal closure detected, not attempting reconnection`);
                     }
                 };
-                this.ws.on('close', closeHandler);
+                this.ws.on("close", closeHandler);
                 // Track event handler removal
                 this.resources.track(() => {
                     if (this.ws) {
-                        this.ws.off('close', closeHandler);
+                        this.ws.off("close", closeHandler);
                     }
                 });
                 // Connection error handler
                 const errorHandler = (error) => {
-                    this.logger.error(error, 'WebSocket error');
-                    this.events.emit('error', error);
+                    this.logger.error(error, "WebSocket error");
+                    this.events.emit("error", error);
                 };
                 // Enhanced error handler with detailed logging
-                this.ws.on('error', (error) => {
+                this.ws.on("error", (error) => {
                     this.logger.error(error, `⛔️⛔️⛔️ [${this.config.packageName}] WebSocket connection error: ${error.message}`);
                     // Try to provide more context
-                    const errMsg = error.message || '';
-                    if (errMsg.includes('ECONNREFUSED')) {
+                    const errMsg = error.message || "";
+                    if (errMsg.includes("ECONNREFUSED")) {
                         this.logger.error(`⛔️⛔️⛔️ [${this.config.packageName}] Connection refused - Check if the server is running at the specified URL`);
                     }
-                    else if (errMsg.includes('ETIMEDOUT')) {
+                    else if (errMsg.includes("ETIMEDOUT")) {
                         this.logger.error(`⛔️⛔️⛔️ [${this.config.packageName}] Connection timed out - Check network connectivity and firewall rules`);
                     }
                     errorHandler(error);
@@ -524,7 +531,7 @@ class AppSession {
                 // Track event handler removal
                 this.resources.track(() => {
                     if (this.ws) {
-                        this.ws.off('error', errorHandler);
+                        this.ws.off("error", errorHandler);
                     }
                 });
                 // Set up connection success handler
@@ -538,10 +545,10 @@ class AppSession {
                     this.logger.error({
                         config: this.config,
                         sessionId: this.sessionId,
-                        timeoutMs
+                        timeoutMs,
                     }, `⏱️⏱️⏱️ [${this.config.packageName}] Connection timeout after ${timeoutMs}ms`);
-                    this.events.emit('error', new Error(`Connection timeout after ${timeoutMs}ms`));
-                    reject(new Error('Connection timeout'));
+                    this.events.emit("error", new Error(`Connection timeout after ${timeoutMs}ms`));
+                    reject(new Error("Connection timeout"));
                 }, timeoutMs);
                 // Clear timeout on successful connection
                 const timeoutCleanup = this.events.onConnected(() => {
@@ -552,7 +559,7 @@ class AppSession {
                 this.resources.track(timeoutCleanup);
             }
             catch (error) {
-                this.logger.error(error, 'Connection setup error');
+                this.logger.error(error, "Connection setup error");
                 const errorMessage = error instanceof Error ? error.message : String(error);
                 reject(new Error(`Failed to setup connection: ${errorMessage}`));
             }
@@ -621,7 +628,7 @@ class AppSession {
             const newSubscriptions = this.subscriptionSettingsHandler(this.settingsData);
             // Update all subscriptions at once
             this.subscriptions.clear();
-            newSubscriptions.forEach(subscription => {
+            newSubscriptions.forEach((subscription) => {
                 this.subscriptions.add(subscription);
             });
             // Send subscription update to cloud if connected
@@ -630,9 +637,9 @@ class AppSession {
             }
         }
         catch (error) {
-            this.logger.error(error, 'Error updating subscriptions from settings');
+            this.logger.error(error, "Error updating subscriptions from settings");
             const errorMessage = error instanceof Error ? error.message : String(error);
-            this.events.emit('error', new Error(`Failed to update subscriptions: ${errorMessage}`));
+            this.events.emit("error", new Error(`Failed to update subscriptions: ${errorMessage}`));
         }
     }
     /**
@@ -645,7 +652,7 @@ class AppSession {
         // Update the settings manager with the new settings
         this.settings.updateSettings(newSettings);
         // Emit update event for backwards compatibility
-        this.events.emit('settings_update', this.settingsData);
+        this.events.emit("settings_update", this.settingsData);
         // Check if we should update subscriptions
         if (this.shouldUpdateSubscriptionsOnSettingsChange) {
             this.updateSubscriptionsFromSettings();
@@ -665,7 +672,7 @@ class AppSession {
                 return parsedConfig;
             }
             else {
-                throw new Error('Invalid App configuration format');
+                throw new Error("Invalid App configuration format");
             }
         }
         catch (error) {
@@ -695,11 +702,11 @@ class AppSession {
     }
     static convertToHttps(rawUrl) {
         if (!rawUrl)
-            return '';
+            return "";
         // Remove ws:// or wss://
-        let url = rawUrl.replace(/^wss?:\/\//, '');
+        let url = rawUrl.replace(/^wss?:\/\//, "");
         // Remove trailing /app-ws
-        url = url.replace(/\/app-ws$/, '');
+        url = url.replace(/\/app-ws$/, "");
         // Prepend https://
         return `https://${url}`;
     }
@@ -710,13 +717,13 @@ class AppSession {
      */
     getDefaultSettings() {
         if (!this.appConfig) {
-            throw new Error('App configuration not loaded. Call loadConfigFromJson first.');
+            throw new Error("App configuration not loaded. Call loadConfigFromJson first.");
         }
         return this.appConfig.settings
-            .filter((s) => s.type !== 'group')
+            .filter((s) => s.type !== "group")
             .map((s) => ({
             ...s,
-            value: s.defaultValue // Set value to defaultValue
+            value: s.defaultValue, // Set value to defaultValue
         }));
     }
     /**
@@ -727,7 +734,7 @@ class AppSession {
     getSettingSchema(key) {
         if (!this.appConfig)
             return undefined;
-        const setting = this.appConfig.settings.find((s) => s.type !== 'group' && 'key' in s && s.key === key);
+        const setting = this.appConfig.settings.find((s) => s.type !== "group" && "key" in s && s.key === key);
         return setting;
     }
     // =====================================
@@ -740,7 +747,7 @@ class AppSession {
         try {
             // Validate message before processing
             if (!this.validateMessage(message)) {
-                this.events.emit('error', new Error('Invalid message format received'));
+                this.events.emit("error", new Error("Invalid message format received"));
                 return;
             }
             // Handle binary data (audio or video)
@@ -764,7 +771,7 @@ class AppSession {
                             this.settingsData = this.getDefaultSettings();
                         }
                         catch (error) {
-                            this.logger.warn('Failed to load default settings from config:', error);
+                            this.logger.warn("Failed to load default settings from config:", error);
                         }
                     }
                     // Update the settings manager with the new settings
@@ -787,18 +794,20 @@ class AppSession {
                         this.logger.debug(`[AppSession] No capabilities provided in CONNECTION_ACK`);
                     }
                     // Emit connected event with settings
-                    this.events.emit('connected', this.settingsData);
+                    this.events.emit("connected", this.settingsData);
                     // Update subscriptions (normal flow)
                     this.updateSubscriptions();
                     // If settings-based subscriptions are enabled, update those too
-                    if (this.shouldUpdateSubscriptionsOnSettingsChange && this.settingsData.length > 0) {
+                    if (this.shouldUpdateSubscriptionsOnSettingsChange &&
+                        this.settingsData.length > 0) {
                         this.updateSubscriptionsFromSettings();
                     }
                 }
-                else if ((0, types_1.isAppConnectionError)(message) || message.type === 'connection_error') {
+                else if ((0, types_1.isAppConnectionError)(message) ||
+                    message.type === "connection_error") {
                     // Handle both App-specific connection_error and standard connection_error
-                    const errorMessage = message.message || 'Unknown connection error';
-                    this.events.emit('error', new Error(errorMessage));
+                    const errorMessage = message.message || "Unknown connection error";
+                    this.events.emit("error", new Error(errorMessage));
                 }
                 else if (message.type === types_1.StreamType.AUDIO_CHUNK) {
                     if (this.subscriptions.has(types_1.StreamType.AUDIO_CHUNK)) {
@@ -808,19 +817,18 @@ class AppSession {
                 }
                 else if ((0, types_1.isDataStream)(message)) {
                     // Ensure streamType exists before emitting the event
-                    let messageStreamType = message.streamType;
-                    if (message.streamType === types_1.StreamType.TRANSCRIPTION) {
-                        const transcriptionData = message.data;
-                        if (transcriptionData.transcribeLanguage) {
-                            messageStreamType = (0, types_1.createTranscriptionStream)(transcriptionData.transcribeLanguage);
-                        }
-                    }
-                    else if (message.streamType === types_1.StreamType.TRANSLATION) {
-                        const translationData = message.data;
-                        if (translationData.transcribeLanguage && translationData.translateLanguage) {
-                            messageStreamType = (0, types_1.createTranslationStream)(translationData.transcribeLanguage, translationData.translateLanguage);
-                        }
-                    }
+                    const messageStreamType = message.streamType;
+                    // if (message.streamType === StreamType.TRANSCRIPTION) {
+                    //   const transcriptionData = message.data as TranscriptionData;
+                    //   if (transcriptionData.transcribeLanguage) {
+                    //     messageStreamType = createTranscriptionStream(transcriptionData.transcribeLanguage) as ExtendedStreamType;
+                    //   }
+                    // } else if (message.streamType === StreamType.TRANSLATION) {
+                    //   const translationData = message.data as TranslationData;
+                    //   if (translationData.transcribeLanguage && translationData.translateLanguage) {
+                    //     messageStreamType = createTranslationStream(translationData.transcribeLanguage, translationData.translateLanguage) as ExtendedStreamType;
+                    //   }
+                    // }
                     if (messageStreamType && this.subscriptions.has(messageStreamType)) {
                         const sanitizedData = this.sanitizeEventData(messageStreamType, message.data);
                         this.events.emit(messageStreamType, sanitizedData);
@@ -850,16 +858,16 @@ class AppSession {
                     // Update the settings manager with the new settings
                     const changes = this.settings.updateSettings(this.settingsData);
                     // Emit settings update event (for backwards compatibility)
-                    this.events.emit('settings_update', this.settingsData);
+                    this.events.emit("settings_update", this.settingsData);
                     // --- MentraOS settings update logic ---
                     // If the message.settings looks like MentraOS settings (object with known keys), update mentraosSettings
-                    if (message.settings && typeof message.settings === 'object') {
+                    if (message.settings && typeof message.settings === "object") {
                         this.settings.updateMentraosSettings(message.settings);
                     }
                     // Check if we should update subscriptions
                     if (this.shouldUpdateSubscriptionsOnSettingsChange) {
                         // Check if any subscription trigger settings changed
-                        const shouldUpdateSubs = this.subscriptionUpdateTriggers.some(key => {
+                        const shouldUpdateSubs = this.subscriptionUpdateTriggers.some((key) => {
                             return key in changes;
                         });
                         if (shouldUpdateSubs) {
@@ -867,11 +875,23 @@ class AppSession {
                         }
                     }
                 }
+                else if ((0, types_1.isCapabilitiesUpdate)(message)) {
+                    // Update device capabilities
+                    const capabilitiesMessage = message;
+                    this.capabilities = capabilitiesMessage.capabilities;
+                    this.logger.info(capabilitiesMessage.capabilities, `[AppSession] Capabilities updated for model: ${capabilitiesMessage.modelName}`);
+                    // Emit capabilities update event for applications to handle
+                    this.events.emit("capabilities_update", {
+                        capabilities: capabilitiesMessage.capabilities,
+                        modelName: capabilitiesMessage.modelName,
+                        timestamp: capabilitiesMessage.timestamp,
+                    });
+                }
                 else if ((0, types_1.isAppStopped)(message)) {
-                    const reason = message.reason || 'unknown';
+                    const reason = message.reason || "unknown";
                     const displayReason = `App stopped: ${reason}`;
                     // Emit disconnected event with clean closure info to prevent reconnection attempts
-                    this.events.emit('disconnected', {
+                    this.events.emit("disconnected", {
                         message: displayReason,
                         code: 1000, // Normal closure code
                         reason: displayReason,
@@ -884,14 +904,14 @@ class AppSession {
                 else if ((0, types_1.isDashboardModeChanged)(message)) {
                     try {
                         // Use proper type
-                        const mode = message.mode || 'none';
+                        const mode = message.mode || "none";
                         // Update dashboard state in the API
-                        if (this.dashboard && 'content' in this.dashboard) {
+                        if (this.dashboard && "content" in this.dashboard) {
                             this.dashboard.content.setCurrentMode(mode);
                         }
                     }
                     catch (error) {
-                        this.logger.error(error, 'Error handling dashboard mode change');
+                        this.logger.error(error, "Error handling dashboard mode change");
                     }
                 }
                 // Handle always-on dashboard state changes
@@ -900,75 +920,78 @@ class AppSession {
                         // Use proper type
                         const enabled = !!message.enabled;
                         // Update dashboard state in the API
-                        if (this.dashboard && 'content' in this.dashboard) {
+                        if (this.dashboard && "content" in this.dashboard) {
                             this.dashboard.content.setAlwaysOnEnabled(enabled);
                         }
                     }
                     catch (error) {
-                        this.logger.error(error, 'Error handling dashboard always-on change');
+                        this.logger.error(error, "Error handling dashboard always-on change");
                     }
                 }
                 // Handle custom messages
                 else if (message.type === types_1.CloudToAppMessageType.CUSTOM_MESSAGE) {
-                    this.events.emit('custom_message', message);
+                    this.events.emit("custom_message", message);
                     return;
                 }
                 // Handle App-to-App communication messages
-                else if (message.type === 'app_message_received') {
-                    this.appEvents.emit('app_message_received', message);
+                else if (message.type === "app_message_received") {
+                    this.appEvents.emit("app_message_received", message);
                 }
-                else if (message.type === 'app_user_joined') {
-                    this.appEvents.emit('app_user_joined', message);
+                else if (message.type === "app_user_joined") {
+                    this.appEvents.emit("app_user_joined", message);
                 }
-                else if (message.type === 'app_user_left') {
-                    this.appEvents.emit('app_user_left', message);
+                else if (message.type === "app_user_left") {
+                    this.appEvents.emit("app_user_left", message);
                 }
-                else if (message.type === 'app_room_updated') {
-                    this.appEvents.emit('app_room_updated', message);
+                else if (message.type === "app_room_updated") {
+                    this.appEvents.emit("app_room_updated", message);
                 }
-                else if (message.type === 'app_direct_message_response') {
+                else if (message.type === "app_direct_message_response") {
                     const response = message;
-                    if (response.messageId && this.pendingDirectMessages.has(response.messageId)) {
+                    if (response.messageId &&
+                        this.pendingDirectMessages.has(response.messageId)) {
                         const { resolve } = this.pendingDirectMessages.get(response.messageId);
                         resolve(response.success);
                         this.pendingDirectMessages.delete(response.messageId);
                     }
                 }
-                else if (message.type === 'augmentos_settings_update') {
+                else if (message.type === "augmentos_settings_update") {
                     const mentraosMsg = message;
-                    if (mentraosMsg.settings && typeof mentraosMsg.settings === 'object') {
+                    if (mentraosMsg.settings &&
+                        typeof mentraosMsg.settings === "object") {
                         this.settings.updateMentraosSettings(mentraosMsg.settings);
                     }
                 }
                 // Handle 'connection_error' as a specific case if cloud sends this string literal
-                else if (message.type === 'connection_error') {
+                else if (message.type === "connection_error") {
                     // Treat 'connection_error' (string literal) like AppConnectionError
                     // This handles cases where the cloud might send the type as a direct string
                     // instead of the enum's 'tpa_connection_error' value.
-                    const errorMessage = message.message || 'Unknown connection error (type: connection_error)';
+                    const errorMessage = message.message ||
+                        "Unknown connection error (type: connection_error)";
                     this.logger.warn(`Received 'connection_error' type directly. Consider aligning cloud to send 'tpa_connection_error'. Message: ${errorMessage}`);
-                    this.events.emit('error', new Error(errorMessage));
+                    this.events.emit("error", new Error(errorMessage));
                 }
-                else if (message.type === 'permission_error') {
+                else if (message.type === "permission_error") {
                     // Handle permission errors from cloud
-                    this.logger.warn('Permission error received:', {
+                    this.logger.warn("Permission error received:", {
                         message: message.message,
                         details: message.details,
                         detailsCount: message.details?.length || 0,
-                        rejectedStreams: message.details?.map(d => d.stream) || []
+                        rejectedStreams: message.details?.map((d) => d.stream) || [],
                     });
                     // Emit permission error event for application handling
-                    this.events.emit('permission_error', {
+                    this.events.emit("permission_error", {
                         message: message.message,
                         details: message.details,
-                        timestamp: message.timestamp
+                        timestamp: message.timestamp,
                     });
                     // Optionally emit individual permission denied events for each stream
-                    message.details?.forEach(detail => {
-                        this.events.emit('permission_denied', {
+                    message.details?.forEach((detail) => {
+                        this.events.emit("permission_denied", {
                             stream: detail.stream,
                             requiredPermission: detail.requiredPermission,
-                            message: detail.message
+                            message: detail.message,
                         });
                     });
                 }
@@ -981,26 +1004,28 @@ class AppSession {
                 else if ((0, cloud_to_app_1.isPhotoResponse)(message)) {
                     // Legacy photo response handling - now photos come directly via webhook
                     // This branch can be removed in the future as all photos now go through /photo-upload
-                    this.logger.warn('Received legacy photo response - photos should now come via /photo-upload webhook');
+                    this.logger.warn("Received legacy photo response - photos should now come via /photo-upload webhook");
                 }
                 // Handle unrecognized message types gracefully
                 else {
                     this.logger.warn(`Unrecognized message type: ${message.type}`);
-                    this.events.emit('error', new Error(`Unrecognized message type: ${message.type}`));
+                    this.events.emit("error", new Error(`Unrecognized message type: ${message.type}`));
                 }
             }
             catch (processingError) {
                 // Catch any errors during message processing to prevent App crashes
-                this.logger.error(processingError, 'Error processing message:');
-                const errorMessage = processingError instanceof Error ? processingError.message : String(processingError);
-                this.events.emit('error', new Error(`Error processing message: ${errorMessage}`));
+                this.logger.error(processingError, "Error processing message:");
+                const errorMessage = processingError instanceof Error
+                    ? processingError.message
+                    : String(processingError);
+                this.events.emit("error", new Error(`Error processing message: ${errorMessage}`));
             }
         }
         catch (error) {
             // Final safety net to ensure the App doesn't crash on any unexpected errors
-            this.logger.error(error, 'Unexpected error in message handler');
+            this.logger.error(error, "Unexpected error in message handler");
             const errorMessage = error instanceof Error ? error.message : String(error);
-            this.events.emit('error', new Error(`Unexpected error in message handler: ${errorMessage}`));
+            this.events.emit("error", new Error(`Unexpected error in message handler: ${errorMessage}`));
         }
     }
     /**
@@ -1018,7 +1043,7 @@ class AppSession {
             return false;
         }
         // Check if message has a type property
-        if (!('type' in message)) {
+        if (!("type" in message)) {
             return false;
         }
         // All other message types should be objects with a type property
@@ -1036,7 +1061,7 @@ class AppSession {
             }
             // Validate buffer has content before processing
             if (!buffer || buffer.byteLength === 0) {
-                this.events.emit('error', new Error('Received empty binary message'));
+                this.events.emit("error", new Error("Received empty binary message"));
                 return;
             }
             // Create a safety wrapped audio chunk with proper defaults
@@ -1044,15 +1069,15 @@ class AppSession {
                 type: types_1.StreamType.AUDIO_CHUNK,
                 timestamp: new Date(),
                 arrayBuffer: buffer,
-                sampleRate: 16000 // Default sample rate
+                sampleRate: 16000, // Default sample rate
             };
             // Emit to subscribers
             this.events.emit(types_1.StreamType.AUDIO_CHUNK, audioChunk);
         }
         catch (error) {
-            this.logger.error(error, 'Error processing binary message');
+            this.logger.error(error, "Error processing binary message");
             const errorMessage = error instanceof Error ? error.message : String(error);
-            this.events.emit('error', new Error(`Error processing binary message: ${errorMessage}`));
+            this.events.emit("error", new Error(`Error processing binary message: ${errorMessage}`));
         }
     }
     /**
@@ -1071,12 +1096,12 @@ class AppSession {
             switch (streamType) {
                 case types_1.StreamType.TRANSCRIPTION:
                     // Ensure text field exists and is a string
-                    if (typeof data.text !== 'string') {
+                    if (typeof data.text !== "string") {
                         return {
-                            text: '',
+                            text: "",
                             isFinal: true,
                             startTime: Date.now(),
-                            endTime: Date.now()
+                            endTime: Date.now(),
                         };
                     }
                     break;
@@ -1084,15 +1109,19 @@ class AppSession {
                     // Ensure position data has required numeric fields
                     // Handle HeadPosition - Note the property position instead of x,y,z
                     const pos = data;
-                    if (typeof pos?.position !== 'string') {
-                        return { position: 'up', timestamp: new Date() };
+                    if (typeof pos?.position !== "string") {
+                        return { position: "up", timestamp: new Date() };
                     }
                     break;
                 case types_1.StreamType.BUTTON_PRESS:
                     // Ensure button type is valid
                     const btn = data;
                     if (!btn.buttonId || !btn.pressType) {
-                        return { buttonId: 'unknown', pressType: 'short', timestamp: new Date() };
+                        return {
+                            buttonId: "unknown",
+                            pressType: "short",
+                            timestamp: new Date(),
+                        };
                     }
                     break;
             }
@@ -1113,7 +1142,7 @@ class AppSession {
             sessionId: this.sessionId,
             packageName: this.config.packageName,
             apiKey: this.config.apiKey,
-            timestamp: new Date()
+            timestamp: new Date(),
         };
         this.send(message);
     }
@@ -1123,10 +1152,10 @@ class AppSession {
     updateSubscriptions() {
         this.logger.info(`[AppSession] updateSubscriptions: sending subscriptions to cloud:`, Array.from(this.subscriptions));
         // [MODIFIED] builds the array of SubscriptionRequest objects to send to the cloud
-        const subscriptionPayload = Array.from(this.subscriptions).map(stream => {
+        const subscriptionPayload = Array.from(this.subscriptions).map((stream) => {
             const rate = this.streamRates.get(stream);
             if (rate && stream === types_1.StreamType.LOCATION_STREAM) {
-                return { stream: 'location_stream', rate: rate };
+                return { stream: "location_stream", rate: rate };
             }
             return stream;
         });
@@ -1135,7 +1164,7 @@ class AppSession {
             packageName: this.config.packageName,
             subscriptions: subscriptionPayload, // [MODIFIED]
             sessionId: this.sessionId,
-            timestamp: new Date()
+            timestamp: new Date(),
         };
         this.send(message);
     }
@@ -1145,7 +1174,7 @@ class AppSession {
     async handleReconnection() {
         // Check if reconnection is allowed
         if (!this.config.autoReconnect || !this.sessionId) {
-            this.logger.debug(`🔄 Reconnection skipped: autoReconnect=${this.config.autoReconnect}, sessionId=${this.sessionId ? 'valid' : 'invalid'}`);
+            this.logger.debug(`🔄 Reconnection skipped: autoReconnect=${this.config.autoReconnect}, sessionId=${this.sessionId ? "valid" : "invalid"}`);
             return;
         }
         // Check if we've exceeded the maximum attempts
@@ -1153,12 +1182,12 @@ class AppSession {
         if (this.reconnectAttempts >= maxAttempts) {
             this.logger.info(`🔄 Maximum reconnection attempts (${maxAttempts}) reached, giving up`);
             // Emit a permanent disconnection event to trigger onStop in the App server
-            this.events.emit('disconnected', {
+            this.events.emit("disconnected", {
                 message: `Connection permanently lost after ${maxAttempts} failed reconnection attempts`,
                 code: 4000, // Custom code for max reconnection attempts exhausted
-                reason: 'Maximum reconnection attempts exceeded',
+                reason: "Maximum reconnection attempts exceeded",
                 wasClean: false,
-                permanent: true // Flag this as a permanent disconnection
+                permanent: true, // Flag this as a permanent disconnection
             });
             return;
         }
@@ -1168,7 +1197,7 @@ class AppSession {
         this.reconnectAttempts++;
         this.logger.debug(`🔄 [${this.config.packageName}] Reconnection attempt ${this.reconnectAttempts}/${maxAttempts} in ${delay}ms`);
         // Use the resource tracker for the timeout
-        await new Promise(resolve => {
+        await new Promise((resolve) => {
             this.resources.setTimeout(() => resolve(), delay);
         });
         try {
@@ -1180,17 +1209,17 @@ class AppSession {
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             this.logger.error(error, `❌ [${this.config.packageName}] Reconnection failed for user ${this.userId}`);
-            this.events.emit('error', new Error(`Reconnection failed: ${errorMessage}`));
+            this.events.emit("error", new Error(`Reconnection failed: ${errorMessage}`));
             // Check if this was the last attempt
             if (this.reconnectAttempts >= maxAttempts) {
                 this.logger.debug(`🔄 [${this.config.packageName}] Final reconnection attempt failed, emitting permanent disconnection`);
                 // Emit permanent disconnection event after the last failed attempt
-                this.events.emit('disconnected', {
+                this.events.emit("disconnected", {
                     message: `Connection permanently lost after ${maxAttempts} failed reconnection attempts`,
                     code: 4000, // Custom code for max reconnection attempts exhausted
-                    reason: 'Maximum reconnection attempts exceeded',
+                    reason: "Maximum reconnection attempts exceeded",
                     wasClean: false,
-                    permanent: true // Flag this as a permanent disconnection
+                    permanent: true, // Flag this as a permanent disconnection
                 });
             }
         }
@@ -1203,27 +1232,27 @@ class AppSession {
         try {
             // Verify WebSocket connection is valid
             if (!this.ws) {
-                throw new Error('WebSocket connection not established');
+                throw new Error("WebSocket connection not established");
             }
             if (this.ws.readyState !== 1) {
                 const stateMap = {
-                    0: 'CONNECTING',
-                    1: 'OPEN',
-                    2: 'CLOSING',
-                    3: 'CLOSED'
+                    0: "CONNECTING",
+                    1: "OPEN",
+                    2: "CLOSING",
+                    3: "CLOSED",
                 };
-                const stateName = stateMap[this.ws.readyState] || 'UNKNOWN';
+                const stateName = stateMap[this.ws.readyState] || "UNKNOWN";
                 throw new Error(`WebSocket not connected (current state: ${stateName})`);
             }
             // Validate message before sending
-            if (!message || typeof message !== 'object') {
-                throw new Error('Invalid message: must be an object');
+            if (!message || typeof message !== "object") {
+                throw new Error("Invalid message: must be an object");
             }
-            if (!('type' in message)) {
+            if (!("type" in message)) {
                 throw new Error('Invalid message: missing "type" property');
             }
             // Ensure message format is consistent
-            if (!('timestamp' in message) || !(message.timestamp instanceof Date)) {
+            if (!("timestamp" in message) || !(message.timestamp instanceof Date)) {
                 message.timestamp = new Date();
             }
             // Try to send with error handling
@@ -1238,13 +1267,13 @@ class AppSession {
         }
         catch (error) {
             // Log the error and emit an event so App developers are aware
-            this.logger.error(error, 'Message send error');
+            this.logger.error(error, "Message send error");
             // Ensure we always emit an Error object
             if (error instanceof Error) {
-                this.events.emit('error', error);
+                this.events.emit("error", error);
             }
             else {
-                this.events.emit('error', new Error(String(error)));
+                this.events.emit("error", new Error(String(error)));
             }
             // Re-throw to maintain the original function behavior
             throw error;
@@ -1257,11 +1286,13 @@ class AppSession {
     async getInstructions() {
         try {
             const baseUrl = this.getServerUrl();
-            const response = await axios_1.default.get(`${baseUrl}/api/instructions`, { params: { userId: this.userId } });
+            const response = await axios_1.default.get(`${baseUrl}/api/instructions`, {
+                params: { userId: this.userId },
+            });
             return response.data.instructions || null;
         }
         catch (err) {
-            this.logger.error('Error fetching instructions from backend:', err);
+            this.logger.error("Error fetching instructions from backend:", err);
             return null;
         }
     }
@@ -1276,26 +1307,26 @@ class AppSession {
     async discoverAppUsers(domain, includeProfiles = false) {
         // Use the domain argument as the base URL if provided
         if (!domain) {
-            throw new Error('Domain (API base URL) is required for user discovery');
+            throw new Error("Domain (API base URL) is required for user discovery");
         }
         const url = `${domain}/api/app-communication/discover-users`;
         // Use the user's core token for authentication
         const appApiKey = this.config.apiKey; // This may need to be updated if you store the core token elsewhere
         if (!appApiKey) {
-            throw new Error('Core token (apiKey) is required for user discovery');
+            throw new Error("Core token (apiKey) is required for user discovery");
         }
         const body = {
             packageName: this.config.packageName,
             userId: this.userId,
-            includeUserProfiles: includeProfiles
+            includeUserProfiles: includeProfiles,
         };
         const response = await (0, node_fetch_1.default)(url, {
-            method: 'POST',
+            method: "POST",
             headers: {
-                'Authorization': `Bearer ${appApiKey}`,
-                'Content-Type': 'application/json'
+                Authorization: `Bearer ${appApiKey}`,
+                "Content-Type": "application/json",
             },
-            body: JSON.stringify(body)
+            body: JSON.stringify(body),
         });
         if (!response.ok) {
             const errorText = await response.text();
@@ -1310,11 +1341,11 @@ class AppSession {
      */
     async isUserActive(userId) {
         try {
-            const userList = await this.discoverAppUsers('', false);
+            const userList = await this.discoverAppUsers("", false);
             return userList.users.some((user) => user.userId === userId);
         }
         catch (error) {
-            this.logger.error({ error, userId }, 'Error checking if user is active');
+            this.logger.error({ error, userId }, "Error checking if user is active");
             return false;
         }
     }
@@ -1328,7 +1359,7 @@ class AppSession {
             return userList.totalUsers;
         }
         catch (error) {
-            this.logger.error(error, 'Error getting user count');
+            this.logger.error(error, "Error getting user count");
             return 0;
         }
     }
@@ -1342,13 +1373,13 @@ class AppSession {
         try {
             const messageId = this.generateMessageId();
             const message = {
-                type: 'app_broadcast_message',
+                type: "app_broadcast_message",
                 packageName: this.config.packageName,
                 sessionId: this.sessionId,
                 payload,
                 messageId,
                 senderUserId: this.userId,
-                timestamp: new Date()
+                timestamp: new Date(),
             };
             this.send(message);
         }
@@ -1370,21 +1401,23 @@ class AppSession {
                 // Store promise resolver
                 this.pendingDirectMessages.set(messageId, { resolve, reject });
                 const message = {
-                    type: 'app_direct_message',
+                    type: "app_direct_message",
                     packageName: this.config.packageName,
                     sessionId: this.sessionId,
                     targetUserId,
                     payload,
                     messageId,
                     senderUserId: this.userId,
-                    timestamp: new Date()
+                    timestamp: new Date(),
                 };
                 this.send(message);
                 // Set timeout to avoid hanging promises
                 const timeoutMs = 15000; // 15 seconds
                 this.resources.setTimeout(() => {
                     if (this.pendingDirectMessages.has(messageId)) {
-                        this.pendingDirectMessages.get(messageId).reject(new Error('Direct message timed out'));
+                        this.pendingDirectMessages
+                            .get(messageId)
+                            .reject(new Error("Direct message timed out"));
                         this.pendingDirectMessages.delete(messageId);
                     }
                 }, timeoutMs);
@@ -1404,12 +1437,12 @@ class AppSession {
     async joinAppRoom(roomId, roomConfig) {
         try {
             const message = {
-                type: 'app_room_join',
+                type: "app_room_join",
                 packageName: this.config.packageName,
                 sessionId: this.sessionId,
                 roomId,
                 roomConfig,
-                timestamp: new Date()
+                timestamp: new Date(),
             };
             this.send(message);
         }
@@ -1426,11 +1459,11 @@ class AppSession {
     async leaveAppRoom(roomId) {
         try {
             const message = {
-                type: 'app_room_leave',
+                type: "app_room_leave",
                 packageName: this.config.packageName,
                 sessionId: this.sessionId,
                 roomId,
-                timestamp: new Date()
+                timestamp: new Date(),
             };
             this.send(message);
         }
@@ -1445,8 +1478,8 @@ class AppSession {
      * @returns Cleanup function to remove the handler
      */
     onAppMessage(handler) {
-        this.appEvents.on('app_message_received', handler);
-        return () => this.appEvents.off('app_message_received', handler);
+        this.appEvents.on("app_message_received", handler);
+        return () => this.appEvents.off("app_message_received", handler);
     }
     /**
      * 👋 Listen for user join events
@@ -1454,8 +1487,8 @@ class AppSession {
      * @returns Cleanup function to remove the handler
      */
     onAppUserJoined(handler) {
-        this.appEvents.on('app_user_joined', handler);
-        return () => this.appEvents.off('app_user_joined', handler);
+        this.appEvents.on("app_user_joined", handler);
+        return () => this.appEvents.off("app_user_joined", handler);
     }
     /**
      * 🚪 Listen for user leave events
@@ -1463,8 +1496,8 @@ class AppSession {
      * @returns Cleanup function to remove the handler
      */
     onAppUserLeft(handler) {
-        this.appEvents.on('app_user_left', handler);
-        return () => this.appEvents.off('app_user_left', handler);
+        this.appEvents.on("app_user_left", handler);
+        return () => this.appEvents.off("app_user_left", handler);
     }
     /**
      * 🏠 Listen for room update events
@@ -1472,8 +1505,8 @@ class AppSession {
      * @returns Cleanup function to remove the handler
      */
     onAppRoomUpdated(handler) {
-        this.appEvents.on('app_room_updated', handler);
-        return () => this.appEvents.off('app_room_updated', handler);
+        this.appEvents.on("app_room_updated", handler);
+        return () => this.appEvents.off("app_room_updated", handler);
     }
     /**
      * 🔧 Generate unique message ID
@@ -1501,8 +1534,8 @@ class TpaSession extends AppSession {
     constructor(config) {
         super(config);
         // Emit a deprecation warning to help developers migrate
-        console.warn('⚠️  DEPRECATION WARNING: TpaSession is deprecated and will be removed in a future version. ' +
-            'Please use AppSession instead. ' +
+        console.warn("⚠️  DEPRECATION WARNING: TpaSession is deprecated and will be removed in a future version. " +
+            "Please use AppSession instead. " +
             'Simply replace "TpaSession" with "AppSession" in your code.');
     }
 }