@mentra/bluetooth-sdk 3.2.0-dev.200 → 3.2.0-dev.203

package/android/src/main/java/com/mentra/bluetoothsdk/sgcs/SGCManager.kt

@@ -313,8 +313,10 @@ abstract class SGCManager {
 
     // Network Management
     abstract fun requestWifiScan(scanId: String?)
+    open fun requestSavedWifiNetworks(requestId: String, sid: String): Boolean = false
     abstract fun sendWifiCredentials(ssid: String, password: String)
     abstract fun forgetWifiNetwork(ssid: String)
+    open fun forgetWifiNetwork(ssid: String, requestId: String?, sid: String?): Boolean = false
     abstract fun sendHotspotState(enabled: Boolean)
 
     /** Set glasses system clock (Mentra Live and G2; no-op on other devices). */

package/android/src/main/java/com/mentra/bluetoothsdk/status/DeviceStatus.kt

@@ -189,6 +189,10 @@ data class VersionInfoResult(
     val appVersion: String,
     val packageName: String,
     val hotspotOtaVersion: Int,
+    val wifiForgetResultVersion: Int? = null,
+    val savedWifiNetworksVersion: Int? = null,
+    val versionInfoType: String? = null,
+    val sid: String? = null,
 ) {
     internal fun toMap(): Map<String, Any> =
         buildMap {
@@ -206,6 +210,10 @@ data class VersionInfoResult(
                 put("packageName", packageName)
             }
             put("hotspotOtaVersion", hotspotOtaVersion)
+            wifiForgetResultVersion?.let { put("wifiForgetResultVersion", it) }
+            savedWifiNetworksVersion?.let { put("savedWifiNetworksVersion", it) }
+            versionInfoType?.let { put("versionInfoType", it) }
+            sid?.let { put("sid", it) }
         }
 
     companion object {
@@ -236,6 +244,12 @@ data class VersionInfoResult(
                 packageName = stringValue(values, "packageName", "package_name") ?: "",
                 hotspotOtaVersion =
                     numberValue(values, "hotspotOtaVersion", "hotspot_ota_version") ?: 0,
+                wifiForgetResultVersion =
+                    numberValue(values, "wifiForgetResultVersion", "wifi_forget_result_version"),
+                savedWifiNetworksVersion =
+                    numberValue(values, "savedWifiNetworksVersion", "saved_wifi_networks_version"),
+                versionInfoType = stringValue(values, "versionInfoType", "version_info_type"),
+                sid = stringValue(values, "sid"),
             )
     }
 }

package/android/src/test/java/com/mentra/bluetoothsdk/GlassesStatusClassicAudioTest.kt

@@ -0,0 +1,14 @@
+package com.mentra.bluetoothsdk
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class GlassesStatusClassicAudioTest {
+    @Test
+    fun `serializes connected Classic audio state for React Native`() {
+        val serialized =
+                GlassesStatus.fromMap(mapOf("bluetoothClassicConnected" to true)).toMap()
+
+        assertThat(serialized["bluetoothClassicConnected"]).isEqualTo(true)
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/MessageAckPolicyTest.kt

@@ -0,0 +1,16 @@
+package com.mentra.bluetoothsdk
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class MessageAckPolicyTest {
+    @Test
+    fun `every non-ack message id is acknowledged regardless of type`() {
+        assertEquals(17L, incomingGlassesMessageAckId("wifi_forget_result", 17L))
+        assertEquals(18L, incomingGlassesMessageAckId("saved_wifi_networks", 18L))
+        assertEquals(19L, incomingGlassesMessageAckId("future_terminal_type", 19L))
+        assertNull(incomingGlassesMessageAckId("msg_ack", 20L))
+        assertNull(incomingGlassesMessageAckId("wifi_forget_result", null))
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/WifiRequestResolutionTest.kt

@@ -0,0 +1,271 @@
+package com.mentra.bluetoothsdk
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class WifiRequestResolutionTest {
+    @Test
+    fun `future fractional and malformed capabilities are unsupported not legacy`() {
+        for (version in listOf(0, 2, -1, 1.5, "1", true)) {
+            val capabilities = WifiSessionCapabilities()
+            capabilities.reset("sid")
+            capabilities.applyVersionInfo1(mapOf("wifiForgetResultVersion" to version, "savedWifiNetworksVersion" to version))
+            assertEquals(WifiRequestMode.UNSUPPORTED, capabilities.forgetMode())
+            assertEquals(WifiRequestMode.UNSUPPORTED, capabilities.savedNetworksMode())
+        }
+        val missingSession = WifiSessionCapabilities()
+        missingSession.applyVersionInfo1(mapOf("wifiForgetResultVersion" to 1))
+        assertEquals(WifiRequestMode.UNSUPPORTED, missingSession.forgetMode())
+    }
+
+    @Test
+    fun `raw response rejects partial tuples and coercion before normalization`() {
+        val tuple = mapOf<String, Any>("protocol_version" to 1, "requestId" to "request", "sid" to "sid")
+        assertTrue(wifiResponseEnvelopeIsValid(tuple, false))
+        for (key in tuple.keys) assertFalse(wifiResponseEnvelopeIsValid(tuple - key, true))
+        for (version in listOf(0, 2, 1.5, "1", true)) {
+            assertFalse(wifiResponseEnvelopeIsValid(tuple + ("protocol_version" to version), true))
+        }
+        assertFalse(wifiResponseEnvelopeIsValid(tuple + ("connected" to 0), true))
+        assertFalse(wifiResponseEnvelopeIsValid(tuple + ("dispatched" to true), true))
+        assertTrue(wifiResponseEnvelopeIsValid(mapOf("dispatched" to true), true))
+        assertFalse(wifiResponseEnvelopeIsValid(mapOf("requestId" to "", "dispatched" to true), true))
+        assertFalse(wifiResponseEnvelopeIsValid(emptyMap(), false))
+    }
+
+    @Test
+    fun `semantic results omit transport metadata`() {
+        val data = mapOf<String, Any>("requestId" to "request", "sid" to "sid", "protocolVersion" to 1,
+            "ssid" to "AP", "outcome" to "confirmed", "networks" to listOf("AP"))
+        val forbidden = setOf("mode", "capabilityVersion", "requestId", "sid", "protocolVersion")
+        assertTrue(parseWifiForgetResult("request", "sid", "AP", 1, data)!!.toMap().keys.intersect(forbidden).isEmpty())
+        assertTrue(parseSavedWifiNetworks("request", "sid", 1, data)!!.toMap().keys.intersect(forbidden).isEmpty())
+        assertNull(parseWifiForgetResult("request", "sid", "AP", 1, data + ("protocolVersion" to 1.5)))
+        assertNull(parseSavedWifiNetworks("request", "sid", 1, data + ("protocolVersion" to 1.5)))
+    }
+
+    @Test
+    fun `capabilities are unknown per session until version info finalizes them`() {
+        val capabilities = WifiSessionCapabilities()
+        capabilities.reset("sid-1")
+
+        assertEquals(WifiRequestMode.DISCOVERING, capabilities.forgetMode())
+        assertEquals(WifiRequestMode.DISCOVERING, capabilities.savedNetworksMode())
+        capabilities.applyVersionInfo1(mapOf("sid" to "sid-1", "wifiForgetResultVersion" to 1))
+
+        assertEquals(WifiProtocolCapability.Supported(1), capabilities.forgetResult)
+        assertEquals(WifiProtocolCapability.Legacy, capabilities.savedNetworks)
+        assertEquals(WifiRequestMode.MODERN, capabilities.forgetMode())
+        assertEquals(WifiRequestMode.LEGACY, capabilities.savedNetworksMode())
+    }
+
+    @Test
+    fun `new session resets capabilities and advances epoch`() {
+        val capabilities = WifiSessionCapabilities()
+        capabilities.reset("sid-1")
+        capabilities.applyVersionInfo1(
+            mapOf("wifiForgetResultVersion" to 1, "savedWifiNetworksVersion" to 1)
+        )
+        val oldEpoch = capabilities.epoch
+
+        capabilities.reset("sid-2")
+
+        assertTrue(capabilities.epoch > oldEpoch)
+        assertEquals("sid-2", capabilities.sessionId)
+        assertEquals(WifiProtocolCapability.Unknown, capabilities.forgetResult)
+        assertEquals(WifiProtocolCapability.Unknown, capabilities.savedNetworks)
+    }
+
+    @Test
+    fun `saved request snapshot cannot mix mode with a later session`() {
+        val capabilities = WifiSessionCapabilities()
+        capabilities.reset("sid-1")
+        capabilities.applyVersionInfo1(mapOf("savedWifiNetworksVersion" to 1))
+        val first = capabilities.savedNetworksRequestSnapshot()
+
+        capabilities.reset("sid-2")
+        val second = capabilities.savedNetworksRequestSnapshot()
+
+        assertEquals(WifiRequestMode.MODERN, first.mode)
+        assertEquals("sid-1", first.sessionId)
+        assertEquals(WifiRequestMode.DISCOVERING, second.mode)
+        assertEquals("sid-2", second.sessionId)
+        assertTrue(second.epoch > first.epoch)
+    }
+
+    @Test
+    fun `SSID validation rejects blank input without changing identity`() {
+        assertFalse(wifiSsidIsValid("   "))
+        assertTrue(wifiSsidIsValid(" Field AP "))
+    }
+
+    @Test
+    fun `forget result requires exact id session ssid and protocol`() {
+        val exact =
+            mapOf<String, Any>(
+                "requestId" to "forget-1",
+                "sid" to "sid-1",
+                "ssid" to " Field AP ",
+                "protocolVersion" to 1,
+                "outcome" to "dispatched",
+                "connected" to false,
+            )
+
+        assertNull(parseWifiForgetResult("other", "sid-1", " Field AP ", 1, exact))
+        assertNull(parseWifiForgetResult("forget-1", "sid-1", " Field AP ", 1, exact - "requestId"))
+        assertNull(parseWifiForgetResult("forget-1", "other", " Field AP ", 1, exact))
+        assertNull(parseWifiForgetResult("forget-1", "sid-1", "Field AP", 1, exact))
+        assertNull(parseWifiForgetResult("forget-1", "sid-1", " Field AP ", 2, exact))
+        assertEquals(
+            WifiForgetOutcome.DISPATCHED,
+            parseWifiForgetResult("forget-1", "sid-1", " Field AP ", 1, exact)?.outcome,
+        )
+    }
+
+    @Test
+    fun `forget parser preserves each honest terminal outcome`() {
+        listOf("confirmed", "dispatched", "not_found", "unsupported", "failed").forEach { outcome ->
+            val parsed =
+                parseWifiForgetResult(
+                    "forget-1",
+                    "sid-1",
+                    "AP",
+                    1,
+                    mapOf(
+                        "requestId" to "forget-1",
+                        "sid" to "sid-1",
+                        "ssid" to "AP",
+                        "protocolVersion" to 1,
+                        "outcome" to outcome,
+                    ),
+                )
+            assertEquals(outcome, parsed?.outcome?.wireValue)
+        }
+    }
+
+    @Test
+    fun `missing connectivity snapshot remains unknown`() {
+        val parsed =
+            parseWifiForgetResult(
+                "forget-1",
+                "sid-1",
+                "AP",
+                1,
+                mapOf(
+                    "requestId" to "forget-1",
+                    "sid" to "sid-1",
+                    "ssid" to "AP",
+                    "protocolVersion" to 1,
+                    "outcome" to "dispatched",
+                ),
+            )
+
+        assertNull(parsed?.connected)
+        assertFalse(parsed?.toMap()?.containsKey("connected") ?: true)
+    }
+
+    @Test
+    fun `legacy forget is explicitly unverified`() {
+        val result =
+            legacyWifiForgetResult(
+                "AP",
+            )
+
+        assertFalse(result.toMap().keys.any { it in setOf("mode", "capabilityVersion", "requestId", "sid") })
+        assertEquals(WifiForgetOutcome.LEGACY_UNVERIFIED, result.outcome)
+        assertNull(result.connected)
+        assertNull(result.currentSsid)
+        assertNull(result.localIp)
+    }
+
+    @Test
+    fun `saved list preserves exact identity and requires correlation tuple`() {
+        val exact =
+            mapOf<String, Any>(
+                "requestId" to "saved-1",
+                "sid" to "sid-1",
+                "protocolVersion" to 1,
+                "outcome" to "confirmed",
+                "networks" to listOf(" Field AP ", "", "Field AP", " Field AP "),
+            )
+
+        assertNull(parseSavedWifiNetworks("other", "sid-1", 1, exact))
+        assertNull(parseSavedWifiNetworks("saved-1", "sid-1", 1, exact - "requestId"))
+        assertNull(parseSavedWifiNetworks("saved-1", "other", 1, exact))
+        assertNull(parseSavedWifiNetworks("saved-1", "sid-1", 2, exact))
+        assertEquals(
+            listOf(" Field AP ", "Field AP"),
+            parseSavedWifiNetworks("saved-1", "sid-1", 1, exact)?.networks,
+        )
+
+        val failure =
+            parseSavedWifiNetworks(
+                "saved-1",
+                "sid-1",
+                1,
+                exact + ("outcome" to "failed") + ("error" to "backend_failed") + ("networks" to emptyList<String>()),
+            )
+        assertEquals(SavedWifiNetworksOutcome.FAILED, failure?.outcome)
+        assertEquals("backend_failed", failure?.error)
+    }
+
+
+    @Test
+    fun `raw forget event preserves modern and legacy wire truth`() {
+        val modern =
+            normalizeWifiForgetResultEvent(
+                "forget-1",
+                "sid-1",
+                "AP",
+                1,
+                "dispatched",
+                null,
+                false,
+                "",
+                "",
+                null,
+            )
+        val legacy =
+            normalizeWifiForgetResultEvent(
+                "",
+                "",
+                "AP",
+                0,
+                "",
+                true,
+                false,
+                "",
+                "",
+                null,
+            )
+        val withoutSnapshot =
+            normalizeWifiForgetResultEvent(
+                "forget-unknown",
+                "sid-1",
+                "AP",
+                1,
+                "dispatched",
+                null,
+                null,
+                "",
+                "",
+                null,
+            )
+
+        assertEquals("modern", modern?.get("mode"))
+        assertEquals("dispatched", modern?.get("outcome"))
+        assertEquals("legacy", legacy?.get("mode"))
+        assertEquals(true, legacy?.get("dispatched"))
+        assertFalse(legacy?.containsKey("sid") ?: true)
+        assertFalse(withoutSnapshot?.containsKey("connected") ?: true)
+        assertNull(
+            normalizeWifiForgetResultEvent(
+                "bad", "", "AP", 0, "", null, false, "", "", null
+            )
+        )
+    }
+
+}

package/android/src/test/java/com/mentra/bluetoothsdk/sgcs/ClassicAudioConnectionTrackerTest.kt

@@ -0,0 +1,131 @@
+package com.mentra.bluetoothsdk.sgcs
+
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Test
+
+class ClassicAudioConnectionTrackerTest {
+    @Test
+    fun `available connected profile is sufficient even if the other query fails or never answers`() {
+        assertThat(readyClassicAudioSnapshot(mapOf(ClassicAudioProfile.A2DP to true)))
+            .containsExactly(ClassicAudioProfile.A2DP)
+        assertThat(readyClassicAudioSnapshot(mapOf(ClassicAudioProfile.HEADSET to true)))
+            .containsExactly(ClassicAudioProfile.HEADSET)
+    }
+
+    @Test
+    fun `missing profile never fabricates a disconnect during a profile switch`() {
+        assertThat(readyClassicAudioSnapshot(mapOf(ClassicAudioProfile.A2DP to false))).isNull()
+        assertThat(readyClassicAudioSnapshot(mapOf(ClassicAudioProfile.A2DP to false,
+            ClassicAudioProfile.HEADSET to false))).isEmpty()
+    }
+
+    private val address = "AA:BB:CC:DD:EE:FF"
+
+    private fun snapshot(tracker: ClassicAudioConnectionTracker, vararg profiles: ClassicAudioProfile) {
+        val ticket = tracker.beginSnapshot(address)!!
+        assertThat(tracker.applySnapshot(ticket, address, profiles.toSet())).isTrue()
+    }
+
+    @Test
+    fun `publishes complete A2DP and HFP snapshots without intermediate false negative`() {
+        val changes = mutableListOf<Boolean>()
+        val tracker = ClassicAudioConnectionTracker(changes::add)
+        tracker.setTarget(address)
+        snapshot(tracker, ClassicAudioProfile.A2DP)
+        snapshot(tracker, ClassicAudioProfile.HEADSET)
+        snapshot(tracker)
+        assertThat(changes).containsExactly(true, false)
+    }
+
+    @Test
+    fun `address comparison is case insensitive`() {
+        val tracker = ClassicAudioConnectionTracker {}
+        tracker.setTarget(address.lowercase())
+        snapshot(tracker, ClassicAudioProfile.A2DP)
+        assertThat(tracker.connected).isTrue()
+    }
+
+    @Test
+    fun `another device cannot request a snapshot`() {
+        val tracker = ClassicAudioConnectionTracker {}
+        tracker.setTarget(address)
+        assertThat(tracker.beginSnapshot("11:22:33:44:55:66")).isNull()
+    }
+
+    @Test
+    fun `late result for previous device cannot replace current profiles`() {
+        val tracker = ClassicAudioConnectionTracker {}
+        tracker.setTarget(address)
+        val ticket = tracker.beginSnapshot(address)!!
+        tracker.setTarget("11:22:33:44:55:66")
+        assertThat(tracker.applySnapshot(ticket, address, setOf(ClassicAudioProfile.A2DP))).isFalse()
+        assertThat(tracker.connected).isFalse()
+    }
+
+    @Test
+    fun `old response cannot resurrect reconnected session with same MAC`() {
+        val tracker = ClassicAudioConnectionTracker {}
+        tracker.setTarget(address)
+        val ticket = tracker.beginSnapshot(address)!!
+        tracker.invalidate(address)
+        tracker.setTarget(address)
+        snapshot(tracker)
+        assertThat(tracker.applySnapshot(ticket, address, setOf(ClassicAudioProfile.A2DP))).isFalse()
+        assertThat(tracker.connected).isFalse()
+    }
+
+    @Test
+    fun `newer query invalidates in flight snapshot even before its response arrives`() {
+        val tracker = ClassicAudioConnectionTracker {}
+        tracker.setTarget(address)
+        val first = tracker.beginSnapshot(address)!!
+        val second = tracker.beginSnapshot(address)!!
+        assertThat(tracker.applySnapshot(first, address, setOf(ClassicAudioProfile.A2DP))).isFalse()
+        assertThat(tracker.applySnapshot(second, address, emptySet())).isTrue()
+    }
+
+    @Test
+    fun `late disconnect snapshot cannot overwrite newer connected snapshot`() {
+        val tracker = ClassicAudioConnectionTracker {}
+        tracker.setTarget(address)
+        val old = tracker.beginSnapshot(address)!!
+        snapshot(tracker, ClassicAudioProfile.HEADSET)
+        assertThat(tracker.applySnapshot(old, address, emptySet())).isFalse()
+        assertThat(tracker.connected).isTrue()
+    }
+
+    @Test
+    fun `clear invalidates queries but retains target for retry`() {
+        val tracker = ClassicAudioConnectionTracker {}
+        tracker.setTarget(address)
+        val old = tracker.beginSnapshot(address)!!
+        assertThat(tracker.clear(address)).isTrue()
+        assertThat(tracker.applySnapshot(old, address, setOf(ClassicAudioProfile.A2DP))).isFalse()
+        snapshot(tracker, ClassicAudioProfile.A2DP)
+        assertThat(tracker.connected).isTrue()
+    }
+
+    @Test
+    fun `reset clears truth and prevents pending results from applying`() {
+        val changes = mutableListOf<Boolean>()
+        val tracker = ClassicAudioConnectionTracker(changes::add)
+        tracker.setTarget(address)
+        snapshot(tracker, ClassicAudioProfile.A2DP)
+        val ticket = tracker.beginSnapshot(address)!!
+        tracker.reset()
+        assertThat(tracker.applySnapshot(ticket, address, setOf(ClassicAudioProfile.A2DP))).isFalse()
+        assertThat(tracker.beginSnapshot(address)).isNull()
+        assertThat(changes).containsExactly(true, false)
+    }
+
+    @Test
+    fun `stale snapshot cannot emit audio routing notifications`() {
+        val tracker = ClassicAudioConnectionTracker {}
+        tracker.setTarget(address)
+        val old = tracker.beginSnapshot(address)!!
+        tracker.setTarget(address)
+        var notifications = 0
+        tracker.applySnapshot(old, address, setOf(ClassicAudioProfile.A2DP)) { notifications++ }
+        assertThat(notifications).isZero()
+    }
+}

package/build/BluetoothSdk.types.d.ts

@@ -99,6 +99,54 @@ export type WifiStatusChangeEvent = WifiStatus & {
      */
     error?: string;
 };
+export type WifiForgetOutcome = "confirmed" | "dispatched" | "not_found" | "unsupported" | "failed" | "legacy_unverified";
+export type WifiForgetResult = {
+    ssid: string;
+    outcome: WifiForgetOutcome;
+    connected?: boolean;
+    currentSsid?: string;
+    localIp?: string;
+    error?: string;
+};
+export type ModernWifiForgetResultEvent = {
+    type: "wifi_forget_result";
+    mode: "modern";
+    requestId: string;
+    sid: string;
+    ssid: string;
+    protocolVersion: number;
+    outcome: Exclude<WifiForgetOutcome, "legacy_unverified">;
+    connected?: boolean;
+    currentSsid?: string;
+    localIp?: string;
+    error?: string;
+};
+export type LegacyWifiForgetResultEvent = {
+    type: "wifi_forget_result";
+    mode: "legacy";
+    ssid: string;
+    dispatched: boolean;
+    connected?: boolean;
+    currentSsid?: string;
+    localIp?: string;
+    error?: string;
+};
+export type WifiForgetResultEvent = ModernWifiForgetResultEvent | LegacyWifiForgetResultEvent;
+export type SavedWifiNetworksOutcome = "confirmed" | "unsupported" | "failed";
+export type SavedWifiNetworksResult = {
+    outcome: SavedWifiNetworksOutcome;
+    networks: string[];
+    error?: string;
+};
+export type SavedWifiNetworksEvent = {
+    type: "saved_wifi_networks";
+    requestId: string;
+    sid: string;
+    protocolVersion: number;
+    outcome: SavedWifiNetworksOutcome;
+    networks: string[];
+    error?: string;
+};
 export type HotspotStatus = {
     state: "disabled";
 } | {
@@ -120,6 +168,8 @@ export type HotspotErrorEvent = {
     timestamp: number;
 };
 export type VersionInfoResult = {
+    versionInfoType?: string;
+    sid?: string;
     androidVersion: string;
     firmwareVersion: string;
     besFirmwareVersion: string;
@@ -142,6 +192,10 @@ export type VersionInfoResult = {
     packageName?: string;
     /** Phone-served hotspot OTA protocol version; 0 means unsupported/legacy glasses. */
     hotspotOtaVersion: number;
+    /** Session-correlated WiFi forget result protocol; absent/0 means unsupported. */
+    wifiForgetResultVersion?: number;
+    /** Session-correlated saved-network listing protocol; absent/0 means unsupported. */
+    savedWifiNetworksVersion?: number;
 };
 export type VersionInfoEvent = VersionInfoResult & {
     type: "version_info";
@@ -782,6 +836,8 @@ export type BluetoothSdkModuleEvents = {
     phone_notification_dismissed: (event: PhoneNotificationDismissedEvent) => void;
     wifi_status_change: (event: WifiStatusChangeEvent) => void;
     wifi_scan_result: (event: WifiScanResultEvent) => void;
+    wifi_forget_result: (event: WifiForgetResultEvent) => void;
+    saved_wifi_networks: (event: SavedWifiNetworksEvent) => void;
     hotspot_status_change: (event: HotspotStatusChangeEvent) => void;
     hotspot_error: (event: HotspotErrorEvent) => void;
     photo_response: (event: PhotoResponseEvent) => void;
@@ -918,6 +974,8 @@ export type BluetoothSdkEventMap = {
     local_transcription: LocalTranscriptionEvent;
     wifi_status_change: WifiStatusChangeEvent;
     wifi_scan_result: WifiScanResultEvent;
+    wifi_forget_result: WifiForgetResultEvent;
+    saved_wifi_networks: SavedWifiNetworksEvent;
     hotspot_status_change: HotspotStatusChangeEvent;
     hotspot_error: HotspotErrorEvent;
     photo_response: PhotoResponseEvent;
@@ -995,8 +1053,11 @@ export interface BluetoothSdkPublicModule {
     /** Keep legacy Mentra Live OTA sessions awake. Modern sessions normally do not require this. */
     ping(): Promise<void>;
     requestWifiScan(): Promise<WifiSearchResult[]>;
+    /** List exact WiFi SSIDs from glasses that support reliable saved-network enumeration. */
+    getSavedWifiNetworks(): Promise<SavedWifiNetworksResult>;
     sendWifiCredentials(ssid: string, password: string): Promise<WifiStatusChangeEvent>;
-    forgetWifiNetwork(ssid: string): Promise<WifiStatusChangeEvent>;
+    /** Forget a saved network and return its correlated semantic outcome. */
+    forgetWifiNetwork(ssid: string): Promise<WifiForgetResult>;
     setHotspotState(enabled: boolean): Promise<HotspotStatusChangeEvent>;
     /** Set the glasses clock from the phone after an OTA clock-skew failure. */
     setSystemTime(timestampMs: number): Promise<void>;