diff --git a/Assets/Plugins/Pun2Task/Pun2TaskNetwork.cs b/Assets/Plugins/Pun2Task/Pun2TaskNetwork.cs
index a83e092..4a883de 100644
--- a/Assets/Plugins/Pun2Task/Pun2TaskNetwork.cs
+++ b/Assets/Plugins/Pun2Task/Pun2TaskNetwork.cs
@@ -22,21 +22,30 @@ public static class Pun2TaskNetwork
         /// <exception cref="ConnectionFailedException">Throw when connection to server fails.</exception>
         public static async UniTask ConnectUsingSettingsAsync(CancellationToken token = default)
         {
-            var task = UniTask.WhenAny(
-                Pun2TaskCallback.OnConnectedToMasterAsync(token).AsAsyncUnitUniTask(),
-                Pun2TaskCallback.OnDisconnectedAsync(token));
-
-            var result = PhotonNetwork.ConnectUsingSettings();
-            if (!result)
+            var cts = CancellationTokenSource.CreateLinkedTokenSource(token);
+            try
             {
-                throw new InvalidNetworkOperationException(nameof(ConnectUsingSettingsAsync) +
-                                                           " is not ready to connect.");
-            }
+                var task = UniTask.WhenAny(
+                    Pun2TaskCallback.OnConnectedToMasterAsync(cts.Token).AsAsyncUnitUniTask(),
+                    Pun2TaskCallback.OnDisconnectedAsync(cts.Token));
 
-            var (winIndex, _, disconnectCause) = await task;
+                var result = PhotonNetwork.ConnectUsingSettings();
+                if (!result)
+                {
+                    throw new InvalidNetworkOperationException(nameof(ConnectUsingSettingsAsync) +
+                                                               " is not ready to connect.");
+                }
 
-            if (winIndex == 0) return;
-            throw new ConnectionFailedException(disconnectCause);
+                var (winIndex, _, disconnectCause) = await task;
+
+                if (winIndex == 0) return;
+                throw new ConnectionFailedException(disconnectCause);
+            }
+            finally
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
         }
 
         /// <summary>
@@ -52,21 +61,30 @@ public static async UniTask ConnectUsingSettingsAsync(
             bool startInOfflineMode = false,
             CancellationToken token = default)
         {
-            var task = UniTask.WhenAny(
-                Pun2TaskCallback.OnConnectedToMasterAsync(token).AsAsyncUnitUniTask(),
-                Pun2TaskCallback.OnDisconnectedAsync(token));
-
-            var result = PhotonNetwork.ConnectUsingSettings(appSettings, startInOfflineMode);
-            if (!result)
+            var cts = CancellationTokenSource.CreateLinkedTokenSource(token);
+            try
             {
-                throw new InvalidNetworkOperationException(nameof(ConnectUsingSettingsAsync) +
-                                                           " is not ready to connect.");
-            }
+                var task = UniTask.WhenAny(
+                    Pun2TaskCallback.OnConnectedToMasterAsync(cts.Token).AsAsyncUnitUniTask(),
+                    Pun2TaskCallback.OnDisconnectedAsync(cts.Token));
 
-            var (winIndex, _, disconnectCause) = await task;
+                var result = PhotonNetwork.ConnectUsingSettings(appSettings, startInOfflineMode);
+                if (!result)
+                {
+                    throw new InvalidNetworkOperationException(nameof(ConnectUsingSettingsAsync) +
+                                                               " is not ready to connect.");
+                }
 
-            if (winIndex == 0) return;
-            throw new ConnectionFailedException(disconnectCause);
+                var (winIndex, _, disconnectCause) = await task;
+
+                if (winIndex == 0) return;
+                throw new ConnectionFailedException(disconnectCause);
+            }
+            finally
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
         }
 
         /// <summary>
