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

19.1 KB
Raw Blame
import Foundation

// Compile the production draft/save adapter against isolated settings and Keychain doubles.
final class UserDefaults {
    static let standard = UserDefaults()
    var values: [String: [String]] = [:]
    // Match Foundation UserDefaults, including an absent key.
    // swiftlint:disable:next discouraged_optional_collection
    func stringArray(forKey key: String) -> [String]? { self.values[key] }
    func set(_ value: [String], forKey key: String) { self.values[key] = value }
}

struct PrivateAIProviderFeature {
    static let shared = PrivateAIProviderFeature()
    let providerID = "fluid"
}

struct ModelRepository {
    static let shared = ModelRepository()
    func isBuiltIn(_ id: String) -> Bool { ["openai", "ollama", "fluid"].contains(id) }
    func defaultModels(for id: String) -> [String] { ["default-model"] }
}

final class SettingsStore {
    struct SavedProvider {
        var id = UUID().uuidString
        let name: String
        let baseURL: String
        let models: [String]
    }

    struct Configuration: Equatable {
        var providerID: String
        var modelName = "model"
        var shortcut = "keep-shortcut"
    }

    var selectedProviderID = "fluid"
    var selectedModel: String? = "mini"
    var rewriteModeSelectedProviderID = ""
    var rewriteModeSelectedModel: String?
    var commandModeSelectedProviderID = ""
    var commandModeSelectedModel: String?
    var availableModelsByProvider: [String: [String]] = [:]
    var selectedModelByProvider: [String: String] = [:]
    var dictationPromptConfigurations: [String: Configuration] = [:]
    var verifiedProviderFingerprints: [String: String] = [:]
}

final class AIEnhancementSettingsViewModel {
    struct ProviderItemData {
        let id: String
        let name: String
        let isBuiltIn: Bool
    }

    let settings = SettingsStore()
    var isTestingConnection = false
    var isFetchingModels = false
    var selectedProviderID = "openai"
    var managedOriginalKey: String?
    var fetchedModelsProviders: Set<String> = []
    var providerAPIKeys: [String: String] = [:]
    var savedProviders: [SettingsStore.SavedProvider] = []
    var availableModelsByProvider: [String: [String]] = [:]
    var selectedModelByProvider: [String: String] = ["fluid": "mini"]
    var cachedAddedProviderItems: [ProviderItemData] = []
    var failKeychain = false
    var saves = 0
    var keySaves = 0
    var persistedKeys: [String: String] = [:]
    func providerKey(for id: String) -> String { id }
    func providerAPIKey(for id: String) -> String { self.providerAPIKeys[id] ?? "" }
    func updateProviderAPIKey(_ value: String, for id: String) { self.providerAPIKeys[id] = value }
    func saveProviderAPIKeys(invalidating id: String) -> Bool {
        self.keySaves += 1
        guard !self.failKeychain else { return false }
        self.persistedKeys = self.providerAPIKeys
        return true
    }

    func hasProviderAPIKeyDraft(for id: String) -> Bool { self.providerAPIKeys[id] != nil }
    func refreshProviderItems() {
        let items = [
            ProviderItemData(id: "openai", name: "OpenAI", isBuiltIn: true),
            ProviderItemData(id: "ollama", name: "Ollama", isBuiltIn: true),
            ProviderItemData(id: "fluid", name: "Fluid", isBuiltIn: true),
        ]
            + self.savedProviders.map { ProviderItemData(id: $0.id, name: $0.name, isBuiltIn: false) }
        self.cachedAddedProviderItems = addedProviderItems(from: items)
    }

    func saveSavedProviders() { self.saves += 1; self.refreshProviderItems() }
    func clearEditProviderDraft() {}
    func finishConfiguringProvider() { self.selectedProviderID = self.settings.selectedProviderID }
    func refreshVerifiedProviders() {}
    func selectSoleVerifiedProviderIfNeeded() {}
}

