feat: parsing JSON chunks

Author: Atharva Vaidya

Sources/CompilerSwiftAI/Model Calling/ChatResponseDTO.swift

@@ -0,0 +1,12 @@
+//
+//  File.swift
+//  CompilerSwiftAI
+//
+//  Created by Atharva Vaidya on 2/23/25.
+//
+
+import Foundation
+
+struct ChatResponseDTO: Decodable {
+    let content: String
+}

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

@@ -85,32 +85,16 @@ extension CompilerClient {
                     }
 
                     for try await line in asyncBytes.lines {
-                        modelLogger.debug("Raw SSE line [\(line.count) bytes]: \(line)")
+                        modelLogger.debug("Raw SSE line: \(line)")
 
-                        // Skip non-SSE lines (like id: lines)
-                        guard line.hasPrefix("data:") else {
-                            modelLogger.debug("Skipping non-SSE line")
+                        guard let content = try parseChatResponse(from: line) else {
                             continue
                         }
 
-                        // Get everything after "data:"
-                        let content = String(line.dropFirst("data:".count))
-                        
-                        // 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")
-                            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("Yielding content of length: \(trimmedContent.count)")
-                        
-                        // Yield the content directly - server handles JSON extraction
-                        continuation.yield(trimmedContent)
+                        modelLogger.debug("Content: \(content.debugDescription)")
 
+                        continuation.yield(content)
+
                         modelLogger.debug("Content yielded successfully")
                     }
 
@@ -175,4 +159,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 -> ChatResponseDTO? {
+        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(ChatResponseDTO.self, from: data)
+            return message
+        } catch {
+            print("[ChatStreamer] ❌ JSON decode error: \(error)")
+            return nil
+        }
+    }
 }

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

@@ -130,7 +130,7 @@ class ChatViewModel: Transcribable {
     private func observeMessageStream() async {
         let throttleInterval: TimeInterval = 0.15
         var lastUpdateTime = Date.distantPast
-        var lastMessages: [Message] = []
+//        var lastMessages: [Message] = []
 
         logger.log("observeMessageStream started. Now waiting for new messages...")
 
@@ -143,33 +143,33 @@ class ChatViewModel: Transcribable {
             logger.log("Received newMessages from actor, count = \(newMessages.count). Checking diff...")
 
             // 1) Check if the array is truly different from what we last published
-            guard newMessages != lastMessages else {
-                logger.log("No diff from lastMessages (count=\(lastMessages.count)). Skipping update to avoid spam.")
-                continue
-            }
+//            guard newMessages != lastMessages else {
+//                logger.log("No diff from lastMessages (count=\(lastMessages.count)). Skipping update to avoid spam.")
+//                continue
+//            }
 
             // 2) If we have *too many updates in quick succession*, we do a small throttle
-            let now = Date()
-            let elapsed = now.timeIntervalSince(lastUpdateTime)
-            let needed = throttleInterval - elapsed
-            if needed > 0 {
-                logger.log("Throttling. Sleeping for \(String(format: "%.2f", needed))s")
-                try? await Task.sleep(nanoseconds: UInt64(needed * 1_000_000_000))
-                
-                // Check again after sleep if task was cancelled
-                guard !Task.isCancelled else { break }
-            }
-            
+//            let now = Date()
+//            let elapsed = now.timeIntervalSince(lastUpdateTime)
+//            let needed = throttleInterval - elapsed
+//            if needed > 0 {
+//                logger.log("Throttling. Sleeping for \(String(format: "%.2f", needed))s")
+//                try? await Task.sleep(nanoseconds: UInt64(needed * 1_000_000_000))
+//                
+//                // Check again after sleep if task was cancelled
+//                guard !Task.isCancelled else { break }
+//            }
+//            
             // 3) Now actually publish these messages to SwiftUI
             logger.log("Publishing updated messages to SwiftUI. count=\(newMessages.count)")
             await MainActor.run {
                 // Only update if the messages are still different
-                guard self.messages != newMessages else { return }
+//                guard self.messages != newMessages else { return }
                 self.messages = newMessages
             }
 
-            lastMessages = newMessages
-            lastUpdateTime = now
+//            lastMessages = newMessages
+//            lastUpdateTime = now
         }
 
         logger.log("observeMessageStream completed or was cancelled.")