From 1dace616d5d1466333ec00ba4a22e3ad7c7126cc Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Wed, 11 Nov 2026 20:22:19 +0700 Subject: [PATCH 1/2] feat(ai-providers): add Meta Model API as an AI provider --- .../Core/AI/AIProviderDraftRules.swift | 28 ++++ .../TablePro/Core/AI/AIProviderFactory.swift | 25 +++- .../InlineSuggestion/AIChatInlineSource.swift | 6 + .../Core/AI/Models/AIModelCatalog.swift | 22 +++ .../Core/AI/Models/AIModelOverlay.swift | 15 +- .../Core/AI/OpenAICompatibleProvider.swift | 20 ++- .../Core/AI/OpenAIResponsesProvider.swift | 67 ++++++++- .../AI/Registry/AIProviderDescriptor.swift | 60 ++++++-- apple/TablePro/Core/Events/AppEvents.swift | 2 + .../TablePro/Models/AI/AIProviderPreset.swift | 95 +++++++++++-- .../AIChatViewModel+Streaming.swift | 6 +- .../TablePro/ViewModels/AIChatViewModel.swift | 132 +++++++++++++++--- .../Views/AIChat/AIChatPanelView.swift | 9 +- .../Settings/AIProviderDetailSheet.swift | 79 +++++++---- .../Views/Settings/AISettingsView.swift | 2 + .../Core/AI/AIModelCatalogTests.swift | 31 ++++ .../Core/AI/AIProviderCapabilitiesTests.swift | 86 ++++++++++++ .../Core/AI/AIProviderDraftRulesTests.swift | 52 +++++++ .../AI/AIProviderFactoryResolveTests.swift | 29 ++++ .../Core/AI/AIProviderModelFetchTests.swift | 108 ++++++++++++++ .../Core/AI/AIProviderPresetTests.swift | 112 +++++++++++++++ ...nAICompatibleProviderConnectionTests.swift | 31 +++- .../OpenAICompatibleProviderParserTests.swift | 49 +++++++ ...AIChatViewModelProviderSettingsTests.swift | 121 ++++++++++++++++ 24 files changed, 1100 insertions(+), 87 deletions(-) create mode 100644 apple/TableProTests/ViewModels/AIChatViewModelProviderSettingsTests.swift diff --git a/apple/TablePro/Core/AI/AIProviderDraftRules.swift b/apple/TablePro/Core/AI/AIProviderDraftRules.swift index 63eed9b41b..f54979369a 100644 --- a/apple/TablePro/Core/AI/AIProviderDraftRules.swift +++ b/apple/TablePro/Core/AI/AIProviderDraftRules.swift @@ -24,6 +24,34 @@ internal enum AIProviderDraftRules { return fetched.count == 1 ? fetched.first?.id : nil } + // Without an effort, a model that always reasons runs the server's default, which can be its costliest. + internal static func effort( + afterPicking current: ReasoningEffort?, + reasoning: AIReasoningSupport, + curated: CuratedModel? + ) -> ReasoningEffort? { + let levels = reasoning.effortLevels + guard !levels.isEmpty else { return nil } + if let current, levels.contains(current) { return current } + guard reasoning.isMandatory else { return curated?.defaultEffort } + return current.flatMap(reasoning.clampedEffort) + ?? curated?.defaultEffort + ?? reasoning.defaultEffort + ?? levels.first + } + + // A typed id is incomplete until the last keystroke; the send path fits the effort to the model anyway. + internal static func effort( + keeping current: ReasoningEffort?, + reasoning: AIReasoningSupport + ) -> ReasoningEffort? { + guard reasoning.isMandatory, !reasoning.effortLevels.isEmpty else { return current } + if let current, reasoning.effortLevels.contains(current) { return current } + return current.flatMap(reasoning.clampedEffort) + ?? reasoning.defaultEffort + ?? reasoning.effortLevels.first + } + /// Save waits for a model only while the provider's own list is there to pick one from. With /// no list, because the fetch is blocked or failed or the provider has not been signed in to /// yet, an empty model is saved as before and can be set later. diff --git a/apple/TablePro/Core/AI/AIProviderFactory.swift b/apple/TablePro/Core/AI/AIProviderFactory.swift index 87ac8543c5..3d01d434e2 100644 --- a/apple/TablePro/Core/AI/AIProviderFactory.swift +++ b/apple/TablePro/Core/AI/AIProviderFactory.swift @@ -69,6 +69,25 @@ enum AIProviderFactory { } } + // `onlyWhereRequired` is for inline suggestions: they send an effort only where a model always reasons. + static func reasoningEffort( + _ requested: ReasoningEffort?, + config: AIProviderConfig, + model: String, + onlyWhereRequired: Bool = false, + catalog: AIModelCatalog = .shared + ) -> ReasoningEffort? { + guard let descriptor = AIProviderRegistry.shared.descriptor(for: config.type.rawValue) else { + return onlyWhereRequired ? nil : requested + } + let fetched = catalog.fetchedInfo(providerID: config.id, modelID: model) + if onlyWhereRequired, + !descriptor.reasoning(forModelID: model, fetched: fetched, preset: config.preset).isMandatory { + return nil + } + return descriptor.effort(requested, forModelID: model, fetched: fetched, preset: config.preset) + } + static func resolve( settings: AISettings, overrideProviderId: UUID? = nil, @@ -76,11 +95,14 @@ enum AIProviderFactory { ) -> ResolvedProvider? { guard settings.enabled else { return nil } let config: AIProviderConfig? + // A model picked for a provider that was since removed belongs to that provider, not the active one. + var model = overrideModel if let overrideProviderId, let match = settings.providers.first(where: { $0.id == overrideProviderId }) { config = match } else { config = settings.activeProvider + if overrideProviderId != nil { model = nil } } guard let config else { return nil } let apiKey: String? @@ -91,7 +113,6 @@ enum AIProviderFactory { apiKey = nil } let provider = createProvider(for: config, apiKey: apiKey) - let model = overrideModel ?? config.model - return ResolvedProvider(provider: provider, model: model, config: config) + return ResolvedProvider(provider: provider, model: model ?? config.model, config: config) } } diff --git a/apple/TablePro/Core/AI/InlineSuggestion/AIChatInlineSource.swift b/apple/TablePro/Core/AI/InlineSuggestion/AIChatInlineSource.swift index 266516fc4c..2ddff7a1fd 100644 --- a/apple/TablePro/Core/AI/InlineSuggestion/AIChatInlineSource.swift +++ b/apple/TablePro/Core/AI/InlineSuggestion/AIChatInlineSource.swift @@ -72,6 +72,12 @@ final class AIChatInlineSource: InlineSuggestionSource { options: ChatTransportOptions( model: resolved.model, systemPrompt: systemPrompt, + reasoningEffort: AIProviderFactory.reasoningEffort( + resolved.config.reasoningEffort, + config: resolved.config, + model: resolved.model, + onlyWhereRequired: true + ), sessionId: sessionId ) ) diff --git a/apple/TablePro/Core/AI/Models/AIModelCatalog.swift b/apple/TablePro/Core/AI/Models/AIModelCatalog.swift index 3483f78f50..3a4c8788e5 100644 --- a/apple/TablePro/Core/AI/Models/AIModelCatalog.swift +++ b/apple/TablePro/Core/AI/Models/AIModelCatalog.swift @@ -15,6 +15,7 @@ final class AIModelCatalog: @unchecked Sendable { private let lock = NSLock() private var fetched: [UUID: [String: AIModelInfo]] = [:] private var refreshTokens: [UUID: UUID] = [:] + private var revisions: [UUID: Int] = [:] init() {} @@ -24,6 +25,7 @@ final class AIModelCatalog: @unchecked Sendable { defer { lock.unlock() } refreshTokens.removeValue(forKey: providerID) fetched[providerID] = Self.indexed(models) + revisions[providerID, default: 0] += 1 } func remove(providerID: UUID) { @@ -31,6 +33,24 @@ final class AIModelCatalog: @unchecked Sendable { defer { lock.unlock() } refreshTokens.removeValue(forKey: providerID) fetched.removeValue(forKey: providerID) + revisions[providerID, default: 0] += 1 + } + + func revision(providerID: UUID) -> Int { + lock.lock() + defer { lock.unlock() } + return revisions[providerID, default: 0] + } + + // For a reader such as the chat panel: it never overtakes a refresh a Save started, and its + // answer is dropped once anything newer was written or begun since it read `revision`. + func store(providerID: UUID, models: [AIModelInfo], ifUnchangedSince revision: Int) { + guard !models.isEmpty else { return } + lock.lock() + defer { lock.unlock() } + guard revisions[providerID, default: 0] == revision else { return } + fetched[providerID] = Self.indexed(models) + revisions[providerID, default: 0] += 1 } /// Loads a provider's list again after Save dropped the one on record. Open chat windows read @@ -49,6 +69,7 @@ final class AIModelCatalog: @unchecked Sendable { lock.lock() defer { lock.unlock() } refreshTokens[providerID] = token + revisions[providerID, default: 0] += 1 return token } @@ -59,6 +80,7 @@ final class AIModelCatalog: @unchecked Sendable { refreshTokens.removeValue(forKey: providerID) guard !models.isEmpty else { return } fetched[providerID] = Self.indexed(models) + revisions[providerID, default: 0] += 1 } private static func indexed(_ models: [AIModelInfo]) -> [String: AIModelInfo] { diff --git a/apple/TablePro/Core/AI/Models/AIModelOverlay.swift b/apple/TablePro/Core/AI/Models/AIModelOverlay.swift index 45993de477..8770d970c2 100644 --- a/apple/TablePro/Core/AI/Models/AIModelOverlay.swift +++ b/apple/TablePro/Core/AI/Models/AIModelOverlay.swift @@ -47,11 +47,9 @@ enum AIModelOverlay { id: modelID, maxOutputTokens: entry.maxOutputTokens, modalities: [.text, .image], - reasoning: AIReasoningSupport( - mode: .effortOnly, - effortLevels: entry.effortLevels, - defaultEffort: .medium - ) + reasoning: entry.effortLevels.isEmpty + ? .unsupported + : AIReasoningSupport(mode: .effortOnly, effortLevels: entry.effortLevels, defaultEffort: .medium) ) } @@ -78,7 +76,14 @@ enum AIModelOverlay { let maxOutputTokens: Int? } + // First match wins. The models without reasoning come first: OpenAI rejects a reasoning + // effort for them, and `gpt-5-chat-latest` would otherwise match `gpt-5`. private static let openAITable: [OpenAIEntry] = [ + OpenAIEntry( + patterns: ["chat-latest", "chatgpt-4o", "gpt-4", "gpt-3.5"], + effortLevels: [], + maxOutputTokens: nil + ), OpenAIEntry( patterns: ["gpt-5.6", "gpt-5-6"], effortLevels: ReasoningEffort.allCases, diff --git a/apple/TablePro/Core/AI/OpenAICompatibleProvider.swift b/apple/TablePro/Core/AI/OpenAICompatibleProvider.swift index 87cba934b7..9a57205e05 100644 --- a/apple/TablePro/Core/AI/OpenAICompatibleProvider.swift +++ b/apple/TablePro/Core/AI/OpenAICompatibleProvider.swift @@ -22,6 +22,7 @@ final class OpenAICompatibleProvider: ChatTransport { private let model: String private let maxOutputTokens: Int? private let treatsForbiddenAsAuthFailure: Bool + private let modelIDs: AIModelIDFilter private let providerID: UUID? private let catalog: AIModelCatalog private let session: URLSession @@ -36,6 +37,7 @@ final class OpenAICompatibleProvider: ChatTransport { model: String = "", maxOutputTokens: Int? = nil, treatsForbiddenAsAuthFailure: Bool = false, + modelIDs: AIModelIDFilter = .all, providerID: UUID? = nil, catalog: AIModelCatalog = .shared, session: URLSession = URLSession(configuration: .ephemeral) @@ -49,6 +51,7 @@ final class OpenAICompatibleProvider: ChatTransport { self.model = model.trimmingCharacters(in: .whitespacesAndNewlines) self.maxOutputTokens = maxOutputTokens self.treatsForbiddenAsAuthFailure = treatsForbiddenAsAuthFailure + self.modelIDs = modelIDs self.providerID = providerID self.catalog = catalog self.session = session @@ -66,6 +69,7 @@ final class OpenAICompatibleProvider: ChatTransport { model: config.model, maxOutputTokens: config.maxOutputTokens, treatsForbiddenAsAuthFailure: config.preset?.rejectsBadKeyWithForbidden ?? false, + modelIDs: config.preset?.modelIDFilter(forEndpoint: config.endpoint) ?? .all, providerID: config.id, session: session ) @@ -319,6 +323,11 @@ final class OpenAICompatibleProvider: ChatTransport { return Self.looksLikeAnAPIResponse(data: data, response: httpResponse) } + // The placeholder model is unknown by design; that answer proves the route and the key. + if model.isEmpty, statusCode == 404, Self.isUnknownModelError(data) { + return true + } + let errorBody = String(data: data, encoding: .utf8) ?? "" throw AIProviderError.mapHTTPError( statusCode: statusCode, @@ -329,6 +338,13 @@ final class OpenAICompatibleProvider: ChatTransport { } } + private static func isUnknownModelError(_ data: Data) -> Bool { + guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any], + let error = json["error"] as? [String: Any] + else { return false } + return error["code"] as? String == "model_not_found" + } + /// A wrong Base URL often lands on a reverse proxy's login page or a single-page app's /// fallback route, both of which answer 200 with HTML that the chat stream cannot read. private static func looksLikeAnAPIResponse(data: Data, response: HTTPURLResponse) -> Bool { @@ -600,7 +616,9 @@ final class OpenAICompatibleProvider: ChatTransport { ) } - return modelsArray.compactMap(Self.decodeModel(_:)).sorted { $0.id < $1.id } + return modelsArray.compactMap(Self.decodeModel(_:)) + .filter { modelIDs.lists($0.id) } + .sorted { $0.id < $1.id } } private func fetchOllamaModels() async throws -> [String] { diff --git a/apple/TablePro/Core/AI/OpenAIResponsesProvider.swift b/apple/TablePro/Core/AI/OpenAIResponsesProvider.swift index e246479c13..43729ee0ef 100644 --- a/apple/TablePro/Core/AI/OpenAIResponsesProvider.swift +++ b/apple/TablePro/Core/AI/OpenAIResponsesProvider.swift @@ -66,11 +66,68 @@ final class OpenAIResponsesProvider: ChatTransport { } func fetchAvailableModels() async throws -> [AIModelInfo] { - try await fetchModelIDs().map { AIModelInfo(id: $0) } + if dialect == .xai, let languageModels = await fetchXAILanguageModels() { + return languageModels + } + let host = resolvedEndpoint?.apiBase.host + return try await fetchModelEntries(resource: AIEndpointStyle.responses.modelsResource, key: "data") + .filter { Self.listsChatModel($0, dialect: dialect, host: host) } + .compactMap { $0["id"] as? String } + .sorted() + .map { AIModelInfo(id: $0) } + } + + // `/v1/models` carries no modality; a gateway in xAI's place may not serve `language-models`. + private func fetchXAILanguageModels() async -> [AIModelInfo]? { + guard let entries = try? await fetchModelEntries(resource: "language-models", key: "models") else { + return nil + } + let models = entries.compactMap(Self.decodeXAILanguageModel(_:)).sorted { $0.id < $1.id } + return models.isEmpty ? nil : models + } + + static func decodeXAILanguageModel(_ json: [String: Any]) -> AIModelInfo? { + guard let id = json["id"] as? String, !id.isEmpty, + let outputs = json["output_modalities"] as? [String], outputs.contains("text") + else { return nil } + let inputs = json["input_modalities"] as? [String] ?? [] + return AIModelInfo(id: id, modalities: inputs.contains("image") ? [.text, .image] : [.text]) + } + + static func listsChatModel(_ json: [String: Any], dialect: ResponsesDialect, host: String?) -> Bool { + guard let id = json["id"] as? String, !id.isEmpty else { return false } + switch dialect { + case .xai: + if json["image_price"] != nil { return false } + return !["imagine", "-image", "voice"].contains(where: { id.contains($0) }) + case .openAI: + guard let host, isOpenAIHost(host) else { return true } + return isOpenAIChatModel(id) + } + } + + // Only OpenAI's own hosts are known to list its non-chat models; a gateway lists what it routes. + private static func isOpenAIHost(_ host: String) -> Bool { + let host = host.lowercased() + return host == "api.openai.com" || host.hasSuffix(".api.openai.com") + } + + // Checked against the Responses column of every live model on platform.openai.com/docs/models. + // A fine-tune is `ft::::`; only its base model says what it is. + static func isOpenAIChatModel(_ id: String) -> Bool { + let base = id.hasPrefix("ft:") ? String(id.dropFirst(3).prefix { $0 != ":" }) : id + let families = ["gpt-", "chatgpt-", "chat-latest", "codex-"] + let isOSeries = base.first == "o" && base.dropFirst().first?.isNumber == true + guard isOSeries || families.contains(where: { base.hasPrefix($0) }) else { return false } + let nonChat = [ + "image", "audio", "realtime", "transcribe", "tts", "whisper", "-live", "search", + "embedding", "moderation", "instruct", "deep-research", "computer-use" + ] + return !nonChat.contains(where: { base.contains($0) }) } - private func fetchModelIDs() async throws -> [String] { - let url = try requestURL(AIEndpointStyle.responses.modelsResource) + private func fetchModelEntries(resource: String, key: String) async throws -> [[String: Any]] { + let url = try requestURL(resource) var request = URLRequest(url: url) request.timeoutInterval = AIProvider.modelListTimeout if let apiKey, !apiKey.isEmpty { @@ -87,11 +144,11 @@ final class OpenAIResponsesProvider: ChatTransport { guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200, let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any], - let modelsArray = json["data"] as? [[String: Any]] + let entries = json[key] as? [[String: Any]] else { throw AIProviderError.networkError("Failed to fetch models") } - return modelsArray.compactMap { $0["id"] as? String }.sorted() + return entries } func testConnection() async throws -> Bool { diff --git a/apple/TablePro/Core/AI/Registry/AIProviderDescriptor.swift b/apple/TablePro/Core/AI/Registry/AIProviderDescriptor.swift index a85ce002bc..1fba48bf3c 100644 --- a/apple/TablePro/Core/AI/Registry/AIProviderDescriptor.swift +++ b/apple/TablePro/Core/AI/Registry/AIProviderDescriptor.swift @@ -53,24 +53,60 @@ struct AIProviderDescriptor: Sendable { var allowsMaxOutputTokens: Bool { capabilities.contains(.maxOutputTokens) } var fetchesModelList: Bool { capabilities.contains(.modelListFetchable) } - func curatedModel(forID id: String) -> CuratedModel? { - curatedModels.first(where: { $0.id == id }) + func curatedModels(for preset: AIProviderPreset?) -> [CuratedModel] { + guard let preset, !preset.curatedModels.isEmpty else { return curatedModels } + return preset.curatedModels } - /// `fetched` is what the provider's own model list said about the model, when it has been - /// loaded. It wins over the offline tables, and its silence leaves the provider's envelope open. - func supportedEffortLevels(forModelID id: String, fetched: AIModelInfo? = nil) -> [ReasoningEffort] { - guard supportsReasoning else { return [] } - if let reasoning = fetched?.reasoning ?? AIModelOverlay.reasoning(providerTypeID: typeID, modelID: id) { - return reasoning.effortLevels + func curatedModel(forID id: String, preset: AIProviderPreset? = nil) -> CuratedModel? { + curatedModels(for: preset).first(where: { $0.id == id }) + } + + // The provider's own list wins over the offline tables; its silence leaves the envelope open. + func reasoning( + forModelID id: String, + fetched: AIModelInfo? = nil, + preset: AIProviderPreset? = nil + ) -> AIReasoningSupport { + guard supportsReasoning else { return .unsupported } + if let known = fetched?.reasoning + ?? preset?.reasoning(forModelID: id) + ?? AIModelOverlay.reasoning(providerTypeID: typeID, modelID: id) { + return known } if let effortLevelResolver { - return effortLevelResolver(id) + return AIReasoningSupport(mode: .effortOnly, effortLevels: effortLevelResolver(id)) } - if let curated = curatedModel(forID: id), !curated.supportedEffortLevels.isEmpty { - return curated.supportedEffortLevels + if let curated = curatedModel(forID: id, preset: preset), !curated.supportedEffortLevels.isEmpty { + return AIReasoningSupport( + mode: .effortOnly, + effortLevels: curated.supportedEffortLevels, + defaultEffort: curated.defaultEffort + ) + } + return AIReasoningSupport(mode: .effortOnly, effortLevels: [.low, .medium, .high]) + } + + func supportedEffortLevels( + forModelID id: String, + fetched: AIModelInfo? = nil, + preset: AIProviderPreset? = nil + ) -> [ReasoningEffort] { + reasoning(forModelID: id, fetched: fetched, preset: preset).effortLevels + } + + // The saved effort belongs to the saved model, and the chat panel can send another one. + func effort( + _ requested: ReasoningEffort?, + forModelID id: String, + fetched: AIModelInfo? = nil, + preset: AIProviderPreset? = nil + ) -> ReasoningEffort? { + let reasoning = reasoning(forModelID: id, fetched: fetched, preset: preset) + guard let requested else { + return reasoning.isMandatory ? reasoning.defaultEffort ?? reasoning.effortLevels.first : nil } - return [.low, .medium, .high] + return reasoning.clampedEffort(requested) } func supportsImages(fetched: AIModelInfo?) -> Bool { diff --git a/apple/TablePro/Core/Events/AppEvents.swift b/apple/TablePro/Core/Events/AppEvents.swift index eb2894539b..ae57663229 100644 --- a/apple/TablePro/Core/Events/AppEvents.swift +++ b/apple/TablePro/Core/Events/AppEvents.swift @@ -44,6 +44,8 @@ final class AppEvents { let currentSchemaChanged = PassthroughSubject() let aiSettingsChanged = PassthroughSubject() + // A new API key lives in the Keychain, so the save that brings it can leave `AISettings` unchanged. + let aiProviderSaved = PassthroughSubject() // MARK: - Connections diff --git a/apple/TablePro/Models/AI/AIProviderPreset.swift b/apple/TablePro/Models/AI/AIProviderPreset.swift index a25b599e33..4de1f96518 100644 --- a/apple/TablePro/Models/AI/AIProviderPreset.swift +++ b/apple/TablePro/Models/AI/AIProviderPreset.swift @@ -5,20 +5,42 @@ import Foundation -/// A named vendor that speaks the OpenAI-compatible wire format. -/// -/// A preset is stored as a `.custom` provider carrying the preset's id, so a build that has never -/// heard of the vendor still decodes it as a working custom provider. A new `AIProviderType` case -/// cannot do that: its raw value fails to decode on every older build that syncs the same settings. +// Stored as `.custom` plus an id: a new `AIProviderType` case fails to decode on older synced builds. struct AIProviderPreset: Identifiable, Equatable, Sendable { let id: String let displayName: String let endpoint: String let symbolName: String let authStyle: AIProviderType.AuthStyle - /// Most servers answer a wrong key with 401. One that answers 403 would otherwise be reported - /// as a server error, which the chat offers to retry. + // A 403 for a wrong key would otherwise read as a server error, which the chat offers to retry. let rejectsBadKeyWithForbidden: Bool + // Ranked: a new provider starts on the first. + let curatedModels: [CuratedModel] + let modelIDs: AIModelIDFilter + // What every chat model here accepts when the server's model list says nothing about reasoning. + let reasoning: AIReasoningSupport? + + init( + id: String, + displayName: String, + endpoint: String, + symbolName: String, + authStyle: AIProviderType.AuthStyle, + rejectsBadKeyWithForbidden: Bool, + curatedModels: [CuratedModel] = [], + modelIDs: AIModelIDFilter = .all, + reasoning: AIReasoningSupport? = nil + ) { + self.id = id + self.displayName = displayName + self.endpoint = endpoint + self.symbolName = symbolName + self.authStyle = authStyle + self.rejectsBadKeyWithForbidden = rejectsBadKeyWithForbidden + self.curatedModels = curatedModels + self.modelIDs = modelIDs + self.reasoning = reasoning + } static let requesty = AIProviderPreset( id: "requesty", @@ -29,10 +51,67 @@ struct AIProviderPreset: Identifiable, Equatable, Sendable { rejectsBadKeyWithForbidden: true ) - static let all: [AIProviderPreset] = [.requesty] + // No Off: without an effort Meta runs its default, max on Muse Wonder and Muse Ember. + private static let museReasoning = AIReasoningSupport( + mode: .effortOnly, + effortLevels: [.minimal, .low, .medium, .high, .xhigh], + defaultEffort: .high, + isMandatory: true + ) + + static let meta = AIProviderPreset( + id: "meta", + displayName: "Meta", + endpoint: "https://api.meta.ai", + symbolName: "infinity.circle", + authStyle: .apiKey, + rejectsBadKeyWithForbidden: false, + curatedModels: [ + CuratedModel(id: "muse-spark-1.3", displayName: "Muse Spark 1.3"), + CuratedModel(id: "muse-wonder-1.0", displayName: "Muse Wonder"), + CuratedModel(id: "muse-ember-1.0", displayName: "Muse Ember") + ], + // Meta may train on what a contributor model is sent, so one is used only when typed under Other…. + modelIDs: AIModelIDFilter( + families: ["muse-spark-", "muse-wonder-", "muse-ember-"], + unlistedParts: ["-contributor"] + ), + reasoning: museReasoning + ) + + static let all: [AIProviderPreset] = [.requesty, .meta] static func preset(withID id: String?) -> AIProviderPreset? { guard let id else { return nil } return all.first { $0.id == id } } + + // A gateway in the vendor's place names its models its own way, so its list is kept whole. + func modelIDFilter(forEndpoint endpoint: String) -> AIModelIDFilter { + guard let host = URL(string: endpoint.trimmingCharacters(in: .whitespacesAndNewlines))?.host?.lowercased(), + host == URL(string: self.endpoint)?.host?.lowercased() + else { return .all } + return modelIDs + } + + func reasoning(forModelID modelID: String) -> AIReasoningSupport? { + guard let reasoning, modelIDs.isChatFamily(modelID) else { return nil } + return reasoning + } +} + +// For a model list with no capability field, where chat models are told apart by their id. +struct AIModelIDFilter: Equatable, Sendable { + let families: [String] + let unlistedParts: [String] + + static let all = AIModelIDFilter(families: [], unlistedParts: []) + + func isChatFamily(_ modelID: String) -> Bool { + families.isEmpty || families.contains { modelID.hasPrefix($0) } + } + + func lists(_ modelID: String) -> Bool { + isChatFamily(modelID) && !unlistedParts.contains { modelID.contains($0) } + } } diff --git a/apple/TablePro/ViewModels/AIChatViewModel+Streaming.swift b/apple/TablePro/ViewModels/AIChatViewModel+Streaming.swift index 9bbc597baa..0e3eca4c1d 100644 --- a/apple/TablePro/ViewModels/AIChatViewModel+Streaming.swift +++ b/apple/TablePro/ViewModels/AIChatViewModel+Streaming.swift @@ -375,7 +375,11 @@ extension AIChatViewModel { model: resolved.model, systemPrompt: systemPrompt, tools: toolSpecs, - reasoningEffort: resolved.config.reasoningEffort, + reasoningEffort: AIProviderFactory.reasoningEffort( + resolved.config.reasoningEffort, + config: resolved.config, + model: resolved.model + ), sessionId: sessionId, connectionId: connection?.id ) diff --git a/apple/TablePro/ViewModels/AIChatViewModel.swift b/apple/TablePro/ViewModels/AIChatViewModel.swift index 21678b4e3f..04b481e4ab 100644 --- a/apple/TablePro/ViewModels/AIChatViewModel.swift +++ b/apple/TablePro/ViewModels/AIChatViewModel.swift @@ -31,6 +31,10 @@ final class AIChatViewModel: ObservableObject { @Published var selectedProviderId: UUID? @Published var selectedModel: String? @Published var availableModels: [UUID: [String]] = [:] + @Published private(set) var providerSettingsRevision = 0 + private var modelListSources: [UUID: AIModelListSource] = [:] + private var staleModelLists: Set = [] + private var modelListGenerations: [UUID: Int] = [:] @Published var attachedContext: [ContextItem] = [] @Published var attachedImages: [ChatImageInput] = [] @Published var savedQueries: [SQLFavorite] = [] @@ -125,6 +129,7 @@ final class AIChatViewModel: ObservableObject { var chatStorage: AIChatStorage { services.aiChatStorage } var cachedSavedQueries: [UUID: SQLFavorite] = [:] private var savedQueryCancellables: Set = [] + private var aiSettingsCancellables: Set = [] static let maxMessageCount = 200 @@ -185,6 +190,7 @@ final class AIChatViewModel: ObservableObject { self.conversationToRestore = conversationId self.queryContextMetadata = services.databaseManager observeSavedQueryUpdates() + observeAISettingsChanges() } deinit { @@ -406,37 +412,92 @@ final class AIChatViewModel: ObservableObject { pendingWalkthroughSource = nil } + private func observeAISettingsChanges() { + services.appEvents.aiSettingsChanged + .receive(on: RunLoop.main) + .sink { [weak self] in self?.dropSelectionOfRemovedProvider() } + .store(in: &aiSettingsCancellables) + services.appEvents.aiProviderSaved + .receive(on: RunLoop.main) + .sink { [weak self] id in self?.providerWasSaved(id) } + .store(in: &aiSettingsCancellables) + } + + private func dropSelectionOfRemovedProvider() { + guard let selectedProviderId, + !services.appSettings.ai.providers.contains(where: { $0.id == selectedProviderId }) + else { return } + self.selectedProviderId = nil + selectedModel = nil + } + + // A save can bring a new key, which nothing in the provider list shows. + private func providerWasSaved(_ id: UUID) { + staleModelLists.insert(id) + modelListGenerations[id, default: 0] += 1 + providerSettingsRevision += 1 + } + + func modelListIsStale(for config: AIProviderConfig) -> Bool { + modelListSources[config.id] != AIModelListSource(config: config) || staleModelLists.contains(config.id) + } + + private enum ModelListOutcome: Sendable { + case listed([String]) + case failed + case notReady + } + + private struct PendingModelList { + let config: AIProviderConfig + let apiKey: String? + let source: AIModelListSource + let generation: Int + let catalogRevision: Int + } + func loadAvailableModels() async { let settings = services.appSettings.ai - let pending = settings.providers.filter { availableModels[$0.id] == nil } + let providerIDs = Set(settings.providers.map(\.id)) + if availableModels.keys.contains(where: { !providerIDs.contains($0) }) { + availableModels = availableModels.filter { providerIDs.contains($0.key) } + } + modelListSources = modelListSources.filter { providerIDs.contains($0.key) } + + let pending = settings.providers.compactMap { config -> PendingModelList? in + guard modelListIsStale(for: config) else { return nil } + return PendingModelList( + config: config, + apiKey: config.authStyle.usesAPIKey ? services.aiKeyStorage.loadAPIKey(for: config.id) : nil, + source: AIModelListSource(config: config), + generation: modelListGenerations[config.id, default: 0], + catalogRevision: AIModelCatalog.shared.revision(providerID: config.id) + ) + } guard !pending.isEmpty else { return } - let results = await withTaskGroup(of: (UUID, [String]?).self) { group in - for config in pending { - let apiKey: String? - switch config.authStyle { - case .apiKey, .optionalApiKey: - apiKey = services.aiKeyStorage.loadAPIKey(for: config.id) - case .oauth, .none: - apiKey = nil - } + let results = await withTaskGroup(of: (UUID, ModelListOutcome).self) { group in + for entry in pending { + let config = entry.config + let apiKey = entry.apiKey + let catalogRevision = entry.catalogRevision group.addTask { let transport = await AIProviderFactory.createProvider(for: config, apiKey: apiKey) do { let models = try await transport.fetchAvailableModels() - AIModelCatalog.shared.store(providerID: config.id, models: models) - return (config.id, models.map(\.id)) + AIModelCatalog.shared.store(providerID: config.id, models: models, ifUnchangedSince: catalogRevision) + return (config.id, .listed(models.map(\.id))) } catch is CancellationError { - return (config.id, nil) + return (config.id, .notReady) } catch CopilotError.serverNotRunning { - return (config.id, nil) + return (config.id, .notReady) } catch { - return (config.id, []) + return (config.id, .failed) } } } - var collected: [(UUID, [String]?)] = [] + var collected: [(UUID, ModelListOutcome)] = [] for await result in group { collected.append(result) } @@ -445,14 +506,26 @@ final class AIChatViewModel: ObservableObject { guard !Task.isCancelled else { return } - for (id, models) in results { - guard let models else { continue } - if models.isEmpty { - let fallback = pending.first(where: { $0.id == id })?.model - availableModels[id] = (fallback?.isEmpty == false) ? [fallback ?? ""] : [] - } else { + for (id, outcome) in results { + // A save while this fetch was out may have brought a new key: its own fetch decides. + guard let entry = pending.first(where: { $0.config.id == id }), + modelListGenerations[id, default: 0] == entry.generation + else { continue } + switch outcome { + case .notReady: + continue + case .listed(let models) where !models.isEmpty: availableModels[id] = models + modelListSources[id] = entry.source + case .failed where modelListSources[id] == entry.source && availableModels[id]?.isEmpty == false: + break + case .listed, .failed: + // Empty, so the menu shows the saved model as it stands; recorded, so a dead server is + // asked again only after a change or a save. + availableModels[id] = [] + modelListSources[id] = entry.source } + staleModelLists.remove(id) } } @@ -497,3 +570,18 @@ final class AIChatViewModel: ObservableObject { } } } + +// A change to any of these means another server, so the list on hand no longer describes it. +struct AIModelListSource: Equatable, Sendable { + let id: UUID + let type: AIProviderType + let presetID: String? + let endpoint: String + + init(config: AIProviderConfig) { + id = config.id + type = config.type + presetID = config.presetID + endpoint = config.endpoint + } +} diff --git a/apple/TablePro/Views/AIChat/AIChatPanelView.swift b/apple/TablePro/Views/AIChat/AIChatPanelView.swift index a79fa47227..4f4a0c1ee9 100644 --- a/apple/TablePro/Views/AIChat/AIChatPanelView.swift +++ b/apple/TablePro/Views/AIChat/AIChatPanelView.swift @@ -73,7 +73,8 @@ struct AIChatPanelView: View { viewModel.connection = connection } .task(id: ModelListTrigger( - providerIDs: settingsManager.ai.providers.map(\.id), + sources: settingsManager.ai.providers.map(AIModelListSource.init(config:)), + savedRevision: viewModel.providerSettingsRevision, isCopilotRunning: copilotService.status == .running )) { await viewModel.loadAvailableModels() @@ -595,9 +596,9 @@ struct AIChatPanelView: View { } } -/// Copilot lists no models until its server runs, and it starts on first use rather than with the -/// panel, so its list is fetched again once it is up. +// Copilot lists no models until its server runs, which starts on first use, not with the panel. private struct ModelListTrigger: Equatable { - let providerIDs: [UUID] + let sources: [AIModelListSource] + let savedRevision: Int let isCopilotRunning: Bool } diff --git a/apple/TablePro/Views/Settings/AIProviderDetailSheet.swift b/apple/TablePro/Views/Settings/AIProviderDetailSheet.swift index dde30a684a..2f02da8516 100644 --- a/apple/TablePro/Views/Settings/AIProviderDetailSheet.swift +++ b/apple/TablePro/Views/Settings/AIProviderDetailSheet.swift @@ -24,6 +24,7 @@ struct AIProviderDetailSheet: View { @State private var isFetchingModels = false @State private var modelFetchError: String? @State private var modelFetchTask: Task? + @State private var choseOtherModel = false @State private var isTesting = false @State private var testResult: TestResult? @@ -94,6 +95,9 @@ struct AIProviderDetailSheet: View { } } .onAppear { + // Before any fetch, so a provider whose list cannot load yet still starts on its curated default. + selectInitialModel() + selectModel(draft.model, picked: false) if draft.type == .copilot { Task { await ensureCopilotRunning() @@ -531,18 +535,27 @@ struct AIProviderDetailSheet: View { } private var curatedModels: [CuratedModel] { - descriptor?.curatedModels ?? [] + descriptor?.curatedModels(for: draft.preset) ?? [] } private var fetchedModels: [String] { fetched.map(\.id) } + private func reasoning(forModelID id: String) -> AIReasoningSupport { + descriptor?.reasoning( + forModelID: id, + fetched: fetched.first(where: { $0.id == id }), + preset: draft.preset + ) ?? .unsupported + } + + private var reasoningForCurrentModel: AIReasoningSupport { + reasoning(forModelID: draft.model) + } + private var effortLevelsForCurrentModel: [ReasoningEffort] { - descriptor?.supportedEffortLevels( - forModelID: draft.model, - fetched: fetched.first(where: { $0.id == draft.model }) - ) ?? [] + reasoningForCurrentModel.effortLevels } private var showsReasoningPicker: Bool { @@ -559,7 +572,7 @@ struct AIProviderDetailSheet: View { Section { modelPicker if isCustomModel { - TextField(String(localized: "Model ID"), text: $draft.model) + TextField(String(localized: "Model ID"), text: typedModelBinding) .textFieldStyle(.roundedBorder) } if showsReasoningPicker { @@ -614,34 +627,48 @@ struct AIProviderDetailSheet: View { }, set: { newValue in switch newValue { - case .curated(let id): - draft.model = id - if let curated = curatedModels.first(where: { $0.id == id }) { - if let defaultEffort = curated.defaultEffort, draft.reasoningEffort == nil { - draft.reasoningEffort = defaultEffort - } - let supported = Set(curated.supportedEffortLevels) - if let currentEffort = draft.reasoningEffort, !supported.contains(currentEffort) { - draft.reasoningEffort = curated.defaultEffort - } - } - case .fetched(let id): - draft.model = id - if let effort = draft.reasoningEffort, !effortLevelsForCurrentModel.contains(effort) { - draft.reasoningEffort = nil - } + case .curated(let id), .fetched(let id): + choseOtherModel = false + selectModel(id, picked: true) case .custom: + choseOtherModel = true if curatedModels.contains(where: { $0.id == draft.model }) || fetchedModels.contains(draft.model) { - draft.model = "" + selectModel("", picked: false) } } } ) } + private var typedModelBinding: Binding { + Binding( + get: { draft.model }, + set: { typed in + choseOtherModel = true + selectModel(typed, picked: false) + } + ) + } + + // The model and the effort it allows change together, in one write. + private func selectModel(_ id: String, picked: Bool) { + var next = draft + next.model = id + next.reasoningEffort = picked + ? AIProviderDraftRules.effort( + afterPicking: draft.reasoningEffort, + reasoning: reasoning(forModelID: id), + curated: curatedModels.first(where: { $0.id == id }) + ) + : AIProviderDraftRules.effort(keeping: draft.reasoningEffort, reasoning: reasoning(forModelID: id)) + draft = next + } + private var reasoningPicker: some View { Picker(String(localized: "Reasoning"), selection: $draft.reasoningEffort) { - Text(String(localized: "Off")).tag(ReasoningEffort?.none) + if !reasoningForCurrentModel.isMandatory { + Text(String(localized: "Off")).tag(ReasoningEffort?.none) + } ForEach(effortLevelsForCurrentModel) { effort in Text(effort.displayName).tag(Optional(effort)) } @@ -852,10 +879,10 @@ struct AIProviderDetailSheet: View { } private func selectInitialModel() { - guard draft.model.isEmpty, + guard draft.model.isEmpty, !choseOtherModel, let initial = AIProviderDraftRules.initialModel(curated: curatedModels, fetched: fetched) else { return } - draft.model = initial + selectModel(initial, picked: false) } func testProvider() { diff --git a/apple/TablePro/Views/Settings/AISettingsView.swift b/apple/TablePro/Views/Settings/AISettingsView.swift index b75d3ea480..0b707876c7 100644 --- a/apple/TablePro/Views/Settings/AISettingsView.swift +++ b/apple/TablePro/Views/Settings/AISettingsView.swift @@ -6,6 +6,7 @@ // context, and privacy. Modeled after Xcode 26 Intelligence settings. // +import Combine import SwiftUI struct AISettingsView: View { @@ -454,6 +455,7 @@ struct AISettingsView: View { if isNew, settings.activeProviderID == nil { settings.activeProviderID = provider.id } + AppEvents.shared.aiProviderSaved.send(provider.id) } private func removeProvider(_ id: UUID) { diff --git a/apple/TableProTests/Core/AI/AIModelCatalogTests.swift b/apple/TableProTests/Core/AI/AIModelCatalogTests.swift index 4efc395aaf..67fcdce1eb 100644 --- a/apple/TableProTests/Core/AI/AIModelCatalogTests.swift +++ b/apple/TableProTests/Core/AI/AIModelCatalogTests.swift @@ -113,6 +113,37 @@ struct AIModelCatalogTests { #expect(catalog.fetchedInfo(providerID: provider, modelID: "m") == nil) } + /// The chat panel reads model lists while a Save in Settings refreshes them. Taking a refresh + /// token there cancelled the Save's refresh, and a failed panel fetch then left no list at all. + @Test("A chat panel answer lands when nothing changed since it started, and never cancels a refresh") + func panelAnswerLandsBesideARefresh() { + let catalog = AIModelCatalog() + let provider = UUID() + let token = catalog.beginRefresh(providerID: provider) + let revision = catalog.revision(providerID: provider) + catalog.store(providerID: provider, models: [AIModelInfo(id: "panel")], ifUnchangedSince: revision) + #expect(catalog.fetchedInfo(providerID: provider, modelID: "panel") != nil) + catalog.finishRefresh(providerID: provider, token: token, models: [AIModelInfo(id: "saved")]) + #expect(catalog.fetchedInfo(providerID: provider, modelID: "saved") != nil) + } + + @Test("A chat panel answer is dropped once a Save stored, removed or began a refresh after it started") + func panelAnswerIsDroppedAfterASave() { + let catalog = AIModelCatalog() + let provider = UUID() + let writes: [(AIModelCatalog) -> Void] = [ + { $0.store(providerID: provider, models: [AIModelInfo(id: "saved")]) }, + { $0.remove(providerID: provider) }, + { _ = $0.beginRefresh(providerID: provider) } + ] + for write in writes { + let revision = catalog.revision(providerID: provider) + write(catalog) + catalog.store(providerID: provider, models: [AIModelInfo(id: "late")], ifUnchangedSince: revision) + #expect(catalog.fetchedInfo(providerID: provider, modelID: "late") == nil) + } + } + @Test("A refresh fetches through the transport it is given") func refreshFetchesThroughTheTransport() async { let catalog = AIModelCatalog() diff --git a/apple/TableProTests/Core/AI/AIProviderCapabilitiesTests.swift b/apple/TableProTests/Core/AI/AIProviderCapabilitiesTests.swift index 9c28638cef..e0e800a123 100644 --- a/apple/TableProTests/Core/AI/AIProviderCapabilitiesTests.swift +++ b/apple/TableProTests/Core/AI/AIProviderCapabilitiesTests.swift @@ -115,4 +115,90 @@ struct AIProviderCapabilitiesTests { #expect(descriptor(type)?.showsTelemetryToggle == false, "\(type.rawValue) must not show telemetry") } } + + /// The effort is saved with the provider's own model, and the chat panel can send another. + /// GPT-5.6 offers Minimal, and picking GPT-5.5 in the panel sent `minimal` to a model that + /// takes low to extra high. + @Test("The effort sent is fitted to the model the chat panel picked") + func effortIsFittedToTheSentModel() { + let chatGPT = AIProviderConfig(type: .chatgptCodex, model: "gpt-5.6-sol", reasoningEffort: .minimal) + let catalog = AIModelCatalog() + #expect(AIProviderFactory.reasoningEffort(.minimal, config: chatGPT, model: "gpt-5.6-sol", catalog: catalog) == .minimal) + #expect(AIProviderFactory.reasoningEffort(.minimal, config: chatGPT, model: "gpt-5.5", catalog: catalog) == .low) + } + + @Test("No effort goes to a model its server lists as not reasoning, or to a provider without reasoning") + func noEffortWhereNoneIsTaken() { + let catalog = AIModelCatalog() + let router = AIProviderConfig(preset: .requesty) + var configured = router + configured.reasoningEffort = .high + catalog.store(providerID: router.id, models: [AIModelInfo(id: "alibaba/qwen-max", reasoning: .unsupported)]) + #expect(AIProviderFactory.reasoningEffort(.high, config: configured, model: "alibaba/qwen-max", catalog: catalog) == nil) + + let copilot = AIProviderConfig(type: .copilot, model: "gpt-5.5", reasoningEffort: .high) + #expect(AIProviderFactory.reasoningEffort(.high, config: copilot, model: "gpt-5.5", catalog: catalog) == nil) + } + + @Test("A Meta provider sends its effort to any Muse chat model the panel picks") + func metaEffortReachesEveryMuseModel() { + var meta = AIProviderConfig(preset: .meta) + meta.model = "muse-spark-1.3" + meta.reasoningEffort = .xhigh + let catalog = AIModelCatalog() + for model in ["muse-spark-1.3", "muse-spark-1.2", "muse-wonder-1.0", "muse-ember-1.0"] { + #expect(AIProviderFactory.reasoningEffort(.xhigh, config: meta, model: model, catalog: catalog) == .xhigh, "\(model)") + } + } + + /// Meta runs its most expensive level when no effort is sent, and inline suggestions and a + /// provider synced from an older build send none. + @Test("A Muse model sent no effort gets its default, and other models stay without one") + func mandatoryReasoningGetsItsDefault() { + let meta = AIProviderConfig(preset: .meta) + let catalog = AIModelCatalog() + #expect(AIProviderFactory.reasoningEffort(nil, config: meta, model: "muse-wonder-1.0", catalog: catalog) == .high) + let openAI = AIProviderConfig(type: .openAI, model: "gpt-5.5") + #expect(AIProviderFactory.reasoningEffort(nil, config: openAI, model: "gpt-5.5", catalog: catalog) == nil) + } + + @Test("Effort levels for every provider without a preset are what they were") + func presetFreeLevelsAreUnchanged() throws { + #expect(try #require(descriptor(.openRouter)).supportedEffortLevels(forModelID: "m") == [.low, .medium, .high]) + #expect(try #require(descriptor(.custom)).supportedEffortLevels(forModelID: "m") == [.low, .medium, .high]) + #expect(try #require(descriptor(.openAI)).supportedEffortLevels(forModelID: "gpt-5.5") == [.low, .medium, .high, .xhigh]) + #expect(try #require(descriptor(.copilot)).supportedEffortLevels(forModelID: "gpt-5.5").isEmpty) + } + + /// Inline suggestions send no effort where a model allows it. A Muse model has no such choice, + /// and sending none there ran Meta's most expensive level on every keystroke pause. + @Test("Inline suggestions send the saved effort only to a model that always reasons") + func inlineEffortOnlyWhereRequired() { + var meta = AIProviderConfig(preset: .meta) + meta.reasoningEffort = .minimal + let openAI = AIProviderConfig(type: .openAI, model: "gpt-5.5", reasoningEffort: .high) + let catalog = AIModelCatalog() + #expect(AIProviderFactory.reasoningEffort( + .minimal, config: meta, model: "muse-spark-1.3", onlyWhereRequired: true, catalog: catalog + ) == .minimal) + #expect(AIProviderFactory.reasoningEffort( + nil, config: meta, model: "muse-ember-1.0", onlyWhereRequired: true, catalog: catalog + ) == .high) + #expect(AIProviderFactory.reasoningEffort( + .high, config: openAI, model: "gpt-5.5", onlyWhereRequired: true, catalog: catalog + ) == nil) + } + + /// OpenAI rejects a reasoning effort for its non-reasoning models, which the chat panel lists + /// beside the reasoning ones. + @Test("No effort goes to an OpenAI model that does not reason") + func noEffortForOpenAINonReasoningModels() throws { + let openAI = AIProviderConfig(type: .openAI, model: "gpt-5.5", reasoningEffort: .high) + let catalog = AIModelCatalog() + for model in ["gpt-4.1", "gpt-4o-mini", "chatgpt-4o-latest", "gpt-5-chat-latest", "gpt-3.5-turbo"] { + #expect(AIProviderFactory.reasoningEffort(.high, config: openAI, model: model, catalog: catalog) == nil, "\(model)") + } + #expect(AIProviderFactory.reasoningEffort(.high, config: openAI, model: "gpt-5.5", catalog: catalog) == .high) + #expect(try #require(descriptor(.openAI)).supportedEffortLevels(forModelID: "gpt-4.1").isEmpty) + } } diff --git a/apple/TableProTests/Core/AI/AIProviderDraftRulesTests.swift b/apple/TableProTests/Core/AI/AIProviderDraftRulesTests.swift index b3845fbfe1..65f13bf00d 100644 --- a/apple/TableProTests/Core/AI/AIProviderDraftRulesTests.swift +++ b/apple/TableProTests/Core/AI/AIProviderDraftRulesTests.swift @@ -136,4 +136,56 @@ struct AIProviderDraftRulesTests { == .keep ) } + + private let optional = AIReasoningSupport(mode: .effortOnly, effortLevels: [.low, .medium, .high]) + private let mandatory = AIReasoningSupport( + mode: .effortOnly, effortLevels: [.minimal, .low, .medium, .high, .xhigh], defaultEffort: .high, isMandatory: true + ) + private let curated = CuratedModel( + id: "gpt-5.5", displayName: "GPT-5.5", supportedEffortLevels: [.low, .medium, .high], defaultEffort: .medium + ) + + @Test("An effort the next model takes is kept") + func effortTheModelTakesIsKept() { + #expect(AIProviderDraftRules.effort(afterPicking: .high, reasoning: optional, curated: nil) == .high) + #expect(AIProviderDraftRules.effort(afterPicking: .low, reasoning: mandatory, curated: nil) == .low) + } + + @Test("A curated model starts on its own default, and replaces an effort it does not take") + func curatedModelStartsOnItsDefault() { + #expect(AIProviderDraftRules.effort(afterPicking: nil, reasoning: optional, curated: curated) == .medium) + #expect(AIProviderDraftRules.effort(afterPicking: .xhigh, reasoning: optional, curated: curated) == .medium) + } + + @Test("A listed or typed model that reasons optionally keeps Off, and drops an effort it does not take") + func optionalReasoningKeepsOff() { + #expect(AIProviderDraftRules.effort(afterPicking: nil, reasoning: optional, curated: nil) == nil) + #expect(AIProviderDraftRules.effort(afterPicking: .xhigh, reasoning: optional, curated: nil) == nil) + } + + /// Meta runs its most expensive level when the effort is left out, so Off there was the + /// costliest choice in the picker. + @Test("A model that always reasons never ends up with no effort") + func mandatoryReasoningAlwaysHasAnEffort() { + #expect(AIProviderDraftRules.effort(afterPicking: nil, reasoning: mandatory, curated: nil) == .high) + let narrow = AIReasoningSupport( + mode: .effortOnly, effortLevels: [.low, .medium], defaultEffort: .low, isMandatory: true + ) + #expect(AIProviderDraftRules.effort(afterPicking: .xhigh, reasoning: narrow, curated: nil) == .medium) + } + + /// Typing a model id under Other… used to keep the effort as it stood. A rule that cleared it + /// on every keystroke turned Extra High into Off before the id was complete. + @Test("Typing, preselecting or reopening keeps the effort, except that a model that always reasons gets one") + func keptEffortChangesOnlyForMandatoryReasoning() { + #expect(AIProviderDraftRules.effort(keeping: .xhigh, reasoning: optional) == .xhigh) + #expect(AIProviderDraftRules.effort(keeping: nil, reasoning: optional) == nil) + #expect(AIProviderDraftRules.effort(keeping: nil, reasoning: mandatory) == .high) + #expect(AIProviderDraftRules.effort(keeping: .minimal, reasoning: mandatory) == .minimal) + } + + @Test("A model that does not reason has no effort") + func noReasoningNoEffort() { + #expect(AIProviderDraftRules.effort(afterPicking: .high, reasoning: .unsupported, curated: curated) == nil) + } } diff --git a/apple/TableProTests/Core/AI/AIProviderFactoryResolveTests.swift b/apple/TableProTests/Core/AI/AIProviderFactoryResolveTests.swift index 38621ed64f..b56163cb23 100644 --- a/apple/TableProTests/Core/AI/AIProviderFactoryResolveTests.swift +++ b/apple/TableProTests/Core/AI/AIProviderFactoryResolveTests.swift @@ -147,4 +147,33 @@ struct AIProviderFactoryResolveTests { let resolved = AIProviderFactory.resolve(settings: settings) #expect(resolved?.model == "") } + + /// The chat panel keeps its pick after the picked provider is removed in Settings, and the + /// next turn went to the active provider under the removed provider's model id. + @Test("A model picked for a removed provider is not sent to the active one") + func removedOverrideProviderDropsItsModel() { + let active = makeProvider(model: "claude-sonnet-5") + let settings = AISettings(enabled: true, providers: [active], activeProviderID: active.id) + let resolved = AIProviderFactory.resolve( + settings: settings, + overrideProviderId: UUID(), + overrideModel: "muse-spark-1.3" + ) + #expect(resolved?.config.id == active.id) + #expect(resolved?.model == "claude-sonnet-5") + } + + @Test("A model picked for a provider that still exists is sent to it") + func overrideModelGoesToItsProvider() { + let active = makeProvider(model: "claude-sonnet-5") + let other = makeProvider(type: .custom, model: "muse-spark-1.3") + let settings = AISettings(enabled: true, providers: [active, other], activeProviderID: active.id) + let resolved = AIProviderFactory.resolve( + settings: settings, + overrideProviderId: other.id, + overrideModel: "muse-wonder-1.0" + ) + #expect(resolved?.config.id == other.id) + #expect(resolved?.model == "muse-wonder-1.0") + } } diff --git a/apple/TableProTests/Core/AI/AIProviderModelFetchTests.swift b/apple/TableProTests/Core/AI/AIProviderModelFetchTests.swift index 97dfb1587c..212c7d235c 100644 --- a/apple/TableProTests/Core/AI/AIProviderModelFetchTests.swift +++ b/apple/TableProTests/Core/AI/AIProviderModelFetchTests.swift @@ -195,4 +195,112 @@ struct AIProviderModelFetchTests { == "https://generativelanguage.googleapis.com/v1beta/models" ) } + + /// OpenAI's list holds embedding, speech, image and realtime models beside the chat ones, and + /// picking one in the chat panel failed the turn. + @Test("OpenAI's own model list keeps only the models Responses can chat with") + func openAIListKeepsChatModels() async throws { + StubModelListProtocol.respond(status: 200, body: #""" + {"object":"list","data":[ + {"id":"gpt-5.5","object":"model"},{"id":"text-embedding-3-small","object":"model"}, + {"id":"whisper-1","object":"model"},{"id":"gpt-image-1","object":"model"}, + {"id":"o3","object":"model"},{"id":"gpt-4o-realtime-preview","object":"model"}, + {"id":"tts-1","object":"model"},{"id":"omni-moderation-latest","object":"model"}, + {"id":"ft:gpt-4.1:acme::abc123","object":"model"} + ]} + """#) + let provider = OpenAIResponsesProvider(endpoint: "https://api.openai.com", apiKey: "key", session: stubSession()) + let models = try await provider.fetchAvailableModels() + #expect(models.map(\.id) == ["ft:gpt-4.1:acme::abc123", "gpt-5.5", "o3"]) + } + + @Test("A gateway in OpenAI's place keeps every model it lists") + func gatewayListIsNotFiltered() async throws { + StubModelListProtocol.respond(status: 200, body: #"{"data":[{"id":"text-embedding-3-small"},{"id":"gpt-5.5"}]}"#) + let provider = OpenAIResponsesProvider(endpoint: "https://gateway.internal/openai", apiKey: "key", session: stubSession()) + let models = try await provider.fetchAvailableModels() + #expect(models.map(\.id) == ["gpt-5.5", "text-embedding-3-small"]) + } + + @Test("xAI lists its chat models from language-models, with the images each one reads") + func xaiListsLanguageModels() async throws { + StubModelListProtocol.respond(status: 200, body: #""" + {"models":[ + {"id":"grok-4.5","input_modalities":["text","image"],"output_modalities":["text"]}, + {"id":"grok-4.20-0309-non-reasoning","input_modalities":["text"],"output_modalities":["text"]}, + {"id":"grok-imagine-image","input_modalities":["text","image"],"output_modalities":["image"]} + ]} + """#) + let provider = OpenAIResponsesProvider( + endpoint: "https://api.x.ai", apiKey: "key", dialect: .xai, session: stubSession() + ) + let models = try await provider.fetchAvailableModels() + #expect(StubModelListProtocol.lastRequestedURL() == "https://api.x.ai/v1/language-models") + #expect(models.map(\.id) == ["grok-4.20-0309-non-reasoning", "grok-4.5"]) + #expect(models.first?.supportsImages == false) + #expect(models.last?.supportsImages == true) + } + + @Test("Without language-models, an xAI list drops image, video and voice models by what it says") + func xaiFallbackDropsNonChatModels() { + let keep: [[String: Any]] = [["id": "grok-4.5"], ["id": "grok-4.3"]] + let drop: [[String: Any]] = [ + ["id": "grok-studio-1", "image_price": 200], + ["id": "grok-imagine-video-1.5"], + ["id": "grok-voice-3.0"] + ] + for entry in keep { + #expect(OpenAIResponsesProvider.listsChatModel(entry, dialect: .xai, host: "api.x.ai")) + } + for entry in drop { + #expect(!OpenAIResponsesProvider.listsChatModel(entry, dialect: .xai, host: "api.x.ai")) + } + } + + @Test("OpenAI's regional hosts are filtered like its main one; a fine-tune is judged by its base model") + func openAIRegionalHostAndFineTunes() { + let whisper: [String: Any] = ["id": "whisper-1"] + #expect(!OpenAIResponsesProvider.listsChatModel(whisper, dialect: .openAI, host: "eu.api.openai.com")) + #expect(OpenAIResponsesProvider.listsChatModel(whisper, dialect: .openAI, host: "gateway.internal")) + #expect(OpenAIResponsesProvider.isOpenAIChatModel("ft:gpt-4o-mini-2024-07-18:watts-energy::AbC123")) + #expect(OpenAIResponsesProvider.isOpenAIChatModel("ft:gpt-4.1:acme:doc-search:x1")) + #expect(!OpenAIResponsesProvider.isOpenAIChatModel("ft:whisper-1:acme::x2")) + } + + @Test("Without a usable language-models answer, xAI's list comes from its model list minus image models") + func xaiFallsBackToTheModelList() async throws { + RoutedModelListProtocol.routes = [ + "/v1/language-models": (200, #"{"models":[{"id":"grok-only-listed-here","input_modalities":["text"]}]}"#), + "/v1/models": (200, #"{"data":[{"id":"grok-4.5"},{"id":"grok-2-image-1212"},{"id":"grok-imagine-image","image_price":200}]}"#) + ] + let config = URLSessionConfiguration.ephemeral + config.protocolClasses = [RoutedModelListProtocol.self] + let provider = OpenAIResponsesProvider( + endpoint: "https://api.x.ai", apiKey: "key", dialect: .xai, session: URLSession(configuration: config) + ) + #expect(try await provider.fetchAvailableModels().map(\.id) == ["grok-4.5"]) + + RoutedModelListProtocol.routes["/v1/language-models"] = (404, "") + #expect(try await provider.fetchAvailableModels().map(\.id) == ["grok-4.5"]) + } +} + +private final class RoutedModelListProtocol: URLProtocol, @unchecked Sendable { + nonisolated(unsafe) static var routes: [String: (status: Int, body: String)] = [:] + + override class func canInit(with request: URLRequest) -> Bool { true } + override class func canonicalRequest(for request: URLRequest) -> URLRequest { request } + override func stopLoading() {} + + override func startLoading() { + guard let url = request.url else { return } + let route = Self.routes[url.path] ?? (404, "") + guard let response = HTTPURLResponse( + url: url, statusCode: route.status, httpVersion: "HTTP/1.1", + headerFields: ["Content-Type": "application/json"] + ) else { return } + client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed) + client?.urlProtocol(self, didLoad: Data(route.body.utf8)) + client?.urlProtocolDidFinishLoading(self) + } } diff --git a/apple/TableProTests/Core/AI/AIProviderPresetTests.swift b/apple/TableProTests/Core/AI/AIProviderPresetTests.swift index a13b06ec59..985de058dc 100644 --- a/apple/TableProTests/Core/AI/AIProviderPresetTests.swift +++ b/apple/TableProTests/Core/AI/AIProviderPresetTests.swift @@ -162,4 +162,116 @@ struct AIProviderPresetTests { ) == nil ) } + + @Test("Meta needs a key, reads a 401 as a bad key, and resolves to its chat completions route") + func metaPreset() { + let preset = AIProviderPreset.meta + #expect(preset.authStyle == .apiKey) + #expect(!preset.rejectsBadKeyWithForbidden) + + let config = AIProviderConfig(preset: preset) + let style = config.type.endpointStyle + #expect(config.kindName == "Meta") + #expect( + AIEndpoint(config.endpoint, style: style)?.chatURL(model: "muse-spark-1.3", style: style)?.absoluteString + == "https://api.meta.ai/v1/chat/completions" + ) + #expect( + AIEndpoint(config.endpoint, style: style)?.url(appending: style.modelsResource)?.absoluteString + == "https://api.meta.ai/v1/models" + ) + } + + @Test("A new Meta provider starts on Muse Spark 1.3 before its model list loads") + func metaStartsOnMuseSpark() throws { + let descriptor = try #require(AIProviderRegistry.shared.descriptor(for: AIProviderType.custom.rawValue)) + let curated = descriptor.curatedModels(for: AIProviderPreset.meta) + #expect(curated.map(\.id) == ["muse-spark-1.3", "muse-wonder-1.0", "muse-ember-1.0"]) + #expect(AIProviderDraftRules.initialModel(curated: curated, fetched: []) == "muse-spark-1.3") + #expect(descriptor.curatedModels(for: AIProviderPreset.requesty).isEmpty) + #expect(descriptor.curatedModels(for: nil).isEmpty) + } + + /// Meta may train on what a contributor model is sent, so a list click never picks one. + @Test("Meta lists only its chat models, without the contributor ones; a preset with no filter lists every model") + func metaListsChatModels() { + let listed = ["muse-image-1.0", "muse-spark-1.3", "muse-spark-1.2-contributor", "muse-voice-transcribe-1.0", + "sam-3.1", "muse-ember-1.0", "muse-wonder-1.0"] + #expect(listed.filter { AIProviderPreset.meta.modelIDs.lists($0) } + == ["muse-spark-1.3", "muse-ember-1.0", "muse-wonder-1.0"]) + #expect(AIProviderPreset.meta.modelIDs.isChatFamily("muse-spark-1.2-contributor")) + #expect(listed.allSatisfy { AIProviderPreset.requesty.modelIDs.lists($0) }) + } + + @Test("A contributor model stays out of Meta's list wherever its id carries the word") + func contributorModelsStayUnlisted() { + for id in ["muse-spark-1.4-contributor-preview", "muse-spark-1.3-contributor"] { + #expect(!AIProviderPreset.meta.modelIDs.lists(id), "\(id)") + } + } + + @Test("Meta's model filter applies on Meta's host only; a gateway keeps its whole list") + func metaFilterFollowsTheHost() { + #expect(AIProviderPreset.meta.modelIDFilter(forEndpoint: "https://api.meta.ai") == AIProviderPreset.meta.modelIDs) + #expect(AIProviderPreset.meta.modelIDFilter(forEndpoint: " https://API.meta.ai/v1 ") == AIProviderPreset.meta.modelIDs) + #expect(AIProviderPreset.meta.modelIDFilter(forEndpoint: "https://gateway.example/meta") == .all) + } + + @Test("Every Meta chat model always reasons, from minimal to extra high, starting at high") + func metaReasoningIsMandatory() throws { + let descriptor = try #require(AIProviderRegistry.shared.descriptor(for: AIProviderType.custom.rawValue)) + for model in ["muse-spark-1.3", "muse-spark-1.1", "muse-wonder-1.0", "muse-ember-1.0"] { + let reasoning = descriptor.reasoning(forModelID: model, fetched: AIModelInfo(id: model), preset: .meta) + #expect(reasoning.isMandatory, "\(model)") + #expect(reasoning.effortLevels == [.minimal, .low, .medium, .high, .xhigh], "\(model)") + #expect(reasoning.defaultEffort == .high, "\(model)") + } + let typed = descriptor.reasoning(forModelID: "llama-4", preset: .meta) + #expect(!typed.isMandatory) + #expect(typed.effortLevels == [.low, .medium, .high]) + #expect(!descriptor.reasoning(forModelID: "muse-spark-1.3").isMandatory) + } + + @Test("A Meta provider asks the server only for chat models") + func metaModelListIsFiltered() async throws { + MetaModelListProtocol.body = #""" + {"object":"list","data":[ + {"id":"muse-image-1.0","object":"model","created":1788000003,"owned_by":"meta"}, + {"id":"muse-spark-1.3","object":"model","created":1788000002,"owned_by":"meta"}, + {"id":"sam-3.1","object":"model","created":1788000001,"owned_by":"meta"}, + {"id":"muse-voice-transcribe-1.0","object":"model","created":1788000000,"owned_by":"meta"}, + {"id":"muse-spark-1.3-contributor","object":"model","created":1787000001,"owned_by":"meta"}, + {"id":"muse-ember-1.0","object":"model","created":1787000000,"owned_by":"meta"} + ]} + """# + let sessionConfig = URLSessionConfiguration.ephemeral + sessionConfig.protocolClasses = [MetaModelListProtocol.self] + let provider = OpenAICompatibleProvider( + config: AIProviderConfig(preset: .meta), + apiKey: "LLM_1_key", + session: URLSession(configuration: sessionConfig) + ) + let models = try await provider.fetchAvailableModels() + #expect(models.map(\.id) == ["muse-ember-1.0", "muse-spark-1.3"]) + } +} + +private final class MetaModelListProtocol: URLProtocol, @unchecked Sendable { + nonisolated(unsafe) static var body = "" + + override class func canInit(with request: URLRequest) -> Bool { true } + override class func canonicalRequest(for request: URLRequest) -> URLRequest { request } + override func stopLoading() {} + + override func startLoading() { + guard let url = request.url, + let response = HTTPURLResponse( + url: url, statusCode: 200, httpVersion: "HTTP/1.1", + headerFields: ["Content-Type": "application/json"] + ) + else { return } + client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed) + client?.urlProtocol(self, didLoad: Data(Self.body.utf8)) + client?.urlProtocolDidFinishLoading(self) + } } diff --git a/apple/TableProTests/Core/AI/OpenAICompatibleProviderConnectionTests.swift b/apple/TableProTests/Core/AI/OpenAICompatibleProviderConnectionTests.swift index f28b644773..014e48578b 100644 --- a/apple/TableProTests/Core/AI/OpenAICompatibleProviderConnectionTests.swift +++ b/apple/TableProTests/Core/AI/OpenAICompatibleProviderConnectionTests.swift @@ -62,6 +62,7 @@ private final class StubConnectionProtocol: URLProtocol, @unchecked Sendable { struct OpenAICompatibleProviderConnectionTests { private func makeProvider( endpoint: String, + model: String = "glm-4.6", treatsForbiddenAsAuthFailure: Bool = false ) -> OpenAICompatibleProvider { let config = URLSessionConfiguration.ephemeral @@ -70,7 +71,7 @@ struct OpenAICompatibleProviderConnectionTests { endpoint: endpoint, apiKey: "key", providerType: .custom, - model: "glm-4.6", + model: model, treatsForbiddenAsAuthFailure: treatsForbiddenAsAuthFailure, session: URLSession(configuration: config) ) @@ -237,4 +238,32 @@ struct OpenAICompatibleProviderConnectionTests { _ = try await makeProvider(endpoint: "https://api.z.ai/api/paas/v4").testConnection() #expect(StubConnectionProtocol.lastRequestedURL() == "https://api.z.ai/api/paas/v4/chat/completions") } + + private static let unknownModelBody = #""" + {"error":{"code":"model_not_found","message":"The model `test` does not exist or is not available","param":"model","type":"invalid_request_error"}} + """# + + /// With no model picked yet the probe names a placeholder, and a server that answers "no such + /// model" read as a wrong Base URL, failing a setup whose route and key were both right. + @Test("With no model picked, a server that says the placeholder model does not exist is reachable") + func unknownPlaceholderModelIsAWorkingConnection() async throws { + StubConnectionProtocol.respond(status: 404, body: Self.unknownModelBody) + #expect(try await makeProvider(endpoint: "https://api.meta.ai", model: "").testConnection()) + } + + @Test("A model the user picked that the server does not know is still a failure") + func unknownChosenModelFails() async { + StubConnectionProtocol.respond(status: 404, body: Self.unknownModelBody) + await #expect(throws: AIProviderError.self) { + _ = try await makeProvider(endpoint: "https://api.meta.ai", model: "muse-spark-9").testConnection() + } + } + + @Test("With no model picked, any other 404 is still a failure") + func otherNotFoundWithoutModelFails() async { + StubConnectionProtocol.respond(status: 404, body: #"{"error":{"code":"not_found","message":"no route"}}"#) + await #expect(throws: AIProviderError.self) { + _ = try await makeProvider(endpoint: "https://host/v1", model: "").testConnection() + } + } } diff --git a/apple/TableProTests/Core/AI/OpenAICompatibleProviderParserTests.swift b/apple/TableProTests/Core/AI/OpenAICompatibleProviderParserTests.swift index da5f8338bb..f036ece50c 100644 --- a/apple/TableProTests/Core/AI/OpenAICompatibleProviderParserTests.swift +++ b/apple/TableProTests/Core/AI/OpenAICompatibleProviderParserTests.swift @@ -313,4 +313,53 @@ struct OpenAICompatibleProviderParserTests { let ollamaEmpty = OpenAICompatibleProvider.decodeStreamLine("", providerType: .ollama) #expect(ollamaEmpty == nil) } + + /// Recorded from Meta's Chat Completions endpoint for `muse-spark-1.3`: text, then a tool call + /// whose id and name come first with empty arguments, and usage on the `finish_reason` chunk. + @Test("A Meta tool-call stream decodes to text, one tool call and its usage") + func metaToolCallStream() throws { + let lines = [ + #"data: {"id":"c1","choices":[{"delta":{"content":"I'll look up the weather.","role":"assistant"},"finish_reason":null,"index":0}],"model":"muse-spark-1.3","object":"chat.completion.chunk"}"#, + #"data: {"id":"c1","choices":[{"delta":{"tool_calls":[{"index":0,"id":"call_01a0","type":"function","function":{"name":"lookup_weather","arguments":""}}]},"finish_reason":null,"index":0}],"model":"muse-spark-1.3","object":"chat.completion.chunk"}"#, + #"data: {"id":"c1","choices":[{"delta":{"tool_calls":[{"index":0,"function":{"arguments":"{\"city\":\"Paris\"}"}}]},"finish_reason":null,"index":0}],"model":"muse-spark-1.3","object":"chat.completion.chunk"}"#, + #"data: {"id":"c1","choices":[{"delta":{},"finish_reason":"tool_calls","index":0}],"model":"muse-spark-1.3","object":"chat.completion.chunk","usage":{"completion_tokens":139,"prompt_tokens":570,"total_tokens":709,"completion_tokens_details":{"reasoning_tokens":70}}}"#, + "data: [DONE]" + ] + var state = OpenAIStreamState() + var events: [ChatStreamEvent] = [] + for line in lines { + guard let json = OpenAICompatibleProvider.decodeStreamLine(line, providerType: .custom) else { continue } + events += try OpenAICompatibleProvider.streamEvents(from: json, state: &state) + } + events += try OpenAICompatibleProvider.finalStreamEvents(state) + + guard events.count == 5 else { + Issue.record("expected 5 events; got \(events)") + return + } + if case .textDelta(let text) = events[0] { #expect(text == "I'll look up the weather.") } else { + Issue.record("expected textDelta; got \(events[0])") + } + if case .toolUseStart(let id, let name, _) = events[1] { + #expect(id == "call_01a0") + #expect(name == "lookup_weather") + } else { + Issue.record("expected toolUseStart; got \(events[1])") + } + if case .toolUseDelta(let id, let delta) = events[2] { + #expect(id == "call_01a0") + #expect(delta == #"{"city":"Paris"}"#) + } else { + Issue.record("expected toolUseDelta; got \(events[2])") + } + if case .toolUseEnd(let id) = events[3] { #expect(id == "call_01a0") } else { + Issue.record("expected toolUseEnd; got \(events[3])") + } + if case .usage(let usage) = events[4] { + #expect(usage.inputTokens == 570) + #expect(usage.outputTokens == 139) + } else { + Issue.record("expected usage; got \(events[4])") + } + } } diff --git a/apple/TableProTests/ViewModels/AIChatViewModelProviderSettingsTests.swift b/apple/TableProTests/ViewModels/AIChatViewModelProviderSettingsTests.swift new file mode 100644 index 0000000000..7306942d71 --- /dev/null +++ b/apple/TableProTests/ViewModels/AIChatViewModelProviderSettingsTests.swift @@ -0,0 +1,121 @@ +// +// AIChatViewModelProviderSettingsTests.swift +// TableProTests +// + +import Combine +import Foundation +@testable import TablePro +import TableProTestSupport +import Testing + +// Claude Agent lists its models without a network call. +private let claudeAgentProvider = AIProviderConfig( + id: UUID(uuidString: "6B1E4F44-31D8-4C47-9B0B-3F0C2A9D1E01") ?? UUID(), + type: .claudeAgent, + model: "sonnet" +) + +// Port 9 refuses the connection at once, so the model list fails without a timeout. +private let unreachableProvider = AIProviderConfig( + id: UUID(uuidString: "6B1E4F44-31D8-4C47-9B0B-3F0C2A9D1E02") ?? UUID(), + type: .custom, + model: "model-a", + endpoint: "http://127.0.0.1:9/v1" +) + +extension GlobalStateSuites { + @Suite(.appSettings { + $0.ai.enabled = true + $0.ai.providers = [claudeAgentProvider] + $0.ai.activeProviderID = claudeAgentProvider.id + }) + @MainActor + struct AIChatViewModelProviderSettingsTests { + private static let agent = claudeAgentProvider + + private func settingsSettle(_ viewModel: AIChatViewModel) async throws { + let revision = viewModel.providerSettingsRevision + AppServices.live.appEvents.aiProviderSaved.send(UUID()) + try await waitUntil { viewModel.providerSettingsRevision > revision } + } + + @Test("A chat panel pick whose provider was removed is cleared when AI settings change") + func removedProviderPickIsCleared() async throws { + let viewModel = AIChatViewModel() + viewModel.selectedProviderId = UUID() + viewModel.selectedModel = "muse-spark-1.3" + + AppServices.live.appEvents.aiSettingsChanged.send(()) + try await settingsSettle(viewModel) + + #expect(viewModel.selectedProviderId == nil) + #expect(viewModel.selectedModel == nil) + } + + @Test("A chat panel pick whose provider is still configured is kept") + func configuredProviderPickIsKept() async throws { + let viewModel = AIChatViewModel() + viewModel.selectedProviderId = Self.agent.id + viewModel.selectedModel = "opus" + + AppServices.live.appEvents.aiSettingsChanged.send(()) + try await settingsSettle(viewModel) + + #expect(viewModel.selectedProviderId == Self.agent.id) + #expect(viewModel.selectedModel == "opus") + } + + /// A key fixed in Settings changes nothing the provider list shows, and the panel kept the + /// list it had fetched with the rejected key. + @Test("Saving a provider makes the chat panel fetch its model list again") + func savedProviderListIsFetchedAgain() async throws { + let viewModel = AIChatViewModel() + await viewModel.loadAvailableModels() + #expect(viewModel.availableModels[Self.agent.id] == ["opus", "sonnet", "haiku"]) + #expect(!viewModel.modelListIsStale(for: Self.agent)) + + let revision = viewModel.providerSettingsRevision + AppServices.live.appEvents.aiProviderSaved.send(Self.agent.id) + try await waitUntil { viewModel.providerSettingsRevision > revision } + #expect(viewModel.modelListIsStale(for: Self.agent)) + + await viewModel.loadAvailableModels() + #expect(!viewModel.modelListIsStale(for: Self.agent)) + } + + /// A server that cannot answer was asked again on every connection switch, and the whole + /// panel waited on it each time. + @Test("A model list that failed to load is not fetched again until the provider changes", .appSettings { + $0.ai.providers = [unreachableProvider] + }) + func failedListIsNotFetchedAgain() async { + let viewModel = AIChatViewModel() + await viewModel.loadAvailableModels() + #expect(viewModel.availableModels[unreachableProvider.id] == []) + #expect(!viewModel.modelListIsStale(for: unreachableProvider)) + + var moved = unreachableProvider + moved.endpoint = "http://127.0.0.1:9/v2" + #expect(viewModel.modelListIsStale(for: moved)) + } + + @Test("A model list depends on the Base URL and the preset, not on the model picked") + func listSourceTracksWhatTheListDependsOn() { + let saved = AIProviderConfig(preset: .meta) + let fetched = AIModelListSource(config: saved) + + var otherModel = saved + otherModel.model = "muse-wonder-1.0" + #expect(AIModelListSource(config: otherModel) == fetched) + + var otherServer = saved + otherServer.endpoint = "https://gateway.example/meta" + #expect(AIModelListSource(config: otherServer) != fetched) + + var noPreset = saved + noPreset.presetID = nil + #expect(AIModelListSource(config: noPreset) != fetched) + } + } +} From 7c25c0d0ff7fea3f7ddd2c30dad8eb07de62fce1 Mon Sep 17 00:00:00 2001 From: Ngo Quoc Dat Date: Wed, 11 Nov 2026 20:46:09 +0700 Subject: [PATCH 2/2] docs(changelog): note the Meta provider and the AI model list fixes --- apple/changelog.d/4191.added.md | 1 + apple/changelog.d/4191.fixed.1.md | 1 + apple/changelog.d/4191.fixed.2.md | 1 + apple/changelog.d/4191.fixed.3.md | 1 + apple/changelog.d/4191.fixed.4.md | 1 + apple/changelog.d/4191.fixed.5.md | 1 + apple/changelog.d/4191.fixed.md | 1 + 7 files changed, 7 insertions(+) create mode 100644 apple/changelog.d/4191.added.md create mode 100644 apple/changelog.d/4191.fixed.1.md create mode 100644 apple/changelog.d/4191.fixed.2.md create mode 100644 apple/changelog.d/4191.fixed.3.md create mode 100644 apple/changelog.d/4191.fixed.4.md create mode 100644 apple/changelog.d/4191.fixed.5.md create mode 100644 apple/changelog.d/4191.fixed.md diff --git a/apple/changelog.d/4191.added.md b/apple/changelog.d/4191.added.md new file mode 100644 index 0000000000..537d2410ae --- /dev/null +++ b/apple/changelog.d/4191.added.md @@ -0,0 +1 @@ +Meta (Muse Spark, Muse Wonder, Muse Ember) is an AI provider in Add Provider, with its Base URL filled in. diff --git a/apple/changelog.d/4191.fixed.1.md b/apple/changelog.d/4191.fixed.1.md new file mode 100644 index 0000000000..a51ef53301 --- /dev/null +++ b/apple/changelog.d/4191.fixed.1.md @@ -0,0 +1 @@ +The chat panel kept a provider's old model list after its key or Base URL changed in Settings. diff --git a/apple/changelog.d/4191.fixed.2.md b/apple/changelog.d/4191.fixed.2.md new file mode 100644 index 0000000000..325fac2121 --- /dev/null +++ b/apple/changelog.d/4191.fixed.2.md @@ -0,0 +1 @@ +A chat panel model picked for a removed provider was sent to the active provider. diff --git a/apple/changelog.d/4191.fixed.3.md b/apple/changelog.d/4191.fixed.3.md new file mode 100644 index 0000000000..d1245f5d5d --- /dev/null +++ b/apple/changelog.d/4191.fixed.3.md @@ -0,0 +1 @@ +OpenAI and xAI model lists offered embedding, speech and image models that cannot chat. diff --git a/apple/changelog.d/4191.fixed.4.md b/apple/changelog.d/4191.fixed.4.md new file mode 100644 index 0000000000..620613a971 --- /dev/null +++ b/apple/changelog.d/4191.fixed.4.md @@ -0,0 +1 @@ +A new provider started with no model when its model list could not load yet. diff --git a/apple/changelog.d/4191.fixed.5.md b/apple/changelog.d/4191.fixed.5.md new file mode 100644 index 0000000000..c6cf9d90c8 --- /dev/null +++ b/apple/changelog.d/4191.fixed.5.md @@ -0,0 +1 @@ +Test Connection failed with a not found error when no model was picked yet. diff --git a/apple/changelog.d/4191.fixed.md b/apple/changelog.d/4191.fixed.md new file mode 100644 index 0000000000..458b4a4909 --- /dev/null +++ b/apple/changelog.d/4191.fixed.md @@ -0,0 +1 @@ +The chat sent a reasoning level that the model picked in the chat panel does not accept.