Removed the async dependency of some tools that are rather syncronous

Took care of race condition when executing update on the unity package manager mutliple times in a row

Author: CoderGamester

Editor/Services/TestRunnerService.cs

@@ -80,7 +80,7 @@ private void CollectTestItems(ITestAdaptor testAdaptor, List<TestItemInfo> tests
         /// <param name="completionSource">TaskCompletionSource to resolve when tests are complete</param>
         /// <param name="timeoutMinutes">Timeout in minutes, defaults to 10</param>
         /// <returns>Task that resolves with test results when tests are complete</returns>
-        public async Task<JObject> ExecuteTests(
+        public async void ExecuteTests(
             TestMode testMode, 
             string testFilter, 
             TaskCompletionSource<JObject> completionSource, 
@@ -109,13 +109,11 @@ public async Task<JObject> ExecuteTests(
 
             if (completedTask != completionSource.Task)
             {
-                return McpUnitySocketHandler.CreateErrorResponse(
+                completionSource.SetResult(McpUnitySocketHandler.CreateErrorResponse(
                     $"Test run timed out after {timeoutMinutes} minutes",
                     "test_runner_timeout"
-                );
+                ));
             }
-                
-            return completionSource.Task.Result;
         }
     }
 

Editor/Tools/McpToolBase.cs

@@ -20,23 +20,43 @@ public abstract class McpToolBase
         /// Description of the tool's functionality
         /// </summary>
         public string Description { get; protected set; }
+
+        /// <summary>
+        /// Flag indicating if the tool executes asynchronously on the main thread.
+        /// If true, ExecuteAsync should be overridden.
+        /// If false, Execute should be overridden.
+        /// </summary>
+        public bool IsAsync { get; protected set; } = false;
 
         /// <summary>
-        /// Execute the tool with the provided parameters
+        /// Execute the tool asynchronously with the provided parameters.
+        /// This should be overridden by tools that need to run on the Unity main thread 
+        /// or perform long-running operations without blocking the WebSocket handler.
         /// </summary>
         /// <param name="parameters">Tool parameters as a JObject</param>
-        /// <returns>The result of the tool execution as a JObject</returns>
-        public abstract Task<JObject> ExecuteAsync(JObject parameters);
+        /// <param name="tcs">TaskCompletionSource to set the result or exception of the execution</param>
+        public virtual void ExecuteAsync(JObject parameters, TaskCompletionSource<JObject> tcs)
+        {
+            // Default implementation for tools that don't override this.
+            // Indicate that this method should have been overridden if IsAsync is true.
+            tcs.TrySetException(new NotImplementedException("ExecuteAsync must be overridden if IsAsync is true."));
+        }
 
         /// <summary>
-        /// Synchronous execution method for backward compatibility
+        /// Execute the tool synchronously with the provided parameters.
+        /// This should be overridden by tools that can execute quickly and directly 
+        /// within the WebSocket message handler thread.
         /// </summary>
         /// <param name="parameters">Tool parameters as a JObject</param>
-        /// <returns>The result of the tool execution as a JObject</returns>
+        /// <returns>The result of the tool execution as a JObject, or an error JObject</returns>
         public virtual JObject Execute(JObject parameters)
         {
-            // Call the async method and wait for it to complete
-            return ExecuteAsync(parameters).GetAwaiter().GetResult();
+            // Default implementation for tools that don't override this.
+            // Indicate that this method should have been overridden if IsAsync is false.
+            return McpUnity.Unity.McpUnitySocketHandler.CreateErrorResponse(
+                "Execute must be overridden if IsAsync is false.", 
+                "implementation_error"
+            );
         }
     }
 }

Editor/Tools/MenuItemTool.cs

@@ -19,19 +19,19 @@ public MenuItemTool()
         }
 
         /// <summary>
-        /// Execute the MenuItem tool with the provided parameters asynchronously
+        /// Execute the MenuItem tool with the provided parameters synchronously
         /// </summary>
         /// <param name="parameters">Tool parameters as a JObject</param>
-        public override Task<JObject> ExecuteAsync(JObject parameters)
+        public override JObject Execute(JObject parameters)
         {
             // Extract parameters with defaults
             string menuPath = parameters["menuPath"]?.ToObject<string>();
             if (string.IsNullOrEmpty(menuPath))
             {
-                return Task.FromResult(McpUnitySocketHandler.CreateErrorResponse(
+                return McpUnitySocketHandler.CreateErrorResponse(
                     "Required parameter 'menuPath' not provided", 
                     "validation_error"
-                ));
+                );
             }
 
             // Log the execution
@@ -41,13 +41,13 @@ public override Task<JObject> ExecuteAsync(JObject parameters)
             bool success = EditorApplication.ExecuteMenuItem(menuPath);
 
             // Create the response
-            return Task.FromResult(new JObject
+            return new JObject
             {
                 ["success"] = success,
                 ["message"] = success 
                     ? $"Successfully executed menu item: {menuPath}" 
                     : $"Failed to execute menu item: {menuPath}"
-            });
+            };
         }
     }
 }

Editor/Tools/NotifyMessageTool.cs

@@ -17,44 +17,44 @@ public NotifyMessageTool()
         }
 
         /// <summary>
-        /// Execute the NotifyMessage tool with the provided parameters asynchronously
+        /// Execute the NotifyMessage tool with the provided parameters synchronously
         /// </summary>
         /// <param name="parameters">Tool parameters as a JObject</param>
-        public override Task<JObject> ExecuteAsync(JObject parameters)
+        public override JObject Execute(JObject parameters)
         {
             // Extract parameters
             string message = parameters["message"]?.ToObject<string>();
+            string type = parameters["type"]?.ToObject<string>()?.ToLower() ?? "info";
+ 
             if (string.IsNullOrEmpty(message))
             {
-                return Task.FromResult(McpUnitySocketHandler.CreateErrorResponse(
+                return McpUnitySocketHandler.CreateErrorResponse(
                     "Required parameter 'message' not provided", 
                     "validation_error"
-                ));
+                );
             }
-            
-            string messageType = parameters["type"]?.ToObject<string>()?.ToLowerInvariant() ?? "info";
-            
-            // Display the message in the Unity console based on the type
-            switch (messageType)
+ 
+            // Log the message based on type
+            switch (type)
             {
-                case "warning":
-                    Debug.LogWarning($"[MCP Unity Notification] {message}");
-                    break;
                 case "error":
-                    Debug.LogError($"[MCP Unity Notification] {message}");
+                    Debug.LogError($"[MCP]: {message}");
+                    break;
+                case "warning":
+                    Debug.LogWarning($"[MCP]: {message}");
                     break;
-                case "info":
                 default:
-                    Debug.Log($"[MCP Unity Notification] {message}");
+                    Debug.Log($"[MCP]: {message}");
                     break;
             }
-            
-            return Task.FromResult(new JObject
+ 
+            // Create the response
+            return new JObject
             {
                 ["success"] = true,
                 ["message"] = $"Message displayed: {message}",
                 ["type"] = "text"
-            });
+            };
         }
     }
 }