@mentra/bluetooth-sdk 0.1.13 → 0.1.16

package/ios/Source/MentraBluetoothSDK.swift

@@ -42,6 +42,7 @@ private final class ActiveScanSession {
 @MainActor
 private final class PendingWifiScan {
     let pending: PendingResponse<[WifiScanResult]>
+    var latestResults: [WifiScanResult] = []
 
     init(pending: PendingResponse<[WifiScanResult]>) {
         self.pending = pending
@@ -135,7 +136,7 @@ private final class PendingResponse<T> {
                     return
                 }
                 self?.reject(
-                    BluetoothError(
+                    BluetoothSdkError(
                         code: "request_timeout",
                         message: "\(self?.operation ?? "Request") timed out waiting for glasses response."
                     )
@@ -150,6 +151,7 @@ public final class MentraBluetoothSDK {
     private static let otaBesVersionWaitMs = 5_000
     private static let otaMtkVersionWaitMs = 2_000
     private static let otaVersionPollMs = 100
+    private static let defaultStreamKeepAliveIntervalSeconds = 5
 
     public weak var delegate: MentraBluetoothSDKDelegate?
 
@@ -168,6 +170,7 @@ public final class MentraBluetoothSDK {
     private var activeStreamKeepAlive: ActiveStreamKeepAlive?
     private let analytics: BluetoothSdkAnalytics
     private var pendingPhotoRequests: [String: PendingResponse<PhotoResponseEvent>] = [:]
+    private var pendingCameraStatusRequests: [String: PendingResponse<CameraStatusEvent>] = [:]
     private var pendingVideoRecordingRequests: [String: PendingVideoRecordingRequest] = [:]
     private var pendingRgbLedRequests: [String: PendingResponse<RgbLedControlResponseEvent>] = [:]
     private var pendingSettingsRequests: [String: PendingResponse<SettingsAckEvent>] = [:]
@@ -234,7 +237,7 @@ public final class MentraBluetoothSDK {
 
     private func requireGlassesConnected(operation: String) throws {
         guard glassesStatus.connected else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "glasses_not_connected",
                 message: "Cannot \(operation) because glasses are not connected."
             )
@@ -348,7 +351,7 @@ public final class MentraBluetoothSDK {
     public func connectDefault(options: ConnectOptions = ConnectOptions()) throws {
         clearBluetoothRestoreIntent()
         guard let device = currentDefaultDevice() else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "default_device_missing",
                 message: "Set a default glasses device before calling connectDefault."
             )
@@ -482,11 +485,7 @@ public final class MentraBluetoothSDK {
         DeviceStore.shared.apply(ObservableStore.bluetoothCategory, "voice_activity_detection_enabled", enabled)
     }
 
-    public func setButtonPhotoSettings(size: ButtonPhotoSize) async throws -> SettingsAckEvent {
-        try await setButtonPhotoSettings(ButtonPhotoSettings(size: size))
-    }
-
-    public func setButtonPhotoSettings(_ settings: ButtonPhotoSettings) async throws -> SettingsAckEvent {
+    public func setPhotoCaptureDefaults(_ settings: PhotoCaptureDefaults) async throws -> SettingsAckEvent {
         try await performSettingsCommand(
             setting: "button_photo",
             updateStore: { _ in
@@ -545,38 +544,26 @@ public final class MentraBluetoothSDK {
         )
     }
 
-    public func setButtonVideoRecordingSettings(width: Int, height: Int, fps: Int) async throws -> SettingsAckEvent {
+    public func setVideoRecordingDefaults(_ defaults: VideoRecordingDefaults) async throws -> SettingsAckEvent {
         try await performSettingsCommand(
             setting: "button_video_recording",
             updateStore: { _ in
-                DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_video_width", width)
-                DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_video_height", height)
-                DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_video_fps", fps)
+                DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_video_width", defaults.width)
+                DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_video_height", defaults.height)
+                DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_video_fps", defaults.fps)
             },
             send: { requestId in
                 try DeviceManager.shared.sendButtonVideoRecordingSettings(
                     requestId: requestId,
-                    width: width,
-                    height: height,
-                    fps: fps
+                    width: defaults.width,
+                    height: defaults.height,
+                    fps: defaults.fps
                 )
             }
         )
     }
 
-    public func setButtonVideoRecordingSettings(_ settings: ButtonVideoRecordingSettings) async throws -> SettingsAckEvent {
-        try await setButtonVideoRecordingSettings(width: settings.width, height: settings.height, fps: settings.fps)
-    }
-
-    public func setButtonCameraLed(enabled: Bool) async throws -> SettingsAckEvent {
-        try await performSettingsCommand(
-            setting: "button_camera_led",
-            updateStore: { _ in DeviceStore.shared.set(ObservableStore.bluetoothCategory, "button_camera_led", enabled) },
-            send: { requestId in try DeviceManager.shared.sendButtonCameraLedSetting(requestId: requestId, enabled: enabled) }
-        )
-    }
-
-    public func setButtonMaxRecordingTime(minutes: Int) async throws -> SettingsAckEvent {
+    public func setMaxVideoRecordingDuration(minutes: Int) async throws -> SettingsAckEvent {
         try await performSettingsCommand(
             setting: "button_max_recording_time",
             updateStore: { _ in
@@ -609,6 +596,20 @@ public final class MentraBluetoothSDK {
         return result
     }
 
+    public func setCameraTuningConfig(anrOn: Bool, gainOn: Bool) async throws -> SettingsAckEvent {
+        return try await performSettingsCommand(
+            setting: "camera_tuning",
+            updateStore: { _ in },
+            send: { requestId in
+                try DeviceManager.shared.sendCameraTuningConfig(
+                    requestId: requestId,
+                    anrOn: anrOn,
+                    gainOn: gainOn
+                )
+            }
+        )
+    }
+
     public func setMicState(
         enabled: Bool,
         useGlassesMic: Bool = true,
@@ -654,7 +655,7 @@ public final class MentraBluetoothSDK {
 
     public func setGlassesMediaVolume(_ level: Int) async throws -> GlassesMediaVolumeSetResult {
         guard (0 ... 15).contains(level) else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "invalid_volume_level",
                 message: "Glasses media volume must be between 0 and 15."
             )
@@ -664,13 +665,14 @@ public final class MentraBluetoothSDK {
 
     public func requestWifiScan() async throws -> [WifiScanResult] {
         guard pendingWifiScan == nil else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "request_in_flight",
                 message: "A WiFi scan is already waiting for a glasses response."
             )
         }
         let pending = PendingResponse<[WifiScanResult]>(operation: "WiFi scan request")
-        pendingWifiScan = PendingWifiScan(pending: pending)
+        let request = PendingWifiScan(pending: pending)
+        pendingWifiScan = request
         DeviceManager.shared.requestWifiScan()
         do {
             let results = try await pending.wait()
@@ -679,16 +681,25 @@ public final class MentraBluetoothSDK {
             }
             return results
         } catch {
+            let fallbackResults: [WifiScanResult]
+            if (error as? BluetoothSdkError)?.code == "request_timeout" {
+                fallbackResults = request.latestResults
+            } else {
+                fallbackResults = []
+            }
             if pendingWifiScan?.pending === pending {
                 pendingWifiScan = nil
             }
+            if !fallbackResults.isEmpty {
+                return fallbackResults
+            }
             throw error
         }
     }
 
     public func sendWifiCredentials(ssid: String, password: String) async throws -> WifiStatusEvent {
         guard pendingWifiStatus == nil else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "request_in_flight",
                 message: "A WiFi status command is already waiting for a glasses response."
             )
@@ -712,7 +723,7 @@ public final class MentraBluetoothSDK {
 
     public func forgetWifiNetwork(ssid: String) async throws -> WifiStatusEvent {
         guard pendingWifiStatus == nil else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "request_in_flight",
                 message: "A WiFi status command is already waiting for a glasses response."
             )
@@ -736,7 +747,7 @@ public final class MentraBluetoothSDK {
 
     public func setHotspotState(enabled: Bool) async throws -> HotspotStatusEvent {
         guard pendingHotspotStatus == nil else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "request_in_flight",
                 message: "A hotspot command is already waiting for a glasses response."
             )
@@ -765,25 +776,53 @@ public final class MentraBluetoothSDK {
     }
 
     public func requestPhoto(_ request: PhotoRequest) async throws -> PhotoResponseEvent {
+        let routedRequest = nonBlankRequestId(request.requestId).map { request.withRequestId($0) }
+            ?? request.withRequestId(generatedCameraRequestId("photo"))
         Bridge.log(
-            "NATIVE: PHOTO PIPELINE [3b/6] MentraBluetoothSdk.requestPhoto requestId=\(request.requestId) appId=\(request.appId)"
+            "NATIVE: PHOTO PIPELINE [3b/6] MentraBluetoothSdk.requestPhoto requestId=\(routedRequest.requestId)"
         )
-        let pending = PendingResponse<PhotoResponseEvent>(operation: "photo request \(request.requestId)")
-        pendingPhotoRequests[request.requestId] = pending
-        DeviceManager.shared.requestPhoto(request)
+        let pending = PendingResponse<PhotoResponseEvent>(operation: "photo request \(routedRequest.requestId)")
+        pendingPhotoRequests[routedRequest.requestId] = pending
+        DeviceManager.shared.requestPhoto(routedRequest)
         do {
             let event = try await pending.wait()
-            pendingPhotoRequests.removeValue(forKey: request.requestId)
+            pendingPhotoRequests.removeValue(forKey: routedRequest.requestId)
             return event
         } catch {
-            pendingPhotoRequests.removeValue(forKey: request.requestId)
+            pendingPhotoRequests.removeValue(forKey: routedRequest.requestId)
+            throw error
+        }
+    }
+
+    public func warmUpCamera(
+        requestId: String? = nil,
+        size: PhotoSize,
+        exposureTimeNs: Double?,
+        durationMs: Int
+    ) async throws -> CameraStatusEvent {
+        let effectiveRequestId = nonBlankRequestId(requestId) ?? generatedCameraRequestId("warm")
+        let pending = PendingResponse<CameraStatusEvent>(operation: "camera warm up \(effectiveRequestId)")
+        pendingCameraStatusRequests[effectiveRequestId] = pending
+        do {
+            // Inside the catch so an unsupported-device throw also clears the pending entry.
+            try DeviceManager.shared.warmUpCamera(
+                requestId: effectiveRequestId,
+                size: size,
+                exposureTimeNs: exposureTimeNs,
+                durationMs: durationMs
+            )
+            let event = try await pending.wait()
+            pendingCameraStatusRequests.removeValue(forKey: effectiveRequestId)
+            return event
+        } catch {
+            pendingCameraStatusRequests.removeValue(forKey: effectiveRequestId)
             throw error
         }
     }
 
     public func queryGalleryStatus() async throws -> GalleryStatusEvent {
         if pendingGalleryStatus != nil {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "request_in_flight",
                 message: "A gallery status query is already waiting for a glasses response."
             )
@@ -806,6 +845,14 @@ public final class MentraBluetoothSDK {
     }
 
     public func startStream(_ request: StreamRequest) async throws -> StreamStatusEvent {
+        try await startStream(request, startSdkKeepAlive: true)
+    }
+
+    func startExternallyManagedStream(_ request: StreamRequest) async throws -> StreamStatusEvent {
+        try await startStream(request, startSdkKeepAlive: false)
+    }
+
+    private func startStream(_ request: StreamRequest, startSdkKeepAlive: Bool) async throws -> StreamStatusEvent {
         var values = request.values
         let streamId = stringValue(values, "streamId").flatMap { $0.isEmpty ? nil : $0 } ?? "sdk-\(UUID().uuidString)"
         values["streamId"] = streamId
@@ -816,8 +863,11 @@ public final class MentraBluetoothSDK {
         do {
             let event = try await pending.wait(timeoutMs: 30_000)
             pendingStreamStarts.removeValue(forKey: streamId)
-            if request.keepAlive, !request.isExternallyManagedKeepAlive {
-                startStreamKeepAliveMonitor(streamId: streamId, intervalSeconds: request.keepAliveIntervalSeconds)
+            if startSdkKeepAlive {
+                startStreamKeepAliveMonitor(
+                    streamId: streamId,
+                    intervalSeconds: Self.defaultStreamKeepAliveIntervalSeconds
+                )
             }
             return event
         } catch {
@@ -854,7 +904,7 @@ public final class MentraBluetoothSDK {
 
     public func stopStream() async throws -> StreamStatusEvent {
         guard pendingStreamStop == nil else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "request_in_flight",
                 message: "A stream stop command is already waiting for a glasses response."
             )
@@ -879,14 +929,14 @@ public final class MentraBluetoothSDK {
 
     public func startVideoRecording(_ request: VideoRecordingRequest) async throws -> VideoRecordingStatusEvent {
         guard !request.requestId.isEmpty else {
-            throw BluetoothError(code: "missing_request_id", message: "requestId is required to start video recording.")
+            throw BluetoothSdkError(code: "missing_request_id", message: "requestId is required to start video recording.")
         }
         try requireGlassesConnected(operation: "start video recording")
         let pending = PendingResponse<VideoRecordingStatusEvent>(
             operation: "start video recording \(request.requestId)"
         )
         guard pendingVideoRecordingRequests[request.requestId] == nil else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "request_in_flight",
                 message: "A video recording command is already waiting for requestId \(request.requestId)."
             )
@@ -918,12 +968,12 @@ public final class MentraBluetoothSDK {
         requestId: String, webhookUrl: String? = nil, authToken: String? = nil
     ) async throws -> VideoRecordingStatusEvent {
         guard !requestId.isEmpty else {
-            throw BluetoothError(code: "missing_request_id", message: "requestId is required to stop video recording.")
+            throw BluetoothSdkError(code: "missing_request_id", message: "requestId is required to stop video recording.")
         }
         try requireGlassesConnected(operation: "stop video recording")
         let pending = PendingResponse<VideoRecordingStatusEvent>(operation: "stop video recording \(requestId)")
         guard pendingVideoRecordingRequests[requestId] == nil else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "request_in_flight",
                 message: "A video recording command is already waiting for requestId \(requestId)."
             )
@@ -948,7 +998,7 @@ public final class MentraBluetoothSDK {
 
     public func requestVersionInfo() async throws -> VersionInfoResult {
         guard pendingVersionInfo == nil else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "request_in_flight",
                 message: "A version info request is already waiting for a glasses response."
             )
@@ -982,13 +1032,13 @@ public final class MentraBluetoothSDK {
     public func checkForOtaUpdate() async throws -> Bool {
         let status = await getFreshGlassesStatus()
         guard status.connected else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "glasses_not_connected",
                 message: "Cannot check OTA update because glasses are not connected."
             )
         }
         guard !status.buildNumber.isEmpty else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "missing_glasses_version",
                 message: "Cannot check OTA update because glasses build number is unavailable."
             )
@@ -1017,7 +1067,7 @@ public final class MentraBluetoothSDK {
         sendRequest: () -> Void
     ) async throws -> OtaQueryResult {
         if pendingOtaQuery != nil {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "request_in_flight",
                 message: "An OTA status query is already waiting for a glasses response."
             )
@@ -1048,7 +1098,7 @@ public final class MentraBluetoothSDK {
 
     private func startOtaCommand(otaVersionUrl: String) async throws -> OtaStartAckEvent {
         if pendingOtaStart != nil {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "request_in_flight",
                 message: "An OTA start command is already waiting for a glasses response."
             )
@@ -1076,13 +1126,6 @@ public final class MentraBluetoothSDK {
 
     func sendOtaQueryStatus() async throws -> OtaQueryResult { try await queryOtaStatus() }
 
-    /// Re-run the glasses-side OTA version check after an internal clock-skew recovery.
-    func retryOtaVersionCheck() async throws -> OtaQueryResult {
-        try await performOtaQuery(operation: "OTA version retry") {
-            DeviceManager.shared.retryOtaVersionCheck()
-        }
-    }
-
     private func getFreshGlassesStatus() async -> GlassesStatus {
         let status = glassesStatus
         if !status.connected || !status.buildNumber.isEmpty {
@@ -1118,7 +1161,7 @@ public final class MentraBluetoothSDK {
         }
 
         guard status.connected else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "glasses_not_connected",
                 message: "Cannot check OTA update because glasses disconnected."
             )
@@ -1152,7 +1195,7 @@ public final class MentraBluetoothSDK {
     private func resolveOtaVersionUrl(status: GlassesStatus) throws -> String {
         let deviceUrl = status.otaVersionUrl.trimmingCharacters(in: .whitespacesAndNewlines)
         if isLegacyAsgOtaStartBuild(status.buildNumber) {
-            return deviceUrl.isEmpty ? OtaManifestDefaults.prodOtaVersionUrl : deviceUrl
+            return OtaManifestDefaults.legacyProdOtaVersionUrl
         }
         // SDK consumers are pinned to the manifest built for their SDK version.
         // A future glasses-advertised URL should not silently change that pairing.
@@ -1164,7 +1207,7 @@ public final class MentraBluetoothSDK {
 
     private func isLegacyAsgOtaStartBuild(_ buildNumber: String) -> Bool {
         guard let parsed = Int(buildNumber) else { return false }
-        return parsed < 100_000
+        return parsed < 39
     }
 
     func sendShutdown() {
@@ -1274,7 +1317,7 @@ public final class MentraBluetoothSDK {
     }
 
     private func startStreamKeepAliveMonitor(streamId: String, intervalSeconds requestedIntervalSeconds: Int) {
-        let intervalSeconds = requestedIntervalSeconds > 0 ? requestedIntervalSeconds : 5
+        let intervalSeconds = requestedIntervalSeconds > 0 ? requestedIntervalSeconds : Self.defaultStreamKeepAliveIntervalSeconds
         let tracker = ActiveStreamKeepAlive(streamId: streamId, intervalSeconds: intervalSeconds)
         activeStreamKeepAlive = tracker
         sendNextStreamKeepAlive(for: tracker)
@@ -1424,14 +1467,14 @@ public final class MentraBluetoothSDK {
         )
     }
 
-    private func streamStatusError(_ event: StreamStatusEvent, code: String) -> BluetoothError {
+    private func streamStatusError(_ event: StreamStatusEvent, code: String) -> BluetoothSdkError {
         let message: String
         if case let .error(_, errorDetails, _, _) = event.status {
             message = errorDetails
         } else {
             message = "Stream status \(event.state.rawValue)"
         }
-        return BluetoothError(code: code, message: message)
+        return BluetoothSdkError(code: code, message: message)
     }
 
     private func handlePhotoResponseForRequests(_ event: PhotoResponseEvent) {
@@ -1441,7 +1484,7 @@ public final class MentraBluetoothSDK {
             pending.resolve(event)
         case let .error(_, errorCode, errorMessage, _):
             pending.reject(
-                BluetoothError(
+                BluetoothSdkError(
                     code: errorCode ?? "photo_request_failed",
                     message: errorMessage
                 )
@@ -1449,6 +1492,24 @@ public final class MentraBluetoothSDK {
         }
     }
 
+    private func handleCameraStatusForRequests(_ event: CameraStatusEvent) {
+        guard let pending = pendingCameraStatusRequests[event.requestId] else { return }
+        switch event.state.lowercased() {
+        case "ready":
+            pending.resolve(event)
+        case "error":
+            pending.reject(
+                BluetoothSdkError(
+                    code: event.errorCode ?? "camera_warm_up_failed",
+                    message: event.errorMessage ?? "Camera warm-up failed."
+                )
+            )
+        default:
+            // "warming"/"stopped" are progress updates; leave the pending promise alone.
+            break
+        }
+    }
+
     private func handleVideoRecordingStatusForRequests(_ event: VideoRecordingStatusEvent) {
         guard let request = pendingVideoRecordingRequests[event.requestId] else { return }
         if event.success {
@@ -1464,7 +1525,7 @@ public final class MentraBluetoothSDK {
             }
         } else {
             request.pending.reject(
-                BluetoothError(
+                BluetoothSdkError(
                     code: event.status.isEmpty ? "video_recording_failed" : event.status,
                     message: event.details ?? "Video recording command failed."
                 )
@@ -1484,7 +1545,7 @@ public final class MentraBluetoothSDK {
             }
         } else {
             request.pending.reject(
-                BluetoothError(
+                BluetoothSdkError(
                     code: "video_upload_failed",
                     message: event.errorMessage ?? "Video upload failed."
                 )
@@ -1498,7 +1559,7 @@ public final class MentraBluetoothSDK {
             pending.resolve(event)
         } else {
             pending.reject(
-                BluetoothError(
+                BluetoothSdkError(
                     code: event.errorCode ?? "rgb_led_control_failed",
                     message: event.errorCode ?? "RGB LED command failed."
                 )
@@ -1511,7 +1572,7 @@ public final class MentraBluetoothSDK {
         if isFailureStatus(event.status) {
             let fallbackSetting = event.setting.isEmpty ? event.requestId : event.setting
             pending.reject(
-                BluetoothError(
+                BluetoothSdkError(
                     code: event.errorCode ?? "\(event.setting.isEmpty ? "settings" : event.setting)_failed",
                     message: event.errorMessage ?? "Settings command \(fallbackSetting) failed."
                 )
@@ -1533,6 +1594,11 @@ public final class MentraBluetoothSDK {
         request.pending.resolve(results)
     }
 
+    private func updateWifiScanLatestResults(_ results: [WifiScanResult]) {
+        guard !results.isEmpty else { return }
+        pendingWifiScan?.latestResults = results
+    }
+
     private func handleWifiStatusForRequests(_ event: WifiStatusEvent) {
         guard let request = pendingWifiStatus else { return }
         guard wifiStatusMatches(event.status, request: request) else { return }
@@ -1581,7 +1647,7 @@ public final class MentraBluetoothSDK {
             pendingHotspotStatus = nil
         }
         request.pending.reject(
-            BluetoothError(
+            BluetoothSdkError(
                 code: "hotspot_command_failed",
                 message: event.message ?? "Hotspot command failed."
             )
@@ -1721,6 +1787,7 @@ public final class MentraBluetoothSDK {
             let networks = (data["networks"] as? [[String: Any]])?.map(WifiScanResult.init(values:)) ?? []
             let hasCompletionFlag = data.keys.contains("scanComplete") || data.keys.contains("scan_complete")
             let scanComplete = data["scanComplete"] as? Bool ?? data["scan_complete"] as? Bool ?? false
+            updateWifiScanLatestResults(networks)
             if scanComplete || !hasCompletionFlag {
                 handleWifiScanResultsForRequests(networks)
             }
@@ -1739,6 +1806,10 @@ public final class MentraBluetoothSDK {
             delegate?.mentraBluetoothSDK(self, didReceive: .photoResponse(event))
         case "photo_status":
             delegate?.mentraBluetoothSDK(self, didReceive: .photoStatus(PhotoStatusEvent(values: data)))
+        case "camera_status":
+            let event = CameraStatusEvent(values: data)
+            handleCameraStatusForRequests(event)
+            delegate?.mentraBluetoothSDK(self, didReceive: .cameraStatus(event))
         case "video_recording_status":
             let event = VideoRecordingStatusEvent(values: data)
             handleVideoRecordingStatusForRequests(event)
@@ -1761,11 +1832,6 @@ public final class MentraBluetoothSDK {
             if !handleStreamKeepAliveAck(event) {
                 delegate?.mentraBluetoothSDK(self, didReceive: .keepAliveAck(event))
             }
-        case "ota_update_available":
-            var resultValues = data
-            resultValues["type"] = "ota_update_available"
-            pendingOtaQuery?.resolve(OtaQueryResult(values: resultValues))
-            delegate?.mentraBluetoothSDK(self, didReceive: .otaUpdateAvailable(OtaUpdateAvailableEvent(values: resultValues)))
         case "ota_start_ack":
             var values = data
             values["type"] = "ota_start_ack"
@@ -1790,7 +1856,7 @@ public final class MentraBluetoothSDK {
         case "pair_failure":
             delegate?.mentraBluetoothSDK(
                 self,
-                didFail: BluetoothError(
+                didFail: BluetoothSdkError(
                     code: "pair_failure",
                     message: data["error"] as? String ?? data.description
                 )

package/ios/Source/OtaManifest.swift

@@ -2,15 +2,15 @@ import Foundation
 
 enum OtaManifestDefaults {
     private static let sdkOtaReleaseBaseUrl = "https://github.com/Mentra-Community/MentraOS/releases/download/bluetooth-sdk-ota"
-    // Keep prod as the legacy-device fallback: pre-override ASG builds ignore
-    // ota_start.ota_version_url and use their compiled MentraOS default.
-    static let prodOtaVersionUrl = "https://ota.mentraglass.com/prod_live_version.json"
+    // ASG builds before 39 ignore ota_start.ota_version_url, so SDK checks must
+    // use the same legacy production manifest those glasses will install from.
+    static let legacyProdOtaVersionUrl = "https://ota.mentraglass.com/prod_live_version.json"
 
     static func defaultOtaVersionUrl() throws -> String {
         guard let sdkVersion = BluetoothSdkDefaults.sdkVersion,
               !sdkVersion.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
         else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "missing_sdk_version",
                 message: "Cannot determine Bluetooth SDK version for the default OTA manifest URL."
             )
@@ -55,28 +55,28 @@ enum OtaManifestChecker {
     static func normalizeHttpUrl(_ value: String) throws -> String {
         let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
         guard !trimmed.isEmpty else {
-            throw BluetoothError(code: "invalid_ota_url", message: "OTA version URL must be a non-empty http(s) URL.")
+            throw BluetoothSdkError(code: "invalid_ota_url", message: "OTA version URL must be a non-empty http(s) URL.")
         }
         guard let url = URL(string: trimmed),
               let scheme = url.scheme?.lowercased(),
               (scheme == "http" || scheme == "https"),
               url.host?.isEmpty == false
         else {
-            throw BluetoothError(code: "invalid_ota_url", message: "OTA version URL must be a valid http(s) URL.")
+            throw BluetoothSdkError(code: "invalid_ota_url", message: "OTA version URL must be a valid http(s) URL.")
         }
         return url.absoluteString
     }
 
     static func fetch(_ otaVersionUrl: String) async throws -> OtaManifest {
         guard let url = URL(string: otaVersionUrl) else {
-            throw BluetoothError(code: "invalid_ota_url", message: "OTA version URL must be a valid http(s) URL.")
+            throw BluetoothSdkError(code: "invalid_ota_url", message: "OTA version URL must be a valid http(s) URL.")
         }
         let (data, response) = try await URLSession.shared.data(from: url)
         guard let httpResponse = response as? HTTPURLResponse else {
-            throw BluetoothError(code: "ota_manifest_request_failed", message: "OTA manifest request failed.")
+            throw BluetoothSdkError(code: "ota_manifest_request_failed", message: "OTA manifest request failed.")
         }
         guard (200 ... 299).contains(httpResponse.statusCode) else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "ota_manifest_request_failed",
                 message: "OTA manifest request failed with HTTP \(httpResponse.statusCode)."
             )
@@ -110,18 +110,18 @@ enum OtaManifestChecker {
         if let versionCode = manifest.versionCode {
             return OtaManifestApp(versionCode: versionCode)
         }
-        throw BluetoothError(code: "invalid_ota_manifest", message: "OTA manifest is missing ASG app versionCode.")
+        throw BluetoothSdkError(code: "invalid_ota_manifest", message: "OTA manifest is missing ASG app versionCode.")
     }
 
     private static func hasApkUpdate(currentBuildNumber: String, manifest: OtaManifest) throws -> Bool {
         guard let currentVersion = Int(currentBuildNumber) else {
-            throw BluetoothError(
+            throw BluetoothSdkError(
                 code: "invalid_glasses_version",
                 message: "Cannot check OTA update because glasses build number is invalid."
             )
         }
         guard let serverVersion = try latestAppInfo(manifest).versionCode else {
-            throw BluetoothError(code: "invalid_ota_manifest", message: "OTA manifest is missing ASG app versionCode.")
+            throw BluetoothSdkError(code: "invalid_ota_manifest", message: "OTA manifest is missing ASG app versionCode.")
         }
         return serverVersion > currentVersion
     }
@@ -144,7 +144,7 @@ enum OtaManifestChecker {
     private static func hasBesUpdate(besFirmware: BesFirmware?, currentVersion: String) throws -> Bool {
         guard let besFirmware else { return false }
         guard let serverVersion = besFirmware.version, !serverVersion.isEmpty else {
-            throw BluetoothError(code: "invalid_ota_manifest", message: "OTA manifest bes_firmware.version is missing.")
+            throw BluetoothSdkError(code: "invalid_ota_manifest", message: "OTA manifest bes_firmware.version is missing.")
         }
         if currentVersion.isEmpty {
             return true