Skip to content

Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more

Anthropic pst processing auth fix

altic-dev6bf359ebb7de
diff --git a/Sources/Fluid/Services/ModelRepository.swift b/Sources/Fluid/Services/ModelRepository.swift
index fdf16596..3620fc73 100644
--- a/Sources/Fluid/Services/ModelRepository.swift
+++ b/Sources/Fluid/Services/ModelRepository.swift
@@ -229,36 +229,84 @@ final class ModelRepository {
/// - apiKey: Optional API key for authentication
/// - Returns: Array of model IDs sorted alphabetically
func fetchModels(for providerID: String, baseURL: String, apiKey: String?) async throws -> [String] {
+ let isAnthropic = providerID == "anthropic" || baseURL.contains("anthropic.com")
+
// Construct the models endpoint URL
let urlString = baseURL.hasSuffix("/") ? "\(baseURL)models" : "\(baseURL)/models"
guard let url = URL(string: urlString) else {
- throw FetchError.invalidURL
+ DebugLogger.shared.error(
+ "fetchModels: Invalid URL constructed from baseURL='\(baseURL)' -> '\(urlString)'",
+ source: "ModelRepository"
+ )
+ throw FetchError.invalidURL(details: "Could not construct valid URL from base: \(baseURL)")
}
+ DebugLogger.shared.debug(
+ "fetchModels: Fetching models for '\(providerID)' from \(urlString) (isAnthropic=\(isAnthropic))",
+ source: "ModelRepository"
+ )
+
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.timeoutInterval = 15
- // Add authorization header if API key is provided
+ // Add authentication headers (different for Anthropic)
if let key = apiKey, !key.isEmpty {
- request.setValue("Bearer \(key)", forHTTPHeaderField: "Authorization")
+ if isAnthropic {
+ // Anthropic uses x-api-key header and requires anthropic-version
+ request.setValue(key, forHTTPHeaderField: "x-api-key")
+ request.setValue("2023-06-01", forHTTPHeaderField: "anthropic-version")
+ } else {
+ request.setValue("Bearer \(key)", forHTTPHeaderField: "Authorization")
+ }
}
- let (data, response) = try await URLSession.shared.data(for: request)
+ let data: Data
+ let response: URLResponse
+ do {
+ (data, response) = try await URLSession.shared.data(for: request)
+ } catch {
+ let errorDetails = self.detailedNetworkError(error)
+ DebugLogger.shared.error(
+ "fetchModels: Network error for '\(providerID)': \(errorDetails)",
+ source: "ModelRepository"
+ )
+ throw FetchError.networkError(details: errorDetails)
+ }
- // Check for HTTP errors
+ // Check for HTTP errors with detailed messages
if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode != 200 {
- throw FetchError.httpError(statusCode: httpResponse.statusCode)
+ let bodyString = String(data: data, encoding: .utf8) ?? "<unable to decode response body>"
+ let errorDetails = self.interpretHTTPError(
+ statusCode: httpResponse.statusCode,
+ providerID: providerID,
+ responseBody: bodyString,
+ endpoint: urlString
+ )
+ DebugLogger.shared.error(
+ "fetchModels: HTTP \(httpResponse.statusCode) for '\(providerID)': \(errorDetails)\nResponse body: \(bodyString.prefix(500))",
+ source: "ModelRepository"
+ )
+ throw FetchError.httpError(statusCode: httpResponse.statusCode, details: errorDetails)
}
// Parse the response - OpenAI format: { "data": [{ "id": "model-name" }, ...] }
- guard let json = try JSONSerialization.jsonObject(with: data) as? [String: Any] else {
- throw FetchError.invalidResponse
+ guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+ let bodyPreview = String(data: data, encoding: .utf8)?.prefix(300) ?? "<binary data>"
+ DebugLogger.shared.error(
+ "fetchModels: Failed to parse JSON for '\(providerID)'. Response preview: \(bodyPreview)",
+ source: "ModelRepository"
+ )
+ throw FetchError.invalidResponse(details: "Response is not valid JSON. Check if the base URL '\(baseURL)' is correct.")
}
// Try OpenAI/Groq/Cerebras format first
if let dataArray = json["data"] as? [[String: Any]] {
let models = dataArray.compactMap { $0["id"] as? String }
+ DebugLogger.shared.debug(
+ "fetchModels: Found \(models.count) models for '\(providerID)' (OpenAI format)",
+ source: "ModelRepository"
+ )
return models.sorted()
}
@@ -271,25 +319,87 @@ final class ModelRepository {
}
return nil
}
+ DebugLogger.shared.debug(
+ "fetchModels: Found \(models.count) models for '\(providerID)' (Google format)",
+ source: "ModelRepository"
+ )
return models.sorted()
}
- throw FetchError.invalidResponse
+ // Log what we actually received
+ let topLevelKeys = json.keys.joined(separator: ", ")
+ DebugLogger.shared.error(
+ "fetchModels: Unknown response format for '\(providerID)'. Top-level keys: [\(topLevelKeys)]. Expected 'data' or 'models' array.",
+ source: "ModelRepository"
+ )
+ throw FetchError.invalidResponse(details: "Unknown response format. Top-level keys: [\(topLevelKeys)]. Expected 'data' or 'models'.")
+ }
+
+ /// Provides detailed interpretation of HTTP errors
+ private func interpretHTTPError(statusCode: Int, providerID: String, responseBody: String, endpoint: String) -> String {
+ let providerName = self.displayName(for: providerID)
+
+ switch statusCode {
+ case 400:
+ return "Bad Request - The request format was invalid. Check if the base URL '\(endpoint)' is correct for \(providerName)."
+ case 401:
+ if responseBody.lowercased().contains("invalid") || responseBody.lowercased().contains("api key") || responseBody.lowercased().contains("authentication") {
+ return "Invalid API Key - The API key for \(providerName) appears to be incorrect or expired. Please verify your API key."
+ }
+ return "Unauthorized - API key is missing or invalid for \(providerName). Double-check your API key."
+ case 403:
+ if responseBody.lowercased().contains("permission") || responseBody.lowercased().contains("access") {
+ return "Forbidden - Your API key doesn't have permission to list models for \(providerName). Check your account permissions."
+ }
+ return "Forbidden - Access denied for \(providerName). Your API key may lack the required permissions."
+ case 404:
+ return "Not Found - The /models endpoint doesn't exist at '\(endpoint)'. This provider may not support model listing, or the base URL is incorrect."
+ case 429:
+ return "Rate Limited - Too many requests to \(providerName). Wait a moment and try again."
+ case 500, 502, 503:
+ return "\(providerName) server error (HTTP \(statusCode)). The service may be temporarily unavailable."
+ default:
+ return "HTTP \(statusCode) from \(providerName). Check your API key and base URL configuration."
+ }
+ }
+
+ /// Provides detailed network error messages
+ private func detailedNetworkError(_ error: Error) -> String {
+ let nsError = error as NSError
+ switch nsError.code {
+ case NSURLErrorTimedOut:
+ return "Connection timed out - The server didn't respond in time. Check if the base URL is correct and the service is running."
+ case NSURLErrorCannotConnectToHost:
+ return "Cannot connect to host - Check if the base URL is correct. For local providers (Ollama, LM Studio), ensure the server is running."
+ case NSURLErrorNetworkConnectionLost:
+ return "Network connection lost - Check your internet connection."
+ case NSURLErrorNotConnectedToInternet:
+ return "No internet connection - Check your network settings."
+ case NSURLErrorSecureConnectionFailed:
+ return "SSL/TLS error - The server's security certificate may be invalid or expired."
+ case NSURLErrorCannotFindHost:
+ return "Cannot find host - The domain name doesn't exist. Check if the base URL is spelled correctly."
+ default:
+ return "\(error.localizedDescription) (Error code: \(nsError.code))"
+ }
}
enum FetchError: LocalizedError {
- case invalidURL
- case httpError(statusCode: Int)
- case invalidResponse
+ case invalidURL(details: String)
+ case httpError(statusCode: Int, details: String)
+ case invalidResponse(details: String)
+ case networkError(details: String)
var errorDescription: String? {
switch self {
- case .invalidURL:
- return "Invalid API URL"
- case let .httpError(code):
- return "API returned error \(code)"
- case .invalidResponse:
- return "Could not parse API response"
+ case let .invalidURL(details):
+ return "Invalid API URL: \(details)"
+ case let .httpError(code, details):
+ return "API error (HTTP \(code)): \(details)"
+ case let .invalidResponse(details):
+ return "Invalid response: \(details)"
+ case let .networkError(details):
+ return "Network error: \(details)"
}
}
}
diff --git a/Sources/Fluid/UI/AISettings/AIEnhancementSettingsViewModel.swift b/Sources/Fluid/UI/AISettings/AIEnhancementSettingsViewModel.swift
index 934138e2..31b334c7 100644
--- a/Sources/Fluid/UI/AISettings/AIEnhancementSettingsViewModel.swift
+++ b/Sources/Fluid/UI/AISettings/AIEnhancementSettingsViewModel.swift
@@ -519,33 +519,34 @@ final class AIEnhancementSettingsViewModel: ObservableObject {
guard !self.isTestingConnection else { return }
let providerID = self.selectedProviderID
+ let providerName = ModelRepository.shared.displayName(for: providerID)
let apiKey = self.providerAPIKeys[self.currentProvider] ?? ""
let baseURL = self.openAIBaseURL.trimmingCharacters(in: .whitespacesAndNewlines)
let isLocal = self.isLocalEndpoint(baseURL)
+ let isAnthropic = providerID == "anthropic" || baseURL.contains("anthropic.com")
- if isLocal {
- guard !baseURL.isEmpty else {
- await MainActor.run {
- self.updateConnectionStatus(.failed, for: providerID)
- self.connectionErrorMessage = "Base URL is required"
- }
- return
+ // Validate inputs with specific error messages
+ if baseURL.isEmpty {
+ await MainActor.run {
+ self.updateConnectionStatus(.failed, for: providerID)
+ self.connectionErrorMessage = "Base URL is required for \(providerName)"
}
- } else {
- guard !apiKey.isEmpty, !baseURL.isEmpty else {
- await MainActor.run {
- self.updateConnectionStatus(.failed, for: providerID)
- self.connectionErrorMessage = "API key and base URL are required"
- }
- return
+ return
+ }
+
+ if !isLocal && apiKey.isEmpty {
+ await MainActor.run {
+ self.updateConnectionStatus(.failed, for: providerID)
+ self.connectionErrorMessage = "API key is required for \(providerName). Enter your API key above."
}
+ return
}
let trimmedModel = self.selectedModel.trimmingCharacters(in: .whitespacesAndNewlines)
guard !trimmedModel.isEmpty else {
await MainActor.run {
self.updateConnectionStatus(.failed, for: providerID)
- self.connectionErrorMessage = "Select a model before verifying"
+ self.connectionErrorMessage = "Select a model before verifying. You may need to add a model manually for \(providerName)."
}
return
}
@@ -556,95 +557,145 @@ final class AIEnhancementSettingsViewModel: ObservableObject {
self.connectionErrorMessage = ""
}
- do {
- let endpoint = baseURL.trimmingCharacters(in: .whitespacesAndNewlines)
- let fullURL: String
- if endpoint.contains("/chat/completions") || endpoint.contains("/api/chat") || endpoint
- .contains("/api/generate")
- {
+ // Build the endpoint URL
+ let endpoint = baseURL.trimmingCharacters(in: .whitespacesAndNewlines)
+ let fullURL: String
+
+ if isAnthropic {
+ // Anthropic uses /messages endpoint, not /chat/completions
+ if endpoint.contains("/messages") {
fullURL = endpoint
} else {
- fullURL = endpoint + "/chat/completions"
+ fullURL = endpoint + "/messages"
}
+ } else if endpoint.contains("/chat/completions") || endpoint.contains("/api/chat") || endpoint.contains("/api/generate") {
+ fullURL = endpoint
+ } else {
+ fullURL = endpoint + "/chat/completions"
+ }
- // Debug logging to diagnose test failures
- DebugLogger.shared.debug(
- "testAPIConnection: provider=\(self.selectedProviderID), model=\(self.selectedModel), baseURL=\(endpoint), fullURL=\(fullURL)",
- source: "AISettingsView"
- )
+ // Debug logging
+ DebugLogger.shared.debug(
+ "testAPIConnection: provider=\(providerID), model=\(trimmedModel), baseURL=\(endpoint), fullURL=\(fullURL), isAnthropic=\(isAnthropic)",
+ source: "AISettingsView"
+ )
- guard let url = URL(string: fullURL) else {
- await MainActor.run {
- self.updateConnectionStatus(.failed, for: providerID)
- self.connectionErrorMessage = "Invalid Base URL format"
- }
- return
+ guard let url = URL(string: fullURL) else {
+ await MainActor.run {
+ self.updateConnectionStatus(.failed, for: providerID)
+ self.connectionErrorMessage = "Invalid Base URL format: '\(endpoint)' could not be parsed as a URL"
}
+ return
+ }
- let provKey = self.providerKey(for: self.selectedProviderID)
- let reasoningConfig = self.settings.getReasoningConfig(forModel: self.selectedModel, provider: provKey)
+ // Build the request based on provider type
+ var request = URLRequest(url: url)
+ request.httpMethod = "POST"
+ request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+ request.timeoutInterval = 15
+
+ // Set authorization header (different for Anthropic)
+ if !apiKey.isEmpty {
+ if isAnthropic {
+ request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
+ request.setValue("2023-06-01", forHTTPHeaderField: "anthropic-version")
+ } else {
+ request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
+ }
+ }
- let usesMaxCompletionTokens = self.settings.isReasoningModel(self.selectedModel)
+ // Build request body (different format for Anthropic)
+ let requestDict: [String: Any]
+ let provKey = self.providerKey(for: providerID)
+ let reasoningConfig = self.settings.getReasoningConfig(forModel: trimmedModel, provider: provKey)
- var requestDict: [String: Any] = [
+ if isAnthropic {
+ // Anthropic API format
+ requestDict = [
+ "model": trimmedModel,
+ "max_tokens": 10,
+ "messages": [["role": "user", "content": "Hi"]],
+ ]
+ } else {
+ // OpenAI-compatible format
+ var dict: [String: Any] = [
"model": trimmedModel,
"messages": [["role": "user", "content": "test"]],
]
+ let usesMaxCompletionTokens = self.settings.isReasoningModel(trimmedModel)
if usesMaxCompletionTokens {
- requestDict["max_completion_tokens"] = 50
+ dict["max_completion_tokens"] = 50
} else {
- requestDict["max_tokens"] = 50
+ dict["max_tokens"] = 50
}
if let config = reasoningConfig, config.isEnabled {
if config.parameterName == "enable_thinking" {
- requestDict[config.parameterName] = config.parameterValue == "true"
+ dict[config.parameterName] = config.parameterValue == "true"
} else {
- requestDict[config.parameterName] = config.parameterValue
+ dict[config.parameterName] = config.parameterValue
}
}
+ requestDict = dict
+ }
- guard let jsonData = try? JSONSerialization.data(withJSONObject: requestDict, options: []) else {
- await MainActor.run {
- self.updateConnectionStatus(.failed, for: providerID)
- self.connectionErrorMessage = "Failed to create test payload"
- }
- return
+ guard let jsonData = try? JSONSerialization.data(withJSONObject: requestDict, options: []) else {
+ await MainActor.run {
+ self.updateConnectionStatus(.failed, for: providerID)
+ self.connectionErrorMessage = "Internal error: Failed to create test request payload"
}
+ return
+ }
+ request.httpBody = jsonData
- var request = URLRequest(url: url)
- request.httpMethod = "POST"
- request.setValue("application/json", forHTTPHeaderField: "Content-Type")
- if !apiKey.isEmpty {
- request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
- }
- request.httpBody = jsonData
- request.timeoutInterval = 12
+ // Make the request
+ do {
+ let (data, response) = try await URLSession.shared.data(for: request)
- let (_, response) = try await URLSession.shared.data(for: request)
- if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode >= 200, httpResponse.statusCode < 300 {
- await MainActor.run {
- self.updateConnectionStatus(.success, for: providerID)
- self.connectionErrorMessage = ""
- self.setEditingAPIKey(false, for: providerID)
- self.storeVerificationFingerprint(for: providerID, baseURL: baseURL, apiKey: apiKey)
- }
- } else if let httpResponse = response as? HTTPURLResponse {
- await MainActor.run {
- self.updateConnectionStatus(.failed, for: providerID)
- self.connectionErrorMessage = "HTTP \(httpResponse.statusCode)"
+ if let httpResponse = response as? HTTPURLResponse {
+ let statusCode = httpResponse.statusCode
+
+ if statusCode >= 200 && statusCode < 300 {
+ await MainActor.run {
+ self.updateConnectionStatus(.success, for: providerID)
+ self.connectionErrorMessage = ""
+ self.setEditingAPIKey(false, for: providerID)
+ self.storeVerificationFingerprint(for: providerID, baseURL: baseURL, apiKey: apiKey)
+ }
+ } else {
+ // Parse error response for more details
+ let errorMessage = self.interpretVerificationError(
+ statusCode: statusCode,
+ responseData: data,
+ providerID: providerID,
+ model: trimmedModel,
+ endpoint: fullURL
+ )
+ DebugLogger.shared.error(
+ "testAPIConnection failed: HTTP \(statusCode) for \(providerID), model=\(trimmedModel)\nError: \(errorMessage)\nResponse: \(String(data: data, encoding: .utf8)?.prefix(500) ?? "nil")",
+ source: "AISettingsView"
+ )
+ await MainActor.run {
+ self.updateConnectionStatus(.failed, for: providerID)
+ self.connectionErrorMessage = errorMessage
+ }
}
} else {
await MainActor.run {
self.updateConnectionStatus(.failed, for: providerID)
- self.connectionErrorMessage = "Unexpected response"
+ self.connectionErrorMessage = "Unexpected response type from server"
}
}
} catch {
+ let errorMessage = self.interpretNetworkError(error, providerID: providerID)
+ DebugLogger.shared.error(
+ "testAPIConnection network error for \(providerID): \(error.localizedDescription)",
+ source: "AISettingsView"
+ )
await MainActor.run {
self.updateConnectionStatus(.failed, for: providerID)
- self.connectionErrorMessage = error.localizedDescription
+ self.connectionErrorMessage = errorMessage
}
}
@@ -653,6 +704,93 @@ final class AIEnhancementSettingsViewModel: ObservableObject {
}
}
+ /// Interprets HTTP error responses with actionable guidance
+ private func interpretVerificationError(statusCode: Int, responseData: Data, providerID: String, model: String, endpoint: String) -> String {
+ let providerName = ModelRepository.shared.displayName(for: providerID)
+ let responseBody = String(data: responseData, encoding: .utf8)?.lowercased() ?? ""
+
+ switch statusCode {
+ case 400:
+ // Check for specific error patterns in response
+ if responseBody.contains("model") {
+ return "Invalid model '\(model)' for \(providerName). Check if the model name is correct."
+ }
+ if responseBody.contains("messages") || responseBody.contains("content") {
+ return "Request format error for \(providerName). The API may have changed or the base URL is pointed at a different API."
+ }
+ return "Bad request (HTTP 400). Check that the base URL '\(endpoint)' is correct for \(providerName)."
+
+ case 401:
+ if responseBody.contains("invalid") || responseBody.contains("expired") {
+ return "Invalid API key for \(providerName). Please verify your API key is correct and not expired."
+ }
+ if responseBody.contains("missing") {
+ return "API key is missing. Enter your \(providerName) API key above."
+ }
+ return "Authentication failed (HTTP 401). Your \(providerName) API key may be invalid. Double-check the key."
+
+ case 403:
+ if responseBody.contains("permission") || responseBody.contains("access") {
+ return "Permission denied. Your \(providerName) API key may not have access to this model."
+ }
+ if responseBody.contains("region") || responseBody.contains("country") {
+ return "Access denied. \(providerName) may not be available in your region."
+ }
+ return "Forbidden (HTTP 403). Check your \(providerName) account permissions and subscription."
+
+ case 404:
+ if responseBody.contains("model") {
+ return "Model '\(model)' not found on \(providerName). Check if the model name is spelled correctly."
+ }
+ return "Endpoint not found (HTTP 404). The base URL '\(endpoint)' may be incorrect for \(providerName)."
+
+ case 422:
+ if responseBody.contains("model") {
+ return "Model '\(model)' is not valid for \(providerName). Try a different model."
+ }
+ return "Invalid request parameters for \(providerName). The model or configuration may be incorrect."
+
+ case 429:
+ return "Rate limited by \(providerName). Wait a moment and try again."
+
+ case 500, 502, 503:
+ return "\(providerName) server error (HTTP \(statusCode)). The service may be temporarily unavailable."
+
+ case 529:
+ return "\(providerName) is overloaded. Try again in a few moments."
+
+ default:
+ return "HTTP \(statusCode) from \(providerName). Check your API key, base URL, and model configuration."
+ }
+ }
+
+ /// Interprets network errors with actionable guidance
+ private func interpretNetworkError(_ error: Error, providerID: String) -> String {
+ let providerName = ModelRepository.shared.displayName(for: providerID)
+ let nsError = error as NSError
+
+ switch nsError.code {
+ case NSURLErrorTimedOut:
+ return "Connection to \(providerName) timed out. Check if the base URL is correct and the service is available."
+ case NSURLErrorCannotConnectToHost:
+ if providerID == "ollama" || providerID == "lmstudio" {
+ return "Cannot connect. Is the \(providerName) server running? Check that the local server is started."
+ }
+ return "Cannot connect to \(providerName). Check your internet connection and base URL."
+ case NSURLErrorNetworkConnectionLost:
+ return "Network connection lost while connecting to \(providerName). Check your internet connection."
+ case NSURLErrorNotConnectedToInternet:
+ return "No internet connection. Connect to the internet to verify \(providerName)."
+ case NSURLErrorSecureConnectionFailed:
+ return "SSL/TLS error connecting to \(providerName). The server's certificate may be invalid."
+ case NSURLErrorCannotFindHost:
+ return "Cannot find host. Check if the base URL for \(providerName) is spelled correctly."
+ default:
+ return "Network error: \(error.localizedDescription)"
+ }
+ }
+
+
// MARK: - Provider/Model Handling
func handleProviderChange(_ newValue: String) {