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

15.4 KB
Raw Blame
import Foundation

struct DictationProviderRoute: Equatable {
    let providerID: String
    let providerKey: String
    let baseURL: String
    let model: String
    let apiKey: String

    var usesPrivateAI: Bool {
        self.providerID == PrivateAIProviderFeature.shared.providerID ||
            self.providerKey == PrivateAIProviderFeature.shared.providerID ||
            self.providerKey == "custom:\(PrivateAIProviderFeature.shared.providerID)"
    }

    static func resolve(
        settings: SettingsStore,
        dictationSlot: SettingsStore.DictationShortcutSlot? = nil,
        appBundleID: String? = nil
    ) -> Self {
        guard let dictationSlot else {
            return self.build(settings: settings, selectedProviderID: settings.selectedProviderID, configuredModel: nil)
        }
        let selection = settings.resolvedDictationPromptSelection(for: dictationSlot, appBundleID: appBundleID)
        switch self.modelChoice(settings: settings, selection: selection, appBundleID: appBundleID) {
        case .none:
            return Self(providerID: "", providerKey: "", baseURL: "", model: "", apiKey: "")
        case .privateAI:
            return self.privateAIRoute(settings: settings)
        case let .provider(providerID, model):
            return self.build(settings: settings, selectedProviderID: providerID, configuredModel: model)
        }
    }

    /// Model routing without credentials or private-model installation checks.
    /// The overlay can snapshot this on main and resolve its display name off main.
    enum ModelChoice: Equatable, Sendable {
        case none
        case privateAI
        case provider(String, String?)
    }

    /// Capture only the intended route here. Installation verification belongs
    /// on the warmup worker, never in the microphone's started callback.
    static func privateAIWarmupVerification(
        settings: SettingsStore,
        slot: SettingsStore.DictationShortcutSlot,
        appBundleID: String?
    ) -> PrivateAIProviderPromptFormat.VerificationInput? {
        let selection = settings.resolvedDictationPromptSelection(for: slot, appBundleID: appBundleID, privateAIAvailable: true)
        switch self.modelChoice(settings: settings, selection: selection, appBundleID: appBundleID) {
        case .none: return nil
        case .privateAI: break
        case let .provider(providerID, _):
            let privateID = PrivateAIProviderFeature.shared.providerID
            guard providerID == privateID || providerID == "custom:\(privateID)" else { return nil }
        }
        return .init(settings: settings)
    }

    static func modelChoice(
        settings: SettingsStore,
        selection: SettingsStore.DictationPromptSelection,
        appBundleID: String?
    ) -> ModelChoice {
        if selection == .off { return .none }
        if selection == .privateAI { return .privateAI }
        let configuration = settings.dictationPromptConfiguration(for: selection)
        let providerID = configuration.providerID.trimmingCharacters(in: .whitespacesAndNewlines)
        let model = configuration.modelName.trimmingCharacters(in: .whitespacesAndNewlines)
        if !providerID.isEmpty, !model.isEmpty { return .provider(providerID, model) }
        let hasAppBinding = settings.appPromptBinding(for: .dictate, appBundleID: appBundleID) != nil
        if selection == .default, !hasAppBinding, self.shouldUseLegacyPrivateAIRoute(
            selectedProviderID: settings.selectedProviderID,
            configuredProviderID: providerID,
            configuredModel: model
        ) {
            return .privateAI
        }
        return .provider(self.externalFallbackProviderID(from: settings.selectedProviderID), nil)
    }

    static func modelID(settings: SettingsStore, providerID: String, configuredModel: String?) -> String {
        if let configuredModel { return configuredModel }
        let selectedModels = settings.selectedModelByProvider
        if let saved = settings.savedProviders.first(where: { $0.id == providerID }) {
            return selectedModels["custom:\(saved.id)"] ?? saved.models.first ?? ""
        }
        if ModelRepository.shared.isBuiltIn(providerID) {
            return selectedModels[providerID] ?? ModelRepository.shared.defaultModels(for: providerID).first ?? ""
        }
        return selectedModels[providerID] ?? ""
    }

    private static func build(settings: SettingsStore, selectedProviderID: String, configuredModel: String?) -> Self {
        let model = self.modelID(settings: settings, providerID: selectedProviderID, configuredModel: configuredModel)
        let providerKeys = settings.providerAPIKeys

        if let saved = settings.savedProviders.first(where: { $0.id == selectedProviderID }) {
            let key = "custom:\(saved.id)"
            return Self(
                providerID: selectedProviderID,
                providerKey: key,
                baseURL: saved.baseURL,
                model: model,
                apiKey: providerKeys[key] ?? providerKeys[selectedProviderID] ?? ""
            )
        }

        if ModelRepository.shared.isBuiltIn(selectedProviderID) {
            return Self(
                providerID: selectedProviderID,
                providerKey: selectedProviderID,
                baseURL: ModelRepository.shared.defaultBaseURL(for: selectedProviderID),
                model: model,
                apiKey: providerKeys[selectedProviderID] ?? ""
            )
        }

        return Self(
            providerID: selectedProviderID,
            providerKey: selectedProviderID,
            baseURL: "",
            model: model,
            apiKey: providerKeys[selectedProviderID] ?? ""
        )
    }

