fix: use LockedValue for continuation properties (Swift 6.3 compat) (#10)

Replace nonisolated(unsafe) on non-Sendable CheckedContinuation
properties with a thread-safe LockedValue wrapper using NSLock.

This fixes Swift 6.3-dev build failures without bumping platform
minimums (preserves macOS 13+/iOS 16+).

Fixes #211

Co-authored-by: Stijn Willems <stijn@promptping.ai>

Author: doozMen

Sources/MCP/Base/Transports/NetworkTransport.swift

@@ -511,9 +511,6 @@ import Logging
             var messageWithNewline = message
             messageWithNewline.append(UInt8(ascii: "\n"))
 
-            // Use a local actor-isolated variable to track continuation state
-            var sendContinuationResumed = false
-
             try await withCheckedThrowingContinuation {
                 [weak self] (continuation: CheckedContinuation<Void, Swift.Error>) in
                 guard let self = self else {
@@ -528,47 +525,35 @@ import Logging
                     completion: .contentProcessed { [weak self] error in
                         guard let self = self else { return }
 
-                        Task { @MainActor in
-                            if !sendContinuationResumed {
-                                sendContinuationResumed = true
-                                if let error = error {
-                                    self.logger.error("Send error: \(error)")
-
-                                    // Check if we should attempt to reconnect on send failure
-                                    let isStopping = await self.isStopping  // Await actor-isolated property
-                                    if !isStopping && self.reconnectionConfig.enabled {
-                                        let isConnected = await self.isConnected
-                                        if isConnected {
-                                            if error.isConnectionLost {
-                                                self.logger.warning(
-                                                    "Connection appears broken, will attempt to reconnect..."
-                                                )
-
-                                                // Schedule connection restart
-                                                Task { [weak self] in  // Operate on self's executor
-                                                    guard let self = self else { return }
-
-                                                    await self.setIsConnected(false)
-
-                                                    try? await Task.sleep(for: .milliseconds(500))
-
-                                                    let currentIsStopping = await self.isStopping
-                                                    if !currentIsStopping {
-                                                        // Cancel the connection, then attempt to reconnect fully.
-                                                        self.connection.cancel()
-                                                        try? await self.connect()
-                                                    }
-                                                }
-                                            }
+                        if let error = error {
+                            self.logger.error("Send error: \(error)")
+
+                            // Schedule reconnection check on a separate task
+                            Task { [weak self] in
+                                guard let self = self else { return }
+                                let isStopping = await self.isStopping
+                                if !isStopping && self.reconnectionConfig.enabled {
+                                    let isConnected = await self.isConnected
+                                    if isConnected && error.isConnectionLost {
+                                        self.logger.warning(
+                                            "Connection appears broken, will attempt to reconnect..."
+                                        )
+                                        await self.setIsConnected(false)
+                                        try? await Task.sleep(for: .milliseconds(500))
+
+                                        let currentIsStopping = await self.isStopping
+                                        if !currentIsStopping {
+                                            self.connection.cancel()
+                                            try? await self.connect()
                                         }
                                     }
-
-                                    continuation.resume(
-                                        throwing: MCPError.internalError("Send error: \(error)"))
-                                } else {
-                                    continuation.resume()
                                 }
                             }
+
+                            continuation.resume(
+                                throwing: MCPError.internalError("Send error: \(error)"))
+                        } else {
+                            continuation.resume()
                         }
                     })
             }
@@ -747,8 +732,6 @@ import Logging
         /// - Returns: The received data chunk
         /// - Throws: Network errors or transport failures
         private func receiveData() async throws -> Data {
-            var receiveContinuationResumed = false
-
             return try await withCheckedThrowingContinuation {
                 [weak self] (continuation: CheckedContinuation<Data, Swift.Error>) in
                 guard let self = self else {
@@ -759,21 +742,15 @@ import Logging
                 let maxLength = bufferConfig.maxReceiveBufferSize ?? Int.max
                 connection.receive(minimumIncompleteLength: 1, maximumLength: maxLength) {
                     content, _, isComplete, error in
-                    Task { @MainActor in
-                        if !receiveContinuationResumed {
-                            receiveContinuationResumed = true
-                            if let error = error {
-                                continuation.resume(throwing: MCPError.transportError(error))
-                            } else if let content = content {
-                                continuation.resume(returning: content)
-                            } else if isComplete {
-                                self.logger.trace("Connection completed by peer")
-                                continuation.resume(throwing: MCPError.connectionClosed)
-                            } else {
-                                // EOF: Resume with empty data instead of throwing an error
-                                continuation.resume(returning: Data())
-                            }
-                        }
+                    if let error = error {
+                        continuation.resume(throwing: MCPError.transportError(error))
+                    } else if let content = content {
+                        continuation.resume(returning: content)
+                    } else if isComplete {
+                        self.logger.trace("Connection completed by peer")
+                        continuation.resume(throwing: MCPError.connectionClosed)
+                    } else {
+                        continuation.resume(returning: Data())
                     }
                 }
             }