Rocky
606 lines
27 KiB
Swift
606 lines
27 KiB
Swift
// ProviderConfig.swift
|
|
// OSGKeyboard · Shared
|
|
//
|
|
// User's LLM configuration. Persisted in App Group UserDefaults so both
|
|
// the main app and keyboard extension read the same values.
|
|
//
|
|
// `apiKey` is the exception: it lives in the Keychain (see
|
|
// `Keychain.swift`) for at-rest encryption. The first time this struct
|
|
// inits after upgrade, a legacy plaintext value from UserDefaults is
|
|
// migrated to the Keychain and removed from UserDefaults.
|
|
|
|
import Combine
|
|
import Foundation
|
|
|
|
/// UI-owned ObservableObject; construct and mutate it on the main thread.
|
|
/// `@unchecked Sendable` does not make `@Published` thread-safe. Credential
|
|
/// observers write only Keychain, while non-secret configuration uses App Group defaults.
|
|
public final class ProviderConfig: ObservableObject, @unchecked Sendable {
|
|
public static let shared = ProviderConfig()
|
|
|
|
@Published public var providerId: String {
|
|
didSet {
|
|
guard !isApplyingConfiguration, providerId != configuration.providerId else { return }
|
|
configuration.providerId = providerId
|
|
isSyncingProviderAPIKey = true
|
|
apiKey = configuration.apiKey
|
|
isSyncingProviderAPIKey = false
|
|
persistConfiguration()
|
|
}
|
|
}
|
|
@Published public var baseURL: String {
|
|
didSet {
|
|
guard !isApplyingConfiguration, baseURL != configuration.baseURL else { return }
|
|
configuration.baseURL = baseURL
|
|
persistConfiguration()
|
|
}
|
|
}
|
|
/// Its observer updates only the provider-scoped Keychain item; the value
|
|
/// must never enter `configuration` or App Group UserDefaults.
|
|
@Published public var apiKey: String {
|
|
didSet {
|
|
guard oldValue != apiKey, !isSyncingProviderAPIKey else { return }
|
|
do {
|
|
try Keychain.setAPIKey(
|
|
apiKey,
|
|
for: providerId,
|
|
useICloudSync: configuration.settingsICloudSyncEnabled
|
|
)
|
|
} catch {
|
|
isSyncingProviderAPIKey = true
|
|
apiKey = oldValue
|
|
isSyncingProviderAPIKey = false
|
|
OSGLog.config.warning("Keychain write failed: \(error.localizedDescription, privacy: .public)")
|
|
}
|
|
}
|
|
}
|
|
@Published public var model: String {
|
|
didSet {
|
|
guard !isApplyingConfiguration, model != configuration.model else { return }
|
|
configuration.model = model
|
|
persistConfiguration()
|
|
}
|
|
}
|
|
@Published public var asrProviderId: String {
|
|
didSet {
|
|
guard !isApplyingConfiguration, asrProviderId != configuration.asrProviderId else { return }
|
|
configuration.asrProviderId = asrProviderId
|
|
isSyncingASRProviderAPIKey = true
|
|
asrApiKey = configuration.asrApiKey
|
|
isSyncingASRProviderAPIKey = false
|
|
persistConfiguration()
|
|
}
|
|
}
|
|
@Published public var asrBaseURL: String {
|
|
didSet {
|
|
guard !isApplyingConfiguration, asrBaseURL != configuration.asrBaseURL else { return }
|
|
configuration.asrBaseURL = asrBaseURL
|
|
persistConfiguration()
|
|
}
|
|
}
|
|
@Published public var asrApiKey: String {
|
|
didSet {
|
|
guard oldValue != asrApiKey, !isSyncingASRProviderAPIKey else { return }
|
|
do {
|
|
try Keychain.setASRAPIKey(
|
|
asrApiKey,
|
|
for: asrProviderId,
|
|
useICloudSync: configuration.settingsICloudSyncEnabled
|
|
)
|
|
} catch {
|
|
isSyncingASRProviderAPIKey = true
|
|
asrApiKey = oldValue
|
|
isSyncingASRProviderAPIKey = false
|
|
OSGLog.config.warning("ASR Keychain write failed: \(error.localizedDescription, privacy: .public)")
|
|
}
|
|
}
|
|
}
|
|
@Published public var asrModel: String {
|
|
didSet {
|
|
guard !isApplyingConfiguration, asrModel != configuration.asrModel else { return }
|
|
configuration.asrModel = asrModel
|
|
persistConfiguration()
|
|
}
|
|
}
|
|
@Published public var modeId: String {
|
|
didSet {
|
|
guard !isApplyingConfiguration, modeId != configuration.modeId else { return }
|
|
configuration.modeId = modeId
|
|
persistConfiguration()
|
|
}
|
|
}
|
|
@Published public var localeId: String {
|
|
didSet {
|
|
guard !isApplyingConfiguration, localeId != configuration.localeId else { return }
|
|
configuration.localeId = localeId
|
|
persistConfiguration(postConfigChanged: true)
|
|
}
|
|
}
|
|
/// "local" → on-device ASR + user's LLM polish (requires user API key).
|
|
/// "cloud" → user's cloud ASR + user's cloud LLM polish (independent picks).
|
|
@Published public var engineMode: String {
|
|
didSet {
|
|
guard !isApplyingConfiguration, engineMode != configuration.engineMode else { return }
|
|
configuration.engineMode = engineMode
|
|
persistConfiguration(postConfigChanged: true)
|
|
}
|
|
}
|
|
/// Orthogonal to `engineMode`: direct provider credentials or an OSG
|
|
/// scope-limited grant. Local and BYOK behavior remain the default.
|
|
@Published public var credentialSource: CredentialSource {
|
|
didSet {
|
|
guard !isApplyingConfiguration,
|
|
credentialSource != configuration.credentialSource else { return }
|
|
configuration.credentialSource = credentialSource
|
|
persistConfiguration(postConfigChanged: true)
|
|
}
|
|
}
|
|
@Published public var hasCompletedOnboarding: Bool {
|
|
didSet {
|
|
guard !isApplyingConfiguration,
|
|
hasCompletedOnboarding != configuration.hasCompletedOnboarding else { return }
|
|
configuration.hasCompletedOnboarding = hasCompletedOnboarding
|
|
// Mirror to the reboot-durable Keychain marker so a device restart
|
|
// can never resurrect the onboarding flow (or lose a replay reset).
|
|
let newValue = hasCompletedOnboarding
|
|
OSGLog.config.info("[onboarding] didSet → \(newValue, privacy: .public), mirroring to Keychain")
|
|
Keychain.setOnboardingCompleted(hasCompletedOnboarding)
|
|
if hasCompletedOnboarding {
|
|
// Persist page reset immediately, but defer the @Published bump
|
|
// so MainAppRoot's OnboardingView → MainTabView swap is not
|
|
// coalesced with an in-flow page update (can freeze step 6).
|
|
configuration.onboardingPage = 0
|
|
let needsPublishedPageReset = onboardingPage != 0
|
|
persistConfiguration()
|
|
if needsPublishedPageReset {
|
|
Task { @MainActor in
|
|
guard self.hasCompletedOnboarding else { return }
|
|
self.onboardingPage = 0
|
|
}
|
|
}
|
|
return
|
|
}
|
|
persistConfiguration()
|
|
}
|
|
}
|
|
/// Persisted onboarding step so returning from Settings does not reset progress.
|
|
@Published public var onboardingPage: Int {
|
|
didSet {
|
|
guard !isApplyingConfiguration, onboardingPage != configuration.onboardingPage else { return }
|
|
configuration.onboardingPage = onboardingPage
|
|
persistConfiguration()
|
|
}
|
|
}
|
|
/// User confirmed that Cloud polish sends transcripts to their configured third-party API.
|
|
@Published public var hasAcknowledgedCloudSharing: Bool {
|
|
didSet {
|
|
guard !isApplyingConfiguration,
|
|
hasAcknowledgedCloudSharing != configuration.hasAcknowledgedCloudSharing else { return }
|
|
configuration.hasAcknowledgedCloudSharing = hasAcknowledgedCloudSharing
|
|
persistConfiguration()
|
|
}
|
|
}
|
|
/// Host-app UI language. Also mirrored to the App Group for the keyboard extension.
|
|
@Published public var uiLanguage: AppUILanguage {
|
|
didSet {
|
|
guard !isApplyingConfiguration, uiLanguage != configuration.uiLanguage else { return }
|
|
configuration.uiLanguage = uiLanguage
|
|
persistConfiguration()
|
|
}
|
|
}
|
|
/// Whether to translate the transcript into
|
|
/// `translationTargetLocaleId` before insertion. **Derived** —
|
|
/// translation is on iff the user has selected a target locale
|
|
/// (i.e. the persisted id is anything other than
|
|
/// `TranslationLanguageCatalog.offLocaleId`). Default off.
|
|
public var translationEnabled: Bool {
|
|
configuration.translationEnabled
|
|
}
|
|
/// BCP-47-ish target language id (e.g. `en`, `ja`, `ko`) the
|
|
/// translate-and-polish prompt should produce. Default `"off"` —
|
|
/// translation is opt-in. Persisted in the App Group so the keyboard
|
|
/// extension can honour it (and so the chip on the keyboard reflects
|
|
/// the user's choice without a host-app round-trip).
|
|
@Published public var translationTargetLocaleId: String {
|
|
didSet {
|
|
guard !isApplyingConfiguration,
|
|
translationTargetLocaleId != configuration.translationTargetLocaleId else { return }
|
|
configuration.translationTargetLocaleId = translationTargetLocaleId
|
|
persistConfiguration(postConfigChanged: true)
|
|
}
|
|
}
|
|
/// Which hand the user holds the phone with — mirrors to the keyboard
|
|
/// extension so delete / space can swap on the bottom row.
|
|
@Published public var handednessPreference: HandednessPreference {
|
|
didSet {
|
|
guard !isApplyingConfiguration,
|
|
handednessPreference != configuration.handednessPreference else { return }
|
|
configuration.handednessPreference = handednessPreference
|
|
persistConfiguration(postConfigChanged: true)
|
|
}
|
|
}
|
|
|
|
/// Typing-grid haptic strength (off / light / strong). Default is light.
|
|
@Published public var keyboardHapticIntensity: KeyboardHapticIntensity {
|
|
didSet {
|
|
guard !isApplyingConfiguration,
|
|
keyboardHapticIntensity != configuration.keyboardHapticIntensity else { return }
|
|
configuration.keyboardHapticIntensity = keyboardHapticIntensity
|
|
persistConfiguration(postConfigChanged: true)
|
|
}
|
|
}
|
|
|
|
/// Controls whether fun styles use the full safety envelope or the
|
|
/// formatting-only high-strength path.
|
|
@Published public var polishIntensity: PolishIntensity {
|
|
didSet {
|
|
guard !isApplyingConfiguration,
|
|
polishIntensity != configuration.polishIntensity else { return }
|
|
configuration.polishIntensity = polishIntensity
|
|
persistConfiguration(postConfigChanged: true)
|
|
}
|
|
}
|
|
|
|
/// Soft AI-mode answer length preference (short / medium / detailed).
|
|
@Published public var aiResponseLength: AIResponseLength {
|
|
didSet {
|
|
guard !isApplyingConfiguration,
|
|
aiResponseLength != configuration.aiResponseLength else { return }
|
|
configuration.aiResponseLength = aiResponseLength
|
|
persistConfiguration(postConfigChanged: true)
|
|
}
|
|
}
|
|
|
|
/// Whether the pipeline should run translate-and-polish (not just
|
|
/// polish). Both engines honour the selected target locale.
|
|
public var isTranslationEffective: Bool {
|
|
configuration.isTranslationEffective
|
|
}
|
|
|
|
/// Translation picker visibility — available on both engines.
|
|
public var isTranslationRowVisible: Bool { true }
|
|
|
|
/// Enables provider-specific reasoning / thinking controls when the
|
|
/// selected polish LLM supports them.
|
|
@Published public var llmThinkingEnabled: Bool {
|
|
didSet {
|
|
guard !isApplyingConfiguration,
|
|
llmThinkingEnabled != configuration.llmThinkingEnabled else { return }
|
|
configuration.llmThinkingEnabled = llmThinkingEnabled
|
|
persistConfiguration(postConfigChanged: true)
|
|
}
|
|
}
|
|
|
|
/// When enabled, the keyboard records clipboard text into a local history list.
|
|
@Published public var clipboardHistoryEnabled: Bool {
|
|
didSet {
|
|
guard !isApplyingConfiguration,
|
|
clipboardHistoryEnabled != configuration.clipboardHistoryEnabled else { return }
|
|
configuration.clipboardHistoryEnabled = clipboardHistoryEnabled
|
|
persistConfiguration(postConfigChanged: true)
|
|
}
|
|
}
|
|
|
|
/// When enabled (and history is on), show the newest clipboard item as a suggestion strip.
|
|
@Published public var clipboardCandidateBarEnabled: Bool {
|
|
didSet {
|
|
guard !isApplyingConfiguration,
|
|
clipboardCandidateBarEnabled != configuration.clipboardCandidateBarEnabled else { return }
|
|
configuration.clipboardCandidateBarEnabled = clipboardCandidateBarEnabled
|
|
persistConfiguration(postConfigChanged: true)
|
|
}
|
|
}
|
|
|
|
/// When enabled, the host app tries to return to the source app after a cold-start handoff.
|
|
@Published public var flowSkipAppSwitch: Bool {
|
|
didSet {
|
|
guard !isApplyingConfiguration, flowSkipAppSwitch != configuration.flowSkipAppSwitch else { return }
|
|
configuration.flowSkipAppSwitch = flowSkipAppSwitch
|
|
persistConfiguration()
|
|
}
|
|
}
|
|
|
|
/// Retained for storage compatibility; persistent PiP sessions do not expire from inactivity.
|
|
@Published public var flowInactivityDuration: FlowInactivityDuration {
|
|
didSet {
|
|
guard !isApplyingConfiguration,
|
|
flowInactivityDuration != configuration.flowInactivityDuration else { return }
|
|
configuration.flowInactivityDuration = flowInactivityDuration
|
|
persistConfiguration()
|
|
}
|
|
}
|
|
|
|
/// Diagnostic switch: disable to isolate whether the custom language model
|
|
/// is causing local SpeechAnalyzer to return empty results.
|
|
@Published public var localASRCustomLanguageModelEnabled: Bool {
|
|
didSet {
|
|
guard !isApplyingConfiguration,
|
|
localASRCustomLanguageModelEnabled != configuration.localASRCustomLanguageModelEnabled else {
|
|
return
|
|
}
|
|
configuration.localASRCustomLanguageModelEnabled = localASRCustomLanguageModelEnabled
|
|
persistConfiguration()
|
|
}
|
|
}
|
|
|
|
public var isConfigured: Bool {
|
|
if isLocalEngine {
|
|
return isPolishConfigured
|
|
}
|
|
return isASRConfigured && isPolishConfigured
|
|
}
|
|
|
|
public var isPolishConfigured: Bool {
|
|
if credentialSource == .managed { return true }
|
|
guard !apiKey.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
|
|
return false
|
|
}
|
|
return !baseURL.isEmpty && !model.isEmpty
|
|
}
|
|
|
|
public var isASRConfigured: Bool {
|
|
guard !isLocalEngine else { return true }
|
|
if credentialSource == .managed { return true }
|
|
let key = asrApiKey.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
let hasKey: Bool = {
|
|
if asrProviderId == "volcengine" {
|
|
return VolcengineASRFields.parse(apiKey: key).hasUsableCredentials
|
|
}
|
|
return !key.isEmpty
|
|
}()
|
|
return hasKey
|
|
&& (!asrBaseURL.isEmpty || CloudASRModelCatalog.strategy(for: asrProviderId) != .prompt)
|
|
}
|
|
|
|
/// On-device ASR only; no cloud API required.
|
|
public var isLocalEngine: Bool { configuration.isLocalEngine }
|
|
|
|
/// Polish provider used by the local engine (same Settings selection as cloud polish).
|
|
public var localModeProviderId: String {
|
|
providerId
|
|
}
|
|
|
|
private let defaults: UserDefaults
|
|
private var configuration: AppGroupConfiguration
|
|
private var persistedConfigurationSnapshot: AppGroupConfiguration
|
|
/// Suppresses `@Published` observer persistence while a complete snapshot
|
|
/// or preset is applied, preventing reentrant writes of partial state.
|
|
private var isApplyingConfiguration = false
|
|
private var isSyncingProviderAPIKey = false
|
|
private var isSyncingASRProviderAPIKey = false
|
|
|
|
public init(defaults: UserDefaults? = nil) {
|
|
guard let resolvedDefaults = defaults ?? AppGroup.defaultsIfAvailable else {
|
|
preconditionFailure(
|
|
"ProviderConfig requires App Group or injected UserDefaults — " +
|
|
"check AppGroup.isAvailable before constructing."
|
|
)
|
|
}
|
|
self.defaults = resolvedDefaults
|
|
let loadedConfiguration = AppGroupConfiguration.load(fromAvailable: resolvedDefaults)
|
|
self.configuration = loadedConfiguration
|
|
self.persistedConfigurationSnapshot = loadedConfiguration
|
|
|
|
// Fresh app container (reinstall after delete): wipe stale Keychain
|
|
// onboarding so the welcome flow shows again. Reboot races still use
|
|
// Keychain restore when the install identity already exists.
|
|
let isFreshInstall = Keychain.beginInstallIdentityIfNeeded()
|
|
if isFreshInstall {
|
|
configuration.hasCompletedOnboarding = false
|
|
resolvedDefaults.set(false, forKey: AppGroupConfiguration.Keys.hasCompletedOnboarding)
|
|
OSGLog.config.info("[onboarding] init: fresh install → force hasCompletedOnboarding=false")
|
|
} else {
|
|
// Onboarding completion must survive a device reboot. App Group
|
|
// UserDefaults can transiently read empty right after boot, which would
|
|
// falsely re-show onboarding. Trust the durable Keychain marker when the
|
|
// App Group value looks unset, and backfill it once the App Group value
|
|
// is confirmed true (covers users onboarded before this safeguard).
|
|
let appGroupOnboarding = configuration.hasCompletedOnboarding
|
|
let keychainOnboarding = Keychain.hasCompletedOnboarding()
|
|
// Distinguish "key absent" (nil → plist not loaded / data-protection race)
|
|
// from "key present == false" (something actually wrote false).
|
|
let rawKeyPresent = resolvedDefaults.object(
|
|
forKey: AppGroupConfiguration.Keys.hasCompletedOnboarding
|
|
) != nil
|
|
OSGLog.config.info(
|
|
"[onboarding] init: appGroup=\(appGroupOnboarding, privacy: .public) (keyPresent=\(rawKeyPresent, privacy: .public)), keychain=\(keychainOnboarding, privacy: .public)"
|
|
)
|
|
if appGroupOnboarding {
|
|
Keychain.setOnboardingCompleted(true)
|
|
} else if keychainOnboarding {
|
|
configuration.hasCompletedOnboarding = true
|
|
OSGLog.config.info(
|
|
"[onboarding] init: App Group read false but Keychain true → restored to true"
|
|
)
|
|
}
|
|
}
|
|
let finalOnboarding = configuration.hasCompletedOnboarding
|
|
OSGLog.config.info("[onboarding] init: final=\(finalOnboarding, privacy: .public)")
|
|
|
|
isApplyingConfiguration = true
|
|
providerId = configuration.providerId
|
|
baseURL = configuration.baseURL
|
|
apiKey = configuration.apiKey
|
|
model = configuration.model
|
|
asrProviderId = configuration.asrProviderId
|
|
asrBaseURL = configuration.asrBaseURL
|
|
asrModel = configuration.asrModel
|
|
modeId = configuration.modeId
|
|
localeId = configuration.localeId
|
|
engineMode = configuration.engineMode
|
|
credentialSource = configuration.credentialSource
|
|
hasCompletedOnboarding = configuration.hasCompletedOnboarding
|
|
onboardingPage = configuration.onboardingPage
|
|
hasAcknowledgedCloudSharing = configuration.hasAcknowledgedCloudSharing
|
|
uiLanguage = configuration.uiLanguage
|
|
translationTargetLocaleId = configuration.translationTargetLocaleId
|
|
handednessPreference = configuration.handednessPreference
|
|
keyboardHapticIntensity = configuration.keyboardHapticIntensity
|
|
polishIntensity = configuration.polishIntensity
|
|
aiResponseLength = configuration.aiResponseLength
|
|
llmThinkingEnabled = configuration.llmThinkingEnabled
|
|
clipboardHistoryEnabled = configuration.clipboardHistoryEnabled
|
|
clipboardCandidateBarEnabled = configuration.clipboardCandidateBarEnabled
|
|
flowSkipAppSwitch = configuration.flowSkipAppSwitch
|
|
flowInactivityDuration = configuration.flowInactivityDuration
|
|
localASRCustomLanguageModelEnabled = configuration.localASRCustomLanguageModelEnabled
|
|
isSyncingProviderAPIKey = true
|
|
apiKey = configuration.apiKey
|
|
isSyncingProviderAPIKey = false
|
|
isSyncingASRProviderAPIKey = true
|
|
asrApiKey = configuration.asrApiKey
|
|
isSyncingASRProviderAPIKey = false
|
|
isApplyingConfiguration = false
|
|
}
|
|
|
|
public func reset() {
|
|
isApplyingConfiguration = true
|
|
let polishPreset = LLMProvider.provider(id: AppGroupConfiguration.defaultPolishProviderId)
|
|
let asrPreset = LLMProvider.provider(id: AppGroupConfiguration.defaultCloudASRProviderId)
|
|
providerId = polishPreset.id
|
|
baseURL = polishPreset.defaultBaseURL
|
|
apiKey = ""
|
|
model = polishPreset.defaultModel
|
|
asrProviderId = asrPreset.id
|
|
asrBaseURL = asrPreset.defaultBaseURL
|
|
asrModel = CloudASRModelCatalog.defaultModel(for: asrPreset.id)
|
|
asrApiKey = ""
|
|
handednessPreference = .left
|
|
keyboardHapticIntensity = .default
|
|
polishIntensity = .default
|
|
aiResponseLength = .default
|
|
localASRCustomLanguageModelEnabled = true
|
|
llmThinkingEnabled = false
|
|
clipboardHistoryEnabled = false
|
|
clipboardCandidateBarEnabled = false
|
|
hasAcknowledgedCloudSharing = false
|
|
credentialSource = .byok
|
|
configuration.providerId = polishPreset.id
|
|
configuration.baseURL = polishPreset.defaultBaseURL
|
|
configuration.model = polishPreset.defaultModel
|
|
configuration.asrProviderId = asrPreset.id
|
|
configuration.asrBaseURL = asrPreset.defaultBaseURL
|
|
configuration.asrModel = CloudASRModelCatalog.defaultModel(for: asrPreset.id)
|
|
configuration.handednessPreference = .left
|
|
configuration.keyboardHapticIntensity = .default
|
|
configuration.polishIntensity = .default
|
|
configuration.aiResponseLength = .default
|
|
configuration.localASRCustomLanguageModelEnabled = true
|
|
configuration.llmThinkingEnabled = false
|
|
configuration.clipboardHistoryEnabled = false
|
|
configuration.clipboardCandidateBarEnabled = false
|
|
configuration.hasAcknowledgedCloudSharing = false
|
|
configuration.credentialSource = .byok
|
|
isApplyingConfiguration = false
|
|
persistConfiguration()
|
|
}
|
|
|
|
private func persistConfiguration(postConfigChanged: Bool = false) {
|
|
configuration.saveChanges(since: persistedConfigurationSnapshot, to: defaults)
|
|
persistedConfigurationSnapshot = configuration
|
|
if postConfigChanged {
|
|
AppGroupConfigDarwin.postConfigChanged()
|
|
}
|
|
scheduleSettingsCloudPushIfEnabled()
|
|
}
|
|
|
|
/// Re-read App Group defaults after a cloud pull updates the cache.
|
|
public func reloadFromPersistedStorage() {
|
|
let persisted = AppGroupConfiguration.load(fromAvailable: defaults)
|
|
var fresh = persisted
|
|
// Keep the reboot-durable onboarding marker authoritative across cloud
|
|
// pulls, matching the resilience applied at init.
|
|
let freshOnboarding = fresh.hasCompletedOnboarding
|
|
let keychainOnboarding = Keychain.hasCompletedOnboarding()
|
|
OSGLog.config.info(
|
|
"[onboarding] reload: appGroup=\(freshOnboarding, privacy: .public), keychain=\(keychainOnboarding, privacy: .public)"
|
|
)
|
|
if freshOnboarding {
|
|
Keychain.setOnboardingCompleted(true)
|
|
} else if keychainOnboarding {
|
|
fresh.hasCompletedOnboarding = true
|
|
OSGLog.config.info("[onboarding] reload: App Group read false but Keychain true → restored to true")
|
|
}
|
|
isApplyingConfiguration = true
|
|
configuration = fresh
|
|
persistedConfigurationSnapshot = persisted
|
|
providerId = fresh.providerId
|
|
baseURL = fresh.baseURL
|
|
model = fresh.model
|
|
asrProviderId = fresh.asrProviderId
|
|
asrBaseURL = fresh.asrBaseURL
|
|
asrModel = fresh.asrModel
|
|
modeId = fresh.modeId
|
|
localeId = fresh.localeId
|
|
engineMode = fresh.engineMode
|
|
credentialSource = fresh.credentialSource
|
|
hasCompletedOnboarding = fresh.hasCompletedOnboarding
|
|
onboardingPage = fresh.onboardingPage
|
|
hasAcknowledgedCloudSharing = fresh.hasAcknowledgedCloudSharing
|
|
uiLanguage = fresh.uiLanguage
|
|
translationTargetLocaleId = fresh.translationTargetLocaleId
|
|
handednessPreference = fresh.handednessPreference
|
|
keyboardHapticIntensity = fresh.keyboardHapticIntensity
|
|
polishIntensity = fresh.polishIntensity
|
|
aiResponseLength = fresh.aiResponseLength
|
|
llmThinkingEnabled = fresh.llmThinkingEnabled
|
|
clipboardHistoryEnabled = fresh.clipboardHistoryEnabled
|
|
clipboardCandidateBarEnabled = fresh.clipboardCandidateBarEnabled
|
|
flowSkipAppSwitch = fresh.flowSkipAppSwitch
|
|
flowInactivityDuration = fresh.flowInactivityDuration
|
|
localASRCustomLanguageModelEnabled = fresh.localASRCustomLanguageModelEnabled
|
|
isSyncingProviderAPIKey = true
|
|
apiKey = fresh.apiKey
|
|
isSyncingProviderAPIKey = false
|
|
isSyncingASRProviderAPIKey = true
|
|
asrApiKey = fresh.asrApiKey
|
|
isSyncingASRProviderAPIKey = false
|
|
isApplyingConfiguration = false
|
|
}
|
|
|
|
private func scheduleSettingsCloudPushIfEnabled() {
|
|
guard configuration.settingsICloudSyncEnabled else { return }
|
|
Task { @MainActor in
|
|
try? await SettingsCloudSync.shared.pushLocalIfEnabled()
|
|
}
|
|
}
|
|
|
|
public func apply(preset: LLMProvider) {
|
|
isApplyingConfiguration = true
|
|
providerId = preset.id
|
|
if !preset.defaultBaseURL.isEmpty {
|
|
baseURL = preset.defaultBaseURL
|
|
}
|
|
if !preset.defaultModel.isEmpty {
|
|
model = preset.defaultModel
|
|
}
|
|
configuration.providerId = providerId
|
|
configuration.baseURL = baseURL
|
|
configuration.model = model
|
|
isSyncingProviderAPIKey = true
|
|
apiKey = configuration.apiKey
|
|
isSyncingProviderAPIKey = false
|
|
isApplyingConfiguration = false
|
|
persistConfiguration()
|
|
}
|
|
|
|
public func applyAsr(preset: LLMProvider) {
|
|
isApplyingConfiguration = true
|
|
engineMode = "cloud"
|
|
asrProviderId = preset.id
|
|
if !preset.defaultBaseURL.isEmpty {
|
|
asrBaseURL = preset.defaultBaseURL
|
|
}
|
|
asrModel = CloudASRModelCatalog.defaultModel(for: preset.id)
|
|
configuration.asrProviderId = asrProviderId
|
|
configuration.asrBaseURL = asrBaseURL
|
|
configuration.asrModel = asrModel
|
|
configuration.engineMode = engineMode
|
|
isSyncingASRProviderAPIKey = true
|
|
asrApiKey = configuration.asrApiKey
|
|
isSyncingASRProviderAPIKey = false
|
|
isApplyingConfiguration = false
|
|
persistConfiguration(postConfigChanged: true)
|
|
}
|
|
}
|