    /// Where `.default` would route for dictation, regardless of what is selected now.
    /// Mirrors the `.default` branch of `resolve` so the picker can drop an option that
    /// would otherwise render as "Default · Unavailable".
    static func resolveDictationDefault(settings: SettingsStore, appBundleID: String? = nil) -> Self {
        let configuration = settings.dictationPromptConfiguration(for: .default)
        let providerID = configuration.providerID.trimmingCharacters(in: .whitespacesAndNewlines)
        let model = configuration.modelName.trimmingCharacters(in: .whitespacesAndNewlines)
        if !providerID.isEmpty, !model.isEmpty {
            return self.build(settings: settings, selectedProviderID: providerID, configuredModel: model)
        }
        let hasAppBinding = settings.appPromptBinding(for: .dictate, appBundleID: appBundleID) != nil
        if !hasAppBinding, self.shouldUseLegacyPrivateAIRoute(
            selectedProviderID: settings.selectedProviderID,
            configuredProviderID: providerID,
            configuredModel: model
        ) {
            return self.privateAIRoute(settings: settings)
        }
        return self.build(
            settings: settings,
            selectedProviderID: self.externalFallbackProviderID(from: settings.selectedProviderID),
            configuredModel: nil
        )
    }

    /// True when picking "Default" would actually reach a configured, verified provider.
    static func isDictationDefaultAvailable(settings: SettingsStore, appBundleID: String? = nil) -> Bool {
        let route = self.resolveDictationDefault(settings: settings, appBundleID: appBundleID)
        guard !route.providerID.isEmpty, !route.model.isEmpty else { return false }
        return DictationAIPostProcessingGate.isProviderConfigured(providerID: route.providerID, model: route.model)
    }

    static func privateAIRoute(settings: SettingsStore) -> Self {
        guard let modelID = PrivateAIProviderPromptFormat.verifiedModelID(settings: settings) else {
            return Self(providerID: "", providerKey: "", baseURL: "", model: "", apiKey: "")
        }
        return Self(
            providerID: PrivateAIProviderFeature.shared.providerID,
            providerKey: PrivateAIProviderFeature.shared.providerID,
            baseURL: ModelRepository.shared.defaultBaseURL(for: PrivateAIProviderFeature.shared.providerID),
            model: modelID,
            apiKey: ""
        )
    }

    static func resolve(settings: SettingsStore, providerID: String, model: String) -> Self {
        let trimmedProviderID = providerID.trimmingCharacters(in: .whitespacesAndNewlines)
        let trimmedModel = model.trimmingCharacters(in: .whitespacesAndNewlines)
        let providerKeys = settings.providerAPIKeys
        if let saved = settings.savedProviders.first(where: { $0.id == trimmedProviderID }) {
            let key = "custom:\(saved.id)"
            return Self(
                providerID: trimmedProviderID,
                providerKey: key,
                baseURL: saved.baseURL,
                model: trimmedModel,
                apiKey: providerKeys[key] ?? providerKeys[trimmedProviderID] ?? ""
            )
        }
        return Self(
            providerID: trimmedProviderID,
            providerKey: trimmedProviderID,
            baseURL: ModelRepository.shared.defaultBaseURL(for: trimmedProviderID),
            model: trimmedModel,
            apiKey: providerKeys[trimmedProviderID] ?? ""
        )
    }

    static func externalFallbackProviderID(from providerID: String) -> String {
        let trimmed = providerID.trimmingCharacters(in: .whitespacesAndNewlines)
        return trimmed == PrivateAIProviderFeature.shared.providerID ? "" : trimmed
    }

    static func shouldUseLegacyPrivateAIRoute(
        selectedProviderID: String,
        configuredProviderID: String,
        configuredModel: String
    ) -> Bool {
        selectedProviderID == PrivateAIProviderFeature.shared.providerID &&
            configuredProviderID.isEmpty && configuredModel.isEmpty
    }

    static func allowsPrivateAIRoute(
        selection: SettingsStore.DictationPromptSelection,
        selectedProviderID: String
    ) -> Bool {
        selection == .privateAI ||
            (selection == .default && selectedProviderID == PrivateAIProviderFeature.shared.providerID)
    }

