fix runtime support for parameterized protocol types is only available in macOS 13.0.0 or newer

Author: NikSativa

Source/SmartRequest.swift

@@ -202,28 +202,75 @@ private final class SessionAdaptor {
         let (asyncBytes, response) = try await session.task(for: request)
         task = asyncBytes.task
 
+        // Get expected content length from response for accurate progress tracking
+        let expectedContentLength = response.expectedContentLength
+        
+        // Also observe task.progress as a fallback, but we'll primarily use manual tracking
+        // for more accurate and frequent updates
         if let progressHandler,
            let task {
             observer = task.progress.observe(progressHandler)
         }
 
         var data = Data()
+        var bytesRead: Int64 = 0
+        // Update progress every 1KB or when significant chunk is received
+        // This provides smoother progress updates than relying solely on task.progress
+        let progressUpdateThreshold: Int64 = 1024
 
         for try await byte in asyncBytes {
             try Task.checkCancellation()
             data.append(byte)
+            bytesRead += 1
+            
+            // Manually update progress if expectedContentLength is known
+            // This ensures we get regular updates even if task.progress updates infrequently
+            if let progressHandler = progressHandler,
+               expectedContentLength > 0,
+               bytesRead % progressUpdateThreshold == 0 {
+                let progress = Progress(totalUnitCount: expectedContentLength)
+                progress.completedUnitCount = bytesRead
+                progressHandler(progress)
+            } else if let progressHandler = progressHandler,
+                       expectedContentLength < 0,
+                       bytesRead % progressUpdateThreshold == 0 {
+                // If content length is unknown, create indeterminate progress
+                // that shows we're making progress (bytesRead increases)
+                let progress = Progress(totalUnitCount: -1)
+                progress.completedUnitCount = bytesRead
+                progressHandler(progress)
+            }
+        }
+        
+        // Send final progress update (100%) if we have a handler and expected length
+        // This ensures completion is always reported, even if task.progress didn't update
+        if let progressHandler = progressHandler {
+            if expectedContentLength > 0 {
+                let progress = Progress(totalUnitCount: expectedContentLength)
+                progress.completedUnitCount = expectedContentLength
+                progressHandler(progress)
+            } else {
+                // For unknown length, send completion with bytesRead as total
+                let progress = Progress(totalUnitCount: bytesRead)
+                progress.completedUnitCount = bytesRead
+                progressHandler(progress)
+            }
         }
 
         return (data, response)
     }
 
     /// Cancels the running task and clears its observer.
     func stop() {
+        // Clear observer first to prevent any further progress updates
+        observer = nil
+        
+        // Then cancel the task if it's running
         if task?.state == .running {
             task?.cancel()
         }
+        
         task = nil
-        observer = nil
     }
 }