@@ -84,20 +102,30 @@ public static async UniTask ConnectToMasterAsync(
             string appID,
             CancellationToken token = default)
         {
-            var task = UniTask.WhenAny(
-                Pun2TaskCallback.OnConnectedToMasterAsync(token).AsAsyncUnitUniTask(),
-                Pun2TaskCallback.OnDisconnectedAsync(token));
-
-            var result = PhotonNetwork.ConnectToMaster(masterServerAddress, port, appID);
-            if (!result)
+            var cts = CancellationTokenSource.CreateLinkedTokenSource(token);
+            try
             {
-                throw new InvalidNetworkOperationException(nameof(ConnectToMasterAsync) + " is not ready to connect.");
-            }
+                var task = UniTask.WhenAny(
+                    Pun2TaskCallback.OnConnectedToMasterAsync(cts.Token).AsAsyncUnitUniTask(),
+                    Pun2TaskCallback.OnDisconnectedAsync(cts.Token));
+
+                var result = PhotonNetwork.ConnectToMaster(masterServerAddress, port, appID);
+                if (!result)
+                {
+                    throw new InvalidNetworkOperationException(nameof(ConnectToMasterAsync) +
+                                                               " is not ready to connect.");
+                }
 
-            var (winIndex, _, disconnectCause) = await task;
+                var (winIndex, _, disconnectCause) = await task;
 
-            if (winIndex == 0) return;
-            throw new ConnectionFailedException(disconnectCause);
+                if (winIndex == 0) return;
+                throw new ConnectionFailedException(disconnectCause);
+            }
+            finally
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
         }
 
         /// <summary>
@@ -108,21 +136,30 @@ public static async UniTask ConnectToMasterAsync(
         /// <exception cref="ConnectionFailedException">Throw when connection to server fails.</exception>
         public static async UniTask ConnectToBestCloudServerAsync(CancellationToken token = default)
         {
-            var task = UniTask.WhenAny(
-                Pun2TaskCallback.OnConnectedToMasterAsync(token).AsAsyncUnitUniTask(),
-                Pun2TaskCallback.OnDisconnectedAsync(token));
-
-            var result = PhotonNetwork.ConnectToBestCloudServer();
-            if (!result)
+            var cts = CancellationTokenSource.CreateLinkedTokenSource(token);
+            try
             {
-                throw new InvalidNetworkOperationException(nameof(ConnectToBestCloudServerAsync) +
-                                                           " is not ready to connect.");
-            }
+                var task = UniTask.WhenAny(
+                    Pun2TaskCallback.OnConnectedToMasterAsync(cts.Token).AsAsyncUnitUniTask(),
+                    Pun2TaskCallback.OnDisconnectedAsync(cts.Token));
+
+                var result = PhotonNetwork.ConnectToBestCloudServer();
+                if (!result)
+                {
+                    throw new InvalidNetworkOperationException(nameof(ConnectToBestCloudServerAsync) +
+                                                               " is not ready to connect.");
+                }
 
-            var (winIndex, _, disconnectCause) = await task;
+                var (winIndex, _, disconnectCause) = await task;
 
-            if (winIndex == 0) return;
-            throw new ConnectionFailedException(disconnectCause);
+                if (winIndex == 0) return;
+                throw new ConnectionFailedException(disconnectCause);
+            }
+            finally
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
         }
 
         /// <summary>
@@ -134,20 +171,30 @@ public static async UniTask ConnectToBestCloudServerAsync(CancellationToken toke
         /// <exception cref="ConnectionFailedException">Throw when connection to server fails.</exception>
         public static async UniTask ConnectToRegionAsync(string region, CancellationToken token = default)
         {
-            var task = UniTask.WhenAny(
-                Pun2TaskCallback.OnConnectedToMasterAsync(token).AsAsyncUnitUniTask(),
-                Pun2TaskCallback.OnDisconnectedAsync(token));
-
-            var result = PhotonNetwork.ConnectToRegion(region);
-            if (!result)
+            var cts = CancellationTokenSource.CreateLinkedTokenSource(token);
+            try
             {
-                throw new InvalidNetworkOperationException(nameof(ConnectToRegionAsync) + " is not ready to connect.");
-            }
+                var task = UniTask.WhenAny(
+                    Pun2TaskCallback.OnConnectedToMasterAsync(cts.Token).AsAsyncUnitUniTask(),
+                    Pun2TaskCallback.OnDisconnectedAsync(cts.Token));
+
+                var result = PhotonNetwork.ConnectToRegion(region);
+                if (!result)
+                {
+                    throw new InvalidNetworkOperationException(nameof(ConnectToRegionAsync) +
+                                                               " is not ready to connect.");
+                }
 
-            var (winIndex, _, disconnectCause) = await task;
+                var (winIndex, _, disconnectCause) = await task;
 
-            if (winIndex == 0) return;
-            throw new ConnectionFailedException(disconnectCause);
+                if (winIndex == 0) return;
+                throw new ConnectionFailedException(disconnectCause);
+            }
+            finally
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
         }
 
         /// <summary>