    static func resolveForPostProcessing(
        settings: SettingsStore,
        dictationSlot: SettingsStore.DictationShortcutSlot
    ) -> Self {
        if settings.dictationPromptSelection(for: dictationSlot) == .privateAI {
            return self.privateAIRoute(settings: settings)
        }
        if settings.promptRoutingScope(for: .dictate) == .selectedAppsOnly {
            return self.resolve(settings: settings)
        }
        return self.resolve(settings: settings, dictationSlot: dictationSlot)
    }
}

@MainActor
final class DictationPostProcessingService {
    static let shared = DictationPostProcessingService()

    private init() {}

    struct Result {
        let text: String
        let providerID: String
        let model: String
    }

    func process(_ inputText: String, dictationSlot: SettingsStore.DictationShortcutSlot = .primary) async throws -> Result {
        guard let summaryActivity = MeetingSummaryActivityCoordinator.shared.beginProcessing() else {
            throw MeetingModelResidencyError.busy
        }
        defer { MeetingSummaryActivityCoordinator.shared.endProcessing(summaryActivity) }

        let trimmed = inputText.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !trimmed.isEmpty else {
            return Result(text: "", providerID: SettingsStore.shared.selectedProviderID, model: "")
        }

        let settings = SettingsStore.shared
        let resolved = DictationProviderRoute.resolveForPostProcessing(
            settings: settings,
            dictationSlot: dictationSlot
        )
        guard !resolved.providerID.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
            throw AIProcessingError.noVerifiedProvider
        }
        DebugLogger.shared.debug(
            "DictationPostProcessingService using provider=\(resolved.providerKey), model=\(resolved.model)",
            source: "DictationPostProcessingService"
        )

        let allowsPrivateAIRoute = DictationProviderRoute.allowsPrivateAIRoute(
            selection: settings.dictationPromptSelection(for: dictationSlot),
            selectedProviderID: settings.selectedProviderID
        )
        guard allowsPrivateAIRoute || !resolved.usesPrivateAI else {
            throw AIProcessingError.noVerifiedProvider
        }

        if allowsPrivateAIRoute,
           resolved.usesPrivateAI || PrivateAIIntegrationService.shouldHandleDictation(model: resolved.model)
        {
            let response = try await PrivateAIIntegrationService.shared.enhanceDictation(
                trimmed,
                runtime: PrivateAIIntegrationService.RuntimeConfiguration(
                    selectedProviderID: resolved.providerID,
                    providerKey: resolved.providerKey,
                    baseURL: resolved.baseURL,
                    model: resolved.model,
                    apiKey: resolved.apiKey,
                    localModelPath: PrivateAIIntegrationService.configuredLocalModelPath,
                    usesStablePromptPrefixKVCache: settings.privateAIPrefixKVCacheEnabled,
                    usesFluid1Boost: settings.privateAIBoostEnabled,
                    contextTokenLimit: settings.privateAIContextTokenLimit
                ),
                context: PrivateAIIntegrationService.AppContext(
                    appName: "",
                    bundleID: "",
                    windowTitle: "",
                    appVersion: Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String
                )
            )
            settings.recordFluidIntelligenceUse(output: response.outputText)
            return Result(
                text: ASRService.applyGAAVFormatting(response.outputText),
                providerID: resolved.providerID,
                model: resolved.model
            )
        }

        let promptText = settings.effectiveDictationSystemPrompt(for: dictationSlot, appBundleID: nil)
        let request = DictationPromptRequest(promptText: promptText, transcript: trimmed)

        guard !resolved.model.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
            throw AIProcessingError.missingModel(provider: resolved.providerKey)
        }

        let isLocal = ModelRepository.shared.isLocalEndpoint(resolved.baseURL)
        if !isLocal, resolved.apiKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
            throw AIProcessingError.missingAPIKey(provider: resolved.providerKey)
        }

        var extraParams: [String: Any] = [:]
        if let config = settings.getReasoningConfig(forModel: resolved.model, provider: resolved.providerKey), config.isEnabled {
            extraParams[config.parameterName] = config.parameterName == "enable_thinking"
                ? (config.parameterValue == "true")
                : config.parameterValue
        }

        var config = LLMClient.Config(
            messages: request.messages,
            model: resolved.model,
            baseURL: resolved.baseURL,
            apiKey: resolved.apiKey,
            streaming: false,
            tools: [],
            temperature: settings.isTemperatureUnsupported(resolved.model, baseURL: resolved.baseURL) ? nil : 0.2,
            extraParameters: extraParams
        )
        config.timeoutSeconds = 120

        let response = try await LLMClient.shared.call(config)
        guard !response.content.isEmpty else {
            throw AIProcessingError.emptyResponse
        }
        return Result(
            text: ASRService.applyGAAVFormatting(response.content),
            providerID: resolved.providerID,
            model: resolved.model
        )
    }
}