@main enum ProviderSetupBoundaryTests {
    static func main() throws {
        var count = 0
        func check(_ value: Bool, _ message: String) {
            precondition(value, message)
            count += 1
        }
        let vm = AIEnhancementSettingsViewModel()
        vm.refreshProviderItems()
        check(vm.cachedAddedProviderItems.isEmpty, "Fresh catalog stays hidden")
        let connectionEdits: [(inout ProviderSetupDraft) -> Void] = [
            { $0.providerID = "ollama" },
            { $0.baseURL = "http://localhost:4321/v1" },
            { $0.apiKey = "replacement-key" },
        ]
        for edit in connectionEdits {
            var fetched = ProviderSetupDraft(name: "Server", baseURL: "http://localhost:1234/v1")
            let oldIdentity = fetched.connectionIdentity
            check(fetched.applyFetchedModels(["second", "first", "first"], for: oldIdentity), "Current discovery is accepted")
            check(fetched.model == "first", "Discovery selects its first sorted result")
            fetched.selectFetchedModel("second")
            edit(&fetched)
            check(fetched.model.isEmpty && fetched.fetchedModels.isEmpty, "Connection edits clear automatic and picker selections immediately")
            check(fetched.modelsToSave(defaults: []).isEmpty, "Saving a new custom connection cannot retain an old fetched model")
            check(!fetched.applyFetchedModels(["stale"], for: oldIdentity), "Late discovery from the old connection is rejected")
            check(fetched.model.isEmpty && fetched.fetchedModels.isEmpty, "Rejected discovery cannot repopulate the cleared selection")

            var manual = ProviderSetupDraft(name: "Server", baseURL: "http://localhost:1234/v1")
            manual.applyFetchedModels(["first"], for: manual.connectionIdentity)
            // Typing even the same ID explicitly makes it a manual choice.
            manual.model = "first"
            edit(&manual)
            check(manual.model == "first" && manual.fetchedModels.isEmpty, "Connection edits preserve an explicitly entered ID")
            check(manual.modelsToSave(defaults: []) == ["first"], "Manual IDs remain available to save")
            manual.applyFetchedModels([], for: manual.connectionIdentity)
            check(manual.model == "first", "Empty discovery must not erase manual entry")
        }
        var reloaded = ProviderSetupDraft(name: "Server", baseURL: "http://localhost:1234/v1")
        reloaded.applyFetchedModels(["first", "second"], for: reloaded.connectionIdentity)
        reloaded.selectFetchedModel("second")
        reloaded.name = "Renamed server"
        reloaded.baseURL = " http://localhost:1234/v1 "
        check(reloaded.model == "second", "Name and URL whitespace edits preserve a valid fetched choice")
        reloaded.applyFetchedModels(["second", "third"], for: reloaded.connectionIdentity)
        check(reloaded.model == "second", "Reload preserves a selection still returned by the server")
        reloaded.applyFetchedModels(["third"], for: reloaded.connectionIdentity)
        check(reloaded.model == "third", "Reload replaces a fetched selection the server no longer returns")
        reloaded.applyFetchedModels([], for: reloaded.connectionIdentity)
        check(reloaded.model.isEmpty, "Empty discovery clears an old fetched selection")
        reloaded.applyFetchedModels(["old-server-model"], for: reloaded.connectionIdentity)
        reloaded.baseURL = "http://localhost:4321/v1"
        reloaded.apiKey = "new-key"
        let freshVM = AIEnhancementSettingsViewModel()
        check(freshVM.addProvider(reloaded), "A custom provider can be saved after rapid connection edits")
        check(freshVM.savedProviders.first?.models == [], "Persistence receives no model from the previous connection")
        check(freshVM.settings.selectedProviderID == "fluid", "Saving the new connection leaves the current dictation route intact")
        var draft = ProviderSetupDraft(name: "Local", baseURL: "http://localhost:1234/v1", model: "tiny")
        check(draft.isValid && vm.saves == 0, "Editing a valid draft has no persistence effects")
        var discoveryDraft = draft
        discoveryDraft.fetchedModels = ["first", "second"]
        discoveryDraft.model = "second"
        check(discoveryDraft.modelsToSave(defaults: []) == ["second", "first"], "Selected discovered model is saved first without dropping other models")
        discoveryDraft.model = "manual"
        check(discoveryDraft.modelsToSave(defaults: []) == ["manual", "first", "second"], "Manual entry preserves discovered models")
        discoveryDraft.model = ""
        check(discoveryDraft.modelsToSave(defaults: ["default"]) == ["first", "second"], "Discovery replaces fallback defaults")
        discoveryDraft.fetchedModels = []
        check(discoveryDraft.modelsToSave(defaults: ["default"]) == ["default"], "Empty discovery preserves default fallback")
        let originalConnection = discoveryDraft.connectionIdentity
        discoveryDraft.model = "another"
        check(discoveryDraft.connectionIdentity == originalConnection, "Model selection does not invalidate a connection request")
        discoveryDraft.apiKey = "changed"
        check(discoveryDraft.connectionIdentity != originalConnection, "Credential edits invalidate stale discovery")
        check(vm.saves == 0 && vm.providerAPIKeys.isEmpty && vm.savedProviders.isEmpty, "Model discovery drafts do not persist credentials or providers")
        draft.baseURL = "file:///tmp/model"
        check(!draft.isValid && !vm.addProvider(draft), "Reject non-HTTP endpoints without persistence")
        draft.baseURL = "https://user:[email protected]"
        check(!draft.isValid, "Reject credentials embedded in URL")
        draft.baseURL = "http://localhost:1234/v1"
        draft.apiKey = "test-key"
        vm.failKeychain = true
        check(
            !vm.addProvider(draft) && vm.savedProviders.isEmpty && vm.providerAPIKeys.isEmpty && vm.saves == 0,
            "Keychain failure keeps records, keys, and model maps unchanged"
        )
        vm.failKeychain = false
        draft.fetchedModels = ["other", "tiny"]
        check(vm.addProvider(draft) && vm.savedProviders.count == 1, "Explicit Add saves a custom provider")
        check(vm.savedProviders.first?.models == ["tiny", "other"], "Add persists the selected model and complete discovered list")
        check(vm.settings.selectedProviderID == "fluid" && vm.selectedModelByProvider["fluid"] == "mini", "Adding does not change current route/model")
        check(vm.addProvider(draft) && vm.savedProviders.count == 2, "Same display name cannot overwrite another provider")
        check(vm.cachedAddedProviderItems.count == 2, "Saved custom providers appear without verification")
        let builtIn = ProviderSetupDraft(providerID: "ollama", name: "Ollama", baseURL: "http://localhost:11434/v1")
        check(vm.addProvider(builtIn), "Keyless local provider can be added")
        check(!vm.addProvider(builtIn), "Duplicate built-in Add is rejected")
        check(vm.cachedAddedProviderItems.contains { $0.id == "ollama" }, "Keyless provider remains visible via explicit membership")
        vm.providerAPIKeys["openai"] = "expired-key"
        vm.refreshProviderItems()
        check(vm.cachedAddedProviderItems.contains { $0.id == "openai" }, "Unverified legacy credentials remain discoverable")
        vm.providerAPIKeys.removeValue(forKey: "openai")
        vm.settings.dictationPromptConfigurations["legacy"] = .init(providerID: "openai")
        vm.refreshProviderItems()
        check(vm.cachedAddedProviderItems.contains { $0.id == "openai" }, "Referenced provider stays visible after credentials disappear")
        vm.isFetchingModels = true
        check(!vm.addProvider(draft), "In-flight editor request blocks another Add")
        let source = try String(contentsOfFile: "Sources/Fluid/UI/AISettingsView+AIConfiguration.swift", encoding: .utf8)
        let manager = source.components(separatedBy: "private var externalProviderManager: some View")[1]
            .components(separatedBy: "private var legacyAIConfigurationCard")[0]
        check(!manager.contains("Use for shortcut") && !manager.contains("Edit details"), "External manager has no duplicate editor or shortcut assignment action")
        check(source.contains(".onSubmit {") && source.contains("self.viewModel.addNewModel()"), "Manual model input retains Enter-to-add behavior")
        check(source.contains(".accessibilityLabel(\"Add model\")"), "Model add button remains accessible")
        check(source.contains("if isCustom || managementLayout"), "Built-in management exposes removal")
        let makeDefault = source.components(separatedBy: "private func makePrimaryDefaultProvider")[1]
            .components(separatedBy: "private func modelBinding")[0]
        check(
            makeDefault.contains("saveManagedProviderAPIKeyIfNeeded") && !makeDefault.contains("saveProviderAPIKeys"),
            "Making a provider default only persists an active credential edit"
        )
        let removal = AIEnhancementSettingsViewModel()
        removal.providerAPIKeys = ["openai": "remove-key", "other": "keep-key"]
        removal.settings.dictationPromptConfigurations = [
            "affected": .init(providerID: "openai"),
            "unrelated": .init(providerID: "other"),
        ]
        removal.settings.rewriteModeSelectedProviderID = "openai"
        removal.settings.rewriteModeSelectedModel = "old"
        removal.settings.commandModeSelectedProviderID = "other"
        removal.settings.commandModeSelectedModel = "keep-model"
        removal.availableModelsByProvider = ["openai": ["old"], "other": ["keep"]]
        removal.selectedModelByProvider["openai"] = "old"
        UserDefaults.standard.set(["openai", "other"], forKey: AIEnhancementSettingsViewModel.addedProviderIDsKey)
        let before = removal.settings.dictationPromptConfigurations
        removal.failKeychain = true
        check(!removal.deleteCurrentProvider(), "Failed credential removal must fail the operation")
        check(removal.providerAPIKeys["openai"] == "remove-key" && removal.saves == 0, "Failed removal restores keys without saving provider changes")
        check(removal.settings.dictationPromptConfigurations == before, "Failed removal preserves assignments")
        check(UserDefaults.standard.stringArray(forKey: AIEnhancementSettingsViewModel.addedProviderIDsKey) == ["openai", "other"], "Failed removal preserves explicit membership")
        removal.failKeychain = false
        removal.isFetchingModels = true
        check(!removal.deleteCurrentProvider(), "Busy editor cannot remove a provider")
        removal.isFetchingModels = false
        check(removal.deleteCurrentProvider(), "Built-in removal succeeds")
        check(removal.settings.selectedProviderID == "fluid" && removal.settings.selectedModel == "mini", "Removing another provider preserves the default")
        check(removal.settings.dictationPromptConfigurations["affected"]?.providerID == "", "Removed provider cannot remain referenced")
        check(removal.settings.dictationPromptConfigurations["affected"]?.shortcut == "keep-shortcut", "Removal preserves hotkeys")
        check(removal.settings.dictationPromptConfigurations["unrelated"] == before["unrelated"], "Unrelated prompt assignment is unchanged")
        check(removal.settings.rewriteModeSelectedProviderID.isEmpty && removal.settings.rewriteModeSelectedModel == nil, "Affected rewrite route is cleared")
        check(removal.settings.commandModeSelectedProviderID == "other" && removal.settings.commandModeSelectedModel == "keep-model", "Unrelated command route is unchanged")
        check(removal.providerAPIKeys == ["other": "keep-key"] && removal.availableModelsByProvider["other"] == ["keep"], "Unrelated provider credentials and models survive")
        check(!removal.cachedAddedProviderItems.contains { $0.id == "openai" }, "Removed built-in disappears from added providers")
        removal.selectedProviderID = "ollama"
        removal.settings.selectedProviderID = "ollama"
        let keySavesBeforeKeylessRemoval = removal.keySaves
        removal.failKeychain = true
        check(
            removal.deleteCurrentProvider() && removal.settings.selectedProviderID.isEmpty && removal.settings.selectedModel == nil,
            "Removing the default clears its model without selecting another provider"
        )
        check(removal.keySaves == keySavesBeforeKeylessRemoval, "Removing a keyless provider does not require a Keychain write")
        removal.selectedProviderID = "fluid"
        check(!removal.deleteCurrentProvider(), "External provider removal cannot remove private AI")
        let closing = AIEnhancementSettingsViewModel()
        closing.providerAPIKeys["openai"] = "edited-key"
        closing.managedOriginalKey = "edited-key"
        closing.failKeychain = true
        check(closing.saveManagedProviderBeforeClosing("openai") && closing.keySaves == 0, "Unchanged key closes without any Keychain write, even if writes would fail")
        closing.managedOriginalKey = "old-key"
        closing.failKeychain = true
        check(!closing.saveManagedProviderBeforeClosing("openai"), "Keychain failure keeps Manage open")
        check(closing.providerAPIKeys["openai"] == "edited-key" && closing.settings.selectedProviderID == "fluid", "Failed close preserves the draft and default")
        closing.failKeychain = false
        check(
            closing.saveManagedProviderBeforeClosing("openai") && closing.persistedKeys["openai"] == "edited-key",
            "Done persists an edited key without verification or model refresh"
        )
        let savedCount = closing.keySaves
        closing.selectedProviderID = "fluid"
        check(closing.saveManagedProviderBeforeClosing("openai") && closing.keySaves == savedCount, "Removal cleanup must not save a different selected provider")
        closing.selectedProviderID = "ollama"
        check(closing.saveManagedProviderBeforeClosing("ollama") && closing.keySaves == savedCount, "Keyless provider close does not touch Keychain")
        closing.failKeychain = true
        check(closing.saveManagedProviderAPIKeyIfNeeded("ollama") && closing.keySaves == savedCount, "Making a keyless provider default does not require a Keychain write")
        closing.isTestingConnection = true
        check(!closing.saveManagedProviderBeforeClosing("ollama"), "Busy editor cannot dismiss")
        check(manager.contains(".interactiveDismissDisabled()"), "Interactive dismissal cannot bypass failed persistence")
        let historySource = try String(contentsOfFile: "Sources/Fluid/UI/TranscriptionHistoryView.swift", encoding: .utf8)
        // Inspect only the request type and its inputs. Unrelated properties may
        // legitimately sit between these declarations and the filtered list.
        func declaration(_ marker: String) -> String {
            guard let start = historySource.range(of: marker),
                  let end = historySource.range(of: "\n    }", range: start.upperBound..<historySource.endIndex)
            else { preconditionFailure("Missing history declaration: \(marker)") }
            return String(historySource[start.lowerBound..<end.upperBound])
        }
        let audioRequest = declaration("private struct AudioAvailabilityRequest")
            + declaration("private var audioAvailabilityRequest:")
        check(!audioRequest.contains("selectedEntry") && !audioRequest.contains("selectedID"), "Row selection cannot restart audio scans")
        print("Passed \(count) provider setup assertions")
    }
}