@@ -168,17 +215,26 @@ public static async UniTask DisconnectAsync()
         /// <exception cref="ConnectionFailedException">Throw when connection to server fails.</exception>
         public static async UniTask ReconnectAsync(CancellationToken token = default)
         {
-            var task = UniTask.WhenAny(
-                Pun2TaskCallback.OnConnectedToMasterAsync(token).AsAsyncUnitUniTask(),
-                Pun2TaskCallback.OnDisconnectedAsync(token));
+            var cts = CancellationTokenSource.CreateLinkedTokenSource(token);
+            try
+            {
+                var task = UniTask.WhenAny(
+                    Pun2TaskCallback.OnConnectedToMasterAsync(cts.Token).AsAsyncUnitUniTask(),
+                    Pun2TaskCallback.OnDisconnectedAsync(cts.Token));
 
-            var result = PhotonNetwork.Reconnect();
-            if (!result) throw new InvalidNetworkOperationException("It is not ready to reconnect.");
+                var result = PhotonNetwork.Reconnect();
+                if (!result) throw new InvalidNetworkOperationException("It is not ready to reconnect.");
 
-            var (winIndex, _, disconnectCause) = await task;
+                var (winIndex, _, disconnectCause) = await task;
 
-            if (winIndex == 0) return;
-            throw new ConnectionFailedException(disconnectCause);
+                if (winIndex == 0) return;
+                throw new ConnectionFailedException(disconnectCause);
+            }
+            finally
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
         }
 
         #endregion
@@ -202,16 +258,25 @@ public static async UniTask CreateRoomAsync(
             string[] expectedUsers = null,
             CancellationToken token = default)
         {
-            var task = UniTask.WhenAny(
-                Pun2TaskCallback.OnJoinedRoomAsync(token).AsAsyncUnitUniTask(),
-                Pun2TaskCallback.OnCreateRoomFailedAsync(token));
+            var cts = CancellationTokenSource.CreateLinkedTokenSource(token);
+            try
+            {
+                var task = UniTask.WhenAny(
+                    Pun2TaskCallback.OnJoinedRoomAsync(cts.Token).AsAsyncUnitUniTask(),
+                    Pun2TaskCallback.OnCreateRoomFailedAsync(cts.Token));
 
-            var valid = PhotonNetwork.CreateRoom(roomName, roomOptions, typedLobby, expectedUsers);
-            if (!valid) throw new InvalidRoomOperationException("It is not ready to create a room.");
+                var valid = PhotonNetwork.CreateRoom(roomName, roomOptions, typedLobby, expectedUsers);
+                if (!valid) throw new InvalidRoomOperationException("It is not ready to create a room.");
 
-            var (winIndex, _, (returnCode, message)) = await task;
-            if (winIndex == 0) return;
-            throw new FailedToCreateRoomException(returnCode, message);
+                var (winIndex, _, (returnCode, message)) = await task;
+                if (winIndex == 0) return;
+                throw new FailedToCreateRoomException(returnCode, message);
+            }
+            finally
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
         }
 
 
@@ -234,25 +299,34 @@ public static async UniTask<bool> JoinOrCreateRoomAsync(
             string[] expectedUsers = null,
             CancellationToken token = default)
         {
-            var createdRoomTask = Pun2TaskCallback.OnCreatedRoomAsync(token).GetAwaiter();
-            var task = UniTask.WhenAny(
-                Pun2TaskCallback.OnJoinedRoomAsync(token).AsAsyncUnitUniTask(),
-                Pun2TaskCallback.OnCreateRoomFailedAsync(token),
-                Pun2TaskCallback.OnJoinRoomFailedAsync(token));
-
-            var valid = PhotonNetwork.JoinOrCreateRoom(roomName, roomOptions, typedLobby, expectedUsers);
-            if (!valid) throw new InvalidRoomOperationException("It is not ready to join a room.");
-
-            var (winIndex,
-                _,
-                (createFailedCode, createFailedMessage),
-                _) = await task;
-            return winIndex switch
-            {
-                0 => createdRoomTask.IsCompleted,
-                1 => throw new FailedToCreateRoomException(createFailedCode, createFailedMessage),
-                _ => throw new FailedToJoinRoomException(createFailedCode, createFailedMessage)
-            };
+            var cts = CancellationTokenSource.CreateLinkedTokenSource(token);
+            try
+            {
+                var createdRoomTask = Pun2TaskCallback.OnCreatedRoomAsync(token).GetAwaiter();
+                var task = UniTask.WhenAny(
+                    Pun2TaskCallback.OnJoinedRoomAsync(cts.Token).AsAsyncUnitUniTask(),
+                    Pun2TaskCallback.OnCreateRoomFailedAsync(cts.Token),
+                    Pun2TaskCallback.OnJoinRoomFailedAsync(cts.Token));
+
+                var valid = PhotonNetwork.JoinOrCreateRoom(roomName, roomOptions, typedLobby, expectedUsers);
+                if (!valid) throw new InvalidRoomOperationException("It is not ready to join a room.");
+
+                var (winIndex,
+                    _,
+                    (createFailedCode, createFailedMessage),
+                    _) = await task;
+                return winIndex switch
+                {
+                    0 => createdRoomTask.IsCompleted,
+                    1 => throw new FailedToCreateRoomException(createFailedCode, createFailedMessage),
+                    _ => throw new FailedToJoinRoomException(createFailedCode, createFailedMessage)
+                };
+            }
+            finally
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
         }
 
         /// <summary>
