wip: adding models and Configuration

Author: maksutovic

Sources/CompilerSwiftAI/CompilerClient.swift

@@ -4,10 +4,28 @@ 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
+        
+        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 baseURL: String = "https://backend.compiler.inc"
+    internal let baseURL: String = "http://localhost:3000"
     internal let keychain: KeychainHelper = KeychainHelper.standard
     internal let functionLogger: DebugLogger
     internal let modelLogger: DebugLogger
@@ -16,11 +34,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+Streaming.swift

@@ -54,10 +54,11 @@ extension CompilerClient {
         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) }
@@ -105,9 +106,12 @@ extension CompilerClient {
                         // 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("Yielding content of length: \(trimmedContent.count)")
 
-                        // Yield the content
+                        // Yield the content directly - server handles JSON extraction
                         continuation.yield(trimmedContent)
+                        
+                        modelLogger.debug("Content yielded successfully")
                     }
 
                     modelLogger.debug("SSE stream complete")

Sources/CompilerSwiftAI/Model Calling/Message.swift

@@ -9,6 +9,24 @@ struct Message: Codable, Sendable, Identifiable, Equatable {
     let content: [Content]
     var state: MessageState
 
+    private enum CodingKeys: String, CodingKey {
+        case role, content
+    }
+    
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.id = UUID()  // Generate new UUID on decode since we don't send it
+        self.role = try container.decode(Role.self, forKey: .role)
+        self.content = try container.decode([Content].self, forKey: .content)
+        self.state = .complete  // Default to complete state when decoding
+    }
+    
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(role, forKey: .role)
+        try container.encode(content, forKey: .content)
+    }
+    
     enum Role: String, Codable, Sendable {
         case system
         case user
@@ -28,33 +46,24 @@ struct Message: Codable, Sendable, Identifiable, Equatable {
             case text(String)
             case image(ImageContent)
 
-            private enum CodingKeys: String, CodingKey {
-                case type, content
-            }
-            
             func encode(to encoder: Encoder) throws {
-                var container = encoder.container(keyedBy: CodingKeys.self)
+                var container = encoder.singleValueContainer()
                 switch self {
                 case .text(let text):
-                    try container.encode(text, forKey: .content)
+                    try container.encode(text)
                 case .image(let imageContent):
-                    try container.encode(imageContent, forKey: .content)
+                    try container.encode(imageContent)
                 }
             }
 
             init(from decoder: Decoder) throws {
-                let container = try decoder.container(keyedBy: CodingKeys.self)
-                let type = try container.decode(String.self, forKey: .type)
-                
-                switch type {
-                case "text":
-                    let text = try container.decode(String.self, forKey: .content)
+                let container = try decoder.singleValueContainer()
+                if let text = try? container.decode(String.self) {
                     self = .text(text)
-                case "image":
-                    let imageContent = try container.decode(ImageContent.self, forKey: .content)
+                } else if let imageContent = try? container.decode(ImageContent.self) {
                     self = .image(imageContent)
-                default:
-                    throw DecodingError.dataCorruptedError(forKey: .type, in: container, debugDescription: "Unknown content type")
+                } else {
+                    throw DecodingError.dataCorruptedError(in: container, debugDescription: "Unable to decode ContentData")
                 }
             }
         }

Sources/CompilerSwiftAI/Model Calling/ModelCall.swift

@@ -52,6 +52,23 @@ struct StreamRequest: ModelCallRequestBase {
 
         Logger.modelCalls.debug("Preparing stream request with \(messages.count) messages")
     }
+    
+    private enum CodingKeys: String, CodingKey {
+        case provider, model, messages, temperature, maxTokens
+    }
+    
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        try container.encode(provider, forKey: .provider)
+        try container.encode(model, forKey: .model)
+        try container.encode(messages, forKey: .messages)
+        if let temperature = temperature {
+            try container.encode(temperature, forKey: .temperature)
+        }
+        if let maxTokens = maxTokens {
+            try container.encode(maxTokens, forKey: .maxTokens)
+        }
+    }
 }
 
 /// Response format for completion calls

Sources/CompilerSwiftAI/Model Calling/Models.swift

@@ -1,23 +1,23 @@
 //  Copyright © 2025 Compiler, Inc. All rights reserved.
 
 /// AI Models supported by Compiler
