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

feat(dictionary): auto-stop voice training

altic-dev02db2c345937
diff --git a/Sources/Fluid/Services/ASRService.swift b/Sources/Fluid/Services/ASRService.swift
index 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.selectedSpeechModel
return selectedModel.streamingPreviewIntervalSeconds
diff --git a/Sources/Fluid/Services/AutomaticDictionaryTrainingSession.swift b/Sources/Fluid/Services/AutomaticDictionaryTrainingSession.swift
index 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 = .training
self.statusMessage = ""
self.hasError = false
+ Task { await DictionaryTrainingEndpointMonitor.shared.prepare() }
}
func returnToChoice() {
@@ -172,6 +173,7 @@ final class AutomaticDictionaryTrainingSession: ObservableObject {
func cancel() {
self.isCancelled = true
self.discardCurrentCapture = true
+ DictionaryTrainingEndpointMonitor.shared.stop()
switch self.capturePhase {
case .starting:
self.stopRequestedDuringStart = true
@@ -229,9 +231,13 @@ final class AutomaticDictionaryTrainingSession: ObservableObject {
self.capturePhase = .recording
self.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 = .processing
self.stopRequestedDuringStart = false
self.hasError = false
diff --git a/Sources/Fluid/Services/DictionaryTrainingEndpointDetector.swift b/Sources/Fluid/Services/DictionaryTrainingEndpointDetector.swift
new file mode 100644
index 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.swift
new file mode 100644
index 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.swift
index 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 buffer
func getAll() -> [Float] {
self.lock.lock()
diff --git a/Sources/Fluid/UI/CustomDictionaryView.swift b/Sources/Fluid/UI/CustomDictionaryView.swift
index 719f3388..7e1016cc 100644
--- a/Sources/Fluid/UI/CustomDictionaryView.swift
+++ b/Sources/Fluid/UI/CustomDictionaryView.swift
@@ -1775,6 +1775,7 @@ struct CustomDictionaryView: View {
self.isTrainingActive = true
self.trainingHasError = false
self.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 = false
self.isTrainingStarting = false
self.trainingStopRequestedDuringStart = false