Merge pull request #2 from Compiler-Inc/add/more-models

feat: add support for more providers and models

Author: maksutovic

Sources/CompilerSwiftAI/Auth/CompilerCient+AppleAuth.swift

@@ -3,7 +3,7 @@
 import AuthenticationServices
 
 extension CompilerClient {
-    public func handleSignInWithApple(_ result: Result<ASAuthorization, Error>) async throws -> Bool {
+    public func handleSignInWithApple(_ result: Result<ASAuthorization, Error>, nonce: String?) async throws -> Bool {
         switch result {
         case .success(let auth):
             guard let appleIDCredential = auth.credential as? ASAuthorizationAppleIDCredential,
@@ -12,11 +12,15 @@ extension CompilerClient {
                 throw AuthError.invalidToken
             }
 
-            // Store Apple ID token - this acts as our "refresh token"
-            // Apple ID tokens can be reused for a while (usually days to weeks)
+            // Store Apple ID token
             await keychain.save(idToken, service: "apple-id-token", account: "user")
 
-            let accessToken = try await authenticateWithServer(idToken: idToken)
+            // Store the nonce for verification
+            if let nonce = nonce {
+                await keychain.save(nonce, service: "apple-nonce", account: "user")
+            }
+            
+            let accessToken = try await authenticateWithServer(idToken: idToken, nonce: nonce)
             await keychain.save(accessToken, service: "access-token", account: "user")
 
             return true

Sources/CompilerSwiftAI/Auth/CompilerClient+Auth.swift

@@ -28,21 +28,23 @@ extension CompilerClient {
         throw AuthError.invalidToken
     }
 
-    func authenticateWithServer(idToken: String) async throws -> String {
+    func authenticateWithServer(idToken: String, nonce: String? = nil) async throws -> String {
         let lowercasedAppID = appID.uuidString.lowercased()
         let endpoint = "\(baseURL)/v1/apps/\(lowercasedAppID)/end-users/apple"
         guard let url = URL(string: endpoint) else {
             authLogger.error("Invalid URL: \(self.baseURL)")
             throw AuthError.invalidResponse
         }
 
+        var body: [String: String] = ["id_token": idToken]
+        if let nonce {
+            body["nonce"] = nonce
+        }
         authLogger.debug("Making auth request to: \(endpoint)")
 
         var request = URLRequest(url: url)
         request.httpMethod = "POST"
         request.setValue("application/json", forHTTPHeaderField: "Content-Type")
-        
-        let body = ["id_token": idToken]
         request.httpBody = try JSONEncoder().encode(body)
 
         authLogger.debug("Request body: \(body)")

Sources/CompilerSwiftAI/Auth/CompilerClient+Nonce.swift

@@ -0,0 +1,47 @@
+import CryptoKit
+import AuthenticationServices
+
+extension CompilerClient {
+    // Generate a random nonce for authentication
+    public static func randomNonceString(length: Int = 32) -> String {
+        precondition(length > 0)
+        let charset: [Character] = Array("0123456789ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvwxyz-._")
+        var result = ""
+        var remainingLength = length
+        
+        while remainingLength > 0 {
+            let randoms: [UInt8] = (0 ..< 16).map { _ in
+                var random: UInt8 = 0
+                let errorCode = SecRandomCopyBytes(kSecRandomDefault, 1, &random)
+                if errorCode != errSecSuccess {
+                    fatalError("Unable to generate nonce. SecRandomCopyBytes failed with OSStatus \(errorCode)")
+                }
+                return random
+            }
+            
+            randoms.forEach { random in
+                if remainingLength == 0 {
+                    return
+                }
+                
+                if random < charset.count {
+                    result.append(charset[Int(random)])
+                    remainingLength -= 1
+                }
+            }
+        }
+        
+        return result
+    }
+    
+    // Compute the SHA256 hash of a string
+    public static func sha256(_ input: String) -> String {
+        let inputData = Data(input.utf8)
+        let hashedData = SHA256.hash(data: inputData)
+        let hashString = hashedData.compactMap {
+            String(format: "%02x", $0)
+        }.joined()
+        
+        return hashString
+    }
+}

Sources/CompilerSwiftAI/CompilerClient.swift

@@ -4,8 +4,29 @@ import OSLog
 
 /// Primary interface for interacting with Compiler's Back End
 public final actor CompilerClient {
+    public struct Configuration {
+        /// Current streaming configuration
+        public var streamingChat: StreamConfiguration
+        /// Whether to enable debug logging
+        public var enableDebugLogging: Bool
+        
+        /// Initialize a new Configuration instance
+        /// - Parameters:
+        ///   - streamingChat: The streaming configuration to use for chat interactions, defaults to OpenAI GPT-4
+        ///   - enableDebugLogging: Whether to enable detailed debug logging output, defaults to false
+        public init(
+            streamingChat: StreamConfiguration = .openAI(.gpt4o),
+            enableDebugLogging: Bool = false
+        ) {
+            self.streamingChat = streamingChat
+            self.enableDebugLogging = enableDebugLogging
+        }
+    }
+    
     /// Application ID (retrievable from the Comiler Developer Dashboard)
     let appID: UUID
+    
+    private(set) var configuration: Configuration
 
     internal let baseURL: String = "https://backend.compiler.inc"
     internal let keychain: KeychainHelper = KeychainHelper.standard
@@ -16,11 +37,29 @@ public final actor CompilerClient {
     /// Initialize the Compiler Client
     /// - Parameters:
     ///   - appID: Application ID (retrievable from the Comiler Developer Dashboard)
-    ///   - enableDebugLogging: Whether or not to log debug info
-    public init(appID: UUID, enableDebugLogging: Bool = false) {
+    ///   - configuration: Client configuration including streaming chat settings and debug options
+    public init(
+        appID: UUID, 
+        configuration: Configuration = Configuration()
+    ) {
         self.appID = appID
-        self.functionLogger = DebugLogger(Logger.functionCalls, isEnabled: enableDebugLogging)
-        self.modelLogger = DebugLogger(Logger.modelCalls, isEnabled: enableDebugLogging)
-        self.authLogger = DebugLogger(Logger.auth, isEnabled: enableDebugLogging)
+        self.configuration = configuration
+        self.functionLogger = DebugLogger(Logger.functionCalls, isEnabled: configuration.enableDebugLogging)
+        self.modelLogger = DebugLogger(Logger.modelCalls, isEnabled: configuration.enableDebugLogging)
+        self.authLogger = DebugLogger(Logger.auth, isEnabled: configuration.enableDebugLogging)
+    }
+    
+    /// Update streaming chat configuration
+    /// - Parameter update: Closure that takes an inout StreamConfiguration parameter
+    public func updateStreamingChat(
+        _ update: (inout StreamConfiguration) -> Void
+    ) {
+        update(&configuration.streamingChat)
+    }
+    
+    /// Creates an immutable streaming session configuration
+    /// This captures the current streaming configuration at a point in time
+    public func makeStreamingSession() -> StreamConfiguration {
+        configuration.streamingChat
     }
 }

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

@@ -6,31 +6,32 @@ extension CompilerClient {
 
     func makeModelCall(
         using metadata: ModelMetadata,
-        messages: [Message],
+        systemPrompt: String? = nil,
+        userPrompt: String,
         state: (any Codable & Sendable)? = nil
     ) async throws -> String {
         let response = try await makeModelCallWithResponse(
             using: metadata,
-            messages: messages,
+            systemPrompt: systemPrompt,
+            userPrompt: userPrompt,
             state: state
         )
         return response.content
     }
 
     func makeModelCallWithResponse(
         using metadata: ModelMetadata,
-        messages: [Message],
+        systemPrompt: String? = nil,
+        userPrompt: String,
         state: (any Codable & Sendable)? = nil
-    ) async throws -> ModelCallResponse {
+    ) async throws -> CompletionResponse {
         let endpoint = "\(baseURL)/v1/apps/\(appID.uuidString)/end-users/model-call"
         guard let url = URL(string: endpoint) else {
             modelLogger.error("Invalid URL: \(self.baseURL)")
             throw URLError(.badURL)
         }
 
-        modelLogger.debug("Making model call to: \(endpoint)")
-        modelLogger.debug("Using \(messages.count) messages")
-        modelLogger.debug("Message roles: \(messages.map { $0.role.rawValue })")
+        modelLogger.debug("Making completion model call to: \(endpoint)")
 
         var request = URLRequest(url: url)
         request.httpMethod = "POST"
@@ -39,25 +40,13 @@ extension CompilerClient {
         let token = try await getValidToken()
         request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
 
-        // If state is provided, append it to the last user message
-        let finalMessages: [Message]
-        if let state = state,
-           let lastUserMessageIndex = messages.lastIndex(where: { $0.role == .user }) {
-            var modifiedMessages = messages
-            let lastUserMessage = modifiedMessages[lastUserMessageIndex]
-            modifiedMessages[lastUserMessageIndex] = Message(
-                id: lastUserMessage.id,
-                role: .user,
-                content: "\(lastUserMessage.content)\n\nThe current app state is: \(state)"
-            )
-            finalMessages = modifiedMessages
-        } else {
-            finalMessages = messages
-        }
+        // If state is provided, append it to the userPrompt
+        let finalUserPrompt = state.map { "\(userPrompt)\n\nThe current app state is: \($0)" } ?? userPrompt
 
-        let body = ModelCallRequest(
+        let body = CompletionRequest(
             using: metadata,
-            messages: finalMessages
+            systemPrompt: systemPrompt,
+            userPrompt: finalUserPrompt
         )
 
         let encoder = JSONEncoder()
@@ -86,6 +75,6 @@ extension CompilerClient {
             throw AuthError.serverError("Model call failed with status \(httpResponse.statusCode)")
         }
 
-        return try JSONDecoder().decode(ModelCallResponse.self, from: data)
+        return try JSONDecoder().decode(CompletionResponse.self, from: data)
     }
 }

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

@@ -2,8 +2,12 @@
 
 import OSLog
 
+struct ChatResponseDataTransferObject: Decodable {
+    let content: String
+}
+
 extension CompilerClient {
-    var streamingProviders: [ModelProvider] { [.openai, .anthropic] }
+    var streamingProviders: [ModelProvider] { [.openai, .anthropic, .google] }
 
     // Specialized String streaming version
     func makeStreamingModelCall(
@@ -35,28 +39,30 @@ extension CompilerClient {
            let lastUserMessageIndex = messages.lastIndex(where: { $0.role == .user }) {
             var modifiedMessages = messages
             let lastUserMessage = modifiedMessages[lastUserMessageIndex]
+            let stateContent = "\(lastUserMessage.content)\n\nThe current app state is: \(state)"
             modifiedMessages[lastUserMessageIndex] = Message(
                 id: lastUserMessage.id,
                 role: .user,
-                content: "\(lastUserMessage.content)\n\nThe current app state is: \(state)"
+                content: stateContent
             )
             finalMessages = modifiedMessages
         } else {
             finalMessages = messages
         }
 
-        let body = ModelCallRequest(
+        let body = StreamRequest(
             using: metadata,
             messages: finalMessages
         )
 
         do {
             let encoder = JSONEncoder()
             encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
-            let jsonData = try encoder.encode(body)
-            request.httpBody = jsonData
 
-            modelLogger.debug("Streaming request body JSON: \(String(data: jsonData, encoding: .utf8) ?? "nil")")
+            // AppId is only in the endpoint URL, not in query params or body
+            request.httpBody = try encoder.encode(body)
+            
+            modelLogger.debug("Streaming request body JSON: \(String(data: request.httpBody ?? Data(), encoding: .utf8) ?? "nil")")
         } catch {
             modelLogger.error("Failed to encode request: \(error)")
             return AsyncThrowingStream { $0.finish(throwing: error) }
@@ -83,30 +89,17 @@ extension CompilerClient {
                     }
 
                     for try await line in asyncBytes.lines {
-                        modelLogger.debug("Raw SSE line [\(line.count) bytes]: \(line)")
-                        
-                        // Skip non-SSE lines (like id: lines)
-                        guard line.hasPrefix("data:") else {
-                            modelLogger.debug("Skipping non-SSE line")
-                            continue
-                        }
-                        
-                        // Get everything after "data:"
-                        let content = String(line.dropFirst("data:".count))
+                        modelLogger.debug("Raw SSE line: \(line)")
 
-                        // If it's just a space or empty after "data:", yield a newline
-                        if content.trimmingCharacters(in: .whitespaces).isEmpty {
-                            modelLogger.debug("Empty data line - yielding newline")
-                            continuation.yield("\n")
+                        guard let content = try parseChatResponse(from: line) else {
                             continue
                         }
 
-                        // For non-empty content, trim just the leading space after "data:"
-                        let trimmedContent = content.hasPrefix(" ") ? String(content.dropFirst()) : content
-                        modelLogger.debug("Content: \(trimmedContent.debugDescription)")
+                        modelLogger.debug("Content: \(content.debugDescription)")
 
-                        // Yield the content
-                        continuation.yield(trimmedContent)
+                        continuation.yield(content)
+
+                        modelLogger.debug("Content yielded successfully")
                     }
 
                     modelLogger.debug("SSE stream complete")
@@ -131,7 +124,15 @@ extension CompilerClient {
         let provider = metadata.provider
         let model = metadata.model
         let capabilities = metadata.capabilities
-        let capturedMetadata = ModelMetadata(provider: provider, capabilities: capabilities, model: model)
+        let temperature = metadata.temperature
+        let maxTokens = metadata.maxTokens
+        let capturedMetadata = ModelMetadata(
+            provider: provider,
+            capabilities: capabilities,
+            model: model,
+            temperature: temperature,
+            maxTokens: maxTokens
+        )
 
         return AsyncThrowingStream { continuation in
             Task {
@@ -162,4 +163,40 @@ extension CompilerClient {
             }
         }
     }
+    
+    private func parseChatResponse(from line: String) throws -> String? {
+        // Skip empty lines and comments
+        guard !line.isEmpty, !line.hasPrefix(":") else {
+            return nil
+        }
+        
+        // Extract the data part from the SSE format
+        guard line.hasPrefix("data: ") else {
+            return nil
+        }
+        
+        let jsonString = String(line.dropFirst(6))
+        
+        guard let parsedResponse = try? parseEventMessage(from: jsonString) else {
+            print("Couldn't parse repsonse")
+            return nil
+        }
+        
+        return parsedResponse.content
+    }
+    
+    private func parseEventMessage(from line: String) throws -> ChatResponseDataTransferObject? {
+        guard let data = line.data(using: .utf8) else {
+            print("[ChatStreamer] ❌ Failed to convert string to data: \(line)")
+            return nil
+        }
+
+        do {
+            let message = try JSONDecoder().decode(ChatResponseDataTransferObject.self, from: data)
+            return message
+        } catch {
+            print("[ChatStreamer] ❌ JSON decode error: \(error)")
+            return nil
+        }
+    }
 }