@mentra/bluetooth-sdk 0.1.20 → 0.1.21-beta.0

package/android/src/main/java/com/mentra/bluetoothsdk/tts/TTSTools.kt

@@ -9,6 +9,9 @@ import com.k2fsa.sherpa.onnx.OfflineTtsModelConfig
 import com.k2fsa.sherpa.onnx.OfflineTtsSupertonicModelConfig
 import com.mentra.bluetoothsdk.Bridge
 import java.io.File
+import java.util.concurrent.Executors
+import java.util.concurrent.ScheduledFuture
+import java.util.concurrent.TimeUnit
 
 /**
  * Utilities for offline Sherpa-ONNX Supertonic 3 TTS model management.
@@ -31,6 +34,21 @@ object TTSTools {
     private const val FILE_UNICODE_INDEXER = "unicode_indexer.bin"
     private const val FILE_VOICE_STYLE = "voice.bin"
 
+    /**
+     * Keep the native model warm briefly after use to reduce repeated TTS latency while
+     * still reclaiming its memory when speech has been idle for a while.
+     */
+    private const val MODEL_IDLE_TIMEOUT_MINUTES = 3L
+    private val modelLock = Any()
+    private val teardownExecutor =
+            Executors.newSingleThreadScheduledExecutor { runnable ->
+                Thread(runnable, "MentraTtsIdleTeardown").apply { isDaemon = true }
+            }
+    private var cachedTts: OfflineTts? = null
+    private var cachedModelPath: String? = null
+    private var teardownFuture: ScheduledFuture<*>? = null
+    private var teardownGeneration = 0L
+
     private val REQUIRED_FILES = listOf(
             FILE_DURATION_PREDICTOR,
             FILE_TEXT_ENCODER,
@@ -42,6 +60,11 @@ object TTSTools {
     )
 
     fun setTtsModelDetails(context: Context, path: String, languageCode: String) {
+        synchronized(modelLock) {
+            if (cachedModelPath != null && cachedModelPath != path) {
+                releaseCachedModelLocked("model path changed")
+            }
+        }
         val prefs = getPrefs(context)
         prefs.edit().apply {
             putString(KEY_TTS_MODEL_PATH, path)
@@ -118,59 +141,104 @@ object TTSTools {
             return false
         }
 
-        val modelDir = File(modelPath)
         val outputFile = File(outputPath)
         outputFile.parentFile?.mkdirs()
 
-        var tts: OfflineTts? = null
-        return try {
-            val supertonic = OfflineTtsSupertonicModelConfig(
-                    durationPredictor = File(modelDir, FILE_DURATION_PREDICTOR).absolutePath,
-                    textEncoder = File(modelDir, FILE_TEXT_ENCODER).absolutePath,
-                    vectorEstimator = File(modelDir, FILE_VECTOR_ESTIMATOR).absolutePath,
-                    vocoder = File(modelDir, FILE_VOCODER).absolutePath,
-                    ttsJson = File(modelDir, FILE_TTS_JSON).absolutePath,
-                    unicodeIndexer = File(modelDir, FILE_UNICODE_INDEXER).absolutePath,
-                    voiceStyle = File(modelDir, FILE_VOICE_STYLE).absolutePath,
-            )
-
-            val modelConfig = OfflineTtsModelConfig(
-                    supertonic = supertonic,
-                    numThreads = 2,
-                    provider = "cpu",
-            )
-
-            val config = OfflineTtsConfig(
-                    model = modelConfig,
-                    maxNumSentences = 1,
-                    silenceScale = 0.2f,
-            )
-
-            tts = OfflineTts(null, config)
-
-            // sid out of range falls back to F1 (sid 0); clamp 0..9.
-            val sid = speakerId.coerceIn(0, tts.numSpeakers() - 1)
-            val clampedSpeed = speed.coerceIn(0.5f, 2.0f)
-            val lang = languageTagToSupertonicLang(languageTag)
-            val genConfig = GenerationConfig(
-                    sid = sid,
-                    speed = clampedSpeed,
-                    extra = mapOf("lang" to lang),
-            )
-            val audio = tts.generateWithConfig(text = text, config = genConfig)
-            val saved = audio.save(outputFile.absolutePath)
-            Bridge.log("TTS generated ${outputFile.absolutePath}: saved=$saved sid=$sid lang=$lang")
-            saved
-        } catch (e: Exception) {
-            Bridge.log("TTS_ERROR: ${e.javaClass.simpleName}: ${e.message}")
-            e.printStackTrace()
-            false
-        } finally {
+        return synchronized(modelLock) {
             try {
-                tts?.release()
+                val tts = getOrCreateModelLocked(modelPath)
+
+                // sid out of range falls back to F1 (sid 0); clamp 0..9.
+                val sid = speakerId.coerceIn(0, tts.numSpeakers() - 1)
+                val clampedSpeed = speed.coerceIn(0.5f, 2.0f)
+                val lang = languageTagToSupertonicLang(languageTag)
+                val genConfig = GenerationConfig(
+                        sid = sid,
+                        speed = clampedSpeed,
+                        numSteps = 5,
+                        extra = mapOf("lang" to lang),
+                )
+                val audio = tts.generateWithConfig(text = text, config = genConfig)
+                val saved = audio.save(outputFile.absolutePath)
+                Bridge.log("TTS generated ${outputFile.absolutePath}: saved=$saved sid=$sid lang=$lang")
+                saved
             } catch (e: Exception) {
-                Bridge.log("TTS release failed: ${e.message}")
+                Bridge.log("TTS_ERROR: ${e.javaClass.simpleName}: ${e.message}")
+                e.printStackTrace()
+                false
+            } finally {
+                scheduleIdleTeardownLocked()
+            }
+        }
+    }
+
+    private fun getOrCreateModelLocked(modelPath: String): OfflineTts {
+        cachedTts?.let { cached ->
+            if (cachedModelPath == modelPath) {
+                Bridge.log("TTS reusing cached model")
+                return cached
             }
+            releaseCachedModelLocked("model path changed")
+        }
+
+        val modelDir = File(modelPath)
+        val supertonic = OfflineTtsSupertonicModelConfig(
+                durationPredictor = File(modelDir, FILE_DURATION_PREDICTOR).absolutePath,
+                textEncoder = File(modelDir, FILE_TEXT_ENCODER).absolutePath,
+                vectorEstimator = File(modelDir, FILE_VECTOR_ESTIMATOR).absolutePath,
+                vocoder = File(modelDir, FILE_VOCODER).absolutePath,
+                ttsJson = File(modelDir, FILE_TTS_JSON).absolutePath,
+                unicodeIndexer = File(modelDir, FILE_UNICODE_INDEXER).absolutePath,
+                voiceStyle = File(modelDir, FILE_VOICE_STYLE).absolutePath,
+        )
+        val modelConfig = OfflineTtsModelConfig(
+                supertonic = supertonic,
+                numThreads = 8,
+                provider = "cpu",
+        )
+        val config = OfflineTtsConfig(
+                model = modelConfig,
+                maxNumSentences = 1,
+                silenceScale = 0.2f,
+        )
+        return OfflineTts(null, config).also {
+            cachedTts = it
+            cachedModelPath = modelPath
+            Bridge.log("TTS loaded model; keeping it warm for $MODEL_IDLE_TIMEOUT_MINUTES minutes after use")
+        }
+    }
+
+    private fun scheduleIdleTeardownLocked() {
+        if (cachedTts == null) return
+        teardownFuture?.cancel(false)
+        val generation = ++teardownGeneration
+        teardownFuture =
+                teardownExecutor.schedule(
+                        {
+                            synchronized(modelLock) {
+                                if (generation == teardownGeneration) {
+                                    releaseCachedModelLocked("idle for $MODEL_IDLE_TIMEOUT_MINUTES minutes")
+                                }
+                            }
+                        },
+                        MODEL_IDLE_TIMEOUT_MINUTES,
+                        TimeUnit.MINUTES,
+                )
+    }
+
+    private fun releaseCachedModelLocked(reason: String) {
+        teardownFuture?.cancel(false)
+        teardownFuture = null
+        teardownGeneration++
+        val tts = cachedTts
+        cachedTts = null
+        cachedModelPath = null
+        if (tts == null) return
+        try {
+            tts.release()
+            Bridge.log("TTS released cached model: $reason")
+        } catch (e: Exception) {
+            Bridge.log("TTS release failed: ${e.message}")
         }
     }
 

package/android/src/main/java/com/mentra/bluetoothsdk/utils/audio/PcmStreamPlayer.kt

@@ -0,0 +1,328 @@
+package com.mentra.bluetoothsdk.utils.audio
+
+import android.media.AudioAttributes
+import android.media.AudioFormat
+import android.media.AudioTrack
+import android.util.Base64
+import android.util.Log
+import java.util.ArrayDeque
+import java.util.concurrent.locks.ReentrantLock
+import kotlin.concurrent.withLock
+import kotlin.math.max
+
+/**
+ * Live PCM chunk player for miniapp `speaker.createStream()`.
+ *
+ * One instance = one stream session. 16-bit LE PCM only. Unlike the SCO-tuned
+ * [PCMAudioPlayer], this uses USAGE_MEDIA so the OS routes it like any media
+ * playback (A2DP to connected glasses, else phone speaker).
+ *
+ * Threading: a dedicated feeder thread drains an in-memory chunk queue into a
+ * MODE_STREAM AudioTrack (AudioTrack.write blocks there, not on callers).
+ * `write` blocks the CALLING thread only while the backlog exceeds
+ * [BACKPRESSURE_CEILING_MS] — call it from a background dispatcher. When the
+ * track underruns (queue empty), AudioTrack plays silence and playback resumes
+ * seamlessly on the next chunk; no stop/start pops.
+ */
+class PcmStreamPlayer(
+        private val streamId: String,
+        private val sampleRate: Int,
+        channels: Int,
+        volume: Float,
+) {
+    companion object {
+        private const val TAG = "PcmStreamPlayer"
+
+        /** write() blocks while more than this is queued but unplayed. */
+        private const val BACKPRESSURE_CEILING_MS = 2_000L
+
+        /** Hard cap — writes that would exceed this are rejected outright. */
+        private const val MAX_BACKLOG_MS = 10_000L
+
+        /** AudioTrack buffer: max(4x minimum, 500ms) of jitter headroom. */
+        private const val TRACK_BUFFER_MS = 500
+    }
+
+    private val bytesPerFrame = 2 * channels
+    private val channelMask =
+            if (channels >= 2) AudioFormat.CHANNEL_OUT_STEREO else AudioFormat.CHANNEL_OUT_MONO
+
+    private val lock = ReentrantLock()
+    private val queueChanged = lock.newCondition()
+
+    /** Pending chunks not yet handed to AudioTrack. Guarded by [lock]. */
+    private val queue = ArrayDeque<ByteArray>()
+    private var queuedBytes = 0L
+
+    /** Total frames handed to AudioTrack.write. Guarded by [lock]. */
+    private var framesWritten = 0L
+
+    private var closing = false
+    private var aborted = false
+    private var writeInProgress = false
+    private var released = false
+    private var finalPlayedFrames: Long? = null
+    private var endedError: String? = null
+
+    private val audioTrack: AudioTrack
+    private val feeder: Thread
+
+    init {
+        val minBuf =
+                AudioTrack.getMinBufferSize(sampleRate, channelMask, AudioFormat.ENCODING_PCM_16BIT)
+        val jitterBuf = sampleRate * bytesPerFrame * TRACK_BUFFER_MS / 1000
+        audioTrack =
+                AudioTrack.Builder()
+                        .setAudioAttributes(
+                                AudioAttributes.Builder()
+                                        .setUsage(AudioAttributes.USAGE_MEDIA)
+                                        .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                                        .build()
+                        )
+                        .setAudioFormat(
+                                AudioFormat.Builder()
+                                        .setEncoding(AudioFormat.ENCODING_PCM_16BIT)
+                                        .setSampleRate(sampleRate)
+                                        .setChannelMask(channelMask)
+                                        .build()
+                        )
+                        .setBufferSizeInBytes(max(minBuf * 4, jitterBuf))
+                        .setTransferMode(AudioTrack.MODE_STREAM)
+                        .build()
+        if (audioTrack.state != AudioTrack.STATE_INITIALIZED) {
+            audioTrack.release()
+            throw IllegalStateException("AudioTrack failed to initialize (rate=$sampleRate)")
+        }
+        audioTrack.setVolume(volume.coerceIn(0f, 1f))
+        audioTrack.play()
+
+        feeder =
+                Thread({ feedLoop() }, "PcmStreamPlayer-$streamId").apply {
+                    isDaemon = true
+                    start()
+                }
+        Log.d(TAG, "[$streamId] opened: rate=$sampleRate ch=$channels vol=$volume")
+    }
+
+    /** Milliseconds of audio accepted but not yet played out. */
+    private fun backlogMsLocked(): Long {
+        val playedFrames = audioTrack.playbackHeadPosition.toLong() and 0xFFFFFFFFL
+        val queuedFrames = queuedBytes / bytesPerFrame
+        return max(0L, (framesWritten - playedFrames + queuedFrames)) * 1000L / sampleRate
+    }
+
+    /**
+     * Append base64-encoded 16-bit LE PCM. Blocks while the backlog is above
+     * the backpressure ceiling. Returns the backlog in ms after this chunk.
+     */
+    fun write(base64: String): Long {
+        val bytes = Base64.decode(base64, Base64.DEFAULT)
+        require(bytes.isNotEmpty()) { "PCM chunk is empty" }
+        require(bytes.size % bytesPerFrame == 0) {
+            "PCM chunk length ${bytes.size} is not aligned to a $bytesPerFrame-byte frame"
+        }
+        lock.withLock {
+            check(!closing && !aborted) { "stream is closed" }
+            endedError?.let { throw IllegalStateException(it) }
+            check(backlogMsLocked() + bytes.size / bytesPerFrame * 1000L / sampleRate <= MAX_BACKLOG_MS) {
+                "backlog exceeds ${MAX_BACKLOG_MS}ms — producer is not throttling"
+            }
+            queue.add(bytes)
+            queuedBytes += bytes.size
+            queueChanged.signalAll()
+            // Backpressure: hold the caller until the feeder drains below the
+            // ceiling. Caller is a background dispatcher, never the UI thread.
+            while (backlogMsLocked() > BACKPRESSURE_CEILING_MS && !closing && !aborted && endedError == null) {
+                queueChanged.await()
+            }
+            endedError?.let { throw IllegalStateException(it) }
+            return backlogMsLocked()
+        }
+    }
+
+    /**
+     * Drain everything queued, then stop. Blocks until played out. Returns the
+     * total played duration in ms.
+     */
+    fun close(): Long {
+        lock.withLock {
+            if (aborted) return playedMsLocked()
+            closing = true
+            queueChanged.signalAll()
+            // Wait for the feeder to hand everything to the track...
+            while ((queue.isNotEmpty() || writeInProgress) && endedError == null && !aborted) {
+                queueChanged.await()
+            }
+        }
+        // ...then for the track to play it out while AudioTrack is still in
+        // PLAYSTATE_PLAYING. Calling stop() first flushes pending MODE_STREAM
+        // audio on several Android builds and truncates the final chunk.
+        try {
+            val deadline = System.currentTimeMillis() + MAX_BACKLOG_MS
+            while (System.currentTimeMillis() < deadline) {
+                val drained =
+                        lock.withLock {
+                            val played = audioTrack.playbackHeadPosition.toLong() and 0xFFFFFFFFL
+                            played >= framesWritten || endedError != null
+                        }
+                if (drained) break
+                Thread.sleep(20)
+            }
+            audioTrack.stop()
+        } catch (e: Exception) {
+            Log.w(TAG, "[$streamId] drain-on-close failed", e)
+        } finally {
+            releaseInternals()
+        }
+        return playedMsLocked()
+    }
+
+    /** Stop now, dropping the backlog. Idempotent. */
+    fun abort() {
+        lock.withLock {
+            if (aborted) return
+            aborted = true
+            queue.clear()
+            queuedBytes = 0
+            queueChanged.signalAll()
+        }
+        try {
+            audioTrack.pause()
+            audioTrack.flush()
+        } catch (e: Exception) {
+            Log.w(TAG, "[$streamId] abort flush failed", e)
+        }
+        releaseInternals()
+        Log.d(TAG, "[$streamId] aborted")
+    }
+
+    /** Played duration so far, in ms. */
+    fun playedMs(): Long = lock.withLock { playedMsLocked() }
+
+    private fun playedMsLocked(): Long {
+        val played =
+                finalPlayedFrames
+                        ?: try {
+                            audioTrack.playbackHeadPosition.toLong() and 0xFFFFFFFFL
+                        } catch (e: Exception) {
+                            framesWritten
+                        }
+        return played * 1000L / sampleRate
+    }
+
+    private fun feedLoop() {
+        try {
+            while (true) {
+                val chunk: ByteArray =
+                        lock.withLock {
+                            while (queue.isEmpty() && !closing && !aborted) {
+                                queueChanged.await()
+                            }
+                            if (aborted) return
+                            if (queue.isEmpty() && closing) return
+                            queue.poll()!!.also { writeInProgress = true }
+                        }
+                // Blocking write OUTSIDE the lock so write()/abort() stay responsive.
+                var off = 0
+                while (off < chunk.size) {
+                    val n = audioTrack.write(chunk, off, chunk.size - off)
+                    if (n < 0) throw IllegalStateException("AudioTrack.write error $n")
+                    off += n
+                }
+                lock.withLock {
+                    queuedBytes -= chunk.size
+                    framesWritten += chunk.size / bytesPerFrame
+                    writeInProgress = false
+                    queueChanged.signalAll()
+                }
+            }
+        } catch (e: Exception) {
+            if (!aborted) {
+                Log.e(TAG, "[$streamId] feeder failed", e)
+                lock.withLock {
+                    endedError = e.message ?: "feeder failed"
+                    queue.clear()
+                    queuedBytes = 0
+                    writeInProgress = false
+                    queueChanged.signalAll()
+                }
+            }
+        } finally {
+            lock.withLock { queueChanged.signalAll() }
+        }
+    }
+
+    private fun releaseInternals() {
+        val shouldRelease =
+                lock.withLock {
+                    if (released) {
+                        false
+                    } else {
+                        finalPlayedFrames =
+                                try {
+                                    audioTrack.playbackHeadPosition.toLong() and 0xFFFFFFFFL
+                                } catch (_: Exception) {
+                                    framesWritten
+                                }
+                        released = true
+                        true
+                    }
+                }
+        if (!shouldRelease) return
+        try {
+            audioTrack.release()
+        } catch (e: Exception) {
+            Log.w(TAG, "[$streamId] release failed", e)
+        }
+    }
+}
+
+/**
+ * Registry of active [PcmStreamPlayer] sessions, keyed by streamId. All
+ * methods are safe to call with unknown ids (write throws, abort no-ops) so
+ * races with teardown resolve cleanly.
+ */
+object PcmStreamManager {
+    private val players = java.util.concurrent.ConcurrentHashMap<String, PcmStreamPlayer>()
+
+    fun open(streamId: String, sampleRate: Int, channels: Int, volume: Float) {
+        require(streamId.isNotBlank()) { "streamId is required" }
+        require(sampleRate == 16000 || sampleRate == 24000 || sampleRate == 48000) {
+            "unsupported PCM sample rate $sampleRate"
+        }
+        require(channels == 1) { "only mono PCM is supported" }
+        // Replacing an id is a caller bug, but never leak the old track.
+        players.remove(streamId)?.abort()
+        players[streamId] = PcmStreamPlayer(streamId, sampleRate, channels, volume)
+    }
+
+    fun write(streamId: String, base64: String): Long {
+        val player =
+                players[streamId] ?: throw IllegalStateException("pcm stream $streamId is not open")
+        return player.write(base64)
+    }
+
+    fun close(streamId: String): Long {
+        val player =
+                players[streamId]
+                        ?: throw IllegalStateException("pcm stream $streamId is not open")
+        return try {
+            player.close()
+        } finally {
+            // Leave a draining player addressable so teardown can still abort
+            // it. The conditional remove preserves a replacement with the
+            // same id if one was opened while this close was completing.
+            players.remove(streamId, player)
+        }
+    }
+
+    fun abort(streamId: String) {
+        players.remove(streamId)?.abort()
+    }
+
+    fun abortAll() {
+        val active = players.values.toList()
+        players.clear()
+        active.forEach { it.abort() }
+    }
+}

package/android/src/test/java/com/mentra/bluetoothsdk/camera/PhotoRequestTest.kt

@@ -36,6 +36,7 @@ class PhotoRequestTest {
 
         assertThat(request.exposureTimeNs).isNull()
         assertThat(request.mode).isEqualTo(PhotoMode.PHOTO)
+        assertThat(request.transferMethod).isEqualTo("auto")
     }
 
     @Test
@@ -93,4 +94,18 @@ class PhotoRequestTest {
 
         assertThat(request.mode).isEqualTo(PhotoMode.TEXT)
     }
+
+    @Test
+    fun `fromMap preserves forced BLE transfer`() {
+        val request =
+            PhotoRequest.fromMap(
+                mapOf(
+                    "size" to "medium",
+                    "transferMethod" to "ble",
+                    "webhookUrl" to "https://example.com/upload",
+                )
+            )
+
+        assertThat(request.transferMethod).isEqualTo("ble")
+    }
 }

package/build/BluetoothSdk.types.d.ts

@@ -88,6 +88,16 @@ export type ConnectedWifiStatus = Extract<WifiStatus, {
 export declare function isConnectedWifiStatus(status: WifiStatus): status is ConnectedWifiStatus;
 export type WifiStatusChangeEvent = WifiStatus & {
     type: "wifi_status_change";
+    /**
+     * Glasses-reported provisioning failure reason when THIS event is the verdict of a
+     * failed connect attempt; absent on routine link-state updates. An attempt property,
+     * not a link property — which is why it lives on the event, not on WifiStatus:
+     * "connect_timeout" arrives on a disconnected status (never associated), while
+     * "connected_to_other_network" arrives on a *connected* status (the attempt failed
+     * and the glasses ended up on / fell back to a different SSID than requested).
+     * Requires ASG client v40+ — older glasses never send it.
+     */
+    error?: string;
 };
 export type HotspotStatus = {
     state: "disabled";
@@ -317,7 +327,7 @@ export type RgbLedControlSuccessResponseEvent = Extract<RgbLedControlResponseEve
     state: "success";
 }>;
 export type SettingsAckStatus = "applied" | "ready" | "error" | "failed" | "failure" | "rejected";
-export type SettingsAckSetting = "gallery_mode" | "button_photo" | "button_video_recording" | "button_max_recording_time" | "camera_fov" | "camera_tuning";
+export type SettingsAckSetting = "gallery_mode" | "button_photo" | "button_video_recording" | "button_max_recording_time" | "camera_fov" | "camera_fov_override" | "camera_tuning";
 export type SettingsAckEvent = {
     type: "settings_ack";
     requestId: string;
@@ -327,6 +337,7 @@ export type SettingsAckEvent = {
     fov?: number;
     roiPosition?: CameraRoiPositionValue;
     hardwareApplied?: boolean;
+    leaseId?: string;
     active?: boolean;
     size?: ButtonPhotoSize | string;
     width?: number;
@@ -429,6 +440,12 @@ export type CameraFovResult = {
     roiPosition: CameraRoiPosition;
     timestamp: number;
 };
+export type CameraFovOverrideRequest = CameraFovRequest & {
+    /** Phone-owned lease used to make delayed releases safe. */
+    leaseId: string;
+    /** Safety TTL; refresh the same lease/configuration to extend without a HAL restart. */
+    ttlMs?: number;
+};
 export type CameraFovSetting = {
     fov: number;
     roiPosition: CameraRoiPositionValue;
@@ -444,6 +461,8 @@ export type PhotoRequestParams = {
     appId?: string;
     size: PhotoSize;
     mode?: PhotoMode;
+    /** `ble` skips direct upload and forces phone-relayed BLE image transfer. */
+    transferMethod?: "auto" | "ble";
     webhookUrl: string | null;
     authToken: string | null;
     compress: PhotoCompression;
@@ -465,9 +484,12 @@ export type PhotoRequestParams = {
     ispAnalogGain?: string;
 };
 export type WarmUpCameraParams = {
+    /** Supply this when the owner needs to call stopCameraWarmUp during teardown. */
     requestId?: string;
     size: PhotoSize;
+    mode?: PhotoMode;
     exposureTimeNs?: number | null;
+    /** Ready-state hold; defaults to 15 seconds and is capped at 60 seconds by ASG. */
     durationMs?: number;
 };
 export type StreamVideoConfig = {
@@ -695,6 +717,8 @@ export type BluetoothSdkModuleEvents = {
     speaking_status: (event: SpeakingStatusEvent) => void;
     battery_status: (event: BatteryStatusEvent) => void;
     local_transcription: (event: LocalTranscriptionEvent) => void;
+    phone_notification: (event: PhoneNotificationEvent) => void;
+    phone_notification_dismissed: (event: PhoneNotificationDismissedEvent) => void;
     wifi_status_change: (event: WifiStatusChangeEvent) => void;
     wifi_scan_result: (event: WifiScanResultEvent) => void;
     hotspot_status_change: (event: HotspotStatusChangeEvent) => void;
@@ -739,6 +763,21 @@ export interface ExtractionProgressEvent {
     bytesRead: number;
     totalBytes: number;
 }
+export interface PhoneNotificationEvent {
+    notificationId: string;
+    app: string;
+    title: string;
+    content: string;
+    priority: string;
+    timestamp: number;
+    packageName: string;
+}
+export interface PhoneNotificationDismissedEvent {
+    notificationId: string;
+    notificationKey: string;
+    packageName: string;
+    timestamp: number;
+}
 export type PublicGlassesStatus = Omit<GlassesStatus, "otaUpdateAvailable" | "otaProgress" | "otaInProgress" | "otaVersionUrl">;
 export type PublicBluetoothStatus = Pick<BluetoothStatus, "searching" | "searchingController" | "systemMicUnavailable" | "micRanking" | "currentMic" | "searchResults" | "wifiScanResults" | "lastLog" | "otherBtConnected" | "galleryModeEnabled">;
 export type BluetoothSdkEventMap = {
@@ -827,6 +866,10 @@ export interface BluetoothSdkPublicModule {
     setVideoRecordingDefaults(settings: VideoRecordingDefaults): Promise<SettingsAckSuccessEvent>;
     setMaxVideoRecordingDuration(minutes: number): Promise<SettingsAckSuccessEvent>;
     setCameraFov(request: CameraFovRequest): Promise<CameraFovResult>;
+    /** One-way FOV command for legacy ASG clients that do not send settings acknowledgements. */
+    setLegacyCameraFov(request: CameraFovRequest): Promise<CameraFovResult>;
+    setCameraFovOverride(request: CameraFovOverrideRequest): Promise<CameraFovResult>;
+    releaseCameraFovOverride(leaseId: string): Promise<SettingsAckSuccessEvent>;
     /**
      * Configure camera HAL tuning (ANR / gain) on Mentra Live glasses.
      *
@@ -844,6 +887,8 @@ export interface BluetoothSdkPublicModule {
     queryGalleryStatus(): Promise<GalleryStatusEvent>;
     requestPhoto(params: PhotoRequestParams): Promise<PhotoSuccessResponseEvent>;
     warmUpCamera(params: WarmUpCameraParams): Promise<CameraStatusEvent>;
+    /** Release one request-owned warm-up. Opening requests reject with camera_warm_up_cancelled. */
+    stopCameraWarmUp(requestId: string): Promise<void>;
     startVideoRecording(requestId: string, save: boolean, sound: boolean, settings?: VideoRecordingSettings): Promise<VideoRecordingStartedStatusEvent>;
     /**
      * Stop the active recording. When {@link webhookUrl} is provided, the glasses