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)
+ }
+ }
+}
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.