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

package/ios/Source/status/DeviceStatus.swift

@@ -376,6 +376,10 @@ public struct VersionInfoResult: CustomStringConvertible {
     public let appVersion: String
     public let packageName: String
     public let hotspotOtaVersion: Int
+    public let wifiForgetResultVersion: Int?
+    public let savedWifiNetworksVersion: Int?
+    public let versionInfoType: String?
+    public let sid: String?
 
     init(status: GlassesStatus) {
         androidVersion = status.androidVersion
@@ -388,6 +392,10 @@ public struct VersionInfoResult: CustomStringConvertible {
         appVersion = status.appVersion
         packageName = status.packageName
         hotspotOtaVersion = status.hotspotOtaVersion
+        wifiForgetResultVersion = nil
+        savedWifiNetworksVersion = nil
+        versionInfoType = nil
+        sid = nil
     }
 
     init(values: [String: Any]) {
@@ -404,6 +412,14 @@ public struct VersionInfoResult: CustomStringConvertible {
             intValue(values["hotspotOtaVersion"])
                 ?? intValue(values["hotspot_ota_version"])
                 ?? 0
+        wifiForgetResultVersion =
+            intValue(values["wifiForgetResultVersion"])
+                ?? intValue(values["wifi_forget_result_version"])
+        savedWifiNetworksVersion =
+            intValue(values["savedWifiNetworksVersion"])
+                ?? intValue(values["saved_wifi_networks_version"])
+        versionInfoType = stringValue(values, "versionInfoType", "version_info_type")
+        sid = stringValue(values, "sid")
     }
 
     public var dictionary: [String: Any] {
@@ -425,6 +441,18 @@ public struct VersionInfoResult: CustomStringConvertible {
         if !packageName.isEmpty {
             values["packageName"] = packageName
         }
+        if let wifiForgetResultVersion {
+            values["wifiForgetResultVersion"] = wifiForgetResultVersion
+        }
+        if let savedWifiNetworksVersion {
+            values["savedWifiNetworksVersion"] = savedWifiNetworksVersion
+        }
+        if let versionInfoType {
+            values["versionInfoType"] = versionInfoType
+        }
+        if let sid {
+            values["sid"] = sid
+        }
         return values
     }
 

package/ios/Tests/WifiRequestResolutionTests.swift

@@ -0,0 +1,320 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class WifiRequestResolutionTests: XCTestCase {
+    @MainActor
+    func testUnsupportedControllerDoesNotClaimWifiDispatch() {
+        let keys = ["fullyBooted", "connected", "connectionState", "micEnabled", "voiceActivityDetectionEnabled", "bluetoothClassicConnected"]
+        let snapshot = keys.compactMap { key in DeviceStore.shared.get("glasses", key).map { (key, $0) } }
+        defer { for (key, value) in snapshot {
+            DeviceStore.shared.apply("glasses", key, value)
+        } }
+        let controller: SGCManager = Simulated()
+        XCTAssertFalse(controller.forgetWifiNetwork("AP", requestId: nil, sid: nil))
+        XCTAssertFalse(controller.forgetWifiNetwork("AP", requestId: "request", sid: "sid"))
+        XCTAssertFalse(controller.requestSavedWifiNetworks(requestId: "request", sid: "sid"))
+    }
+
+    func testFutureFractionalAndMalformedCapabilitiesAreUnsupportedNotLegacy() {
+        for version in [0, 2, -1, 1.5, "1", true, NSNull()] as [Any] {
+            let capabilities = WifiSessionCapabilities()
+            capabilities.reset(sessionId: "sid")
+            capabilities.applyVersionInfo1(["wifiForgetResultVersion": version, "savedWifiNetworksVersion": version])
+            XCTAssertEqual(capabilities.forgetMode(), .unsupported)
+            XCTAssertEqual(capabilities.savedNetworksMode(), .unsupported)
+        }
+        let missingSession = WifiSessionCapabilities()
+        missingSession.applyVersionInfo1(["wifiForgetResultVersion": 1])
+        XCTAssertEqual(missingSession.forgetMode(), .unsupported)
+    }
+
+    func testRawResponseRejectsPartialTuplesAndCoercionBeforeNormalization() {
+        let tuple: [String: Any] = ["protocol_version": 1, "requestId": "request", "sid": "sid"]
+        XCTAssertTrue(wifiResponseEnvelopeIsValid(tuple, allowLegacy: false))
+        for key in tuple.keys {
+            XCTAssertFalse(wifiResponseEnvelopeIsValid(tuple.filter { $0.key != key }, allowLegacy: true))
+        }
+        for version in [0, 2, 1.5, "1", true, NSNull()] as [Any] {
+            var malformed = tuple
+            malformed["protocol_version"] = version
+            XCTAssertFalse(wifiResponseEnvelopeIsValid(malformed, allowLegacy: true))
+        }
+        XCTAssertFalse(wifiResponseEnvelopeIsValid(tuple.merging(["connected": 0]) { _, new in new }, allowLegacy: true))
+        XCTAssertFalse(wifiResponseEnvelopeIsValid(tuple.merging(["dispatched": true]) { _, new in new }, allowLegacy: true))
+        XCTAssertTrue(wifiResponseEnvelopeIsValid(["dispatched": true], allowLegacy: true))
+        XCTAssertFalse(wifiResponseEnvelopeIsValid(["requestId": "", "dispatched": true], allowLegacy: true))
+        XCTAssertFalse(wifiResponseEnvelopeIsValid([:], allowLegacy: false))
+    }
+
+    func testSemanticResultsOmitTransportMetadata() throws {
+        let data: [String: Any] = ["requestId": "request", "sid": "sid", "protocolVersion": 1,
+                                   "ssid": "AP", "outcome": "confirmed", "networks": ["AP"]]
+        let forbidden: Set = ["mode", "capabilityVersion", "requestId", "sid", "protocolVersion"]
+        let forget = try XCTUnwrap(parseWifiForgetResult(expectedRequestId: "request", expectedSid: "sid", expectedSsid: "AP", capabilityVersion: 1, data: data))
+        let saved = try XCTUnwrap(parseSavedWifiNetworks(expectedRequestId: "request", expectedSid: "sid", capabilityVersion: 1, data: data))
+        XCTAssertTrue(Set(forget.values.keys).isDisjoint(with: forbidden))
+        XCTAssertTrue(Set(saved.values.keys).isDisjoint(with: forbidden))
+        for version in [1.5, true] as [Any] {
+            var malformed = data
+            malformed["protocolVersion"] = version
+            XCTAssertNil(parseWifiForgetResult(expectedRequestId: "request", expectedSid: "sid", expectedSsid: "AP", capabilityVersion: 1, data: malformed))
+            XCTAssertNil(parseSavedWifiNetworks(expectedRequestId: "request", expectedSid: "sid", capabilityVersion: 1, data: malformed))
+        }
+    }
+
+    @MainActor
+    func testPendingResponseCancellationResumesExactlyOnceWithoutTimeout() async {
+        let pending = PendingResponse<Int>(operation: "WiFi capability negotiation")
+        let waiter = Task { @MainActor in
+            try await pending.wait(timeoutMs: nil)
+        }
+        await Task.yield()
+
+        waiter.cancel()
+
+        do {
+            _ = try await waiter.value
+            XCTFail("Expected cancellation")
+        } catch let error as BluetoothSdkError {
+            XCTAssertEqual(error.code, "request_cancelled")
+        } catch {
+            XCTFail("Unexpected error: \(error)")
+        }
+        pending.resolve(42)
+        do {
+            _ = try await pending.wait(timeoutMs: nil)
+            XCTFail("Late resolve must not replace the cancellation result")
+        } catch let error as BluetoothSdkError {
+            XCTAssertEqual(error.code, "request_cancelled")
+        } catch {
+            XCTFail("Unexpected error: \(error)")
+        }
+    }
+
+    func testCapabilitiesAreUnknownPerSessionUntilVersionInfoFinalizesThem() {
+        let capabilities = WifiSessionCapabilities()
+        capabilities.reset(sessionId: "sid-1")
+
+        XCTAssertEqual(capabilities.forgetResult, .unknown)
+        XCTAssertEqual(capabilities.savedNetworks, .unknown)
+        capabilities.applyVersionInfo1(["sid": "sid-1", "wifiForgetResultVersion": 1])
+
+        XCTAssertEqual(capabilities.forgetResult, .supported(version: 1))
+        XCTAssertEqual(capabilities.savedNetworks, .legacy)
+        XCTAssertEqual(capabilities.forgetMode(), .modern)
+        XCTAssertEqual(capabilities.savedNetworksMode(), .legacy)
+    }
+
+    func testNewSessionResetsCapabilitiesAndAdvancesEpoch() {
+        let capabilities = WifiSessionCapabilities()
+        capabilities.reset(sessionId: "sid-1")
+        capabilities.applyVersionInfo1([
+            "wifiForgetResultVersion": 1,
+            "savedWifiNetworksVersion": 1,
+        ])
+        let oldEpoch = capabilities.epoch
+
+        capabilities.reset(sessionId: "sid-2")
+
+        XCTAssertGreaterThan(capabilities.epoch, oldEpoch)
+        XCTAssertEqual(capabilities.sessionId, "sid-2")
+        XCTAssertEqual(capabilities.forgetResult, .unknown)
+        XCTAssertEqual(capabilities.savedNetworks, .unknown)
+    }
+
+    func testSsidValidationRejectsBlankInputWithoutChangingIdentity() {
+        XCTAssertFalse(wifiSsidIsValid("   "))
+        XCTAssertTrue(wifiSsidIsValid(" Field AP "))
+    }
+
+    func testForgetResultRequiresExactIdSessionSsidAndProtocol() {
+        let exact: [String: Any] = [
+            "requestId": "forget-1",
+            "sid": "sid-1",
+            "ssid": " Field AP ",
+            "protocolVersion": 1,
+            "outcome": "dispatched",
+            "connected": false,
+        ]
+
+        XCTAssertNil(parseWifiForgetResult(
+            expectedRequestId: "other", expectedSid: "sid-1", expectedSsid: " Field AP ",
+            capabilityVersion: 1, data: exact
+        ))
+        XCTAssertNil(parseWifiForgetResult(
+            expectedRequestId: "forget-1", expectedSid: "sid-1", expectedSsid: " Field AP ",
+            capabilityVersion: 1, data: exact.filter { $0.key != "requestId" }
+        ))
+        XCTAssertNil(parseWifiForgetResult(
+            expectedRequestId: "forget-1", expectedSid: "other", expectedSsid: " Field AP ",
+            capabilityVersion: 1, data: exact
+        ))
+        XCTAssertNil(parseWifiForgetResult(
+            expectedRequestId: "forget-1", expectedSid: "sid-1", expectedSsid: "Field AP",
+            capabilityVersion: 1, data: exact
+        ))
+        XCTAssertNil(parseWifiForgetResult(
+            expectedRequestId: "forget-1", expectedSid: "sid-1", expectedSsid: " Field AP ",
+            capabilityVersion: 2, data: exact
+        ))
+        XCTAssertEqual(
+            parseWifiForgetResult(
+                expectedRequestId: "forget-1", expectedSid: "sid-1", expectedSsid: " Field AP ",
+                capabilityVersion: 1, data: exact
+            )?.outcome,
+            .dispatched
+        )
+    }
+
+    func testForgetParserPreservesEveryHonestTerminalOutcome() {
+        for outcome in ["confirmed", "dispatched", "not_found", "unsupported", "failed"] {
+            let parsed = parseWifiForgetResult(
+                expectedRequestId: "forget-1",
+                expectedSid: "sid-1",
+                expectedSsid: "AP",
+                capabilityVersion: 1,
+                data: [
+                    "requestId": "forget-1",
+                    "sid": "sid-1",
+                    "ssid": "AP",
+                    "protocolVersion": 1,
+                    "outcome": outcome,
+                ]
+            )
+            XCTAssertEqual(parsed?.outcome.rawValue, outcome)
+        }
+    }
+
+    func testMissingConnectivitySnapshotRemainsUnknown() {
+        let parsed = parseWifiForgetResult(
+            expectedRequestId: "forget-1",
+            expectedSid: "sid-1",
+            expectedSsid: "AP",
+            capabilityVersion: 1,
+            data: [
+                "requestId": "forget-1",
+                "sid": "sid-1",
+                "ssid": "AP",
+                "protocolVersion": 1,
+                "outcome": "dispatched",
+            ]
+        )
+
+        XCTAssertNil(parsed?.connected)
+        XCTAssertNil(parsed?.values["connected"])
+    }
+
+    func testLegacyForgetIsExplicitlyUnverified() {
+        let result = legacyWifiForgetResult(
+            ssid: "AP"
+        )
+
+        XCTAssertTrue(Set(result.values.keys).isDisjoint(with: ["mode", "capabilityVersion", "requestId", "sid"]))
+        XCTAssertEqual(result.outcome, .legacyUnverified)
+        XCTAssertNil(result.connected)
+        XCTAssertNil(result.currentSsid)
+        XCTAssertNil(result.localIp)
+    }
+
+    func testSavedListPreservesIdentityAndRequiresCorrelationTuple() {
+        let exact: [String: Any] = [
+            "requestId": "saved-1",
+            "sid": "sid-1",
+            "protocolVersion": 1,
+            "outcome": "confirmed",
+            "networks": [" Field AP ", "", "Field AP", " Field AP "],
+        ]
+
+        XCTAssertNil(parseSavedWifiNetworks(
+            expectedRequestId: "other", expectedSid: "sid-1", capabilityVersion: 1, data: exact
+        ))
+        XCTAssertNil(parseSavedWifiNetworks(
+            expectedRequestId: "saved-1", expectedSid: "sid-1", capabilityVersion: 1,
+            data: exact.filter { $0.key != "requestId" }
+        ))
+        XCTAssertNil(parseSavedWifiNetworks(
+            expectedRequestId: "saved-1", expectedSid: "other", capabilityVersion: 1, data: exact
+        ))
+        XCTAssertNil(parseSavedWifiNetworks(
+            expectedRequestId: "saved-1", expectedSid: "sid-1", capabilityVersion: 2, data: exact
+        ))
+        XCTAssertEqual(
+            parseSavedWifiNetworks(
+                expectedRequestId: "saved-1", expectedSid: "sid-1", capabilityVersion: 1, data: exact
+            )?.networks,
+            [" Field AP ", "Field AP"]
+        )
+
+        var failure = exact
+        failure["outcome"] = "failed"
+        failure["error"] = "backend_failed"
+        failure["networks"] = [String]()
+        let parsedFailure = parseSavedWifiNetworks(
+            expectedRequestId: "saved-1",
+            expectedSid: "sid-1",
+            capabilityVersion: 1,
+            data: failure
+        )
+        XCTAssertEqual(parsedFailure?.outcome, .failed)
+        XCTAssertEqual(parsedFailure?.error, "backend_failed")
+    }
+
+
+    func testRawForgetEventPreservesModernAndLegacyWireTruth() {
+        let modern = normalizeWifiForgetResultEvent(
+            requestId: "forget-1",
+            sid: "sid-1",
+            ssid: "AP",
+            protocolVersion: 1,
+            outcome: "dispatched",
+            legacyDispatched: nil,
+            connected: false,
+            currentSsid: "",
+            localIp: "",
+            error: nil
+        )
+        let legacy = normalizeWifiForgetResultEvent(
+            requestId: "",
+            sid: "",
+            ssid: "AP",
+            protocolVersion: 0,
+            outcome: "",
+            legacyDispatched: true,
+            connected: false,
+            currentSsid: "",
+            localIp: "",
+            error: nil
+        )
+        let withoutSnapshot = normalizeWifiForgetResultEvent(
+            requestId: "forget-unknown",
+            sid: "sid-1",
+            ssid: "AP",
+            protocolVersion: 1,
+            outcome: "dispatched",
+            legacyDispatched: nil,
+            connected: nil,
+            currentSsid: "",
+            localIp: "",
+            error: nil
+        )
+
+        XCTAssertEqual(modern?["mode"] as? String, "modern")
+        XCTAssertEqual(modern?["outcome"] as? String, "dispatched")
+        XCTAssertEqual(legacy?["mode"] as? String, "legacy")
+        XCTAssertEqual(legacy?["dispatched"] as? Bool, true)
+        XCTAssertNil(legacy?["sid"])
+        XCTAssertNil(withoutSnapshot?["connected"])
+        XCTAssertNil(normalizeWifiForgetResultEvent(
+            requestId: "bad",
+            sid: "",
+            ssid: "AP",
+            protocolVersion: 0,
+            outcome: "",
+            legacyDispatched: nil,
+            connected: false,
+            currentSsid: "",
+            localIp: "",
+            error: nil
+        ))
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/bluetooth-sdk",
-  "version": "3.2.0-dev.200",
+  "version": "3.2.0-dev.203",
   "description": "SDK for communicating with smart glasses",
   "main": "build/index.js",
   "react-native": "src/index.ts",

package/src/BluetoothSdk.types.ts

@@ -128,6 +128,68 @@ 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"} | {state: "enabled"; ssid: string; password: string; localIp: string}
 
 export type EnabledHotspotStatus = Extract<HotspotStatus, {state: "enabled"}>
@@ -147,6 +209,8 @@ export type HotspotErrorEvent = {
 }
 
 export type VersionInfoResult = {
+  versionInfoType?: string
+  sid?: string
   androidVersion: string
   firmwareVersion: string
   besFirmwareVersion: string
@@ -169,6 +233,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 & {
@@ -930,6 +998,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
@@ -1090,6 +1160,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
@@ -1182,8 +1254,11 @@ export interface BluetoothSdkPublicModule {
   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>

package/src/_private/BluetoothSdkModule.ts

@@ -55,6 +55,8 @@ import {
   VideoRecordingStatusEvent,
   VersionInfoResult,
   WarmUpCameraParams,
+  SavedWifiNetworksResult,
+  WifiForgetResult,
   WifiSearchResult,
   WifiStatusChangeEvent,
 } from "../BluetoothSdk.types"
@@ -125,8 +127,9 @@ declare class BluetoothSdkNativeModule extends NativeModule<BluetoothSdkModuleEv
 
   // WiFi Commands
   requestWifiScan(): Promise<WifiSearchResult[]>
+  getSavedWifiNetworks(): Promise<SavedWifiNetworksResult>
   sendWifiCredentials(ssid: string, password: string): Promise<WifiStatusChangeEvent>
-  forgetWifiNetwork(ssid: string): Promise<WifiStatusChangeEvent>
+  forgetWifiNetwork(ssid: string): Promise<WifiForgetResult>
   setHotspotState(enabled: boolean): Promise<HotspotStatusChangeEvent>
   /** Enable or disable Wi-Fi ADB on Mentra Live (no-op on other devices). */
   setWifiAdbState(enabled: boolean): Promise<void>

package/src/generated/changelogCatalog.ts

@@ -3,7 +3,7 @@ export const GENERATED_RELEASE_CHANGELOGS = Object.freeze(
 [
   {
     "version": "3.2.0",
-    "markdown": "This release is under active development. User-facing changes will be documented as they land."
+    "markdown": "This release is under active development. User-facing changes will be documented as they land.\n\n- Breaking Bluetooth SDK change: `forgetWifiNetwork(ssid)` now returns `WifiForgetResult` instead of `WifiStatusChangeEvent`. Migrate status-only consumers to the semantic `outcome`; the requested network remains `ssid`, while optional post-command connectivity is reported by `connected`, `currentSsid`, and `localIp`."
   },
   {
     "version": "3.1.0",

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface BluetoothSdkReleaseMetadata {
 export const BLUETOOTH_SDK_RELEASE_METADATA: Readonly<BluetoothSdkReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "3.2.0",
-  "releaseIdentity": "3.2.0-dev.200",
-  "releaseSetId": "mentra-3.2.0-dev.200",
-  "sourceCommit": "1cdd911f596eba7b2b2f0e9ba5655c7ff16b5362",
-  "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.200.json",
-  "otaManifestSha256": "f0b5cca2fa4d1d43acf5933fb4de629819d36a145a162c763f4faa27a7c8ff79"
+  "releaseIdentity": "3.2.0-dev.203",
+  "releaseSetId": "mentra-3.2.0-dev.203",
+  "sourceCommit": "7eb4deefff27d498c2b4562d628607f399aa1f40",
+  "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.203.json",
+  "otaManifestSha256": "0ae026238c8e70970be4e181cc1ae73dd905418292edebddb610012f4f0a9b6f"
 })

package/src/index.ts

@@ -26,6 +26,8 @@ const PUBLIC_EVENT_NAMES = new Set<BluetoothSdkEventName>([
   "local_transcription",
   "wifi_status_change",
   "wifi_scan_result",
+  "wifi_forget_result",
+  "saved_wifi_networks",
   "hotspot_status_change",
   "hotspot_error",
   "photo_response",
@@ -117,6 +119,7 @@ export const BluetoothSdk: BluetoothSdkPublicModule = Object.freeze({
   setScreenDisabled: bindPublicMethod("setScreenDisabled"),
   ping: bindPublicMethod("ping"),
   requestWifiScan: bindPublicMethod("requestWifiScan"),
+  getSavedWifiNetworks: bindPublicMethod("getSavedWifiNetworks"),
   sendWifiCredentials: bindPublicMethod("sendWifiCredentials"),
   forgetWifiNetwork: bindPublicMethod("forgetWifiNetwork"),
   setHotspotState: bindPublicMethod("setHotspotState"),
@@ -308,6 +311,14 @@ export type {
   VideoRecordingSuccessStatusEvent,
   VersionInfoEvent,
   VersionInfoResult,
+  SavedWifiNetworksEvent,
+  SavedWifiNetworksOutcome,
+  SavedWifiNetworksResult,
+  WifiForgetOutcome,
+  WifiForgetResult,
+  WifiForgetResultEvent,
+  LegacyWifiForgetResultEvent,
+  ModernWifiForgetResultEvent,
   WifiScanResultEvent,
   VoiceActivityDetectionStatusEvent,
   WifiSearchResult,