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
import AppKit
import Combine
import CryptoKit
import Foundation
@MainActor
final class RewriteModeService: ObservableObject {
@Published var originalText: String = ""
@Published var selectedContextText: String = ""
@Published var rewrittenText: String = ""
@Published var streamingThinkingText: String = "" // Real-time thinking tokens for UI
@Published var isProcessing = false
@Published var conversationHistory: [Message] = []
/// Why the last request produced nothing, for the overlay to show.
@Published private(set) var lastErrorMessage: String?
@Published var isWriteMode: Bool = false // true = no text selected (write/improve), false = text selected (rewrite)
private var promptAppBundleID: String?
/// The front window as read when the shortcut was pressed.
private var windowCapture: DictationContextCapture?
private var windowCaptureRevision: UInt64?
private let captureWindow: @MainActor (TypingService.RecordingTargetContext) -> DictationContextCapture?
init(captureWindow: @escaping @MainActor (TypingService.RecordingTargetContext) -> DictationContextCapture? = {
DictationContextCapture.startForEditMode(target: $0)
}) {
self.captureWindow = captureWindow
}
private let textSelectionService = TextSelectionService.shared
private let typingService = TypingService()
private var thinkingBuffer: [String] = [] // Buffer thinking tokens
private var forcePromptTraceToConsole: Bool {
ProcessInfo.processInfo.environment["FLUID_PROMPT_TRACE"] == "1"
}
private var diagnosticsEnabled: Bool {
if ProcessInfo.processInfo.environment["FLUID_REWRITE_DIAGNOSTICS"] == "1" {
return true
}
return UserDefaults.standard.bool(forKey: "RewriteModeDiagnosticsEnabled")
}
private var shouldTracePromptProcessing: Bool {
if let explicit = UserDefaults.standard.object(forKey: "RewriteModePromptTraceEnabled") as? Bool {
return explicit
}
// Default OFF to avoid logging prompt/context content in normal usage.
return false
}
struct Message: Identifiable, Equatable {
let id = UUID()
let role: Role
let content: String
enum Role: Equatable {
case user
case assistant
}
}
func captureSelectedText() -> Bool {
if let text = textSelectionService.getSelectedText(), !text.isEmpty {
self.originalText = text
self.selectedContextText = text
self.rewrittenText = ""
self.conversationHistory = []
self.isWriteMode = false
if self.shouldTracePromptProcessing {
self.logPromptTrace("Captured selected context", value: text)
}
return true
}
return false
}
/// Start rewrite mode without selected text - user will provide text via voice
func startWithoutSelection() {
self.originalText = ""
self.selectedContextText = ""
self.rewrittenText = ""
self.conversationHistory = []
self.isWriteMode = true
if self.shouldTracePromptProcessing {
self.logPromptTrace("Starting edit with no selected context", value: "<empty>")
}
}
/// Set the original text directly (from voice input when no text was selected)
func setOriginalText(_ text: String) {
self.originalText = text
self.rewrittenText = ""
self.conversationHistory = []
}
func processRewriteRequest(_ prompt: String) async {
guard let summaryActivity = MeetingSummaryActivityCoordinator.shared.beginProcessing() else {
MeetingSummaryActivityCoordinator.presentBusyError()
return
}
defer { MeetingSummaryActivityCoordinator.shared.endProcessing(summaryActivity) }
let startTime = Date()
self.lastErrorMessage = nil
AnalyticsService.shared.recordUsage(
mode: .edit,
aiModel: SettingsStore.shared.analyticsAIModelDescriptor(for: .edit)
)
self.appendDiagnosticLog(
"processRewriteRequest start | promptChars=\(prompt.count) | hadOriginal=\(!self.originalText.isEmpty) | contextChars=\(self.selectedContextText.count)"
)
// If no original text, we're in "Write Mode" - generate content based on user's request
if self.originalText.isEmpty {
self.originalText = prompt
self.isWriteMode = true
// Write Mode: User is asking AI to write/generate something
self.conversationHistory.append(Message(role: .user, content: prompt))
} else {
// Rewrite Mode: User has selected text and is giving instructions
self.isWriteMode = false
let hasContext = !self.selectedContextText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
if self.conversationHistory.isEmpty {
let rewritePrompt: String
if hasContext {
rewritePrompt = """
User's instruction: \(prompt)
Apply the instruction to the selected context. Output ONLY the rewritten text, nothing else.
"""
} else {
rewritePrompt = """
User's instruction: \(prompt)
Output ONLY the requested text, nothing else.
"""
}
self.conversationHistory.append(Message(role: .user, content: rewritePrompt))
} else {
// Follow-up request
self.conversationHistory.append(Message(role: .user, content: "Follow-up instruction: \(prompt)\n\nApply this to the previous result. Output ONLY the updated text."))
}
}
guard !self.conversationHistory.isEmpty else { return }
self.isProcessing = true
do {
let response = try await callLLM(messages: conversationHistory, isWriteMode: isWriteMode, instruction: prompt)
self.conversationHistory.append(Message(role: .assistant, content: response))
self.rewrittenText = response
self.isProcessing = false
self.appendDiagnosticLog(
"processRewriteRequest success | writeMode=\(self.isWriteMode) | outputChars=\(response.count) | latency=\(String(format: "%.2fs", Date().timeIntervalSince(startTime)))"
)
} catch {
self.conversationHistory.append(Message(role: .assistant, content: "Error: \(error.localizedDescription)"))
self.lastErrorMessage = error.localizedDescription
self.isProcessing = false
self.appendDiagnosticLog(
"processRewriteRequest failure | writeMode=\(self.isWriteMode) | error=\(error.localizedDescription)"
)
}
}
@MainActor
func acceptRewrite(_ text: String) async {
guard let summaryActivity = MeetingSummaryActivityCoordinator.shared.beginProcessing() else {
MeetingSummaryActivityCoordinator.presentBusyError()
return
}
defer { MeetingSummaryActivityCoordinator.shared.endProcessing(summaryActivity) }
// The panel may clear its state before this queued action starts.
guard !text.isEmpty else { return }
NSApp.hide(nil)
// Hiding alone races the paste: the focused element can still be our
// panel when the editability check runs. Put focus back on the field
// the rewrite was recorded from, and fall back to a short settle.
var targetPID: pid_t?
if let context = NotchContentState.shared.recordingTargetContext {
let preparation = await TypingService.prepareTargetForDelivery(context)
targetPID = context.pid
self.appendDiagnosticLog("acceptRewrite focus=\(preparation.rawValue) pid=\(context.pid)")
} else {
try? await Task.sleep(nanoseconds: 80_000_000)
}
_ = await self.typingService.typeTextInstantly(text, preferredTargetPID: targetPID)
}
func clearState() {
self.originalText = ""
self.selectedContextText = ""
self.rewrittenText = ""
self.streamingThinkingText = ""
self.conversationHistory = []
self.isWriteMode = false
self.thinkingBuffer = []
self.promptAppBundleID = nil
self.lastErrorMessage = nil
self.stopReadingWindow()
}
/// Starts reading the window while it is still in front, so the answer can use
/// what the user is looking at. Replaces the reading of any earlier press.
func startReadingWindow(target: TypingService.RecordingTargetContext) {
self.stopReadingWindow()
guard SettingsStore.shared.editModeReadsScreen else { return }
self.windowCaptureRevision = SettingsStore.shared.editModeScreenContextRevision
self.windowCapture = self.captureWindow(target)
}
func windowContextForRewrite() async -> DictationTypingContext? {
self.cancelOutdatedWindowCapture()
guard let capture = self.windowCapture, let revision = self.windowCaptureRevision else { return nil }
let context = await capture.result(timeout: .seconds(2))
// The switch or target may change while the window reader is pending.
guard !Task.isCancelled, SettingsStore.shared.editModeReadsScreen,
revision == SettingsStore.shared.editModeScreenContextRevision,
self.windowCapture === capture
else { return nil }
return context
}
func cancelOutdatedWindowCapture() {
if !SettingsStore.shared.editModeReadsScreen || self.windowCaptureRevision != SettingsStore.shared.editModeScreenContextRevision {
self.stopReadingWindow()
}
}
func stopReadingWindow() {
self.windowCapture?.cancel()
self.windowCapture = nil
self.windowCaptureRevision = nil
}
func setPromptAppBundleID(_ bundleID: String?) {
let trimmed = bundleID?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
self.promptAppBundleID = (trimmed?.isEmpty == true) ? nil : trimmed
}
// MARK: - LLM Integration
private func callLLM(messages: [Message], isWriteMode: Bool, instruction: String) async throws -> String {
let settings = SettingsStore.shared
let promptMode: SettingsStore.PromptMode = .edit
let appBundleID = self.promptAppBundleID
let selectedProfile = settings.resolvedPromptProfile(for: promptMode, appBundleID: appBundleID)
let selectedPromptName: String = {
if let profile = selectedProfile {
return profile.name.isEmpty ? "Untitled Prompt" : profile.name
}
return "Default Edit"
}()
let promptBody = settings.effectivePromptBody(for: promptMode, appBundleID: appBundleID)
let builtInDefaultPrompt = SettingsStore.defaultSystemPromptText(for: promptMode)
let systemPromptBeforeContext = settings.effectiveSystemPrompt(for: promptMode, appBundleID: appBundleID)
// Use global provider/model when linked, otherwise use Edit Mode's independent settings.
let providerID = settings.effectiveRewriteModeProviderID
guard !providerID.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
throw NSError(
domain: "RewriteMode",
code: -2,
userInfo: [NSLocalizedDescriptionKey: "No verified AI provider selected"]
)
}
let usesPrivateAIProvider = self.isPrivateAIProviderID(providerID)
guard usesPrivateAIProvider || self.isProviderVerified(providerID, settings: settings) else {
throw NSError(
domain: "RewriteMode",
code: -3,
userInfo: [NSLocalizedDescriptionKey: "Selected AI provider is not verified"]
)
}
var systemPrompt = systemPromptBeforeContext
let contextText = self.selectedContextText.trimmingCharacters(in: .whitespacesAndNewlines)
var contextBlock = ""
contextBlock = SettingsStore.runtimeContextBlock(
context: self.selectedContextText,
template: SettingsStore.contextTemplateText()
)
if !contextBlock.isEmpty {
systemPrompt = "\(systemPrompt)\n\n\(contextBlock)"
DebugLogger.shared.debug("Injected selected-text context into \(promptMode.rawValue) prompt", source: "RewriteModeService")
}
if self.shouldTracePromptProcessing {
let messageDump = messages.map {
let role = ($0.role == .user) ? "user" : "assistant"
return "[\(role)]\n\($0.content)"
}.joined(separator: "\n\n")
self.logPromptTrace("Mode", value: isWriteMode ? "Edit (write)" : "Edit (rewrite)")
self.logPromptTrace("Selected prompt profile", value: selectedPromptName)
self.logPromptTrace("Prompt body (custom/default body)", value: promptBody)
self.logPromptTrace("Built-in default system prompt (baseline)", value: builtInDefaultPrompt)
self.logPromptTrace("System prompt before context", value: systemPromptBeforeContext)
self.logPromptTrace("Selected context text", value: contextText.isEmpty ? "<empty>" : contextText)
self.logPromptTrace("Context block injected", value: contextBlock.isEmpty ? "<none>" : contextBlock)
self.logPromptTrace("Final system prompt sent to model", value: systemPrompt)
self.logPromptTrace("Conversation input (Q/history)", value: messageDump.isEmpty ? "<empty>" : messageDump)
}
let model = settings.effectiveRewriteModeSelectedModel
guard !model.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
throw NSError(
domain: "RewriteMode",
code: -4,
userInfo: [NSLocalizedDescriptionKey: "No AI model selected"]
)
}
var runtimeModel = model
var localModelPath = PrivateAIIntegrationService.configuredLocalModelPath
if usesPrivateAIProvider {
let route = EditModeRoute.current(providerID: providerID)
guard case let .local(editModel) = route,
let editModelPath = PrivateAIIntegrationService.localModelPath(for: editModel)
else {
throw NSError(
domain: "RewriteMode",
code: -5,
userInfo: [NSLocalizedDescriptionKey: route.failureMessage ?? EditModeRoute.modelMissing.failureMessage ?? ""]
)
}
runtimeModel = editModel.id
localModelPath = editModelPath
}
self.appendDiagnosticLog(
"LLM config | writeMode=\(isWriteMode) | linkedToGlobal=\(settings.rewriteModeLinkedToGlobal) | " +
"provider=\(providerID) | model=\(model) | profile=\(selectedPromptName) | " +
"contextChars=\(contextText.count) | contextInjected=\(!contextBlock.isEmpty) | appBundle=\(appBundleID ?? "none")"
)
let apiKey = settings.getAPIKey(for: providerID) ?? ""
let baseURL: String
if let provider = settings.savedProviders.first(where: { $0.id == providerID }) {
baseURL = provider.baseURL
} else if ModelRepository.shared.isBuiltIn(providerID) {
baseURL = ModelRepository.shared.defaultBaseURL(for: providerID)
} else {
baseURL = ""
}
if usesPrivateAIProvider || PrivateAIIntegrationService.shouldHandleDictation(model: model) {
// A follow-up applies to the last result, not to the original selection.
let textToEdit = self.rewrittenText.isEmpty ? self.selectedContextText : self.rewrittenText
let window = await self.windowContextForRewrite()
// Counts only: what was read is never logged.
DebugLogger.shared.info(
"Edit Mode read the window | lines=\(window?.windowLines?.count ?? 0) | hasSelection=\(!textToEdit.isEmpty)",
source: "RewriteModeService"
)
let response = try await PrivateAIIntegrationService.shared.rewrite(
instruction,
systemPrompt: systemPrompt,
runtime: PrivateAIIntegrationService.RuntimeConfiguration(
selectedProviderID: providerID,
providerKey: self.providerKey(for: providerID),
baseURL: baseURL,
model: runtimeModel,
apiKey: apiKey,
localModelPath: localModelPath,
usesStablePromptPrefixKVCache: settings.privateAIPrefixKVCacheEnabled,
usesFluid1Boost: settings.privateAIBoostEnabled,
contextTokenLimit: settings.privateAIContextTokenLimit
),
context: PrivateAIIntegrationService.AppContext(
appName: "",
bundleID: appBundleID ?? "",
windowTitle: "",
appVersion: Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String,
selectedText: textToEdit.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ? nil : textToEdit,
windowLines: window?.windowLines,
userDisplayName: NSFullUserName()
)
)
return response.outputText
}
// Build messages array for LLMClient
var apiMessages: [[String: Any]] = [
["role": "system", "content": systemPrompt],
]
for msg in messages {
apiMessages.append(["role": msg.role == .user ? "user" : "assistant", "content": msg.content])
}
// Edit Text mode does not need token-by-token UI updates.
// Keep this non-streaming to reduce CPU/battery churn on smaller devices.
let enableStreaming = false
// Reasoning models (o1, o3, gpt-5) don't support temperature parameter at all
let isReasoningModel = settings.isReasoningModel(model)
let isTemperatureUnsupported = settings.isTemperatureUnsupported(model, baseURL: baseURL)
// Get reasoning config for this model (e.g., reasoning_effort, enable_thinking)
let reasoningConfig = settings.getReasoningConfig(forModel: model, provider: providerID)
var extraParams: [String: Any] = [:]
if let rConfig = reasoningConfig, rConfig.isEnabled {
if rConfig.parameterName == "enable_thinking" {
extraParams = [rConfig.parameterName: rConfig.parameterValue == "true"]
} else {
extraParams = [rConfig.parameterName: rConfig.parameterValue]
}
DebugLogger.shared.debug("Added reasoning param: \(rConfig.parameterName)=\(rConfig.parameterValue)", source: "RewriteModeService")
}
// Build LLMClient configuration
var config = LLMClient.Config(
messages: apiMessages,
model: model,
baseURL: baseURL,
apiKey: apiKey,
streaming: enableStreaming,
tools: [],
temperature: isTemperatureUnsupported ? nil : 0.7,
maxTokens: isReasoningModel ? 32_000 : nil, // Reasoning models like o1 need a large budget for extended thought chains
extraParameters: extraParams
)
// Add real-time streaming callbacks for UI updates
if enableStreaming {
// Thinking tokens callback
config.onThinkingChunk = { [weak self] chunk in
Task { @MainActor in
self?.thinkingBuffer.append(chunk)
self?.streamingThinkingText = self?.thinkingBuffer.joined() ?? ""
}
}
// Content callback
config.onContentChunk = { [weak self] chunk in
Task { @MainActor in
self?.rewrittenText += chunk
}
}
}
DebugLogger.shared.info("Using LLMClient for Edit mode (streaming=\(enableStreaming))", source: "RewriteModeService")
// Clear streaming buffers before starting
if enableStreaming {
self.rewrittenText = ""
self.streamingThinkingText = ""
self.thinkingBuffer = []
}
let response = try await LLMClient.shared.call(config)
// Clear thinking display after response complete
self.streamingThinkingText = ""
self.thinkingBuffer = []
// Log thinking if present (for debugging)
if let thinking = response.thinking {
DebugLogger.shared.debug("LLM thinking tokens extracted (\(thinking.count) chars)", source: "RewriteModeService")
if self.shouldTracePromptProcessing {
self.logPromptTrace("Model thinking", value: thinking)
}
}
DebugLogger.shared.debug("Response complete. Content length: \(response.content.count)", source: "RewriteModeService")
if self.shouldTracePromptProcessing {
self.logPromptTrace("Model answer (A)", value: response.content)
}
// For non-streaming, we return the content directly
// For streaming, rewrittenText is already updated via callback,
// but we return the final content for consistency
return response.content
}
private func logPromptTrace(_ title: String, value: String) {
let line = "[PromptTrace][Edit] \(title):\n\(value)"
if self.forcePromptTraceToConsole {
print(line)
}
self.appendDiagnosticLog(line)
}
private func appendDiagnosticLog(_ message: String) {
guard self.diagnosticsEnabled || self.forcePromptTraceToConsole else { return }
DebugLogger.shared.info(message, source: "RewriteModeService")
}
private func providerKey(for providerID: String) -> String {
let trimmed = providerID.trimmingCharacters(in: .whitespacesAndNewlines)
guard !trimmed.isEmpty else { return "" }
if ModelRepository.shared.isBuiltIn(trimmed) { return trimmed }
if trimmed.hasPrefix("custom:") { return trimmed }
return "custom:\(trimmed)"
}
private func providerBaseURL(for providerID: String, settings: SettingsStore) -> String {
if let saved = settings.savedProviders.first(where: { $0.id == providerID }) {
return saved.baseURL.trimmingCharacters(in: .whitespacesAndNewlines)
}
if ModelRepository.shared.isBuiltIn(providerID) {
return ModelRepository.shared.defaultBaseURL(for: providerID).trimmingCharacters(in: .whitespacesAndNewlines)
}
return ""
}
private func providerFingerprint(baseURL: String, apiKey: String) -> String? {
let trimmedBase = baseURL.trimmingCharacters(in: .whitespacesAndNewlines)
let trimmedKey = apiKey.trimmingCharacters(in: .whitespacesAndNewlines)
guard !trimmedBase.isEmpty else { return nil }
let input = "\(trimmedBase)|\(trimmedKey)"
let digest = SHA256.hash(data: Data(input.utf8))
return digest.map { String(format: "%02x", $0) }.joined()
}
private func isProviderVerified(_ providerID: String, settings: SettingsStore) -> Bool {
guard !self.isPrivateAIProviderID(providerID) else { return false }
let key = self.providerKey(for: providerID)
guard let stored = settings.verifiedProviderFingerprints[key] else { return false }
let baseURL = self.providerBaseURL(for: providerID, settings: settings)
let apiKey = settings.getAPIKey(for: providerID) ?? ""
let current = self.providerFingerprint(baseURL: baseURL, apiKey: apiKey)
return current == stored
}
private func isPrivateAIProviderID(_ providerID: String) -> Bool {
PrivateFeatures.privateAIProvider &&
providerID.trimmingCharacters(in: .whitespacesAndNewlines) == PrivateAIProviderFeature.shared.providerID
}
}