@@ -267,16 +341,25 @@ public static async UniTask JoinRoomAsync(string roomName,
             string[] expectedUsers = null,
             CancellationToken token = default)
         {
-            var task = UniTask.WhenAny(
-                Pun2TaskCallback.OnJoinedRoomAsync(token).AsAsyncUnitUniTask(),
-                Pun2TaskCallback.OnJoinRoomFailedAsync(token));
+            var cts = CancellationTokenSource.CreateLinkedTokenSource(token);
+            try
+            {
+                var task = UniTask.WhenAny(
+                    Pun2TaskCallback.OnJoinedRoomAsync(cts.Token).AsAsyncUnitUniTask(),
+                    Pun2TaskCallback.OnJoinRoomFailedAsync(cts.Token));
 
-            var valid = PhotonNetwork.JoinRoom(roomName, expectedUsers);
-            if (!valid) throw new InvalidRoomOperationException("It is not ready to join a room.");
+                var valid = PhotonNetwork.JoinRoom(roomName, expectedUsers);
+                if (!valid) throw new InvalidRoomOperationException("It is not ready to join a room.");
 
-            var (winIndex, _, (returnCode, message)) = await task;
-            if (winIndex == 0) return;
-            throw new FailedToJoinRoomException(returnCode, message);
+                var (winIndex, _, (returnCode, message)) = await task;
+                if (winIndex == 0) return;
+                throw new FailedToJoinRoomException(returnCode, message);
+            }
+            finally
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
         }
 
         /// <summary>
@@ -300,22 +383,31 @@ public static async UniTask JoinRandomRoomAsync(
             string[] expectedUsers = null,
             CancellationToken token = default)
         {
-            var task = UniTask.WhenAny(
-                Pun2TaskCallback.OnJoinedRoomAsync(token).AsAsyncUnitUniTask(),
-                Pun2TaskCallback.OnJoinRandomFailedAsync(token));
-
-            var valid = PhotonNetwork.JoinRandomRoom(
-                expectedCustomRoomProperties,
-                expectedMaxPlayers,
-                matchingType,
-                typedLobby,
-                sqlLobbyFilter,
-                expectedUsers);
-            if (!valid) throw new InvalidRoomOperationException("It is not ready to join a room.");
-
-            var (winIndex, _, (returnCode, message)) = await task;
-            if (winIndex == 0) return;
-            throw new FailedToJoinRoomException(returnCode, message);
+            var cts = CancellationTokenSource.CreateLinkedTokenSource(token);
+            try
+            {
+                var task = UniTask.WhenAny(
+                    Pun2TaskCallback.OnJoinedRoomAsync(cts.Token).AsAsyncUnitUniTask(),
+                    Pun2TaskCallback.OnJoinRandomFailedAsync(cts.Token));
+
+                var valid = PhotonNetwork.JoinRandomRoom(
+                    expectedCustomRoomProperties,
+                    expectedMaxPlayers,
+                    matchingType,
+                    typedLobby,
+                    sqlLobbyFilter,
+                    expectedUsers);
+                if (!valid) throw new InvalidRoomOperationException("It is not ready to join a room.");
+
+                var (winIndex, _, (returnCode, message)) = await task;
+                if (winIndex == 0) return;
+                throw new FailedToJoinRoomException(returnCode, message);
+            }
+            finally
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
         }
 
         /// <summary>
