Skip to content

Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more

changes for Voice Engine - model selection screen revamp ; AI settings changes and bug fixes

altic-devdb726eb96d65
diff --git a/Sources/Fluid/Persistence/SettingsStore.swift b/Sources/Fluid/Persistence/SettingsStore.swift
index b9fa1bd6..2b92eb68 100644
--- a/Sources/Fluid/Persistence/SettingsStore.swift
+++ b/Sources/Fluid/Persistence/SettingsStore.swift
@@ -3,6 +3,9 @@ import ApplicationServices
import Combine
import Foundation
import ServiceManagement
+#if canImport(FluidAudio)
+import FluidAudio
+#endif
final class SettingsStore: ObservableObject {
static let shared = SettingsStore()
@@ -1399,8 +1402,8 @@ final class SettingsStore: ObservableObject {
switch self {
case .parakeetTDT: return "Parakeet TDT v3 (Multilingual)"
case .parakeetTDTv2: return "Parakeet TDT v2 (English Only)"
- case .appleSpeech: return "Apple Speech (Legacy)"
- case .appleSpeechAnalyzer: return "Apple Speech (macOS 26+)"
+ case .appleSpeech: return "Apple ASR Legacy"
+ case .appleSpeechAnalyzer: return "Apple Speech - macOS 26+"
case .whisperTiny: return "Whisper Tiny"
case .whisperBase: return "Whisper Base"
case .whisperSmall: return "Whisper Small"
@@ -1509,6 +1512,234 @@ final class SettingsStore: ObservableObject {
static var defaultModel: SpeechModel {
CPUArchitecture.isAppleSilicon ? .parakeetTDT : .whisperBase
}
+
+ // MARK: - UI Card Metadata
+
+ /// Human-readable marketing name for the card UI
+ var humanReadableName: String {
+ switch self {
+ case .parakeetTDT: return "Blazing Fast - Multilingual"
+ case .parakeetTDTv2: return "Blazing Fast - English"
+ case .appleSpeech: return "Apple ASR Legacy"
+ case .appleSpeechAnalyzer: return "Apple Speech - macOS 26+"
+ case .whisperTiny: return "Fast & Light"
+ case .whisperBase: return "Standard Choice"
+ case .whisperSmall: return "Balanced Speed & Accuracy"
+ case .whisperMedium: return "Medium Quality"
+ case .whisperLargeTurbo: return "Higher Quality but Faster"
+ case .whisperLarge: return "Maximum Accuracy"
+ }
+ }
+
+ /// One-line description for the card UI
+ var cardDescription: String {
+ switch self {
+ case .parakeetTDT:
+ return "Fast multilingual transcription with 25 languages. Best for everyday use."
+ case .parakeetTDTv2:
+ return "Optimized for English accuracy and fastest transcription."
+ case .appleSpeech:
+ return "Built-in macOS speech recognition. No download required."
+ case .appleSpeechAnalyzer:
+ return "Advanced and modern on-device recognition for newer macOS devices."
+ case .whisperTiny:
+ return "Minimal resource usage. Best for older Macs or battery life."
+ case .whisperBase:
+ return "Good balance of speed and accuracy. Works on any Mac."
+ case .whisperSmall:
+ return "Better accuracy than Base. Moderate resource usage."
+ case .whisperMedium:
+ return "High accuracy for demanding tasks. Requires more memory."
+ case .whisperLargeTurbo:
+ return "Near-maximum accuracy with optimized speed."
+ case .whisperLarge:
+ return "Best possible accuracy. Large download and memory usage."
+ }
+ }
+
+ /// Speed rating (1-5, higher is faster)
+ var speedRating: Int {
+ switch self {
+ case .parakeetTDT: return 5
+ case .parakeetTDTv2: return 5
+ case .appleSpeech: return 4
+ case .appleSpeechAnalyzer: return 4
+ case .whisperTiny: return 4
+ case .whisperBase: return 4
+ case .whisperSmall: return 3
+ case .whisperMedium: return 2
+ case .whisperLargeTurbo: return 3
+ case .whisperLarge: return 1
+ }
+ }
+
+ /// Accuracy rating (1-5, higher is more accurate)
+ var accuracyRating: Int {
+ switch self {
+ case .parakeetTDT: return 5
+ case .parakeetTDTv2: return 5
+ case .appleSpeech: return 4
+ case .appleSpeechAnalyzer: return 4
+ case .whisperTiny: return 2
+ case .whisperBase: return 3
+ case .whisperSmall: return 4
+ case .whisperMedium: return 4
+ case .whisperLargeTurbo: return 5
+ case .whisperLarge: return 5
+ }
+ }
+
+ /// Exact speed percentage (0.0 - 1.0) for the liquid bars
+ var speedPercent: Double {
+ switch self {
+ case .parakeetTDT: return 1.0
+ case .parakeetTDTv2: return 1.0
+ case .appleSpeech: return 0.60
+ case .appleSpeechAnalyzer: return 0.85
+ case .whisperTiny: return 0.90
+ case .whisperBase: return 0.80
+ case .whisperSmall: return 0.60
+ case .whisperMedium: return 0.40
+ case .whisperLargeTurbo: return 0.65
+ case .whisperLarge: return 0.20
+ }
+ }
+
+ /// Exact accuracy percentage (0.0 - 1.0) for the liquid bars
+ var accuracyPercent: Double {
+ switch self {
+ case .parakeetTDT: return 0.95
+ case .parakeetTDTv2: return 0.98
+ case .appleSpeech: return 0.60
+ case .appleSpeechAnalyzer: return 0.80
+ case .whisperTiny: return 0.40
+ case .whisperBase: return 0.60
+ case .whisperSmall: return 0.70
+ case .whisperMedium: return 0.80
+ case .whisperLargeTurbo: return 0.95
+ case .whisperLarge: return 1.00
+ }
+ }
+
+ /// Optional badge text for the card (e.g., "FluidVoice Pick")
+ var badgeText: String? {
+ switch self {
+ case .parakeetTDT: return "FluidVoice Pick"
+ case .parakeetTDTv2: return "FluidVoice Pick"
+ case .appleSpeechAnalyzer: return "New"
+ default: return nil
+ }
+ }
+
+ /// Optimization level for Apple Silicon (for display)
+ var appleSiliconOptimized: Bool {
+ switch self {
+ case .parakeetTDT, .parakeetTDTv2, .appleSpeechAnalyzer:
+ return true
+ default:
+ return false
+ }
+ }
+
+ /// Whether this model supports real-time streaming/chunk processing.
+ /// Large Whisper models are too slow for streaming, so they only do final transcription on stop.
+ var supportsStreaming: Bool {
+ switch self {
+ case .whisperMedium, .whisperLarge, .whisperLargeTurbo:
+ return false // Too slow for real-time chunk processing
+ default:
+ return true // All other models support streaming
+ }
+ }
+
+ /// Provider category for tab grouping
+ enum Provider: String, CaseIterable {
+ case nvidia = "NVIDIA"
+ case apple = "Apple"
+ case openai = "OpenAI"
+ }
+
+ /// Which provider this model belongs to
+ var provider: Provider {
+ switch self {
+ case .parakeetTDT, .parakeetTDTv2:
+ return .nvidia
+ case .appleSpeech, .appleSpeechAnalyzer:
+ return .apple
+ case .whisperTiny, .whisperBase, .whisperSmall, .whisperMedium, .whisperLargeTurbo, .whisperLarge:
+ return .openai
+ }
+ }
+
+ /// Get models filtered by provider
+ static func models(for provider: Provider) -> [SpeechModel] {
+ availableModels.filter { $0.provider == provider }
+ }
+
+ /// Whether this model is built-in or already downloaded on disk
+ var isInstalled: Bool {
+ switch self {
+ case .appleSpeech, .appleSpeechAnalyzer:
+ return true
+ case .parakeetTDT:
+ // Hardcoded path check for NVIDIA v3
+ return Self.parakeetCacheDirectory(version: "parakeet-tdt-0.6b-v3-coreml")
+ case .parakeetTDTv2:
+ // Hardcoded path check for NVIDIA v2
+ return Self.parakeetCacheDirectory(version: "parakeet-tdt-0.6b-v2-coreml")
+ default:
+ // Whisper models
+ guard let whisperFile = self.whisperModelFile else { return false }
+ let directory = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first?
+ .appendingPathComponent("WhisperModels")
+ let modelURL = directory?.appendingPathComponent(whisperFile)
+ return modelURL.map { FileManager.default.fileExists(atPath: $0.path) } ?? false
+ }
+ }
+
+ private static func parakeetCacheDirectory(version: String) -> Bool {
+ #if canImport(FluidAudio)
+ let baseCacheDir = AsrModels.defaultCacheDirectory().deletingLastPathComponent()
+ let modelDir = baseCacheDir.appendingPathComponent(version)
+ return FileManager.default.fileExists(atPath: modelDir.path)
+ #else
+ let baseCacheDir = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first?
+ .appendingPathComponent(version)
+ return baseCacheDir.map { FileManager.default.fileExists(atPath: $0.path) } ?? false
+ #endif
+ }
+
+ /// Brand/provider name for the model (NVIDIA, Apple, OpenAI)
+ var brandName: String {
+ switch self {
+ case .parakeetTDT, .parakeetTDTv2:
+ return "NVIDIA"
+ case .appleSpeech, .appleSpeechAnalyzer:
+ return "Apple"
+ case .whisperTiny, .whisperBase, .whisperSmall, .whisperMedium, .whisperLargeTurbo, .whisperLarge:
+ return "OpenAI"
+ }
+ }
+
+ /// Whether this model uses Apple's SF Symbol for branding (apple.logo)
+ var usesAppleLogo: Bool {
+ switch self {
+ case .appleSpeech, .appleSpeechAnalyzer: return true
+ default: return false
+ }
+ }
+
+ /// Brand color for the provider badge
+ var brandColorHex: String {
+ switch self {
+ case .parakeetTDT, .parakeetTDTv2:
+ return "#76B900" // NVIDIA Green
+ case .appleSpeech, .appleSpeechAnalyzer:
+ return "#A2AAAD" // Apple Gray
+ case .whisperTiny, .whisperBase, .whisperSmall, .whisperMedium, .whisperLargeTurbo, .whisperLarge:
+ return "#10A37F" // OpenAI Teal
+ }
+ }
}
// MARK: - Transcription Provider (ASR)
diff --git a/Sources/Fluid/Services/ASRService.swift b/Sources/Fluid/Services/ASRService.swift
index 8f2eb4d2..d6c93621 100644
--- a/Sources/Fluid/Services/ASRService.swift
+++ b/Sources/Fluid/Services/ASRService.swift
@@ -88,6 +88,10 @@ final class ASRService: ObservableObject {
@Published var isDownloadingModel: Bool = false
@Published var isLoadingModel: Bool = false // True when loading cached model into memory (not downloading)
@Published var modelsExistOnDisk: Bool = false
+ @Published var downloadProgress: Double? = nil
+
+ private var downloadProgressTask: Task<Void, Never>?
+ private var hasCompletedFirstTranscription: Bool = false // Track if model has warmed up with first transcription
// MARK: - Error Handling
@@ -193,6 +197,9 @@ final class ASRService: ObservableObject {
self.isAsrReady = false
self.modelsExistOnDisk = false
+ self.downloadProgress = nil
+ self.hasCompletedFirstTranscription = false // Reset warm-up state when switching models
+ self.stopDownloadProgressMonitor()
self.ensureReadyTask?.cancel()
self.ensureReadyTask = nil
self.ensureReadyProviderKey = nil
@@ -460,8 +467,14 @@ final class ASRService: ObservableObject {
DebugLogger.shared.debug("ℹ️ No device to monitor", source: "ASRService")
}
- DebugLogger.shared.debug("📡 Starting streaming transcription...", source: "ASRService")
- self.startStreamingTranscription()
+ // Only start streaming for models that support it (large Whisper models are too slow)
+ let model = SettingsStore.shared.selectedSpeechModel
+ if model.supportsStreaming {
+ DebugLogger.shared.debug("📡 Starting streaming transcription...", source: "ASRService")
+ self.startStreamingTranscription()
+ } else {
+ DebugLogger.shared.debug("⏸️ Skipping streaming - model '\(model.displayName)' does not support real-time chunk processing", source: "ASRService")
+ }
DebugLogger.shared.info("✅ START() completed successfully", source: "ASRService")
} catch {
DebugLogger.shared.error("Failed to start ASR session: \(error)", source: "ASRService")
@@ -586,6 +599,16 @@ final class ASRService: ObservableObject {
let pcm = self.audioBuffer.getAll()
self.audioBuffer.clear()
+ // Avoid whisper.cpp assertions by skipping too-short audio buffers
+ let minSamples = 16_000
+ guard pcm.count >= minSamples else {
+ DebugLogger.shared.debug(
+ "stop(): insufficient audio for transcription (\(pcm.count)/\(minSamples) samples)",
+ source: "ASRService"
+ )
+ return ""
+ }
+
do {
DebugLogger.shared.debug("🔍 Calling ensureAsrReady()...", source: "ASRService")
try await self.ensureAsrReady()
@@ -611,6 +634,16 @@ final class ASRService: ObservableObject {
"Transcription completed: '\(result.text)' (confidence: \(result.confidence))",
source: "ASRService"
)
+
+ // Mark first transcription as complete to clear loading state
+ if !self.hasCompletedFirstTranscription {
+ self.hasCompletedFirstTranscription = true
+ DispatchQueue.main.async {
+ self.isLoadingModel = false
+ DebugLogger.shared.info("✅ Model warmed up - first transcription completed", source: "ASRService")
+ }
+ }
+
// Do not update self.finalText here to avoid instant binding insert in playground
let cleanedText = ASRService.applyCustomDictionary(ASRService.removeFillerWords(result.text))
DebugLogger.shared.debug("After post-processing: '\(cleanedText)'", source: "ASRService")
@@ -1604,10 +1637,14 @@ final class ASRService: ObservableObject {
if modelsAlreadyCached {
self.isLoadingModel = true
self.isDownloadingModel = false
+ self.downloadProgress = nil
+ self.stopDownloadProgressMonitor()
DebugLogger.shared.info("📦 LOADING cached model into memory...", source: "ASRService")
} else {
self.isDownloadingModel = true
self.isLoadingModel = false
+ self.downloadProgress = nil
+ self.startParakeetDownloadProgressMonitor()
DebugLogger.shared.info("⬇️ DOWNLOADING model...", source: "ASRService")
}
}
@@ -1615,13 +1652,26 @@ final class ASRService: ObservableObject {
// Use the transcription provider to prepare models
let downloadStartTime = Date()
DebugLogger.shared.info("Calling transcriptionProvider.prepare()...", source: "ASRService")
- try await provider.prepare(progressHandler: nil)
+ try await provider.prepare(progressHandler: { [weak self] progress in
+ DispatchQueue.main.async {
+ let clamped = max(0.0, min(1.0, progress))
+ self?.downloadProgress = clamped
+ }
+ })
let downloadDuration = Date().timeIntervalSince(downloadStartTime)
DebugLogger.shared.info("✓ Provider preparation completed in \(String(format: "%.1f", downloadDuration)) seconds", source: "ASRService")
DispatchQueue.main.async {
self.isDownloadingModel = false
- self.isLoadingModel = false
+ // Keep isLoadingModel true until first transcription completes (for large models that need warm-up)
+ if !self.hasCompletedFirstTranscription {
+ self.isLoadingModel = true
+ DebugLogger.shared.info("⏳ Model loaded, waiting for first transcription to complete...", source: "ASRService")
+ } else {
+ self.isLoadingModel = false
+ }
+ self.downloadProgress = nil
+ self.stopDownloadProgressMonitor()
self.modelsExistOnDisk = true
}
@@ -1636,11 +1686,84 @@ final class ASRService: ObservableObject {
DispatchQueue.main.async {
self.isDownloadingModel = false
self.isLoadingModel = false
+ self.downloadProgress = nil
+ self.stopDownloadProgressMonitor()
}
throw error
}
}
+ private func startParakeetDownloadProgressMonitor() {
+ let model = SettingsStore.shared.selectedSpeechModel
+ guard model == .parakeetTDT || model == .parakeetTDTv2 else { return }
+ guard let modelDir = self.parakeetCacheDirectory(for: model) else { return }
+
+ self.stopDownloadProgressMonitor()
+ self.downloadProgress = 0.0
+
+ let estimatedBytes = self.estimatedParakeetSizeBytes(for: model)
+ self.downloadProgressTask = Task(priority: .background) { [weak self] in
+ guard let self = self else { return }
+ while !Task.isCancelled {
+ let isDownloading = await MainActor.run { self.isDownloadingModel }
+ if !isDownloading { break }
+ let size = self.directorySize(at: modelDir)
+ let pct = estimatedBytes > 0 ? min(0.99, Double(size) / Double(estimatedBytes)) : 0.0
+ await MainActor.run {
+ self.downloadProgress = max(self.downloadProgress ?? 0.0, pct)
+ }
+ try? await Task.sleep(nanoseconds: 700_000_000)
+ }
+ }
+ }
+
+ private func stopDownloadProgressMonitor() {
+ self.downloadProgressTask?.cancel()
+ self.downloadProgressTask = nil
+ }
+
+ private func parakeetCacheDirectory(for model: SettingsStore.SpeechModel) -> URL? {
+ #if arch(arm64)
+ let baseCacheDir = AsrModels.defaultCacheDirectory().deletingLastPathComponent()
+ let folder = (model == .parakeetTDTv2) ? "parakeet-tdt-0.6b-v2-coreml" : "parakeet-tdt-0.6b-v3-coreml"
+ return baseCacheDir.appendingPathComponent(folder)
+ #else
+ return nil
+ #endif
+ }
+
+ private func estimatedParakeetSizeBytes(for model: SettingsStore.SpeechModel) -> Int64 {
+ // Approximate size for progress display only.
+ switch model {
+ case .parakeetTDT, .parakeetTDTv2:
+ return 520 * 1024 * 1024
+ default:
+ return 0
+ }
+ }
+
+ private func directorySize(at url: URL) -> Int64 {
+ let fm = FileManager.default
+ guard let enumerator = fm.enumerator(
+ at: url,
+ includingPropertiesForKeys: [.isRegularFileKey, .fileSizeKey],
+ options: [.skipsHiddenFiles]
+ ) else {
+ return 0
+ }
+
+ var total: Int64 = 0
+ for case let fileURL as URL in enumerator {
+ if let values = try? fileURL.resourceValues(forKeys: [.isRegularFileKey, .fileSizeKey]),
+ values.isRegularFile == true,
+ let size = values.fileSize
+ {
+ total += Int64(size)
+ }
+ }
+ return total
+ }
+
// MARK: - Model lifecycle helpers (parity with original API)
func predownloadSelectedModel() {
@@ -1815,6 +1938,15 @@ final class ASRService: ObservableObject {
let rawText = result.text.trimmingCharacters(in: .whitespacesAndNewlines)
let newText = ASRService.applyCustomDictionary(ASRService.removeFillerWords(rawText))
+ // Mark first transcription as complete to clear loading state
+ if !self.hasCompletedFirstTranscription {
+ self.hasCompletedFirstTranscription = true
+ DispatchQueue.main.async {
+ self.isLoadingModel = false
+ DebugLogger.shared.info("✅ Model warmed up - first streaming transcription completed", source: "ASRService")
+ }
+ }
+
if !newText.isEmpty {
// Smart diff: only show truly new words
let updatedText = self.smartDiffUpdate(previous: self.previousFullTranscription, current: newText)
diff --git a/Sources/Fluid/Services/WhisperProvider.swift b/Sources/Fluid/Services/WhisperProvider.swift
index b7f5b2e7..1e9272dd 100644
--- a/Sources/Fluid/Services/WhisperProvider.swift
+++ b/Sources/Fluid/Services/WhisperProvider.swift
@@ -81,6 +81,16 @@ final class WhisperProvider: TranscriptionProvider {
}
func transcribe(_ samples: [Float]) async throws -> ASRTranscriptionResult {
+ // Whisper.cpp asserts on very short buffers; guard early to avoid abort.
+ let minSamples = 16_000
+ guard samples.count >= minSamples else {
+ throw NSError(
+ domain: "WhisperProvider",
+ code: -2,
+ userInfo: [NSLocalizedDescriptionKey: "Audio too short for Whisper transcription"]
+ )
+ }
+
guard let whisper = whisper else {
throw NSError(
domain: "WhisperProvider",
@@ -131,29 +141,11 @@ final class WhisperProvider: TranscriptionProvider {
let maxAttempts = 3
for attempt in 1...maxAttempts {
do {
- let (tempURL, response) = try await self.urlSession.download(from: url)
-
- guard let httpResponse = response as? HTTPURLResponse else {
- throw NSError(
- domain: "WhisperProvider",
- code: -1,
- userInfo: [NSLocalizedDescriptionKey: "Invalid server response"]
- )
- }
-
- guard httpResponse.statusCode == 200 else {
- throw NSError(
- domain: "WhisperProvider",
- code: httpResponse.statusCode,
- userInfo: [NSLocalizedDescriptionKey: "Failed to download model (HTTP \(httpResponse.statusCode))"]
- )
+ if attempt == 1 {
+ progressHandler?(0.0)
}
- // Move to final location
- if FileManager.default.fileExists(atPath: self.modelURL.path) {
- try FileManager.default.removeItem(at: self.modelURL)
- }
- try FileManager.default.moveItem(at: tempURL, to: self.modelURL)
+ try await self.downloadFile(from: url, to: self.modelURL, progressHandler: progressHandler)
DebugLogger.shared.info("WhisperProvider: Model downloaded successfully", source: "WhisperProvider")
return
@@ -200,4 +192,88 @@ final class WhisperProvider: TranscriptionProvider {
}
}
}
+
+ private func downloadFile(from url: URL, to destination: URL, progressHandler: ((Double) -> Void)?) async throws {
+ let delegate = DownloadProgressDelegate(onProgress: progressHandler)
+ let session = URLSession(configuration: .default, delegate: delegate, delegateQueue: nil)
+ let task = session.downloadTask(with: url)
+
+ try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
+ let lock = NSLock()
+ var didResume = false
+
+ func resumeOnce(_ result: Result<Void, Error>) {
+ lock.lock()
+ defer { lock.unlock() }
+ guard !didResume else { return }
+ didResume = true
+ session.finishTasksAndInvalidate()
+ continuation.resume(with: result)
+ }
+
+ delegate.onFinish = { tempURL, response in
+ do {
+ guard let httpResponse = response as? HTTPURLResponse else {
+ throw NSError(
+ domain: "WhisperProvider",
+ code: -1,
+ userInfo: [NSLocalizedDescriptionKey: "Invalid server response"]
+ )
+ }
+
+ guard httpResponse.statusCode == 200 else {
+ throw NSError(
+ domain: "WhisperProvider",
+ code: httpResponse.statusCode,
+ userInfo: [NSLocalizedDescriptionKey: "Failed to download model (HTTP \(httpResponse.statusCode))"]
+ )
+ }
+
+ try FileManager.default.createDirectory(at: destination.deletingLastPathComponent(), withIntermediateDirectories: true)
+ if FileManager.default.fileExists(atPath: destination.path) {
+ try FileManager.default.removeItem(at: destination)
+ }
+ try FileManager.default.moveItem(at: tempURL, to: destination)
+ resumeOnce(.success(()))
+ } catch {
+ resumeOnce(.failure(error))
+ }
+ }
+ delegate.onError = { error in
+ resumeOnce(.failure(error))
+ }
+ task.resume()
+ }
+ }
+
+ private final class DownloadProgressDelegate: NSObject, URLSessionDownloadDelegate {
+ private let onProgress: ((Double) -> Void)?
+ var onFinish: ((URL, URLResponse) -> Void)?
+ var onError: ((Error) -> Void)?
+
+ init(onProgress: ((Double) -> Void)?) {
+ self.onProgress = onProgress
+ }
+
+ func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask, didFinishDownloadingTo location: URL) {
+ guard let response = downloadTask.response else { return }
+ self.onFinish?(location, response)
+ }
+
+ func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+ if let error = error { self.onError?(error) }
+ }
+
+ func urlSession(
+ _ session: URLSession,
+ downloadTask: URLSessionDownloadTask,
+ didWriteData bytesWritten: Int64,
+ totalBytesWritten: Int64,
+ totalBytesExpectedToWrite: Int64
+ ) {
+ guard totalBytesExpectedToWrite > 0 else { return }
+ let pct = Double(totalBytesWritten) / Double(totalBytesExpectedToWrite)
+ self.onProgress?(pct)
+ }
+ }
}
diff --git a/Sources/Fluid/Theme/ThemeEnvironment.swift b/Sources/Fluid/Theme/ThemeEnvironment.swift
index 9c63fafe..39b694d7 100644
--- a/Sources/Fluid/Theme/ThemeEnvironment.swift
+++ b/Sources/Fluid/Theme/ThemeEnvironment.swift
@@ -17,3 +17,24 @@ extension View {
environment(\.theme, theme)
}
}
+
+// MARK: - Color Hex Initializer
+
+extension Color {
+ /// Initialize a Color from a hex string (e.g., "#FF5733" or "FF5733")
+ init?(hex: String) {
+ var hexSanitized = hex.trimmingCharacters(in: .whitespacesAndNewlines)
+ hexSanitized = hexSanitized.replacingOccurrences(of: "#", with: "")
+
+ guard hexSanitized.count == 6 else { return nil }
+
+ var rgb: UInt64 = 0
+ guard Scanner(string: hexSanitized).scanHexInt64(&rgb) else { return nil }
+
+ let red = Double((rgb & 0xFF0000) >> 16) / 255.0
+ let green = Double((rgb & 0x00FF00) >> 8) / 255.0
+ let blue = Double(rgb & 0x0000FF) / 255.0
+
+ self.init(red: red, green: green, blue: blue)
+ }
+}
diff --git a/Sources/Fluid/UI/AISettingsView.swift b/Sources/Fluid/UI/AISettingsView.swift
index 1c0fe3ae..bb0259ab 100644
--- a/Sources/Fluid/UI/AISettingsView.swift
+++ b/Sources/Fluid/UI/AISettingsView.swift
@@ -16,6 +16,155 @@ enum AIConnectionStatus {
case unknown, testing, success, failed
}
+// MARK: - Liquid Layer Shape (Gentle bobbing wave)
+
+/// A gentle wave surface that bobs up and down
+private struct LiquidLayer: Shape {
+ var phase: Double // Phase offset for this layer
+ var time: Double // Animation time
+
+ var animatableData: Double {
+ get { time }
+ set { time = newValue }
+ }
+
+ func path(in rect: CGRect) -> Path {
+ var path = Path()
+ let width = Double(rect.width)
+ let height = Double(rect.height)
+
+ // Wave surface very close to the top (only 3% offset for wave amplitude)
+ let baseY = height * 0.03
+
+ path.move(to: CGPoint(x: 0, y: CGFloat(baseY)))
+
+ // Create a gentle, organic wave surface
+ for x in stride(from: 0.0, through: width, by: 1.0) {
+ let normalizedX = x / width
+
+ // Slow, gentle wave like water sloshing in a jar
+ let waveAmplitude = 2.0
+ let waveFrequency = 1.5 // Lower frequency = broader, more ocean-like waves
+ let y = baseY + sin((normalizedX * waveFrequency + time * 0.25 + phase) * .pi) * waveAmplitude
+
+
+
+ path.addLine(to: CGPoint(x: CGFloat(x), y: CGFloat(y)))
+ }
+
+ // Fill down to bottom
+ path.addLine(to: CGPoint(x: CGFloat(width), y: CGFloat(height)))
+ path.addLine(to: CGPoint(x: 0, y: CGFloat(height)))
+ path.closeSubpath()
+
+ return path
+ }
+}
+
+/// A vertical liquid-filled bar with animated fill level
+private struct LiquidBar: View {
+ let fillPercent: Double
+ let color: Color
+ let secondaryColor: Color
+ let icon: String
+ let label: String
+
+ // Animated fill level (smoothly transitions between values)
+ @State private var animatedFill: Double = 0
+
+ var body: some View {
+ VStack(spacing: 8) {
+ // Label
+ HStack(spacing: 4) {
+ Image(systemName: icon)
+ .font(.system(size: 10))
+ .foregroundStyle(color)
+ Text(label)
+ .font(.system(size: 10, weight: .bold))
+ .foregroundStyle(.secondary)
+ }
+
+ // Liquid Container (Capsule Glass)
+ ZStack(alignment: .bottom) {
+ // Background (Empty glass interior)
+ Capsule()
+ .fill(Color.black.opacity(0.35))
+ .overlay(
+ Capsule()
+ .strokeBorder(
+ LinearGradient(
+ colors: [.white.opacity(0.25), .white.opacity(0.05)],
+ startPoint: .topLeading,
+ endPoint: .bottomTrailing
+ ),
+ lineWidth: 1.5
+ )
+ )
+
+ // Single clean liquid layer with animated height
+ GeometryReader { geo in
+ let displayHeight = geo.size.height * CGFloat(animatedFill)
+
+ TimelineView(.animation(minimumInterval: 1.0/30.0)) { timeline in
+ let time = timeline.date.timeIntervalSinceReferenceDate
+
+ // Single organic liquid surface
+ LiquidLayer(phase: 0.0, time: time)
+ .fill(
+ LinearGradient(
+ colors: [color, secondaryColor],
+ startPoint: .bottom,
+ endPoint: .top
+ )
+ )
+ .frame(height: displayHeight)
+ }
+ .frame(maxHeight: .infinity, alignment: .bottom)
+ }
+ .clipShape(Capsule())
+ .padding(3)
+
+ // Glass highlight (3D glossy effect)
+ Capsule()
+ .fill(
+ LinearGradient(
+ stops: [
+ .init(color: .white.opacity(0.25), location: 0),
+ .init(color: .white.opacity(0.08), location: 0.25),
+ .init(color: .clear, location: 0.5)
+ ],
+ startPoint: .topLeading,
+ endPoint: .bottomTrailing
+ )
+ )
+ .padding(2)
+ .allowsHitTesting(false)
+ }
+ .frame(width: 48, height: 90)
+
+ // Percentage (shows target, not animated)
+ Text("\(Int(fillPercent * 100))%")
+ .font(.system(size: 11, weight: .bold, design: .rounded))
+ .foregroundStyle(fillPercent > 0 ? color : .secondary)
+ .contentTransition(.numericText())
+ }
+ .onAppear {
+ // Initialize to target on first appear
+ animatedFill = fillPercent
+ }
+ .onChange(of: fillPercent) { _, newValue in
+ // Animate liquid level change with a gentle "sloshing" feel
+ withAnimation(.interpolatingSpring(stiffness: 140, damping: 18)) {
+ animatedFill = newValue
+ }
+ }
+ }
+}
+
+
+
+
+
private enum PromptEditorMode: Identifiable, Equatable {
case defaultPrompt
case newPrompt
@@ -116,6 +265,11 @@ struct AISettingsView: View {
@State private var pendingDeletePromptID: String? = nil
@State private var pendingDeletePromptName: String = ""
+ // Speech Model Provider Tab Selection
+ @State private var selectedSpeechProvider: SettingsStore.SpeechModel.Provider = .nvidia
+ @State private var previewSpeechModel: SettingsStore.SpeechModel = SettingsStore.shared.selectedSpeechModel
+ @State private var showAdvancedSpeechInfo: Bool = false
+
var body: some View {
ScrollView(.vertical, showsIndicators: false) {
VStack(alignment: .leading, spacing: 14) {
@@ -149,6 +303,11 @@ struct AISettingsView: View {
.onChange(of: self.selectedProviderID) { _, newValue in
SettingsStore.shared.selectedProviderID = newValue
}
+ .onChange(of: self.settings.selectedSpeechModel) { _, newValue in
+ // Keep preview in sync if the active model changes elsewhere
+ self.previewSpeechModel = newValue
+ self.selectedSpeechProvider = newValue.provider
+ }
.onChange(of: self.showKeychainPermissionAlert) { _, isPresented in
guard isPresented else { return }
self.presentKeychainAccessAlert(message: self.keychainPermissionMessage)
@@ -180,6 +339,8 @@ struct AISettingsView: View {
self.selectedModelByProvider = SettingsStore.shared.selectedModelByProvider
self.providerAPIKeys = SettingsStore.shared.providerAPIKeys
self.savedProviders = SettingsStore.shared.savedProviders
+ self.previewSpeechModel = SettingsStore.shared.selectedSpeechModel
+ self.selectedSpeechProvider = SettingsStore.shared.selectedSpeechModel.provider
// Normalize provider keys
var normalized: [String: [String]] = [:]
@@ -212,7 +373,9 @@ struct AISettingsView: View {
// Determine initial model list AND set baseURL BEFORE calling updateCurrentProvider
if let saved = savedProviders.first(where: { $0.id == selectedProviderID }) {
- self.availableModels = saved.models
+ let key = self.providerKey(for: self.selectedProviderID)
+ let stored = self.availableModelsByProvider[key]
+ self.availableModels = saved.models.isEmpty ? (stored ?? []) : saved.models
self.openAIBaseURL = saved.baseURL // Set this FIRST
} else if ModelRepository.shared.isBuiltIn(self.selectedProviderID) {
// Handle all built-in providers using ModelRepository
@@ -243,90 +406,347 @@ struct AISettingsView: View {
private var speechRecognitionCard: some View {
ThemedCard(hoverEffect: false) {
- VStack(alignment: .leading, spacing: 10) {
- HStack {
- Image(systemName: "brain.head.profile")
+ VStack(alignment: .leading, spacing: 14) {
+ // Header
+ HStack(spacing: 10) {
+ Image(systemName: "waveform")
.font(.title2)
- .foregroundStyle(.white)
- Text("Speech Recognition")
+ .foregroundStyle(self.theme.palette.accent)
+ Text("Voice Engine")
.font(.title3)
.fontWeight(.semibold)
+ Toggle("Show model names", isOn: self.$showAdvancedSpeechInfo)
+ .toggleStyle(.checkbox)
+ .font(.caption)
+ Spacer()
}
- VStack(alignment: .leading, spacing: 10) {
- // Single unified model picker
- HStack(spacing: 12) {
- Text("Model")
- .fontWeight(.medium)
- Spacer()
- Menu(SettingsStore.shared.selectedSpeechModel.displayName) {
- ForEach(SettingsStore.SpeechModel.availableModels) { model in
- Button {
- SettingsStore.shared.selectedSpeechModel = model
- self.asr.resetTranscriptionProvider()
- } label: {
- HStack {
- Text(model.displayName)
- Spacer()
- Text("\(model.languageSupport) • \(model.downloadSize)")
- .foregroundStyle(.secondary)
- }
- }
- }
+ // Provider Tabs (centered, no label)
+ HStack {
+ Spacer()
+ Picker("", selection: self.$selectedSpeechProvider) {
+ ForEach(SettingsStore.SpeechModel.Provider.allCases, id: \.self) { provider in
+ Text(provider.rawValue).tag(provider)
}
- .disabled(self.asr.isRunning)
}
+ .pickerStyle(.segmented)
+ .labelsHidden()
+ .frame(maxWidth: 280)
+ Spacer()
+ }
+ .padding(.vertical, 4)
+ .onChange(of: self.selectedSpeechProvider) { _, newProvider in
+ // Preview the first model in the new provider (do not activate)
+ if let firstModel = SettingsStore.SpeechModel.models(for: newProvider).first {
+ self.previewSpeechModel = firstModel
+ }
+ }
- // Model info badges
- HStack(spacing: 8) {
- Label(SettingsStore.shared.selectedSpeechModel.languageSupport, systemImage: "globe")
- .font(.caption)
- .padding(.horizontal, 8)
- .padding(.vertical, 4)
- .background(RoundedRectangle(cornerRadius: 5).fill(.quaternary))
+ // Stats Panel - Dynamic bars that update based on selected model
+ self.modelStatsPanel
- Label(SettingsStore.shared.selectedSpeechModel.downloadSize, systemImage: "arrow.down.circle")
- .font(.caption)
- .padding(.horizontal, 8)
- .padding(.vertical, 4)
- .background(RoundedRectangle(cornerRadius: 5).fill(.quaternary))
+ // Model Cards for selected provider
+ VStack(spacing: 8) {
+ ForEach(SettingsStore.SpeechModel.models(for: self.selectedSpeechProvider)) { model in
+ self.speechModelCard(for: model)
+ }
+ }
- Spacer()
+ Divider().padding(.vertical, 4)
- if SettingsStore.shared.selectedSpeechModel.requiresAppleSilicon {
- Text("Apple Silicon")
- .font(.caption)
- .padding(.horizontal, 8)
- .padding(.vertical, 4)
- .background(RoundedRectangle(cornerRadius: 5, style: .continuous).fill(self.theme.palette.accent.opacity(0.2)))
- }
+ // Filler Words Section
+ self.fillerWordsSection
+ }
+ .padding(14)
+ }
+ }
+
+ /// Stats panel showing speed/accuracy bars that animate when model changes
+ private var modelStatsPanel: some View {
+ let model = self.previewSpeechModel
+
+ return VStack(alignment: .leading, spacing: 8) {
+ // Model name and description
+ VStack(alignment: .leading, spacing: 4) {
+ HStack {
+ Text(model.humanReadableName)
+ .font(.system(size: 16, weight: .bold))
+ .foregroundStyle(self.theme.palette.primaryText)
+
+ if let badge = model.badgeText {
+ Text(badge)
+ .font(.caption2)
+ .fontWeight(.semibold)
+ .padding(.horizontal, 6)
+ .padding(.vertical, 2)
+ .background(Capsule().fill(badge == "FluidVoice Pick" ? .cyan.opacity(0.2) : .orange.opacity(0.2)))
+ .foregroundStyle(badge == "FluidVoice Pick" ? .cyan : .orange)
}
- // Model status indicator
- self.modelStatusView
+ Spacer()
+ }
- // Performance note
- HStack(alignment: .top, spacing: 8) {
- Image(systemName: "info.circle.fill")
- .foregroundStyle(self.theme.palette.accent)
- .font(.caption)
- Text(self.modelDescriptionText)
- .font(.caption)
+ Text(model.cardDescription)
+ .font(.system(size: 12))
+ .foregroundStyle(.secondary)
+ .lineLimit(2)
+ }
+
+ HStack(spacing: 8) {
+ Label(model.downloadSize, systemImage: "internaldrive")
+ .font(.caption2)
+ .foregroundStyle(.secondary)
+
+ if model.requiresAppleSilicon {
+ Text("Apple Silicon")
+ .font(.caption2)
+ .padding(.horizontal, 6)
+ .padding(.vertical, 2)
+ .background(Capsule().fill(self.theme.palette.accent.opacity(0.2)))
+ .foregroundStyle(self.theme.palette.accent)
+ }
+
+ Text(model.languageSupport)
+ .font(.caption2)
+ .padding(.horizontal, 6)
+ .padding(.vertical, 2)
+ .background(Capsule().fill(.quaternary))
+ .foregroundStyle(.secondary)
+
+ Spacer()
+ }
+
+ // Speed and Accuracy - Vertical Liquid Bars (FluidVoice easter egg!)
+ HStack(spacing: 16) {
+ Spacer()
+
+ // Speed liquid bar
+ LiquidBar(
+ fillPercent: model.speedPercent,
+ color: .yellow,
+ secondaryColor: .orange,
+ icon: "bolt.fill",
+ label: "Speed"
+ )
+
+ // Accuracy liquid bar
+ LiquidBar(
+ fillPercent: model.accuracyPercent,
+ color: .green,
+ secondaryColor: .cyan,
+ icon: "target",
+ label: "Accuracy"
+ )
+
+ Spacer()
+ }
+ .animation(.spring(response: 0.5, dampingFraction: 0.7), value: model.id)
+ }
+ .padding(.vertical, 6)
+ }
+
+ /// Simplified card for selecting a speech model
+ private func speechModelCard(for model: SettingsStore.SpeechModel) -> some View {
+ let isSelected = self.previewSpeechModel == model
+ let isActive = self.isActiveSpeechModel(model)
+
+ return HStack(spacing: 10) {
+ // Selection indicator
+ Circle()
+ .fill(isSelected ? .green : .white.opacity(0.1))
+ .frame(width: 8, height: 8)
+ .overlay(
+ Circle()
+ .stroke(isSelected ? .green : .white.opacity(0.3), lineWidth: 1)
+ )
+
+ // Brand logo/badge - fixed size container for consistency
+ ZStack {
+ if model.usesAppleLogo {
+ // Apple logo uses SF Symbol
+ Image(systemName: "apple.logo")
+ .font(.system(size: 12, weight: .medium))
+ .foregroundStyle(Color(hex: model.brandColorHex) ?? .gray)
+ } else {
+ // Text badges (NVIDIA, OpenAI)
+ Text(model.brandName)
+ .font(.system(size: 8, weight: .bold))
+ .foregroundStyle(.white)
+ .padding(.horizontal, 4)
+ .padding(.vertical, 2)
+ .background(
+ RoundedRectangle(cornerRadius: 3)
+ .fill(Color(hex: model.brandColorHex) ?? .gray)
+ )
+ }
+ }
+ .frame(width: 48, height: 18, alignment: .center)
+
+ // Title + technical name
+ VStack(alignment: .leading, spacing: 2) {
+ Text(model.humanReadableName)
+ .font(.system(size: 13, weight: isSelected ? .semibold : .regular))
+ .foregroundStyle(isSelected ? self.theme.palette.primaryText : .secondary)
+ if self.showAdvancedSpeechInfo {
+ Text(model.displayName)
+ .font(.caption2)
+ .foregroundStyle(.secondary.opacity(0.7))
+ }
+ }
+ .frame(maxWidth: .infinity, alignment: .leading)
+
+ // Action area (right side)
+ if (self.asr.isDownloadingModel || self.asr.isLoadingModel) && isActive && !self.asr.isAsrReady {
+ VStack(alignment: .trailing, spacing: 4) {
+ if let progress = self.asr.downloadProgress, self.asr.isDownloadingModel {
+ ProgressView(value: progress)
+ .progressViewStyle(.linear)
+ .frame(width: 90)
+ Text("\(Int(progress * 100))%")
+ .font(.caption2)
+ .foregroundStyle(.secondary)
+ } else {
+ ProgressView()
+ .controlSize(.mini)
+ Text(self.asr.isLoadingModel ? "Loading…" : "Downloading…")
+ .font(.caption2)
.foregroundStyle(.secondary)
}
- .padding(10)
- .background(RoundedRectangle(cornerRadius: 8).fill(.ultraThinMaterial.opacity(0.3)))
+ }
+ } else if model.isInstalled {
+ HStack(spacing: 8) {
+ if isActive {
+ let isLoading = (self.asr.isLoadingModel || self.asr.isDownloadingModel) && !self.asr.isAsrReady
+ Text(isLoading ? "Loading…" : "Active")
+ .font(.caption2)
+ .fontWeight(.semibold)
+ .padding(.horizontal, 10)
+ .padding(.vertical, 4)
+ .background(Capsule().fill(isLoading ? .orange.opacity(0.25) : .green.opacity(0.25)))
+ .foregroundStyle(isLoading ? .orange : .green)
+ } else {
+ Button("Activate") {
+ self.activateSpeechModel(model)
+ }
+ .buttonStyle(.borderedProminent)
+ .controlSize(.small)
+ .tint(.green)
+ .fontWeight(.semibold)
+ .shadow(color: .green.opacity(0.35), radius: 4, x: 0, y: 1)
+ .disabled(self.asr.isRunning)
+ }
- Divider().padding(.vertical, 4)
+ if !model.usesAppleLogo {
+ Button {
+ self.deleteSpeechModel(model)
+ } label: {
+ Image(systemName: "trash")
+ .font(.system(size: 15))
+ .foregroundStyle(.red.opacity(0.7))
+ }
+ .buttonStyle(.plain)
+ .disabled(self.asr.isRunning)
+ }
+ }
+ } else {
+ Button("Download") {
+ self.previewSpeechModel = model
+ self.downloadSpeechModel(model)
+ }
+ .buttonStyle(.borderedProminent)
+ .controlSize(.small)
+ .tint(.blue)
+ .disabled(self.asr.isRunning)
+ }
+ }
+ .padding(.horizontal, 12)
+ .padding(.vertical, 10)
+ .contentShape(Rectangle())
+ .background(
+ RoundedRectangle(cornerRadius: 8)
+ .fill(isSelected ? .white.opacity(0.05) : .clear)
+ .overlay(
+ RoundedRectangle(cornerRadius: 8)
+ .stroke(isSelected ? .white.opacity(0.25) : .white.opacity(0.05), lineWidth: 1)
+ )
+ .overlay(
+ RoundedRectangle(cornerRadius: 8)
+ .stroke(isActive ? .green.opacity(0.9) : .clear, lineWidth: 2)
+ )
+ )
+ .onTapGesture {
+ self.previewSpeechModel = model
+ }
+ .opacity(self.asr.isRunning ? 0.6 : 1.0)
+ .allowsHitTesting(!self.asr.isRunning)
+ }
+
+ private func activateSpeechModel(_ model: SettingsStore.SpeechModel) {
+ guard !self.asr.isRunning else { return }
+ withAnimation(.spring(response: 0.3, dampingFraction: 0.7)) {
+ SettingsStore.shared.selectedSpeechModel = model
+ self.previewSpeechModel = model
+ self.selectedSpeechProvider = model.provider
+ }
+ self.asr.resetTranscriptionProvider()
+ Task {
+ do {
+ try await self.asr.ensureAsrReady()
+ } catch {
+ DebugLogger.shared.error("Failed to prepare model after activation: \(error)", source: "AISettingsView")
+ }
+ }
+ }
+
+ private func downloadSpeechModel(_ model: SettingsStore.SpeechModel) {
+ guard !self.asr.isRunning else { return }
+ let previousActive = SettingsStore.shared.selectedSpeechModel
+
+ Task {
+ await MainActor.run {
+ SettingsStore.shared.selectedSpeechModel = model
+ self.asr.resetTranscriptionProvider()
+ }
- // Filler Words Section
- self.fillerWordsSection
+ await self.downloadModels()
+
+ if previousActive != model {
+ await MainActor.run {
+ if SettingsStore.shared.selectedSpeechModel == model {
+ SettingsStore.shared.selectedSpeechModel = previousActive
+ self.asr.resetTranscriptionProvider()
+ }
}
}
- .padding(14)
}
}
+ private func deleteSpeechModel(_ model: SettingsStore.SpeechModel) {
+ guard !self.asr.isRunning else { return }
+ let previousActive = SettingsStore.shared.selectedSpeechModel
+
+ Task {
+ await MainActor.run {
+ SettingsStore.shared.selectedSpeechModel = model
+ self.asr.resetTranscriptionProvider()
+ }
+
+ await self.deleteModels()
+
+ if previousActive != model {
+ await MainActor.run {
+ SettingsStore.shared.selectedSpeechModel = previousActive
+ self.asr.resetTranscriptionProvider()
+ }
+ }
+ }
+ }
+
+ private func isActiveSpeechModel(_ model: SettingsStore.SpeechModel) -> Bool {
+ SettingsStore.shared.selectedSpeechModel == model
+ }
+
+
/// Returns the appropriate description text for the currently selected speech model
private var modelDescriptionText: String {
let model = SettingsStore.shared.selectedSpeechModel
@@ -346,7 +766,7 @@ struct AISettingsView: View {
private var modelStatusView: some View {
HStack(spacing: 12) {
- if self.asr.isDownloadingModel || self.asr.isLoadingModel {
+ if (self.asr.isDownloadingModel || self.asr.isLoadingModel) && !self.asr.isAsrReady {
HStack(spacing: 8) {
ProgressView().controlSize(.small)
Text(self.asr.isLoadingModel ? "Loading model…" : "Downloading…")
@@ -380,17 +800,16 @@ struct AISettingsView: View {
}
.buttonStyle(.plain)
} else {
- Image(systemName: "arrow.down.circle").foregroundStyle(.orange).font(.caption)
-
Button(action: { Task { await self.downloadModels() } }) {
HStack(spacing: 4) {
Image(systemName: "arrow.down.circle.fill")
Text("Download")
}
.font(.caption)
- .foregroundStyle(self.theme.palette.accent)
}
- .buttonStyle(.plain)
+ .buttonStyle(.borderedProminent)
+ .controlSize(.small)
+ .tint(.blue)
}
}
.padding(.horizontal, 12)
@@ -774,53 +1193,23 @@ struct AISettingsView: View {
private var aiConfigurationCard: some View {
VStack(spacing: 14) {
ThemedCard(style: .prominent, hoverEffect: false) {
- VStack(alignment: .leading, spacing: 12) {
+ VStack(alignment: .leading, spacing: 10) {
// Header
HStack(spacing: 12) {
HStack(spacing: 8) {
- Image(systemName: "key.fill")
+ Image(systemName: "sparkles")
.font(.title3)
.foregroundStyle(self.theme.palette.accent)
- Text("API Configuration")
+ Text("AI Enhancement")
.font(.headline)
.fontWeight(.semibold)
}
-
- // Compatibility Badge
- if self.selectedProviderID == "apple-intelligence" {
- HStack(spacing: 4) {
- Image(systemName: "apple.logo").font(.caption2)
- Text("On-device").font(.caption)
- }
- .foregroundStyle(.secondary)
- .padding(.horizontal, 8)
- .padding(.vertical, 2)
- .background(Capsule().fill(.quaternary.opacity(0.5)))
- } else {
- HStack(spacing: 4) {
- Image(systemName: "checkmark.seal.fill").font(.caption2)
- Text("OpenAI Compatible").font(.caption)
- }
- .foregroundStyle(.secondary)
- .padding(.horizontal, 8)
- .padding(.vertical, 2)
- .background(Capsule().fill(.quaternary.opacity(0.5)))
- }
-
Spacer()
-
- Button(action: { self.showHelp.toggle() }) {
- Image(systemName: self.showHelp ? "questionmark.circle.fill" : "questionmark.circle")
- .font(.system(size: 20))
- .foregroundStyle(self.theme.palette.accent.opacity(0.8))
- }
- .buttonStyle(.plain)
+ Toggle("", isOn: self.$enableAIProcessing)
+ .toggleStyle(.switch)
+ .labelsHidden()
}
-
- // AI Enhancement Toggle
- self.aiEnhancementToggle
-
// Streaming Toggle
if self.enableAIProcessing && self.selectedProviderID != "apple-intelligence" {
HStack(spacing: 20) {
@@ -839,7 +1228,7 @@ struct AISettingsView: View {
.font(.system(size: 13))
.foregroundStyle(self.theme.palette.secondaryText)
.padding(.leading, 4)
- .padding(.top, -4)
+ .padding(.top, -2)
}
// API Key Warning
@@ -854,32 +1243,60 @@ struct AISettingsView: View {
if self.showHelp { self.helpSectionView }
- // Provider/Model Configuration
- self.providerConfigurationSection
+ // Provider/Model Configuration (only shown when AI Enhancement is enabled)
+ if self.enableAIProcessing {
+ HStack(spacing: 12) {
+ HStack(spacing: 8) {
+ Image(systemName: "key.fill")
+ .font(.title3)
+ .foregroundStyle(self.theme.palette.accent)
+ Text("API Configuration")
+ .font(.headline)
+ .fontWeight(.semibold)
+ }
+
+ // Compatibility Badge
+ if self.selectedProviderID == "apple-intelligence" {
+ HStack(spacing: 4) {
+ Image(systemName: "apple.logo").font(.caption2)
+ Text("On-device").font(.caption)
+ }
+ .foregroundStyle(.secondary)
+ .padding(.horizontal, 8)
+ .padding(.vertical, 2)
+ .background(Capsule().fill(.quaternary.opacity(0.5)))
+ } else {
+ HStack(spacing: 4) {
+ Image(systemName: "checkmark.seal.fill").font(.caption2)
+ Text("OpenAI Compatible").font(.caption)
+ }
+ .foregroundStyle(.secondary)
+ .padding(.horizontal, 8)
+ .padding(.vertical, 2)
+ .background(Capsule().fill(.quaternary.opacity(0.5)))
+ }
+
+ Spacer()
+
+ Button(action: { self.showHelp.toggle() }) {
+ Image(systemName: self.showHelp ? "questionmark.circle.fill" : "questionmark.circle")
+ .font(.system(size: 20))
+ .foregroundStyle(self.theme.palette.accent.opacity(0.8))
+ }
+ .buttonStyle(.plain)
+ }
+
+ self.providerConfigurationSection
+
+ self.advancedSettingsCard
+ }
}
.padding(14)
}
.modifier(CardAppearAnimation(delay: 0.1, appear: self.$appear))
-
- // Advanced Settings Card
- self.advancedSettingsCard
}
}
- private var aiEnhancementToggle: some View {
- HStack(alignment: .center, spacing: 16) {
- Text("Enable AI Enhancement")
- .font(.system(size: 15, weight: .semibold))
- .foregroundStyle(self.theme.palette.primaryText)
- Spacer()
- Toggle("", isOn: self.$enableAIProcessing)
- .toggleStyle(.switch)
- .labelsHidden()
- }
- .padding(.horizontal, 4)
- }
-
-
private var apiKeyWarningView: some View {
HStack(spacing: 10) {
Image(systemName: "exclamationmark.triangle.fill")
@@ -938,13 +1355,15 @@ struct AISettingsView: View {
if self.selectedProviderID == "apple-intelligence" { self.appleIntelligenceBadge }
// API Key Management
- if self.selectedProviderID != "apple-intelligence" {
+ if self.selectedProviderID != "apple-intelligence" {
HStack(spacing: 8) {
Button(action: { self.handleAPIKeyButtonTapped() }) {
Label("Add or Modify API Key", systemImage: "key.fill")
.labelStyle(.titleAndIcon).font(.caption)
}
- .buttonStyle(GlassButtonStyle())
+ .buttonStyle(.borderedProminent)
+ .controlSize(.small)
+ .tint(self.theme.palette.accent.opacity(0.8))
// Get API Key / Download button for built-in providers
if let websiteInfo = ModelRepository.shared.providerWebsiteURL(for: self.selectedProviderID),
@@ -1271,6 +1690,17 @@ struct AISettingsView: View {
self.availableModelsByProvider[key] = models
SettingsStore.shared.availableModelsByProvider = self.availableModelsByProvider
+ if let providerIndex = self.savedProviders.firstIndex(where: { $0.id == self.selectedProviderID }) {
+ let updatedProvider = SettingsStore.SavedProvider(
+ id: self.savedProviders[providerIndex].id,
+ name: self.savedProviders[providerIndex].name,
+ baseURL: self.savedProviders[providerIndex].baseURL,
+ models: models
+ )
+ self.savedProviders[providerIndex] = updatedProvider
+ self.saveSavedProviders()
+ }
+
// Select first model if current selection not in list
if !models.contains(self.selectedModel) {
self.selectedModel = models.first ?? ""
@@ -1421,7 +1851,9 @@ struct AISettingsView: View {
Button(action: { Task { await self.testAPIConnection() } }) {
Text(self.isTestingConnection ? "Verifying..." : "Verify Connection").font(.caption).fontWeight(.semibold)
}
- .buttonStyle(GlassButtonStyle())
+ .buttonStyle(.borderedProminent)
+ .controlSize(.small)
+ .tint(self.theme.palette.accent.opacity(0.8))
.disabled(self.isTestingConnection || (!self.isLocalEndpoint(self.openAIBaseURL.trimmingCharacters(in: .whitespacesAndNewlines)) && (self.providerAPIKeys[self.currentProvider] ?? "").isEmpty))
}
diff --git a/Sources/Fluid/Views/BottomOverlayView.swift b/Sources/Fluid/Views/BottomOverlayView.swift
index 1abc6fe4..12ab0eda 100644
--- a/Sources/Fluid/Views/BottomOverlayView.swift
+++ b/Sources/Fluid/Views/BottomOverlayView.swift
@@ -180,6 +180,7 @@ final class BottomOverlayWindowController {
struct BottomOverlayView: View {
@ObservedObject private var contentState = NotchContentState.shared
+ @ObservedObject private var appServices = AppServices.shared
@ObservedObject private var settings = SettingsStore.shared
@State private var showPromptHoverMenu = false
@State private var promptHoverWorkItem: DispatchWorkItem?
@@ -429,23 +430,42 @@ struct BottomOverlayView: View {
HStack(spacing: self.layout.hPadding / 1.5) {
// Target app icon (the app where text will be typed)
if let appIcon = contentState.targetAppIcon {
- Image(nsImage: appIcon)
- .resizable()
- .aspectRatio(contentMode: .fit)
- .frame(width: self.layout.iconSize, height: self.layout.iconSize)
- .clipShape(RoundedRectangle(cornerRadius: self.layout.iconSize / 4))
+ let showModelLoading = !self.appServices.asr.isAsrReady &&
+ (self.appServices.asr.isLoadingModel || self.appServices.asr.isDownloadingModel)
+ VStack(spacing: 2) {
+ if showModelLoading {
+ ProgressView()
+ .controlSize(.mini)
+ }
+ Image(nsImage: appIcon)
+ .resizable()
+ .aspectRatio(contentMode: .fit)
+ .frame(width: self.layout.iconSize, height: self.layout.iconSize)
+ .clipShape(RoundedRectangle(cornerRadius: self.layout.iconSize / 4))
+ }
}
// Waveform visualization
BottomWaveformView(color: self.modeColor, layout: self.layout)
.frame(width: self.layout.waveformWidth, height: self.layout.waveformHeight)
- // Mode label
- Text(self.modeLabel)
- .font(.system(size: self.layout.modeFontSize, weight: .semibold))
- .foregroundStyle(self.modeColor)
- .lineLimit(1)
- .fixedSize(horizontal: true, vertical: false)
+ // Mode label + model load hint
+ VStack(alignment: .leading, spacing: 2) {
+ Text(self.modeLabel)
+ .font(.system(size: self.layout.modeFontSize, weight: .semibold))
+ .foregroundStyle(self.modeColor)
+ .lineLimit(1)
+ .fixedSize(horizontal: true, vertical: false)
+
+ if !self.appServices.asr.isAsrReady &&
+ (self.appServices.asr.isLoadingModel || self.appServices.asr.isDownloadingModel)
+ {
+ Text("Loading model…")
+ .font(.system(size: max(self.layout.modeFontSize - 2, 9), weight: .medium))
+ .foregroundStyle(.orange.opacity(0.85))
+ .lineLimit(1)
+ }
+ }
}
}
.padding(.horizontal, self.layout.hPadding)