Cleanup

Author: aure

Sources/CompilerSwiftAI/Auth/KeychainHelper.swift

@@ -4,7 +4,7 @@ import AuthenticationServices
 import SwiftUI
 
 /// Helper for Keychain operations
-actor KeychainHelper: Actor {
+actor KeychainHelper {
     static let standard = KeychainHelper()
 
     func save(_ data: String, service: String, account: String) async {

Sources/CompilerSwiftAI/Model Calling/CompilerClient+Streaming.swift

@@ -129,9 +129,9 @@ extension CompilerClient {
 
         // Capture metadata values before the closure to prevent data races
         let provider = metadata.provider
-        let modelID = metadata.id
+        let modelID = metadata.modelID
         let capabilities = metadata.capabilities
-        let capturedMetadata = ModelMetadata(provider: provider, capabilities: capabilities, id: modelID)
+        let capturedMetadata = ModelMetadata(provider: provider, capabilities: capabilities, modelID: modelID)
 
         return AsyncThrowingStream { continuation in
             Task {

Sources/CompilerSwiftAI/Model Calling/Message.swift

@@ -0,0 +1,49 @@
+//  Copyright © 2025 Compiler, Inc. All rights reserved.
+
+import Combine
+import SwiftUI
+
+struct Message: Codable, Sendable, Identifiable, Equatable {
+    let id: UUID
+    let role: Role
+    let content: String
+    var state: MessageState
+    
+    enum Role: String, Codable, Sendable {
+        case system
+        case user
+        case assistant
+    }
+    
+    enum MessageState: Codable, Sendable, Equatable {
+        case complete
+        case streaming(String)
+        
+        var isStreaming: Bool {
+            if case .streaming = self { return true }
+            return false
+        }
+        
+        var currentContent: String {
+            switch self {
+            case .complete: return ""
+            case .streaming(let partial): return partial
+            }
+        }
+    }
+    
+    init(role: Role, content: String) {
+        self.id = UUID()
+        self.role = role
+        self.content = content
+        self.state = .complete
+    }
+    
+    init(id: UUID = UUID(), role: Role, content: String, state: MessageState = .complete) {
+        self.id = id
+        self.role = role
+        self.content = content
+        self.state = state
+    }
+}
+

Sources/CompilerSwiftAI/Model Calling/ModelCall.swift

@@ -11,12 +11,12 @@ struct APIMessage: Codable {
 /// Request format for model calls, matching the backend API contract
 struct ModelCallRequest: Codable {
     let provider: ModelProvider
-    let model: ModelID
+    let modelID: ModelID
     let messages: [APIMessage]
 
     init(using metadata: ModelMetadata, messages: [Message]) {
         self.provider = metadata.provider
-        self.model = metadata.id
+        self.modelID = metadata.modelID
 
         Logger.modelCalls.debug("Converting \(messages.count) messages to API format")
         let apiMessages = messages.map { message in

Sources/CompilerSwiftAI/Model Calling/ModelMetadata.swift

@@ -13,81 +13,37 @@ enum ModelCapability: String, Codable, Sendable, Equatable {
 }
 
 struct ModelMetadata: Codable, Sendable, Equatable {
-    let id: ModelID
+    let modelID: ModelID
     let provider: ModelProvider
     let capabilities: [ModelCapability]
 
-    init(provider: ModelProvider, capabilities: [ModelCapability] = [.chat], id: ModelID) {
+    init(provider: ModelProvider, capabilities: [ModelCapability] = [.chat], modelID: ModelID) {
         self.provider = provider
         self.capabilities = capabilities
-        self.id = id
+        self.modelID = modelID
     }
 
     // Convenience initializers for each provider's Models
     static func openAI(_ model: OpenAIModel) -> ModelMetadata {
-        ModelMetadata(provider: .OpenAI, id: model.rawValue)
+        ModelMetadata(provider: .OpenAI, modelID: model.rawValue)
     }
 
     static func anthropic(_ model: AnthropicModel) -> ModelMetadata {
-        ModelMetadata(provider: .Anthropic, id: model.rawValue)
+        ModelMetadata(provider: .Anthropic, modelID: model.rawValue)
     }
 
     static func perplexity(_ model: PerplexityModel) -> ModelMetadata {
-        ModelMetadata(provider: .Perplexity, id: model.rawValue)
+        ModelMetadata(provider: .Perplexity, modelID: model.rawValue)
     }
 
     static func deepseek(_ model: DeepSeekModel) -> ModelMetadata {
-        ModelMetadata(provider: .DeepSeek, id: model.rawValue)
+        ModelMetadata(provider: .DeepSeek, modelID: model.rawValue)
     }
 
     static func == (lhs: ModelMetadata, rhs: ModelMetadata) -> Bool {
-        lhs.id == rhs.id
+        lhs.modelID == rhs.modelID
         && lhs.provider == rhs.provider
         && lhs.capabilities == rhs.capabilities
     }
 }
 
-struct Message: Codable, Sendable, Identifiable, Equatable {
-    let id: UUID
-    let role: Role
-    let content: String
-    var state: MessageState
-    
-    enum Role: String, Codable, Sendable {
-        case system
-        case user
-        case assistant
-    }
-    
-    enum MessageState: Codable, Sendable, Equatable {
-        case complete
-        case streaming(String)
-        
-        var isStreaming: Bool {
-            if case .streaming = self { return true }
-            return false
-        }
-        
-        var currentContent: String {
-            switch self {
-            case .complete: return ""
-            case .streaming(let partial): return partial
-            }
-        }
-    }
-    
-    init(role: Role, content: String) {
-        self.id = UUID()
-        self.role = role
-        self.content = content
-        self.state = .complete
-    }
-    
-    init(id: UUID = UUID(), role: Role, content: String, state: MessageState = .complete) {
-        self.id = id
-        self.role = role
-        self.content = content
-        self.state = state
-    }
-}
-