@@ -327,16 +419,25 @@ public static async UniTask JoinRandomRoomAsync(
         /// <exception cref="FailedToJoinRoomException">Throw when you fail to join the room.</exception>
         public static async UniTask RejoinRoomAsync(string roomName, CancellationToken token = default)
         {
-            var task = UniTask.WhenAny(
-                Pun2TaskCallback.OnJoinedRoomAsync(token).AsAsyncUnitUniTask(),
-                Pun2TaskCallback.OnJoinRoomFailedAsync(token));
+            var cts = CancellationTokenSource.CreateLinkedTokenSource(token);
+            try
+            {
+                var task = UniTask.WhenAny(
+                    Pun2TaskCallback.OnJoinedRoomAsync(cts.Token).AsAsyncUnitUniTask(),
+                    Pun2TaskCallback.OnJoinRoomFailedAsync(cts.Token));
 
-            var valid = PhotonNetwork.RejoinRoom(roomName);
-            if (!valid) throw new InvalidRoomOperationException("It is not ready to join a room.");
+                var valid = PhotonNetwork.RejoinRoom(roomName);
+                if (!valid) throw new InvalidRoomOperationException("It is not ready to join a room.");
 
-            var (winIndex, _, (returnCode, message)) = await task;
-            if (winIndex == 0) return;
-            throw new FailedToJoinRoomException(returnCode, message);
+                var (winIndex, _, (returnCode, message)) = await task;
+                if (winIndex == 0) return;
+                throw new FailedToJoinRoomException(returnCode, message);
+            }
+            finally
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
         }
 
         /// <summary>
@@ -347,16 +448,25 @@ public static async UniTask RejoinRoomAsync(string roomName, CancellationToken t
         /// <exception cref="FailedToJoinRoomException">Throw when you fail to join the room.</exception>
         public static async UniTask ReconnectAndRejoinAsync(CancellationToken token)
         {
-            var task = UniTask.WhenAny(
-                Pun2TaskCallback.OnJoinedRoomAsync(token).AsAsyncUnitUniTask(),
-                Pun2TaskCallback.OnJoinRoomFailedAsync(token));
+            var cts = CancellationTokenSource.CreateLinkedTokenSource(token);
+            try
+            {
+                var task = UniTask.WhenAny(
+                    Pun2TaskCallback.OnJoinedRoomAsync(cts.Token).AsAsyncUnitUniTask(),
+                    Pun2TaskCallback.OnJoinRoomFailedAsync(cts.Token));
 
-            var valid = PhotonNetwork.ReconnectAndRejoin();
-            if (!valid) throw new InvalidRoomOperationException("It is not ready to join a room.");
+                var valid = PhotonNetwork.ReconnectAndRejoin();
+                if (!valid) throw new InvalidRoomOperationException("It is not ready to join a room.");
 
-            var (winIndex, _, (returnCode, message)) = await task;
-            if (winIndex == 0) return;
-            throw new FailedToJoinRoomException(returnCode, message);
+                var (winIndex, _, (returnCode, message)) = await task;
+                if (winIndex == 0) return;
+                throw new FailedToJoinRoomException(returnCode, message);
+            }
+            finally
+            {
+                cts.Cancel();
+                cts.Dispose();
+            }
         }
 
         /// <summary>
@@ -428,6 +538,7 @@ public static async UniTask<IList<RoomInfo>> GetCustomRoomListAsync(TypedLobby t
             return await Pun2TaskCallback.OnRoomListUpdateAsync(token);
         }
 
+
         #region Exceptions
 
         public class ConnectionFailedException : Pun2TaskException
diff --git a/Assets/Plugins/Pun2Task/package.json b/Assets/Plugins/Pun2Task/package.json
index e3fd29c..efcfa44 100644
--- a/Assets/Plugins/Pun2Task/package.json
+++ b/Assets/Plugins/Pun2Task/package.json
@@ -1,7 +1,7 @@
 {
     "name": "com.torisoup.pun2task",
     "displayName": "Pun2Task",
-    "version": "1.1.0",
+    "version": "1.1.1",
     "unity": "2022.3",
     "description": "Provides async/await support for PUN2 ",
     "license": "MIT",