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
feat(dictionary): auto-stop voice training
altic-dev02db2c345937
diff --git a/Sources/Fluid/Services/ASRService.swift b/Sources/Fluid/Services/ASRService.swiftindex 2e0c0040..aea270fb 100644--- a/Sources/Fluid/Services/ASRService.swift+++ b/Sources/Fluid/Services/ASRService.swift@@ -52,14 +52,6 @@ private actor TranscriptionExecutor {/// The service is designed to work seamlessly with macOS system APIs and provides/// robust error handling and performance optimization.///-/// ## Usage-/// ```swift-/// let asrService = ASRService()-/// await asrService.start() // Begin recording-/// // ... speak ...-/// let transcribedText = await asrService.stop() // Stop and get transcription-/// ```-////// ## Language Support/// The service supports multiple models with varying language capabilities:/// - **Parakeet TDT v3** (Default): Automatically detects and transcribes 25 European languages:@@ -918,6 +910,10 @@ final class ASRService: ObservableObject {return snapshot}+ func dictionaryTrainingAudioChunk(at offset: Int, count: Int) -> [Float] {+ self.audioBuffer.getRange(startingAt: offset, count: count)+ }+private var streamingChunkDurationSeconds: Double {let selectedModel = SettingsStore.shared.selectedSpeechModelreturn selectedModel.streamingPreviewIntervalSecondsdiff --git a/Sources/Fluid/Services/AutomaticDictionaryTrainingSession.swift b/Sources/Fluid/Services/AutomaticDictionaryTrainingSession.swiftindex bb5b409c..ea930fbf 100644--- a/Sources/Fluid/Services/AutomaticDictionaryTrainingSession.swift+++ b/Sources/Fluid/Services/AutomaticDictionaryTrainingSession.swift@@ -133,6 +133,7 @@ final class AutomaticDictionaryTrainingSession: ObservableObject {self.screen = .trainingself.statusMessage = ""self.hasError = false+ Task { await DictionaryTrainingEndpointMonitor.shared.prepare() }}func returnToChoice() {@@ -172,6 +173,7 @@ final class AutomaticDictionaryTrainingSession: ObservableObject {func cancel() {self.isCancelled = trueself.discardCurrentCapture = true+ DictionaryTrainingEndpointMonitor.shared.stop()switch self.capturePhase {case .starting:self.stopRequestedDuringStart = true@@ -229,9 +231,13 @@ final class AutomaticDictionaryTrainingSession: ObservableObject {self.capturePhase = .recordingself.statusMessage = "Listening..."}+ DictionaryTrainingEndpointMonitor.shared.start(asr: self.asr) { [weak self] in+ self?.handleAutomaticSpeechEnd()+ }}private func stopCapture() async {+ DictionaryTrainingEndpointMonitor.shared.stop()switch self.capturePhase {case .starting:self.stopRequestedDuringStart = true@@ -243,8 +249,16 @@ final class AutomaticDictionaryTrainingSession: ObservableObject {}}+ private func handleAutomaticSpeechEnd() {+ guard self.capturePhase == .starting || self.capturePhase == .recording else { return }+ self.statusMessage = "Stopping..."+ self.stopTask?.cancel()+ self.stopTask = Task { await self.stopCapture() }+ }+private func finishCapture() async {guard self.capturePhase == .recording || self.capturePhase == .starting else { return }+ DictionaryTrainingEndpointMonitor.shared.stop()self.capturePhase = .processingself.stopRequestedDuringStart = falseself.hasError = falsediff --git a/Sources/Fluid/Services/DictionaryTrainingEndpointDetector.swift b/Sources/Fluid/Services/DictionaryTrainingEndpointDetector.swiftnew file mode 100644index 00000000..3dcb966c--- /dev/null+++ b/Sources/Fluid/Services/DictionaryTrainingEndpointDetector.swift@@ -0,0 +1,117 @@+import Foundation+#if arch(arm64)+import FluidAudio+#endif++actor DictionaryTrainingEndpointDetector {+ static let chunkSize = 4096++ enum Event: Sendable {+ case speechStarted+ case speechEnded+ }++ struct Session: Equatable, Sendable {+ let id: UUID+ }++ #if arch(arm64)+ private var manager: VadManager?+ private var managerTask: Task<VadManager, Error>?+ private var activeSessionID: UUID?+ private var streamState: VadStreamState?+ private var hasDetectedSpeech = false++ func prepare() async throws {+ _ = try await self.preparedManager()+ }++ func beginSession() async throws -> Session? {+ let manager = try await self.preparedManager()+ let session = Session(id: UUID())+ self.activeSessionID = session.id+ self.streamState = await manager.makeStreamState()+ self.hasDetectedSpeech = false+ return session+ }++ func process(_ samples: [Float], session: Session) async throws -> Event? {+ guard samples.count == Self.chunkSize,+ self.activeSessionID == session.id,+ let manager,+ let streamState+ else {+ return nil+ }++ let result = try await manager.processStreamingChunk(+ samples,+ state: streamState,+ config: .default+ )+ guard self.activeSessionID == session.id else { return nil }++ self.streamState = result.state+ guard let event = result.event else { return nil }++ switch event.kind {+ case .speechStart:+ self.hasDetectedSpeech = true+ return .speechStarted+ case .speechEnd:+ return self.hasDetectedSpeech ? .speechEnded : nil+ }+ }++ func endSession(_ session: Session) {+ guard self.activeSessionID == session.id else { return }+ self.activeSessionID = nil+ self.streamState = nil+ self.hasDetectedSpeech = false+ }++ private func preparedManager() async throws -> VadManager {+ if let manager {+ return manager+ }+ if let managerTask {+ do {+ let manager = try await managerTask.value+ self.manager = manager+ self.managerTask = nil+ return manager+ } catch {+ self.managerTask = nil+ throw error+ }+ }++ let task = Task<VadManager, Error> {+ try await VadManager()+ }+ self.managerTask = task++ do {+ let manager = try await task.value+ self.manager = manager+ self.managerTask = nil+ return manager+ } catch {+ self.managerTask = nil+ throw error+ }+ }+ #else+ func prepare() async throws {}++ func beginSession() async throws -> Session? {+ nil+ }++ func process(_: [Float], session _: Session) async throws -> Event? {+ nil+ }++ func endSession(_: Session) {}+ #endif+}diff --git a/Sources/Fluid/Services/DictionaryTrainingEndpointMonitor.swift b/Sources/Fluid/Services/DictionaryTrainingEndpointMonitor.swiftnew file mode 100644index 00000000..39df201d--- /dev/null+++ b/Sources/Fluid/Services/DictionaryTrainingEndpointMonitor.swift@@ -0,0 +1,102 @@+import Foundation++@MainActor+final class DictionaryTrainingEndpointMonitor {+ static let shared = DictionaryTrainingEndpointMonitor()++ private let detector = DictionaryTrainingEndpointDetector()+ private var task: Task<Void, Never>?++ private init() {}++ func prepare() async {+ do {+ try await self.detector.prepare()+ DebugLogger.shared.debug(+ "Dictionary training endpoint detector ready",+ source: "DictionaryTrainingEndpointMonitor"+ )+ } catch {+ DebugLogger.shared.warning(+ "Dictionary training endpoint detector unavailable: \(error.localizedDescription)",+ source: "DictionaryTrainingEndpointMonitor"+ )+ }+ }++ func start(+ asr: ASRService,+ onSpeechEnded: @escaping @MainActor () -> Void+ ) {+ self.stop()+ let detector = self.detector++ self.task = Task { @MainActor [weak asr] in+ do {+ guard let asr,+ let detectorSession = try await detector.beginSession()+ else {+ return+ }+ defer {+ Task { await detector.endSession(detectorSession) }+ }++ var sampleOffset = 0+ while !Task.isCancelled {+ guard asr.isRunning, asr.isDictionaryTrainingCaptureActive else { return }++ let chunk = asr.dictionaryTrainingAudioChunk(+ at: sampleOffset,+ count: DictionaryTrainingEndpointDetector.chunkSize+ )+ guard !chunk.isEmpty else {+ try await Task.sleep(nanoseconds: 40_000_000)+ continue+ }+ sampleOffset += chunk.count++ guard let event = try await detector.process(+ chunk,+ session: detectorSession+ ) else {+ continue+ }+ guard !Task.isCancelled,+ asr.isRunning,+ asr.isDictionaryTrainingCaptureActive+ else {+ return+ }++ switch event {+ case .speechStarted:+ DebugLogger.shared.debug(+ "Dictionary training speech started",+ source: "DictionaryTrainingEndpointMonitor"+ )+ case .speechEnded:+ DebugLogger.shared.debug(+ "Dictionary training speech ended; stopping sample",+ source: "DictionaryTrainingEndpointMonitor"+ )+ onSpeechEnded()+ return+ }+ }+ } catch is CancellationError {+ return+ } catch {+ DebugLogger.shared.warning(+ "Dictionary training endpoint detection failed: \(error.localizedDescription)",+ source: "DictionaryTrainingEndpointMonitor"+ )+ }+ }+ }++ func stop() {+ self.task?.cancel()+ self.task = nil+ }+}diff --git a/Sources/Fluid/Services/ThreadSafeAudioBuffer.swift b/Sources/Fluid/Services/ThreadSafeAudioBuffer.swiftindex d0c0eca4..b7648f80 100644--- a/Sources/Fluid/Services/ThreadSafeAudioBuffer.swift+++ b/Sources/Fluid/Services/ThreadSafeAudioBuffer.swift@@ -2,7 +2,7 @@ import Foundation/// A thread-safe wrapper around a float array to prevent data races between/// the audio engine (background thread) and the ASR service (main thread).-final class ThreadSafeAudioBuffer {+final nonisolated class ThreadSafeAudioBuffer {private var buffer: [Float] = []private let lock = NSLock()@@ -35,6 +35,20 @@ final class ThreadSafeAudioBuffer {return Array(self.buffer[0..<safeLength])}+ /// Returns an exact range when enough samples are available.+ func getRange(startingAt start: Int, count: Int) -> [Float] {+ self.lock.lock()+ defer { lock.unlock() }+ guard start >= 0,+ count > 0,+ start <= self.buffer.count,+ count <= self.buffer.count - start+ else {+ return []+ }+ return Array(self.buffer[start..<(start + count)])+ }+/// Returns a copy of the entire bufferfunc getAll() -> [Float] {self.lock.lock()diff --git a/Sources/Fluid/UI/CustomDictionaryView.swift b/Sources/Fluid/UI/CustomDictionaryView.swiftindex 719f3388..7e1016cc 100644--- a/Sources/Fluid/UI/CustomDictionaryView.swift+++ b/Sources/Fluid/UI/CustomDictionaryView.swift@@ -1775,6 +1775,7 @@ struct CustomDictionaryView: View {self.isTrainingActive = trueself.trainingHasError = falseself.trainingStatusMessage = ""+ Task { await DictionaryTrainingEndpointMonitor.shared.prepare() }}private func startTrainingSample() async {@@ -1798,10 +1799,15 @@ struct CustomDictionaryView: View {if self.trainingStopRequestedDuringStart {await self.finishTrainingSampleStop()+ return+ }+ DictionaryTrainingEndpointMonitor.shared.start(asr: self.asr) {+ self.handleAutomaticTrainingSpeechEnd()}}private func stopTrainingSample() async {+ DictionaryTrainingEndpointMonitor.shared.stop()guard self.isTrainingRecording else { return }guard !self.trainingStopRequestedDuringStart else { return }@@ -1815,8 +1821,14 @@ struct CustomDictionaryView: View {await self.finishTrainingSampleStop()}+ private func handleAutomaticTrainingSpeechEnd() {+ guard self.isTrainingRecording else { return }+ Task { await self.stopTrainingSample() }+ }+private func finishTrainingSampleStop() async {guard self.isTrainingRecording else { return }+ DictionaryTrainingEndpointMonitor.shared.stop()self.isTrainingRecording = falseself.isTrainingStarting = falseself.trainingStopRequestedDuringStart = false