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

Fixed issues related to reasoning models vs non reasoning models. Now reasoning models have settings enabled to choose level/effort ; API key retrieval modified for command and write mode ; solved issues related to model incompatibility with command mode

altic-devb1d48a263725
diff --git a/Sources/Fluid/ContentView.swift b/Sources/Fluid/ContentView.swift
index 37e299a8..0019765d 100644
--- a/Sources/Fluid/ContentView.swift
+++ b/Sources/Fluid/ContentView.swift
@@ -110,6 +110,12 @@ struct ContentView: View {
@State private var showingAddModel: Bool = false
@State private var newModelName: String = ""
+ // Model Reasoning Configuration
+ @State private var showingReasoningConfig: Bool = false
+ @State private var editingReasoningParamName: String = "reasoning_effort"
+ @State private var editingReasoningParamValue: String = "low"
+ @State private var editingReasoningEnabled: Bool = false
+
// MARK: - Provider Management
@State private var providerAPIKeys: [String: String] = [:] // [providerKey: apiKey]
@State private var currentProvider: String = "openai" // canonical key: "openai" | "groq" | "custom:<id>"
@@ -1565,6 +1571,46 @@ struct ContentView: View {
.buttonStyle(CompactButtonStyle())
.buttonHoverEffect()
}
+
+ // Reasoning Config button
+ Button(action: {
+ // Load current config for this model
+ let providerKey = self.providerKey(for: selectedProviderID)
+ if let config = SettingsStore.shared.getReasoningConfig(forModel: selectedModel, provider: providerKey) {
+ editingReasoningParamName = config.parameterName
+ editingReasoningParamValue = config.parameterValue
+ editingReasoningEnabled = config.isEnabled
+ } else {
+ // Check if model has auto-detected defaults
+ let modelLower = selectedModel.lowercased()
+ if modelLower.hasPrefix("gpt-5") || modelLower.contains("gpt-5.") ||
+ modelLower.hasPrefix("o1") || modelLower.hasPrefix("o3") ||
+ modelLower.contains("gpt-oss") || modelLower.hasPrefix("openai/") {
+ editingReasoningParamName = "reasoning_effort"
+ editingReasoningParamValue = "low"
+ editingReasoningEnabled = true
+ } else if modelLower.contains("deepseek") && modelLower.contains("reasoner") {
+ editingReasoningParamName = "enable_thinking"
+ editingReasoningParamValue = "true"
+ editingReasoningEnabled = true
+ } else {
+ editingReasoningParamName = "reasoning_effort"
+ editingReasoningParamValue = "low"
+ editingReasoningEnabled = false
+ }
+ }
+ showingReasoningConfig = true
+ }) {
+ HStack(spacing: 4) {
+ Image(systemName: hasReasoningConfigForCurrentModel() ? "brain.fill" : "brain")
+ Text("Reasoning")
+ }
+ .font(.caption)
+ .foregroundStyle(hasReasoningConfigForCurrentModel() ? theme.palette.accent : .secondary)
+ }
+ .buttonStyle(CompactButtonStyle())
+ .buttonHoverEffect()
+ .help("Configure reasoning/thinking parameters for this model")
}
// Add model input (appears below on new line when in add mode)
@@ -1595,6 +1641,149 @@ struct ContentView: View {
}
.padding(.leading, 122) // Align with model picker
}
+
+ // Reasoning Config Editor (appears below when editing)
+ if showingReasoningConfig {
+ VStack(alignment: .leading, spacing: 10) {
+ HStack {
+ Image(systemName: "brain.head.profile")
+ .foregroundStyle(theme.palette.accent)
+ Text("Reasoning Config for \(selectedModel)")
+ .font(.caption)
+ .fontWeight(.semibold)
+ Spacer()
+
+ // Auto-detect indicator
+ if !SettingsStore.shared.hasCustomReasoningConfig(forModel: selectedModel, provider: providerKey(for: selectedProviderID)) && editingReasoningEnabled {
+ Text("Auto-detected")
+ .font(.caption2)
+ .foregroundStyle(.green)
+ .padding(.horizontal, 6)
+ .padding(.vertical, 2)
+ .background(.green.opacity(0.15))
+ .cornerRadius(4)
+ }
+ }
+
+ Toggle("Enable reasoning parameter", isOn: $editingReasoningEnabled)
+ .toggleStyle(.switch)
+ .font(.caption)
+
+ if editingReasoningEnabled {
+ HStack(spacing: 12) {
+ VStack(alignment: .leading, spacing: 4) {
+ Text("Parameter Name")
+ .font(.caption2)
+ .foregroundStyle(.secondary)
+ Picker("", selection: $editingReasoningParamName) {
+ Text("reasoning_effort").tag("reasoning_effort")
+ Text("enable_thinking").tag("enable_thinking")
+ Text("thinking").tag("thinking")
+ Text("Custom...").tag("__custom__")
+ }
+ .pickerStyle(.menu)
+ .labelsHidden()
+ .frame(width: 150)
+ }
+
+ VStack(alignment: .leading, spacing: 4) {
+ Text("Value")
+ .font(.caption2)
+ .foregroundStyle(.secondary)
+
+ if editingReasoningParamName == "reasoning_effort" {
+ Picker("", selection: $editingReasoningParamValue) {
+ Text("minimal").tag("minimal")
+ Text("low").tag("low")
+ Text("medium").tag("medium")
+ Text("high").tag("high")
+ }
+ .pickerStyle(.menu)
+ .labelsHidden()
+ .frame(width: 100)
+ } else if editingReasoningParamName == "enable_thinking" {
+ Picker("", selection: $editingReasoningParamValue) {
+ Text("true").tag("true")
+ Text("false").tag("false")
+ }
+ .pickerStyle(.menu)
+ .labelsHidden()
+ .frame(width: 100)
+ } else {
+ TextField("Value", text: $editingReasoningParamValue)
+ .textFieldStyle(.roundedBorder)
+ .frame(width: 100)
+ }
+ }
+ }
+
+ // Help text
+ HStack(spacing: 6) {
+ Image(systemName: "info.circle")
+ .font(.caption2)
+ Text("gpt-5.x, o1, gpt-oss models use reasoning_effort. DeepSeek uses enable_thinking.")
+ .font(.caption2)
+ }
+ .foregroundStyle(.secondary)
+ }
+
+ HStack(spacing: 8) {
+ Button("Save") {
+ let providerKey = self.providerKey(for: selectedProviderID)
+ if editingReasoningEnabled {
+ let config = SettingsStore.ModelReasoningConfig(
+ parameterName: editingReasoningParamName,
+ parameterValue: editingReasoningParamValue,
+ isEnabled: true
+ )
+ SettingsStore.shared.setReasoningConfig(config, forModel: selectedModel, provider: providerKey)
+ } else {
+ // Save as disabled config to override auto-detection
+ let config = SettingsStore.ModelReasoningConfig(
+ parameterName: "",
+ parameterValue: "",
+ isEnabled: false
+ )
+ SettingsStore.shared.setReasoningConfig(config, forModel: selectedModel, provider: providerKey)
+ }
+ showingReasoningConfig = false
+ }
+ .buttonStyle(GlassButtonStyle())
+ .buttonHoverEffect()
+
+ Button("Cancel") {
+ showingReasoningConfig = false
+ }
+ .buttonStyle(CompactButtonStyle())
+ .buttonHoverEffect()
+
+ Spacer()
+
+ // Reset to auto-detect
+ if SettingsStore.shared.hasCustomReasoningConfig(forModel: selectedModel, provider: providerKey(for: selectedProviderID)) {
+ Button("Reset to Auto") {
+ let providerKey = self.providerKey(for: selectedProviderID)
+ SettingsStore.shared.setReasoningConfig(nil, forModel: selectedModel, provider: providerKey)
+ showingReasoningConfig = false
+ }
+ .buttonStyle(CompactButtonStyle())
+ .buttonHoverEffect()
+ .foregroundStyle(.orange)
+ }
+ }
+ }
+ .padding(12)
+ .background(
+ RoundedRectangle(cornerRadius: 8)
+ .fill(theme.palette.accent.opacity(0.08))
+ .overlay(
+ RoundedRectangle(cornerRadius: 8)
+ .stroke(theme.palette.accent.opacity(0.2), lineWidth: 1)
+ )
+ )
+ .padding(.leading, 122) // Align with model picker
+ .transition(.opacity)
+ }
} // End of else block for non-Apple Intelligence model row
@@ -2511,25 +2700,47 @@ struct ContentView: View {
let systemPrompt = buildSystemPrompt(appInfo: appInfo)
DebugLogger.shared.debug("Using app context for AI: app=\(appInfo.name), bundleId=\(appInfo.bundleId), title=\(appInfo.windowTitle)", source: "ContentView")
- // Check if model is gpt-oss (Groq reasoning models) and add reasoning_effort parameter
- let modelLower = selectedModel.lowercased()
- let shouldAddReasoningEffort = modelLower.contains("gpt-oss") || modelLower.hasPrefix("openai/")
+ // Get reasoning config for this model (uses per-model settings or auto-detection)
+ let providerKey = self.providerKey(for: selectedProviderID)
+ let reasoningConfig = SettingsStore.shared.getReasoningConfig(forModel: selectedModel, provider: providerKey)
+
+ if let config = reasoningConfig {
+ DebugLogger.shared.debug("Model '\(selectedModel)' reasoning config: \(config.parameterName)=\(config.parameterValue), enabled=\(config.isEnabled)", source: "ContentView")
+ } else {
+ DebugLogger.shared.debug("Model '\(selectedModel)' has no reasoning config", source: "ContentView")
+ }
// Get streaming setting
let enableStreaming = SettingsStore.shared.enableAIStreaming
- let body = ChatRequest(
- model: selectedModel,
- messages: [
- ChatMessage(role: "system", content: systemPrompt),
- ChatMessage(role: "user", content: inputText)
+ // Build request body dynamically to support different reasoning parameters
+ var requestDict: [String: Any] = [
+ "model": selectedModel,
+ "messages": [
+ ["role": "system", "content": systemPrompt],
+ ["role": "user", "content": inputText]
],
- temperature: 0.2,
- reasoning_effort: shouldAddReasoningEffort ? "low" : nil,
- stream: enableStreaming ? true : nil
- )
+ "temperature": 0.2
+ ]
+
+ // Add reasoning parameter if configured for this model
+ if let config = reasoningConfig, config.isEnabled {
+ if config.parameterName == "enable_thinking" {
+ // DeepSeek uses boolean
+ requestDict[config.parameterName] = config.parameterValue == "true"
+ } else {
+ // OpenAI/Groq use string values
+ requestDict[config.parameterName] = config.parameterValue
+ }
+ DebugLogger.shared.debug("Added reasoning param: \(config.parameterName)=\(config.parameterValue)", source: "ContentView")
+ }
+
+ // Add streaming if enabled
+ if enableStreaming {
+ requestDict["stream"] = true
+ }
- guard let jsonData = try? JSONEncoder().encode(body) else {
+ guard let jsonData = try? JSONSerialization.data(withJSONObject: requestDict, options: []) else {
return "Error: Failed to encode request"
}
@@ -2891,24 +3102,9 @@ struct ContentView: View {
let baseURL = openAIBaseURL.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)
let isLocal = isLocalEndpoint(baseURL)
- // Debug logging
- DebugLogger.shared.info("API connection test started (provider: \(currentProvider), baseURL: \(baseURL), isLocal: \(isLocal))", source: "ContentView")
- DebugLogger.shared.debug("API key supplied: \(!apiKey.isEmpty), length: \(apiKey.count)", source: "ContentView")
-
- // Only validate API key for non-local endpoints
- if !isLocal {
- if !apiKey.hasPrefix("sk-") {
- DebugLogger.shared.warning("PROBLEM: API key doesn't start with 'sk-' - this is likely the cause of the 401 error!", source: "ContentView")
- }
- if apiKey.count < 20 || apiKey.count > 200 {
- DebugLogger.shared.warning("PROBLEM: API key length is unusual - should be 20-200 characters!", source: "ContentView")
- }
- }
-
// For local endpoints, only baseURL is required
if isLocal {
guard !baseURL.isEmpty else {
- DebugLogger.shared.error("Missing required field - base URL is empty", source: "ContentView")
await MainActor.run {
connectionStatus = .failed
connectionErrorMessage = "Base URL is required"
@@ -2918,7 +3114,6 @@ struct ContentView: View {
} else {
// For remote endpoints, both API key and baseURL are required
guard !apiKey.isEmpty && !baseURL.isEmpty else {
- DebugLogger.shared.error("Missing required fields - API key or base URL is empty", source: "ContentView")
await MainActor.run {
connectionStatus = .failed
connectionErrorMessage = "API key and base URL are required"
@@ -2938,20 +3133,15 @@ struct ContentView: View {
// Build the full URL - only append /chat/completions if not already present
let fullURL: String
- if endpoint.contains("/chat/completions") ||
- endpoint.contains("/api/chat") ||
+ if endpoint.contains("/chat/completions") ||
+ endpoint.contains("/api/chat") ||
endpoint.contains("/api/generate") {
- // URL already has a complete path, use as-is
fullURL = endpoint
} else {
- // Append /chat/completions for OpenAI-compatible endpoints
fullURL = endpoint + "/chat/completions"
}
-
- DebugLogger.shared.debug("Full endpoint URL: \(fullURL)", source: "ContentView")
guard let url = URL(string: fullURL) else {
- DebugLogger.shared.error("Failed to create URL from: \(fullURL)", source: "ContentView")
await MainActor.run {
connectionStatus = .failed
connectionErrorMessage = "Invalid Base URL format"
@@ -2959,30 +3149,37 @@ struct ContentView: View {
return
}
- DebugLogger.shared.debug("Successfully created URL: \(url.absoluteString)", source: "ContentView")
-
- // Use the exact same format as the real API calls
- struct TestChatMessage: Codable {
- let role: String
- let content: String
+ // Get reasoning config for this model (uses per-model settings or auto-detection)
+ let providerKey = self.providerKey(for: selectedProviderID)
+ let reasoningConfig = SettingsStore.shared.getReasoningConfig(forModel: selectedModel, provider: providerKey)
+
+ // Build request body dynamically based on model requirements
+ let modelLower = selectedModel.lowercased()
+ let usesMaxCompletionTokens = modelLower.hasPrefix("gpt-5") || modelLower.contains("gpt-5.") ||
+ modelLower.hasPrefix("o1") || modelLower.hasPrefix("o3")
+
+ var requestDict: [String: Any] = [
+ "model": selectedModel,
+ "messages": [["role": "user", "content": "test"]]
+ ]
+
+ // Use appropriate token limit parameter
+ if usesMaxCompletionTokens {
+ requestDict["max_completion_tokens"] = 50
+ } else {
+ requestDict["max_tokens"] = 50
}
-
- struct TestChatRequest: Codable {
- let model: String
- let messages: [TestChatMessage]
- let max_tokens: Int
+
+ // Add reasoning parameter if configured for this model
+ if let config = reasoningConfig, config.isEnabled {
+ if config.parameterName == "enable_thinking" {
+ requestDict[config.parameterName] = config.parameterValue == "true"
+ } else {
+ requestDict[config.parameterName] = config.parameterValue
+ }
}
- let testBody = TestChatRequest(
- model: selectedModel, // Use the selected model from the UI
- messages: [TestChatMessage(role: "user", content: "test")],
- max_tokens: 1 // Minimal response to save tokens
- )
-
- print("Using model for test: \(selectedModel)")
-
- guard let jsonData = try? JSONEncoder().encode(testBody) else {
- print("[DEBUG] Failed to encode test request body")
+ guard let jsonData = try? JSONSerialization.data(withJSONObject: requestDict, options: []) else {
await MainActor.run {
connectionStatus = .failed
connectionErrorMessage = "Failed to encode test request"
@@ -2990,84 +3187,96 @@ struct ContentView: View {
return
}
- // Create request with proper logging
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+ request.timeoutInterval = 30
- // Only add Authorization header for non-local endpoints
if !isLocal {
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
}
request.httpBody = jsonData
- // Log request details (mask API key for security)
- let maskedKey = apiKey.count > 8 ? "\(apiKey.prefix(4))****\(apiKey.suffix(4))" : "****"
- print("[DEBUG] Request details:")
- print("[DEBUG] Method: \(request.httpMethod ?? "Unknown")")
- print("[DEBUG] URL: \(request.url?.absoluteString ?? "Unknown")")
- print("[DEBUG] Content-Type: \(request.value(forHTTPHeaderField: "Content-Type") ?? "Not set")")
- if isLocal {
- print("[DEBUG] Authorization header: Skipped (local endpoint detected)")
- } else {
- print("[DEBUG] Authorization header: \(request.value(forHTTPHeaderField: "Authorization") != nil ? "Set (Bearer \(maskedKey))" : "NOT SET - This is likely the problem!")")
- print("[DEBUG] Full Authorization header: \(request.value(forHTTPHeaderField: "Authorization") ?? "NOT SET")")
- }
- print("[DEBUG] Body size: \(jsonData.count) bytes")
- if let bodyString = String(data: jsonData, encoding: .utf8) {
- print("[DEBUG] Request body: \(bodyString)")
- }
-
- print("=== SENDING REQUEST ===")
- print("URL: \(request.url?.absoluteString ?? "Unknown")")
- print("Method: \(request.httpMethod ?? "Unknown")")
- print("Authorization: \(request.value(forHTTPHeaderField: "Authorization") != nil ? "Set" : "NOT SET")")
-
- let (_, response) = try await URLSession.shared.data(for: request)
-
- print("=== RECEIVED RESPONSE ===")
+ let (data, response) = try await URLSession.shared.data(for: request)
if let httpResponse = response as? HTTPURLResponse {
- print("HTTP Status: \(httpResponse.statusCode)")
- print("Response headers: \(httpResponse.allHeaderFields)")
-
if (200...299).contains(httpResponse.statusCode) {
- print("SUCCESS: Connection test passed!")
await MainActor.run {
connectionStatus = .success
connectionErrorMessage = ""
}
} else {
- print("FAILED: HTTP \(httpResponse.statusCode)")
- if httpResponse.statusCode == 401 {
- print("401 Error: This usually means:")
- print(" - API key is invalid or expired")
- print(" - API key doesn't start with 'sk-'")
- print(" - Insufficient credits on the account")
- print(" - Wrong API key type (using secret key instead of API key)")
+ // Parse error response for better error messages
+ var errorMessage = "HTTP \(httpResponse.statusCode)"
+
+ if let responseBody = String(data: data, encoding: .utf8),
+ let jsonData = responseBody.data(using: .utf8),
+ let json = try? JSONSerialization.jsonObject(with: jsonData) as? [String: Any] {
+
+ if let error = json["error"] as? [String: Any],
+ let message = error["message"] as? String {
+ errorMessage = message
+ } else if let message = json["message"] as? String {
+ errorMessage = message
+ } else if let errorStr = json["error"] as? String {
+ errorMessage = errorStr
+ }
+ }
+
+ // Provide helpful error messages based on status code
+ if errorMessage == "HTTP \(httpResponse.statusCode)" {
+ switch httpResponse.statusCode {
+ case 400:
+ errorMessage = "Bad Request - Model '\(selectedModel)' may be invalid"
+ case 401:
+ errorMessage = "Invalid API key or unauthorized"
+ case 403:
+ errorMessage = "Access forbidden - check API key permissions"
+ case 404:
+ errorMessage = "Model '\(selectedModel)' not found"
+ case 429:
+ errorMessage = "Rate limited - try again later"
+ case 500...599:
+ errorMessage = "Server error - provider may be down"
+ default:
+ break
+ }
}
+
await MainActor.run {
connectionStatus = .failed
- connectionErrorMessage = "HTTP \(httpResponse.statusCode): Invalid API key or insufficient credits"
+ connectionErrorMessage = errorMessage
}
}
} else {
- print("[DEBUG] Invalid response type - not HTTPURLResponse")
await MainActor.run {
connectionStatus = .failed
connectionErrorMessage = "Invalid response from server"
}
}
- } catch {
- print("[DEBUG] Network error during connection test:")
- print("[DEBUG] Error: \(error.localizedDescription)")
- print("[DEBUG] Error type: \(type(of: error))")
- if let urlError = error as? URLError {
- print("[DEBUG] URL Error Code: \(urlError.code.rawValue)")
- print("[DEBUG] URL Error User Info: \(urlError.userInfo)")
+ } catch let urlError as URLError {
+ var errorMessage: String
+ switch urlError.code {
+ case .timedOut:
+ errorMessage = "Request timed out - server not responding"
+ case .cannotConnectToHost:
+ errorMessage = "Cannot connect to host - check URL"
+ case .notConnectedToInternet:
+ errorMessage = "No internet connection"
+ case .secureConnectionFailed:
+ errorMessage = "SSL/TLS connection failed"
+ case .serverCertificateUntrusted:
+ errorMessage = "Server certificate not trusted"
+ default:
+ errorMessage = urlError.localizedDescription
}
+ await MainActor.run {
+ connectionStatus = .failed
+ connectionErrorMessage = errorMessage
+ }
+ } catch {
await MainActor.run {
connectionStatus = .failed
connectionErrorMessage = error.localizedDescription
@@ -3076,12 +3285,6 @@ struct ContentView: View {
await MainActor.run {
isTestingConnection = false
- print("🏁 ===== CONNECTION TEST COMPLETE =====")
- print("🏁 Final Status: \(connectionStatus)")
- if !connectionErrorMessage.isEmpty {
- print("🏁 Error: \(connectionErrorMessage)")
- }
- print("🏁 ===== END OF TEST =====")
}
}
@@ -3402,6 +3605,25 @@ struct ContentView: View {
return !defaultModels(for: currentProvider).contains(model)
}
+ /// Check if the current model has a reasoning config (either custom or auto-detected)
+ private func hasReasoningConfigForCurrentModel() -> Bool {
+ let providerKey = self.providerKey(for: selectedProviderID)
+
+ // Check for custom config first
+ if SettingsStore.shared.hasCustomReasoningConfig(forModel: selectedModel, provider: providerKey) {
+ if let config = SettingsStore.shared.getReasoningConfig(forModel: selectedModel, provider: providerKey) {
+ return config.isEnabled
+ }
+ }
+
+ // Check for auto-detected models
+ let modelLower = selectedModel.lowercased()
+ return modelLower.hasPrefix("gpt-5") || modelLower.contains("gpt-5.") ||
+ modelLower.hasPrefix("o1") || modelLower.hasPrefix("o3") ||
+ modelLower.contains("gpt-oss") || modelLower.hasPrefix("openai/") ||
+ (modelLower.contains("deepseek") && modelLower.contains("reasoner"))
+ }
+
private func removeModel(_ model: String) {
// Don't remove if it's currently selected
if selectedModel == model {
diff --git a/Sources/Fluid/Persistence/SettingsStore.swift b/Sources/Fluid/Persistence/SettingsStore.swift
index 8e6d6aac..0637fa6d 100644
--- a/Sources/Fluid/Persistence/SettingsStore.swift
+++ b/Sources/Fluid/Persistence/SettingsStore.swift
@@ -55,6 +55,9 @@ final class SettingsStore: ObservableObject
static let rewriteModeSelectedProviderID = "RewriteModeSelectedProviderID"
static let rewriteModeLinkedToGlobal = "RewriteModeLinkedToGlobal"
+ // Model Reasoning Config Keys
+ static let modelReasoningConfigs = "ModelReasoningConfigs"
+
// Stats Keys
static let userTypingWPM = "UserTypingWPM"
@@ -62,6 +65,33 @@ final class SettingsStore: ObservableObject
static let fillerWords = "FillerWords"
static let removeFillerWordsEnabled = "RemoveFillerWordsEnabled"
}
+
+ // MARK: - Model Reasoning Configuration
+
+ /// Configuration for model-specific reasoning/thinking parameters
+ struct ModelReasoningConfig: Codable, Equatable {
+ /// The parameter name to use (e.g., "reasoning_effort", "enable_thinking", "thinking")
+ var parameterName: String
+
+ /// The value to use for the parameter (e.g., "low", "medium", "high", "none", "true")
+ var parameterValue: String
+
+ /// Whether this config is enabled (allows disabling without deleting)
+ var isEnabled: Bool
+
+ init(parameterName: String = "reasoning_effort", parameterValue: String = "low", isEnabled: Bool = true) {
+ self.parameterName = parameterName
+ self.parameterValue = parameterValue
+ self.isEnabled = isEnabled
+ }
+
+ /// Common presets for different model types
+ static let openAIGPT5 = ModelReasoningConfig(parameterName: "reasoning_effort", parameterValue: "low", isEnabled: true)
+ static let openAIO1 = ModelReasoningConfig(parameterName: "reasoning_effort", parameterValue: "medium", isEnabled: true)
+ static let groqGPTOSS = ModelReasoningConfig(parameterName: "reasoning_effort", parameterValue: "low", isEnabled: true)
+ static let deepSeekReasoner = ModelReasoningConfig(parameterName: "enable_thinking", parameterValue: "true", isEnabled: true)
+ static let disabled = ModelReasoningConfig(parameterName: "", parameterValue: "", isEnabled: false)
+ }
struct SavedProvider: Codable, Identifiable, Hashable
{
@@ -142,6 +172,17 @@ final class SettingsStore: ObservableObject
persistProviderAPIKeys(newValue)
}
}
+
+ /// Securely retrieve API key for a provider, handling custom prefix logic
+ func getAPIKey(for providerID: String) -> String? {
+ let keys = providerAPIKeys
+ // Try exact match first
+ if let key = keys[providerID] { return key }
+
+ // Try canonical key format (custom:ID)
+ let canonical = canonicalProviderKey(for: providerID)
+ return keys[canonical]
+ }
var selectedProviderID: String
{
@@ -454,6 +495,83 @@ final class SettingsStore: ObservableObject
}
}
+ // MARK: - Model Reasoning Configuration
+
+ /// Per-model reasoning configuration storage
+ /// Key format: "provider:model" (e.g., "openai:gpt-5.1", "groq:gpt-oss-120b")
+ var modelReasoningConfigs: [String: ModelReasoningConfig]
+ {
+ get {
+ guard let data = defaults.data(forKey: Keys.modelReasoningConfigs),
+ let decoded = try? JSONDecoder().decode([String: ModelReasoningConfig].self, from: data) else {
+ return [:]
+ }
+ return decoded
+ }
+ set {
+ objectWillChange.send()
+ if let encoded = try? JSONEncoder().encode(newValue) {
+ defaults.set(encoded, forKey: Keys.modelReasoningConfigs)
+ }
+ }
+ }
+
+ /// Get reasoning config for a specific model, with smart defaults for known models
+ func getReasoningConfig(forModel model: String, provider: String) -> ModelReasoningConfig? {
+ let key = "\(provider):\(model)"
+
+ // First check if user has a custom config
+ if let customConfig = modelReasoningConfigs[key] {
+ return customConfig.isEnabled ? customConfig : nil
+ }
+
+ // Apply smart defaults for known model patterns
+ let modelLower = model.lowercased()
+
+ // OpenAI gpt-5.x models
+ if modelLower.hasPrefix("gpt-5") || modelLower.contains("gpt-5.") {
+ return .openAIGPT5
+ }
+
+ // OpenAI o1/o3 reasoning models
+ if modelLower.hasPrefix("o1") || modelLower.hasPrefix("o3") {
+ return .openAIO1
+ }
+
+ // Groq gpt-oss models
+ if modelLower.contains("gpt-oss") || modelLower.hasPrefix("openai/") {
+ return .groqGPTOSS
+ }
+
+ // DeepSeek reasoner models
+ if modelLower.contains("deepseek") && modelLower.contains("reasoner") {
+ return .deepSeekReasoner
+ }
+
+ // No reasoning config needed for standard models (gpt-4.x, claude, llama, etc.)
+ return nil
+ }
+
+ /// Set reasoning config for a specific model
+ func setReasoningConfig(_ config: ModelReasoningConfig?, forModel model: String, provider: String) {
+ let key = "\(provider):\(model)"
+ var configs = modelReasoningConfigs
+
+ if let config = config {
+ configs[key] = config
+ } else {
+ configs.removeValue(forKey: key)
+ }
+
+ modelReasoningConfigs = configs
+ }
+
+ /// Check if a model has a custom (user-defined) reasoning config
+ func hasCustomReasoningConfig(forModel model: String, provider: String) -> Bool {
+ let key = "\(provider):\(model)"
+ return modelReasoningConfigs[key] != nil
+ }
+
// MARK: - Stats Settings
/// User's typing speed in words per minute (for time saved calculation)
diff --git a/Sources/Fluid/Services/CommandModeService.swift b/Sources/Fluid/Services/CommandModeService.swift
index 4a299b8b..d928d70d 100644
--- a/Sources/Fluid/Services/CommandModeService.swift
+++ b/Sources/Fluid/Services/CommandModeService.swift
@@ -643,7 +643,7 @@ final class CommandModeService: ObservableObject {
// Use Command Mode's independent provider/model settings
let providerID = settings.commandModeSelectedProviderID
let model = settings.commandModeSelectedModel ?? "gpt-4o"
- let apiKey = settings.providerAPIKeys[providerID] ?? ""
+ let apiKey = settings.getAPIKey(for: providerID) ?? ""
let baseURL: String
if let provider = settings.savedProviders.first(where: { $0.id == providerID }) {
@@ -784,12 +784,14 @@ final class CommandModeService: ObservableObject {
let enableStreaming = SettingsStore.shared.enableAIStreaming
// Build request
+ let isReasoningModel = model.hasPrefix("o1") || model.hasPrefix("o3") || model.hasPrefix("gpt-5")
+
var body: [String: Any] = [
"model": model,
"messages": messages,
"tools": [TerminalService.toolDefinition],
"tool_choice": "auto",
- "temperature": 0.1
+ "temperature": isReasoningModel ? 1.0 : 0.1
]
if enableStreaming {
diff --git a/Sources/Fluid/Services/RewriteModeService.swift b/Sources/Fluid/Services/RewriteModeService.swift
index 1d739eb2..3163049b 100644
--- a/Sources/Fluid/Services/RewriteModeService.swift
+++ b/Sources/Fluid/Services/RewriteModeService.swift
@@ -128,7 +128,7 @@ final class RewriteModeService: ObservableObject {
}
let model = settings.rewriteModeSelectedModel ?? "gpt-4o"
- let apiKey = settings.providerAPIKeys[providerID] ?? ""
+ let apiKey = settings.getAPIKey(for: providerID) ?? ""
let baseURL: String
if let provider = settings.savedProviders.first(where: { $0.id == providerID }) {
@@ -180,10 +180,12 @@ final class RewriteModeService: ObservableObject {
// Check streaming setting
let enableStreaming = settings.enableAIStreaming
+ let isReasoningModel = model.hasPrefix("o1") || model.hasPrefix("o3") || model.hasPrefix("gpt-5")
+
var body: [String: Any] = [
"model": model,
"messages": apiMessages,
- "temperature": 0.7
+ "temperature": isReasoningModel ? 1.0 : 0.7
]
if enableStreaming {