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

package/ios/Source/sgcs/MentraLive.swift

@@ -1022,17 +1022,17 @@ extension MentraLive: CBCentralManagerDelegate {
     }
 
     #if !os(macOS)
-    nonisolated func centralManager(
-        _: CBCentralManager, didUpdateANCSAuthorizationFor peripheral: CBPeripheral
-    ) {
-        DispatchQueue.main.async { [weak self] in
-            guard let self, peripheral === self.connectedPeripheral else { return }
-            Bridge.log(
-                "LIVE: ANCS authorization updated: \(peripheral.ancsAuthorized ? "authorized" : "not authorized")"
-            )
-            self.enableAncsRelayIfAuthorized()
+        nonisolated func centralManager(
+            _: CBCentralManager, didUpdateANCSAuthorizationFor peripheral: CBPeripheral
+        ) {
+            DispatchQueue.main.async { [weak self] in
+                guard let self, peripheral === self.connectedPeripheral else { return }
+                Bridge.log(
+                    "LIVE: ANCS authorization updated: \(peripheral.ancsAuthorized ? "authorized" : "not authorized")"
+                )
+                self.enableAncsRelayIfAuthorized()
+            }
         }
-    }
     #endif
 
     nonisolated func centralManager(
@@ -2154,6 +2154,8 @@ class MentraLive: NSObject, SGCManager {
         Bridge.log("Starting stream")
         var json = message
         json.removeValue(forKey: "timestamp")
+        json["controllerProbeVersion"] = 1
+        json["controllerId"] = StreamControllerProbe.controllerId
         sendJson(json, wakeUp: true)
     }
 
@@ -2461,16 +2463,16 @@ class MentraLive: NSObject, SGCManager {
         startConnectionTimeout()
 
         #if os(macOS)
-        centralManager?.connect(peripheral, options: nil)
+            centralManager?.connect(peripheral, options: nil)
         #else
-        // ANCS is hosted by iOS and is only exposed to authorized accessories.
-        // The default requirement lets the system complete that authorization flow
-        // before the glasses subscribe; apps that do not relay notifications can opt out.
-        Bridge.log("LIVE: ANCS connection requirement \(requiresAncs ? "enabled" : "disabled")")
-        centralManager?.connect(
-            peripheral,
-            options: MentraLiveConnectionOptions.coreBluetoothOptions(requiresAncs: requiresAncs)
-        )
+            // ANCS is hosted by iOS and is only exposed to authorized accessories.
+            // The default requirement lets the system complete that authorization flow
+            // before the glasses subscribe; apps that do not relay notifications can opt out.
+            Bridge.log("LIVE: ANCS connection requirement \(requiresAncs ? "enabled" : "disabled")")
+            centralManager?.connect(
+                peripheral,
+                options: MentraLiveConnectionOptions.coreBluetoothOptions(requiresAncs: requiresAncs)
+            )
         #endif
     }
 
@@ -2479,23 +2481,23 @@ class MentraLive: NSObject, SGCManager {
     /// for old mobile clients that never send it.
     private func enableAncsRelayIfAuthorized() {
         #if !os(macOS)
-        guard !ancsRelayEnableRequested,
-              let peripheral = connectedPeripheral,
-              txCharacteristic != nil,
-              rxCharacteristic?.isNotifying == true,
-              peripheral.ancsAuthorized
-        else {
-            return
-        }
+            guard !ancsRelayEnableRequested,
+                  let peripheral = connectedPeripheral,
+                  txCharacteristic != nil,
+                  rxCharacteristic?.isNotifying == true,
+                  peripheral.ancsAuthorized
+            else {
+                return
+            }
 
-        let command: [String: Any] = [
-            "C": "cs_ancs",
-            "B": ["enabled": 1],
-        ]
-        if sendRawK900Command(command) {
-            ancsRelayEnableRequested = true
-            Bridge.log("LIVE: Requested ANCS relay from compatible firmware")
-        }
+            let command: [String: Any] = [
+                "C": "cs_ancs",
+                "B": ["enabled": 1],
+            ]
+            if sendRawK900Command(command) {
+                ancsRelayEnableRequested = true
+                Bridge.log("LIVE: Requested ANCS relay from compatible firmware")
+            }
         #endif
     }
 
@@ -2796,8 +2798,16 @@ class MentraLive: NSObject, SGCManager {
             // Record the session id BEFORE marking ready: an unsolicited glasses_ready
             // already runs this full remote-reset flow, so recording (not re-triggering)
             // is correct here; version_info detection covers the restart case.
-            if let sid = json["sid"] as? String, !sid.isEmpty { glassesSessionId = sid }
+            glassesSessionId = (json["sid"] as? String).flatMap { $0.isEmpty ? nil : $0 }
+            Bridge.sendTypedMessage(
+                "wifi_protocol_session_ready",
+                body: ["sid": glassesSessionId ?? ""]
+            )
             readinessCompletedThisBleSession = true
+            Bridge.sendTypedMessage("stream_control_ready", body: [
+                "sid": json["sid"] as? String ?? "",
+                "streamControlVersion": json["streamControlVersion"] as? Int ?? 0,
+            ])
             handleGlassesReady()
 
         case "battery_status":
@@ -2834,6 +2844,33 @@ class MentraLive: NSObject, SGCManager {
             }
             updateWifiStatus(connected: connected, ssid: ssid, ip: ip, error: wifiError.isEmpty ? nil : wifiError)
 
+        case "wifi_forget_result":
+            guard wifiResponseEnvelopeIsValid(json, allowLegacy: true) else { return }
+            Bridge.sendWifiForgetResult(
+                requestId: json["requestId"] as? String ?? "",
+                sid: json["sid"] as? String ?? "",
+                ssid: json["ssid"] as? String ?? "",
+                protocolVersion: (json["protocol_version"] as? NSNumber)?.intValue ?? 0,
+                outcome: json["outcome"] as? String ?? "",
+                legacyDispatched: json["dispatched"] as? Bool,
+                connected: json["connected"] as? Bool,
+                currentSsid: json["current_ssid"] as? String ?? "",
+                localIp: json["local_ip"] as? String ?? "",
+                error: (json["error"] as? String).flatMap { $0.isEmpty ? nil : $0 }
+            )
+
+        case "saved_wifi_networks":
+            guard wifiResponseEnvelopeIsValid(json, allowLegacy: false) else { return }
+            guard let networks = json["networks"] as? [String] else { return }
+            Bridge.sendSavedWifiNetworks(
+                requestId: json["requestId"] as? String ?? "",
+                sid: json["sid"] as? String ?? "",
+                protocolVersion: (json["protocol_version"] as? NSNumber)?.intValue ?? 0,
+                outcome: json["outcome"] as? String ?? "",
+                networks: networks,
+                error: (json["error"] as? String).flatMap { $0.isEmpty ? nil : $0 }
+            )
+
         case "hotspot_status_update":
             let enabled = json["hotspot_enabled"] as? Bool ?? false
             let ssid = json["hotspot_ssid"] as? String ?? ""
@@ -2938,11 +2975,16 @@ class MentraLive: NSObject, SGCManager {
             let error = json["errorCode"] as? String ?? json["error"] as? String
             Bridge.sendRgbLedControlResponse(requestId: requestId, success: success, error: error)
 
+        case "stream_controller_probe":
+            if let response = StreamControllerProbe.response(json) {
+                sendJson(response)
+            }
+
         case "pong":
             Bridge.log("LIVE: Received pong response - connection healthy")
 
         case "entering_pairing_mode":
-            let windowMs = max(5_000, min(180_000, json["window_ms"] as? Int ?? 120_000))
+            let windowMs = max(5000, min(180_000, json["window_ms"] as? Int ?? 120_000))
             Bridge.log("LIVE: Glasses entering pairing mode — yield \(windowMs)ms (no forget)")
             enterPairingYield(windowMs: windowMs)
             let body: [String: Any] = [
@@ -3086,6 +3128,7 @@ class MentraLive: NSObject, SGCManager {
 
                 // Extract all fields from JSON (except "type")
                 var fields: [String: Any] = [:]
+                fields["version_info_type"] = type
                 for (key, value) in json {
                     if key != "type" {
                         fields[key] = value
@@ -3647,19 +3690,67 @@ class MentraLive: NSObject, SGCManager {
     }
 
     func forgetWifiNetwork(_ ssid: String) {
-        Bridge.log("LIVE: 📶 Sending WiFi forget command for SSID: \(ssid)")
+        forgetWifiNetwork(ssid, requestId: nil, sid: nil)
+    }
 
-        guard !ssid.isEmpty else {
-            Bridge.log("LIVE: Cannot forget WiFi network - SSID is empty")
-            return
+    @discardableResult func forgetWifiNetwork(_ ssid: String, requestId: String?, sid: String?) -> Bool {
+        guard let peripheral = connectedPeripheral, peripheral.state == .connected, txCharacteristic != nil,
+              (requestId == nil) == (sid == nil)
+        else { return false }
+        if let requestId, let sid, requestId.isEmpty || sid.isEmpty { return false }
+        transportLog("LIVE: 📶 Sending WiFi forget command for SSID: \(ssid)", bridgeLogging: false)
+
+        guard !ssid.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            transportLog("LIVE: Cannot forget WiFi network - SSID is empty", bridgeLogging: false)
+            if let requestId {
+                Bridge.sendWifiForgetResult(
+                    requestId: requestId,
+                    sid: sid ?? "",
+                    ssid: ssid,
+                    protocolVersion: 1,
+                    outcome: "failed",
+                    legacyDispatched: nil,
+                    connected: nil,
+                    currentSsid: "",
+                    localIp: "",
+                    error: "invalid_ssid"
+                )
+            }
+            return false
         }
 
-        let json: [String: Any] = [
+        var json: [String: Any] = [
             "type": "forget_wifi",
             "ssid": ssid,
         ]
+        if let requestId, !requestId.isEmpty {
+            json["requestId"] = requestId
+        }
+        if let sid, !sid.isEmpty {
+            json["sid"] = sid
+            json["protocolVersion"] = 1
+        }
 
-        sendJson(json, wakeUp: true)
+        // The coordinator dispatches while isolated on MainActor. Keep this path native-only so a
+        // public log delegate cannot synchronously reset the session before the payload is queued.
+        return sendJson(json, wakeUp: true, requireAck: true, bridgeLogging: false)
+    }
+
+    @discardableResult func requestSavedWifiNetworks(requestId: String, sid: String) -> Bool {
+        guard let peripheral = connectedPeripheral, peripheral.state == .connected, txCharacteristic != nil,
+              !requestId.isEmpty, !sid.isEmpty
+        else { return false }
+        var command: [String: Any] = ["type": "request_saved_wifi_networks", "requestId": requestId]
+        command["protocolVersion"] = 1
+        if !sid.isEmpty {
+            command["sid"] = sid
+        }
+        return sendJson(
+            command,
+            wakeUp: true,
+            requireAck: true,
+            bridgeLogging: false
+        )
     }
 
     func queryGalleryStatus() {
@@ -4822,20 +4913,31 @@ class MentraLive: NSObject, SGCManager {
         wireBytes: Int,
         packetCount: Int,
         protocolVersion: Int,
-        direction: String
+        direction: String,
+        bridgeLogging: Bool = true
     ) {
-        Bridge.log(
-            "BLE_TRACE direction=\(direction) proto=v\(protocolVersion) payload=\(payloadBytes) wire=\(wireBytes) packets=\(packetCount)"
+        transportLog(
+            "BLE_TRACE direction=\(direction) proto=v\(protocolVersion) payload=\(payloadBytes) wire=\(wireBytes) packets=\(packetCount)",
+            bridgeLogging: bridgeLogging
         )
     }
 
-    private func sendJsonBinary(
+    private func transportLog(_ message: String, bridgeLogging: Bool) {
+        if bridgeLogging {
+            Bridge.log(message)
+        } else {
+            NSLog("%@", message)
+        }
+    }
+
+    @discardableResult private func sendJsonBinary(
         jsonString: String,
         messageId: Int64,
         trackingId: String,
         wakeUp: Bool,
-        requireAck: Bool
-    ) {
+        requireAck: Bool,
+        bridgeLogging: Bool
+    ) -> Bool {
         let payload = Data(jsonString.utf8)
         let msgId = UInt16(truncatingIfNeeded: messageId)
         let fragments = MessageChunker.createBinaryFragments(
@@ -4845,8 +4947,8 @@ class MentraLive: NSObject, SGCManager {
             ackRequested: requireAck && messageId >= 0
         )
         guard !fragments.isEmpty else {
-            Bridge.log("LIVE: Failed to create binary wire fragments")
-            return
+            transportLog("LIVE: Failed to create binary wire fragments", bridgeLogging: bridgeLogging)
+            return false
         }
 
         var totalWireBytes = 0
@@ -4858,7 +4960,7 @@ class MentraLive: NSObject, SGCManager {
                 fragCount: fragment.fragCount,
                 payload: fragment.payload
             ) else {
-                continue
+                return false
             }
             totalWireBytes += packed.count
             let isFinalChunk = index == fragments.count - 1
@@ -4875,12 +4977,30 @@ class MentraLive: NSObject, SGCManager {
             wireBytes: totalWireBytes,
             packetCount: fragments.count,
             protocolVersion: BleWireProtocol.protocolV2,
-            direction: "phone_to_glasses"
+            direction: "phone_to_glasses",
+            bridgeLogging: bridgeLogging
         )
-        Bridge.log("LIVE: Binary v2 queued \(fragments.count) fragments, wireBytes=\(totalWireBytes)")
+        transportLog(
+            "LIVE: Binary v2 queued \(fragments.count) fragments, wireBytes=\(totalWireBytes)",
+            bridgeLogging: bridgeLogging
+        )
+        return true
+    }
+
+    func sendJson(
+        _ jsonOriginal: [String: Any],
+        wakeUp: Bool = false,
+        requireAck: Bool = true
+    ) {
+        sendJson(jsonOriginal, wakeUp: wakeUp, requireAck: requireAck, bridgeLogging: true)
     }
 
-    func sendJson(_ jsonOriginal: [String: Any], wakeUp: Bool = false, requireAck: Bool = true) {
+    @discardableResult private func sendJson(
+        _ jsonOriginal: [String: Any],
+        wakeUp: Bool,
+        requireAck: Bool,
+        bridgeLogging: Bool
+    ) -> Bool {
         do {
             var json = jsonOriginal
             var messageId: Int64 = -1
@@ -4904,14 +5024,14 @@ class MentraLive: NSObject, SGCManager {
                 )
 
                 if useBinaryWireProtocol, isNewVersion {
-                    sendJsonBinary(
+                    return sendJsonBinary(
                         jsonString: jsonString,
                         messageId: messageId,
                         trackingId: trackingId,
                         wakeUp: wakeUp,
-                        requireAck: requireAck
+                        requireAck: requireAck,
+                        bridgeLogging: bridgeLogging
                     )
-                    return
                 }
 
                 // First check if the message needs chunking
@@ -4925,17 +5045,20 @@ class MentraLive: NSObject, SGCManager {
 
                 // Check if chunking is needed
                 if MessageChunker.needsChunking(testWrappedJson) {
-                    Bridge.log("LIVE: Message exceeds threshold, chunking required")
+                    transportLog("LIVE: Message exceeds threshold, chunking required", bridgeLogging: bridgeLogging)
 
                     // Create chunks
                     let chunks = MessageChunker.createChunks(
                         originalJson: jsonString, messageId: messageId, wakeUp: wakeUp
                     )
                     guard !chunks.isEmpty else {
-                        Bridge.log("LIVE: Failed to create BLE chunks within K900 packet limit")
-                        return
+                        transportLog(
+                            "LIVE: Failed to create BLE chunks within K900 packet limit",
+                            bridgeLogging: bridgeLogging
+                        )
+                        return false
                     }
-                    Bridge.log("LIVE: Sending \(chunks.count) chunks")
+                    transportLog("LIVE: Sending \(chunks.count) chunks", bridgeLogging: bridgeLogging)
 
                     // Send each chunk
                     for (index, chunk) in chunks.enumerated() {
@@ -4943,7 +5066,11 @@ class MentraLive: NSObject, SGCManager {
                         if let chunkStr = String(data: chunkData, encoding: .utf8) {
                             // Pack each chunk using the normal K900 protocol
                             let packedData =
-                                packJson(chunkStr, wakeUp: wakeUp && index == 0) ?? Data() // Only wakeup on first chunk
+                                packJson(
+                                    chunkStr,
+                                    wakeUp: wakeUp && index == 0,
+                                    bridgeLogging: bridgeLogging
+                                ) ?? Data() // Only wakeup on first chunk
 
                             // Queue the chunk for sending
                             // Only track ACK for the final chunk (which has the mId)
@@ -4964,6 +5091,7 @@ class MentraLive: NSObject, SGCManager {
                                 "chunkJsonBytes": chunkStr.data(using: .utf8)?.count,
                                 "messageBytes": jsonData.count,
                             ])
+                            guard !packedData.isEmpty else { return false }
                             queueSend(packedData, id: chunkTrackingId, trace: trace)
 
                             // Add small delay between chunks to avoid overwhelming the connection
@@ -4973,14 +5101,22 @@ class MentraLive: NSObject, SGCManager {
                         }
                     }
 
-                    Bridge.log("LIVE: All chunks queued for transmission")
+                    transportLog("LIVE: All chunks queued for transmission", bridgeLogging: bridgeLogging)
                 } else {
                     // Normal single message transmission
                     if (json["type"] as? String) == "take_photo" {
-                        Bridge.log("LIVE: PHOTO PIPELINE BLE handoff — sendJson -> queueSend take_photo")
+                        transportLog(
+                            "LIVE: PHOTO PIPELINE BLE handoff — sendJson -> queueSend take_photo",
+                            bridgeLogging: bridgeLogging
+                        )
                     }
-                    Bridge.log("LIVE: Sending data to glasses: \(jsonString)")
-                    let packedData = packJson(jsonString, wakeUp: wakeUp) ?? Data()
+                    transportLog("LIVE: Sending data to glasses: \(jsonString)", bridgeLogging: bridgeLogging)
+                    let packedData =
+                        packJson(
+                            jsonString,
+                            wakeUp: wakeUp,
+                            bridgeLogging: bridgeLogging
+                        ) ?? Data()
                     let trace = createBleWriteTrace(
                         commandInfo: commandInfo,
                         chunkId: nil,
@@ -4994,12 +5130,15 @@ class MentraLive: NSObject, SGCManager {
                     logBleChunkTrace("created", trace, extra: [
                         "messageBytes": jsonData.count,
                     ])
+                    guard !packedData.isEmpty else { return false }
                     queueSend(packedData, id: trackingId, trace: trace)
                 }
+                return true
             }
         } catch {
-            Bridge.log("LIVE: Error creating JSON: \(error)")
+            transportLog("LIVE: Error creating JSON: \(error)", bridgeLogging: bridgeLogging)
         }
+        return false
     }
 
     // MARK: - Status Requests
@@ -5990,7 +6129,11 @@ extension MentraLive {
      * 1. Wrap with C-field: {"C": jsonData}
      * 2. Then pack with BES2700 protocol using little-endian: ## + type + length + {"C": jsonData} + $$
      */
-    private func packJson(_ jsonData: String?, wakeUp: Bool = false) -> Data? {
+    private func packJson(
+        _ jsonData: String?,
+        wakeUp: Bool = false,
+        bridgeLogging: Bool = true
+    ) -> Data? {
         guard let jsonData else { return nil }
 
         do {
@@ -6013,7 +6156,10 @@ extension MentraLive {
             )
 
         } catch {
-            Bridge.log("Error creating JSON wrapper for K900: \(error)")
+            transportLog(
+                "Error creating JSON wrapper for K900: \(error)",
+                bridgeLogging: bridgeLogging
+            )
             return nil
         }
     }

package/ios/Source/sgcs/SGCManager.swift

@@ -195,8 +195,10 @@ protocol SGCManager {
     // MARK: - Network Management
 
     func requestWifiScan(scanId: String?)
+    @discardableResult func requestSavedWifiNetworks(requestId: String, sid: String) -> Bool
     func sendWifiCredentials(_ ssid: String, _ password: String)
     func forgetWifiNetwork(_ ssid: String)
+    @discardableResult func forgetWifiNetwork(_ ssid: String, requestId: String?, sid: String?) -> Bool
     func sendHotspotState(_ enabled: Bool)
     func sendWifiAdbState(_ enabled: Bool)
     func sendOtaStart(otaVersionUrl: String?)
@@ -232,7 +234,17 @@ protocol SGCManager {
 /// doesn't seem to work for concurrency reasons :(
 /// we can make read-only getters for convienence though:
 extension SGCManager {
-    var isMicSuspendedForAudio: Bool { false }
+    var isMicSuspendedForAudio: Bool {
+        false
+    }
+
+    @discardableResult func requestSavedWifiNetworks(requestId _: String, sid _: String) -> Bool {
+        false
+    }
+
+    @discardableResult func forgetWifiNetwork(_: String, requestId _: String?, sid _: String?) -> Bool {
+        false
+    }
 
     /// Default: no-op. Only G2 renders positioned text containers; other glasses ignore it.
     func sendPositionedText(

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/Source/streaming/StreamControllerProbe.swift

@@ -0,0 +1,18 @@
+import CoreFoundation
+import Foundation
+
+/// Process-scoped native ownership survives BLE reconnects, not app termination.
+enum StreamControllerProbe {
+    static let controllerId = UUID().uuidString
+
+    static func response(_ values: [String: Any]) -> [String: Any]? {
+        guard let version = values["protocolVersion"] as? NSNumber,
+              CFGetTypeID(version) != CFBooleanGetTypeID(), version.doubleValue == 1,
+              values["controllerId"] as? String == controllerId,
+              let streamId = values["streamId"] as? String, !streamId.isEmpty,
+              let probeId = values["probeId"] as? String, !probeId.isEmpty
+        else { return nil }
+        return ["type": "stream_controller_response", "protocolVersion": 1,
+                "controllerId": controllerId, "streamId": streamId, "probeId": probeId]
+    }
+}

package/ios/Source/streaming/StreamModels.swift

@@ -629,6 +629,10 @@ public enum StreamStatus: CustomStringConvertible, Equatable {
 public struct StreamStatusEvent: CustomStringConvertible {
     public let status: StreamStatus
     public let stats: StreamLiveStats?
+    public private(set) var processSessionId: String?
+    public private(set) var revision: Int?
+    public private(set) var terminal: Bool?
+    public private(set) var errorDetails: String?
     /// True when the glasses will retry the failed publisher themselves
     /// (emitting side lands in PR #3488); absent on older firmware and on
     /// events not parsed from a glasses status map. Carried here instead of
@@ -644,6 +648,10 @@ public struct StreamStatusEvent: CustomStringConvertible {
         status = StreamStatus(values: values)
         stats = StreamLiveStats(values: values["stats"] as? [String: Any])
         willRetry = boolValue(values, "willRetry")
+        processSessionId = stringValue(values, "sid")
+        revision = optionalIntValue(values, "revision")
+        terminal = boolValue(values, "terminal")
+        errorDetails = stringValue(values, "errorDetails")
     }
 
     public var state: StreamState {
@@ -661,6 +669,10 @@ public struct StreamStatusEvent: CustomStringConvertible {
     public var values: [String: Any] {
         var values = status.values
         values["type"] = "stream_status"
+        if let processSessionId { values["sid"] = processSessionId }
+        if let revision { values["revision"] = revision }
+        if let terminal { values["terminal"] = terminal }
+        if let errorDetails { values["errorDetails"] = errorDetails }
         if let stats {
             values["stats"] = stats.values
         }

package/ios/Source/streaming/StreamSessionState.swift

@@ -0,0 +1,29 @@
+import Foundation
+
+/// Observes glasses-owned streaming; delivery gaps never imply publisher failure.
+final class StreamSessionState {
+    private(set) var processSessionId: String?
+    private(set) var currentStreamId: String?
+    private(set) var supported = false
+    private var revision: Int = -1
+
+    func ready(sessionId: String?, controlVersion: Int?) {
+        supported = controlVersion == 1 && !(sessionId ?? "").isEmpty
+        if processSessionId != sessionId {
+            currentStreamId = nil
+            revision = -1
+        }
+        processSessionId = sessionId
+    }
+
+    func accept(_ values: [String: Any]) -> Bool {
+        guard supported,
+              let sid = values["sid"] as? String, sid == processSessionId,
+              let incomingRevision = values["revision"] as? Int,
+              incomingRevision >= revision
+        else { return false }
+        revision = incomingRevision
+        currentStreamId = values["terminal"] as? Bool == true ? nil : values["streamId"] as? String
+        return true
+    }
+}

package/ios/Tests/StreamControllerProbeTests.swift

@@ -0,0 +1,27 @@
+@testable import MentraBluetoothSDK
+import XCTest
+
+final class StreamControllerProbeTests: XCTestCase {
+    private func probe() -> [String: Any] {
+        ["protocolVersion": 1, "controllerId": StreamControllerProbe.controllerId,
+         "streamId": "stream", "probeId": "nonce"]
+    }
+
+    func testAnswersCurrentProcessChallengeWithoutJsOrTimer() {
+        let response = StreamControllerProbe.response(probe())
+        XCTAssertEqual(response?["type"] as? String, "stream_controller_response")
+        XCTAssertEqual(response?["probeId"] as? String, "nonce")
+        XCTAssertEqual(response?["streamId"] as? String, "stream")
+    }
+
+    func testRejectsPreviousProcessAndMalformedChallenges() {
+        for (key, value) in [("controllerId", "previous-process" as Any),
+                             ("protocolVersion", 2), ("protocolVersion", true),
+                             ("probeId", ""), ("streamId", "")]
+        {
+            var input = probe()
+            input[key] = value
+            XCTAssertNil(StreamControllerProbe.response(input))
+        }
+    }
+}