minor changes

Author: sanchitmonga22

Playground/YapRun/YapRun/Core/AppTypes.swift

@@ -11,6 +11,7 @@ import SwiftUI
 
 enum DictationPhase: Equatable {
     case idle
+    case loadingModel
     case recording
     case transcribing
     case inserting

Playground/YapRun/YapRun/Core/ModelRegistry.swift

@@ -20,8 +20,14 @@ enum ModelRegistry {
         let sizeBytes: Int64
     }
 
-    /// Default model used during onboarding.
+    /// Default model used during onboarding and auto-load.
+    /// macOS uses the larger "Accurate" model (Neural Engine handles it easily).
+    /// iOS uses the smaller "Fast" model to conserve battery/memory.
+    #if os(macOS)
+    static let defaultModelId = "whisperkit-base.en"
+    #else
     static let defaultModelId = "whisperkit-tiny.en"
+    #endif
 
     /// Curated ASR models with consumer-friendly names (tar.gz for fast native gzip extraction on iOS/macOS).
     static let asrModels: [ASRModel] = [

Playground/YapRun/YapRun/Features/VoiceKeyboard/FlowSessionManager.swift

@@ -102,6 +102,18 @@ final class FlowSessionManager: ObservableObject {
         transition(to: .idle)
     }
 
+    /// Hard kill: tears down everything and immediately removes all live activities.
+    func killSession() async {
+        logger.info("Flow session killing — immediate teardown")
+
+        elapsedTask?.cancel()
+        audioCapture.stopRecording()
+
+        if #available(iOS 16.1, *) { await endAllLiveActivitiesImmediately() }
+        SharedDataBridge.shared.clearSession()
+        transition(to: .idle)
+    }
+
     // MARK: - Session Activation
 
     private func activateSession() async {
@@ -295,6 +307,13 @@ final class FlowSessionManager: ObservableObject {
             logger.info("Live Activities not enabled — skipping")
             return
         }
+
+        // End any orphaned live activities from previous sessions to prevent stacking
+        for orphan in Activity<DictationActivityAttributes>.activities {
+            logger.info("Ending orphaned Live Activity: \(orphan.id)")
+            Task { await orphan.end(nil, dismissalPolicy: .immediate) }
+        }
+
         let attributes = DictationActivityAttributes(sessionId: UUID().uuidString)
         let state = DictationActivityAttributes.ContentState(
             phase: "ready", elapsedSeconds: 0, transcript: "", wordCount: 0
@@ -333,6 +352,21 @@ final class FlowSessionManager: ObservableObject {
         logger.info("Live Activity ended")
     }
 
+    /// Immediately ends the tracked live activity AND any orphaned activities.
+    @available(iOS 16.1, *)
+    private func endAllLiveActivitiesImmediately() async {
+        // End the tracked activity
+        if let activity = liveActivity {
+            await activity.end(nil, dismissalPolicy: .immediate)
+            liveActivity = nil
+        }
+        // Also sweep any orphans (e.g. from a previous crash)
+        for activity in Activity<DictationActivityAttributes>.activities {
+            await activity.end(nil, dismissalPolicy: .immediate)
+        }
+        logger.info("All Live Activities ended immediately")
+    }
+
     // MARK: - Elapsed Timer + Heartbeat
 
     private func startElapsedTimer() {

Playground/YapRun/YapRun/YapRunApp.swift

@@ -106,10 +106,9 @@ struct YapRunApp: App {
                 showFlowActivation = true
                 Task { await flowSession.handleStartFlow() }
             case "kill":
-                logger.info("Received kill deep link — ending session and terminating")
+                logger.info("Received kill deep link — killing session and terminating")
                 Task {
-                    await flowSession.endSession()
-                    try? await Task.sleep(nanoseconds: 300_000_000)
+                    await flowSession.killSession()
                     exit(0)
                 }
             case "playground":

Playground/YapRun/YapRun/macOS/Features/FlowBarView.swift

@@ -21,6 +21,8 @@ struct FlowBarView: View {
             switch dictation.phase {
             case .idle:
                 idleContent
+            case .loadingModel:
+                loadingModelContent
             case .recording:
                 recordingContent
             case .transcribing:
@@ -51,6 +53,16 @@ struct FlowBarView: View {
 
     // MARK: - States
 
+    private var loadingModelContent: some View {
+        HStack(spacing: 6) {
+            ProgressView()
+                .scaleEffect(0.6)
+            Text("Loading model...")
+                .font(.system(size: 12, weight: .medium))
+                .foregroundStyle(.white.opacity(0.7))
+        }
+    }
+
     private var idleContent: some View {
         HStack(spacing: 6) {
             Image(systemName: "waveform")

Playground/YapRun/YapRun/macOS/MacAppDelegate.swift

@@ -77,11 +77,32 @@ final class MacAppDelegate: NSObject, NSApplicationDelegate {
             if discovered > 0 {
                 logger.info("Discovered \(discovered) previously downloaded models")
             }
+
+            // Auto-load preferred model so dictation is ready immediately
+            await autoLoadPreferredModel()
         } catch {
             logger.error("SDK initialization failed: \(error.localizedDescription)")
         }
     }
 
+    private func autoLoadPreferredModel() async {
+        let preferredId = UserDefaults.standard.string(forKey: "preferredSTTModelId")
+            ?? ModelRegistry.defaultModelId
+
+        guard let allModels = try? await RunAnywhere.availableModels(),
+              let model = allModels.first(where: { $0.id == preferredId }),
+              model.localPath != nil else {
+            return
+        }
+
+        do {
+            try await RunAnywhere.loadSTTModel(preferredId)
+            logger.info("Auto-loaded STT model: \(preferredId)")
+        } catch {
+            logger.error("Auto-load STT model failed: \(error.localizedDescription)")
+        }
+    }
+
     // MARK: - Hub Window
 
     func showHub() {

Playground/YapRun/YapRun/macOS/Services/MacDictationService.swift

@@ -30,6 +30,8 @@ final class MacDictationService {
     private let audioCapture = AudioCaptureManager()
     private var audioBuffer = Foundation.Data()
     private var timerTask: Task<Void, Never>?
+    private var modelLoadTask: Task<Void, Never>?
+    private var hotkeyIsDown = false
     private var cancellables = Set<AnyCancellable>()
     private let logger = Logger(subsystem: "com.runanywhere.yaprun", category: "Dictation")
 
@@ -45,6 +47,7 @@ final class MacDictationService {
             .receive(on: DispatchQueue.main)
             .sink { [weak self] in
                 guard let self else { return }
+                self.hotkeyIsDown = true
                 Task { await self.beginRecording() }
             }
             .store(in: &cancellables)
@@ -53,6 +56,7 @@ final class MacDictationService {
             .receive(on: DispatchQueue.main)
             .sink { [weak self] in
                 guard let self else { return }
+                self.hotkeyIsDown = false
                 Task { await self.finishRecordingAndTranscribe() }
             }
             .store(in: &cancellables)
@@ -70,9 +74,13 @@ final class MacDictationService {
     func toggleFromFlowBar() async {
         switch phase {
         case .idle:
+            hotkeyIsDown = true
             await beginRecording()
         case .recording:
+            hotkeyIsDown = false
             await finishRecordingAndTranscribe()
+        case .loadingModel:
+            cancelModelLoad()
         default:
             break
         }
@@ -83,19 +91,76 @@ final class MacDictationService {
     private func beginRecording() async {
         guard phase == .idle else { return }
 
-        guard await RunAnywhere.currentSTTModel != nil else {
-            phase = .error("No STT model loaded")
+        // If no model loaded, auto-download/load the default
+        if await RunAnywhere.currentSTTModel == nil {
+            await ensureModelLoaded()
+            // If model load failed or user released the key, stop here
+            guard phase == .loadingModel else { return }
+            // Model is now loaded — continue to recording
+        }
+
+        await startMicAndRecord()
+    }
+
+    /// Downloads (if needed) and loads the preferred STT model.
+    /// Sets phase to `.loadingModel` during the process.
+    private func ensureModelLoaded() async {
+        phase = .loadingModel
+        logger.info("No STT model loaded — auto-loading default")
+
+        let modelId = UserDefaults.standard.string(forKey: "preferredSTTModelId")
+            ?? ModelRegistry.defaultModelId
+
+        do {
+            let allModels = try await RunAnywhere.availableModels()
+            guard let model = allModels.first(where: { $0.id == modelId }) else {
+                phase = .error("Model not found")
+                resetAfterDelay()
+                return
+            }
+
+            // Download if not already on disk
+            if model.localPath == nil {
+                logger.info("Downloading model: \(modelId)")
+                let stream = try await RunAnywhere.downloadModel(modelId)
+                for await progress in stream {
+                    // Bail out if user released hotkey during download
+                    guard phase == .loadingModel else { return }
+                    if progress.stage == .completed { break }
+                }
+            }
+
+            // Bail out if user released hotkey during download
+            guard phase == .loadingModel else { return }
+
+            // Load the model
+            logger.info("Loading model: \(modelId)")
+            try await RunAnywhere.loadSTTModel(modelId)
+            UserDefaults.standard.set(modelId, forKey: "preferredSTTModelId")
+            logger.info("Model \(modelId) auto-loaded successfully")
+        } catch {
+            guard phase == .loadingModel else { return }
+            phase = .error("Model load failed")
+            logger.error("Auto-load failed: \(error.localizedDescription)")
             resetAfterDelay()
-            return
         }
+    }
 
+    /// Starts the microphone and transitions to the recording phase.
+    private func startMicAndRecord() async {
         let permitted = await audioCapture.requestPermission()
         guard permitted else {
             phase = .error("Microphone access required")
             resetAfterDelay()
             return
         }
 
+        // Check if user released key while we were requesting permission
+        guard hotkeyIsDown || phase == .loadingModel else {
+            phase = .idle
+            return
+        }
+
         audioBuffer = Foundation.Data()
         elapsedSeconds = 0
 
@@ -117,6 +182,12 @@ final class MacDictationService {
     }
 
     private func finishRecordingAndTranscribe() async {
+        // If still loading model, cancel the load and go idle
+        if phase == .loadingModel {
+            cancelModelLoad()
+            return
+        }
+
         guard phase == .recording else { return }
 
         audioCapture.stopRecording()
@@ -153,11 +224,20 @@ final class MacDictationService {
         }
     }
 
+    private func cancelModelLoad() {
+        modelLoadTask?.cancel()
+        modelLoadTask = nil
+        phase = .idle
+        logger.info("Model load cancelled")
+    }
+
     private func cancelRecording() {
         audioCapture.stopRecording()
         audioLevel = 0
         timerTask?.cancel()
         timerTask = nil
+        modelLoadTask?.cancel()
+        modelLoadTask = nil
         audioBuffer = Foundation.Data()
         phase = .idle
     }