-enum ModelProvider: String, Codable, Sendable, Equatable {
+public enum ModelProvider: String, Codable, Sendable, Equatable {
     case openai
     case anthropic
     case perplexity
     case deepseek
     case gemini
 }
 
-enum OpenAIModel: String, Codable {
+public enum OpenAIModel: String, Codable {
     case gpt4o = "chatgpt-4o-latest"
     case gpt4oMini = "gpt-4o-mini"
     case o1 = "o1"
     case o1Mini = "o1-mini"
     case o3Mini = "o3-mini"
 }
 
-enum GeminiModel: String, Codable {
+public enum GeminiModel: String, Codable {
     case flash = "gemini-2.0-flash"
     case flashLitePreview = "gemini-2.0-flash-lite-preview-02-05"
     case flash15 = "gemini-1.5-flash"
@@ -26,18 +26,18 @@ enum GeminiModel: String, Codable {
     case textEmbedding = "text-embedding-004"
 }
 
-enum AnthropicModel: String, Codable {
+public enum AnthropicModel: String, Codable {
     case claudeSonnet = "claude-3-5-sonnet-latest"
     case claudeHaiku = "claude-3-5-haiku-latest"
     case claudeOpus = "claude-3-5-opus-latest"
 }
 
-enum PerplexityModel: String, Codable {
+public enum PerplexityModel: String, Codable {
     case sonarReasoning = "sonar-reasoning"
     case sonarPro = "sonar-pro"
     case sonar = "sonar"
 } 
-enum DeepSeekModel: String, Codable {
+public enum DeepSeekModel: String, Codable {
     case chat = "deepseek-chat"
     case reasoner = "deepseek-reasoner"
 }

Sources/CompilerSwiftAI/Model Calling/StreamConfiguration.swift

@@ -0,0 +1,123 @@
+//  Copyright © 2025 Compiler, Inc. All rights reserved.
+
+import Foundation
+
+/// Configuration for streaming chat sessions
+public struct StreamConfiguration: Sendable {
+    // Internal access to metadata
+    internal let metadata: ModelMetadata
+    
+    // Internal init for SDK use
+    internal init(metadata: ModelMetadata) {
+        self.metadata = metadata
+    }
+    
+    /// Create a streaming configuration with raw values
+    public init(
+        provider: ModelProvider,
+        model: Model,
+        temperature: Float? = nil,
+        maxTokens: Int? = nil
+    ) {
+        self.metadata = ModelMetadata(
+            provider: provider,
+            capabilities: [.chat],
+            model: model,
+            temperature: temperature,
+            maxTokens: maxTokens
+        )
+    }
+}
+
+// MARK: - Public Factory Methods
+public extension StreamConfiguration {
+    /// Create an OpenAI streaming configuration
+    /// - Parameters:
+    ///   - model: The OpenAI model to use
+    ///   - temperature: Optional temperature parameter (0.0 - 1.0)
+    ///   - maxTokens: Optional maximum tokens to generate
+    static func openAI(
+        _ model: OpenAIModel,
+        temperature: Float? = nil,
+        maxTokens: Int? = nil
+    ) -> StreamConfiguration {
+        .init(metadata: ModelMetadata(
+            provider: .openai,
+            model: model.rawValue,
+            temperature: temperature,
+            maxTokens: maxTokens
+        ))
+    }
+    
+    /// Create an Anthropic streaming configuration
+    /// - Parameters:
+    ///   - model: The Anthropic model to use
+    ///   - temperature: Optional temperature parameter (0.0 - 1.0)
+    ///   - maxTokens: Optional maximum tokens to generate
+    static func anthropic(
+        _ model: AnthropicModel,
+        temperature: Float? = nil,
+        maxTokens: Int? = nil
+    ) -> StreamConfiguration {
+        .init(metadata: ModelMetadata(
+            provider: .anthropic,
+            model: model.rawValue,
+            temperature: temperature,
+            maxTokens: maxTokens
+        ))
+    }
+    
+    /// Create a Perplexity streaming configuration
+    /// - Parameters:
+    ///   - model: The Perplexity model to use
+    ///   - temperature: Optional temperature parameter (0.0 - 1.0)
+    ///   - maxTokens: Optional maximum tokens to generate
+    static func perplexity(
+        _ model: PerplexityModel,
+        temperature: Float? = nil,
+        maxTokens: Int? = nil
+    ) -> StreamConfiguration {
+        .init(metadata: ModelMetadata(
+            provider: .perplexity,
+            model: model.rawValue,
+            temperature: temperature,
+            maxTokens: maxTokens
+        ))
+    }
+    
+    /// Create a DeepSeek streaming configuration
+    /// - Parameters:
+    ///   - model: The DeepSeek model to use
+    ///   - temperature: Optional temperature parameter (0.0 - 1.0)
+    ///   - maxTokens: Optional maximum tokens to generate
+    static func deepseek(
+        _ model: DeepSeekModel,
+        temperature: Float? = nil,
+        maxTokens: Int? = nil
+    ) -> StreamConfiguration {
+        .init(metadata: ModelMetadata(
+            provider: .deepseek,
+            model: model.rawValue,
+            temperature: temperature,
+            maxTokens: maxTokens
+        ))
+    }
+    
+    /// Create a Gemini streaming configuration
+    /// - Parameters:
+    ///   - model: The Gemini model to use
+    ///   - temperature: Optional temperature parameter (0.0 - 1.0)
+    ///   - maxTokens: Optional maximum tokens to generate
+    static func gemini(
+        _ model: GeminiModel,
+        temperature: Float? = nil,
+        maxTokens: Int? = nil
+    ) -> StreamConfiguration {
+        .init(metadata: ModelMetadata(
+            provider: .gemini,
+            model: model.rawValue,
+            temperature: temperature,
+            maxTokens: maxTokens
+        ))
+    }
+} 

Sources/CompilerSwiftAI/UI/Chat/ChatView/ChatViewModel.swift

@@ -193,7 +193,9 @@ class ChatViewModel: Transcribable {
                 let messagesSoFar = await self.chatHistory.messages
                 self.logger.log("Calling service.streamModelResponse with \(messagesSoFar.count) messages.")
 
-                let stream = await self.client.streamModelResponse(using: .openAI(.gpt4oMini), messages: messagesSoFar)
+                // Get immutable streaming configuration
+                let config = await self.client.makeStreamingSession()
+                let stream = await self.client.streamModelResponse(using: config.metadata, messages: messagesSoFar)
 
                 var chunkCount = 0
                 for try await partialMessage in stream {