Fixed the issue preventing GetTestsResource to work

Added capacity for McpResources to work asynchronously

Author: CoderGamester

.windsurfrules

@@ -55,10 +55,21 @@
 
 - MCP Protocol: https://modelcontextprotocol.io
 - TypeScript SDK: https://github.com/modelcontextprotocol/typescript-sdk
+- Inspector: https://github.com/modelcontextprotocol/inspector
 
 ## 9. Conventions
 
 - Use WebSockets for all cross-process communication.
 - Follow the MCP protocol for all tool/resource definitions.
 - All new tools/resources should be registered in both Unity and Node.js server entry points.
-- Follow Conventional Commits for all commit messages.
+- Follow Conventional Commits for all commit messages.
+
+## 10. Debugging with MCP Inspector
+
+To debug the MCP Node.js server using the Model Context Protocol Inspector, run the following command from the project root:
+
+```shell
+npx @modelcontextprotocol/inspector node Server/build/index.js
+```
+
+This will launch the MCP Inspector, allowing you to inspect and debug live MCP traffic between the Node.js server and connected clients (such as Unity or LLM IDEs).

Editor/Resources/GetTestsResource.cs

@@ -1,11 +1,7 @@
-using System;
-using System.Linq;
 using System.Collections.Generic;
 using System.Threading.Tasks;
-using UnityEngine;
-using Newtonsoft.Json.Linq;
-using McpUnity.Unity;
 using McpUnity.Services;
+using Newtonsoft.Json.Linq;
 
 namespace McpUnity.Resources
 {
@@ -24,25 +20,23 @@ public GetTestsResource(ITestRunnerService testRunnerService)
             Name = "get_tests";
             Description = "Gets available tests from Unity Test Runner";
             Uri = "unity://tests/{testMode}";
-            
+            IsAsync = true;
             _testRunnerService = testRunnerService;
         }
 
         /// <summary>
-        /// Fetch tests based on provided parameters
+        /// Asynchronously fetch tests based on provided parameters
         /// </summary>
         /// <param name="parameters">Resource parameters as a JObject</param>
-        public override JObject Fetch(JObject parameters)
+        /// <param name="tcs">TaskCompletionSource to set the result or exception</param>
+        public override async void FetchAsync(JObject parameters, TaskCompletionSource<JObject> tcs)
         {
             // Get filter parameters
             string testModeFilter = parameters["testMode"]?.ToObject<string>();
-            
-            // Get all tests from the service
-            var allTests = _testRunnerService.GetAllTests(testModeFilter);
-            
-            // Create the results array
+            List<TestItemInfo> allTests = await _testRunnerService.GetAllTestsAsync(testModeFilter);
             var results = new JArray();
-            foreach (var test in allTests)
+            
+            foreach (TestItemInfo test in allTests)
             {
                 results.Add(new JObject
                 {
@@ -54,13 +48,12 @@ public override JObject Fetch(JObject parameters)
                 });
             }
 
-            // Return the results
-            return new JObject
+            tcs.SetResult(new JObject
             {
                 ["success"] = true,
                 ["message"] = $"Retrieved {allTests.Count} tests",
                 ["tests"] = results
-            };
+            });
         }
     }
 }

Editor/Resources/McpResourceBase.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using UnityEngine;
 using Newtonsoft.Json.Linq;
 
@@ -31,10 +32,33 @@ public abstract class McpResourceBase
         public bool IsEnabled { get; protected set; } = true;
 
         /// <summary>
-        /// Fetch the resource data with the provided parameters
+        /// Indicates if the fetch operation is asynchronous.
         /// </summary>
-        /// <param name="parameters">Resource parameters as a JObject</param>
-        /// <returns>The result of the resource fetch as a JObject</returns>
-        public abstract JObject Fetch(JObject parameters);
+        public bool IsAsync { get; protected set; } = false;
+
+        /// <summary>
+        /// Synchronously fetch the resource data.
+        /// Implement this for synchronous resources (IsAsync = false).
+        /// </summary>
+        /// <param name="parameters">Parameters extracted from the URI or query.</param>
+        /// <returns>Result as JObject.</returns>
+        public virtual JObject Fetch(JObject parameters)
+        {
+            // Default implementation throws, forcing sync resources to override.
+            throw new NotImplementedException($"Synchronous Fetch not implemented for resource '{Name}'. Mark IsAsync=true and implement FetchAsync, or override Fetch.");
+        }
+
+        /// <summary>
+        /// Asynchronously fetch the resource data.
+        /// Implement this for asynchronous resources (IsAsync = true).
+        /// The implementation MUST eventually call tcs.SetResult() or tcs.SetException().
+        /// </summary>
+        /// <param name="parameters">Parameters extracted from the URI or query.</param>
+        /// <param name="tcs">TaskCompletionSource to set the result on.</param>
+        public virtual void FetchAsync(JObject parameters, TaskCompletionSource<JObject> tcs)
+        {
+            // Default implementation throws, forcing async resources to override.
+            tcs.SetException(new NotImplementedException($"Asynchronous FetchAsync not implemented for resource '{Name}'. Mark IsAsync=false and implement Fetch, or override FetchAsync."));
+        }
     }
 }

Editor/Services/ITestRunnerService.cs

@@ -14,13 +14,13 @@ public interface ITestRunnerService
         /// Get the TestRunnerApi instance
         /// </summary>
         TestRunnerApi TestRunnerApi { get; }
-        
+
         /// <summary>
-        /// Get a list of available tests, optionally filtered by test mode
+        /// Async retrieval of all tests using TestRunnerApi callbacks
         /// </summary>
         /// <param name="testMode">Optional test mode filter (EditMode, PlayMode, or empty for all)</param>
         /// <returns>List of test items matching the specified test mode, or all tests if no mode specified</returns>
-        List<TestItemInfo> GetAllTests(string testMode = "");
+        Task<List<TestItemInfo>> GetAllTestsAsync(string testMode = "");
 
         /// <summary>
         /// Execute tests with the provided parameters

Editor/Services/TestRunnerService.cs

@@ -4,6 +4,7 @@
 using System.Threading.Tasks;
 using McpUnity.Unity;
 using UnityEngine;
+using UnityEditor;
 using UnityEditor.TestTools.TestRunner.Api;
 using Newtonsoft.Json.Linq;
 
@@ -28,29 +29,59 @@ public TestRunnerService()
         {
             _testRunnerApi = ScriptableObject.CreateInstance<TestRunnerApi>();
         }
-        
+
+        [MenuItem("Tools/MCP Unity/Debug call path")]
+        public static async void DebugCallGetAllTests()
+        {
+            var service = new TestRunnerService();
+            var tests = await service.GetAllTestsAsync();
+            Debug.Log($"Retrieved {tests.Count} tests:");
+            foreach (var t in tests)
+                Debug.Log($"Test: {t.FullName} ({t.TestMode}) - State: {t.RunState}");
+        }
+
         /// <summary>
-        /// Get a list of available tests, optionally filtered by test mode
+        /// Async retrieval of all tests using TestRunnerApi callbacks
         /// </summary>
         /// <param name="testMode">Optional test mode filter (EditMode, PlayMode, or empty for all)</param>
         /// <returns>List of test items matching the specified test mode, or all tests if no mode specified</returns>
-        public List<TestItemInfo> GetAllTests(string testMode = "")
+        public async Task<List<TestItemInfo>> GetAllTestsAsync(string testMode = "")
         {
             var tests = new List<TestItemInfo>();
-            
-            // Check if we need to retrieve EditMode tests
+            var tcs = new TaskCompletionSource<bool>();
+            int pending = 0;
+
             if (string.IsNullOrEmpty(testMode) || testMode.Equals("EditMode", StringComparison.OrdinalIgnoreCase))
             {
-                _testRunnerApi.RetrieveTestList(TestMode.EditMode, adaptor => CollectTestItems(adaptor, tests));
+                Interlocked.Increment(ref pending);
+                _testRunnerApi.RetrieveTestList(TestMode.EditMode, adaptor =>
+                {
+                    CollectTestItems(adaptor, tests);
+                    CheckDone();
+                });
             }
-            
-            // Check if we need to retrieve PlayMode tests
             if (string.IsNullOrEmpty(testMode) || testMode.Equals("PlayMode", StringComparison.OrdinalIgnoreCase))
             {
-                _testRunnerApi.RetrieveTestList(TestMode.PlayMode, adaptor => CollectTestItems(adaptor, tests));
+                Interlocked.Increment(ref pending);
+                _testRunnerApi.RetrieveTestList(TestMode.PlayMode, adaptor =>
+                {
+                    CollectTestItems(adaptor, tests);
+                    CheckDone();
+                });
             }
-            
+
+            if (pending == 0)
+                tcs.SetResult(true);
+
+            await tcs.Task;
+
             return tests;
+
+            void CheckDone()
+            {
+                if (Interlocked.Decrement(ref pending) == 0)
+                    tcs.TrySetResult(true);
+            }
         }
 
         /// <summary>

Editor/Tools/RunTestsTool.cs

@@ -145,12 +145,15 @@ public void RunFinished(ITestResultAdaptor result)
             // Create test results summary
             var summary = new JObject
             {
+                ["name"] = result.Name,
+                ["fullName"] = result.FullName,
                 ["testCount"] = result.PassCount + result.FailCount + result.SkipCount + result.InconclusiveCount,
                 ["passCount"] = result.PassCount,
                 ["failCount"] = result.FailCount,
                 ["skipCount"] = result.SkipCount,
                 ["inconclusiveCount"] = result.InconclusiveCount,
                 ["duration"] = result.Duration,
+                ["resultState"] = result.ResultState,
                 ["success"] = result.ResultState == "Passed",
                 ["status"] = "completed",
                 ["message"] = $"Test run completed: {result.Test.Name} - {result.ResultState}"

Editor/UnityBridge/McpUnitySocketHandler.cs

@@ -177,18 +177,24 @@ private IEnumerator FetchResourceCoroutine(McpResourceBase resource, JObject par
         {
             try
             {
-                var result = resource.Fetch(parameters);
-                tcs.SetResult(result);
+                if (resource.IsAsync)
+                {
+                    resource.FetchAsync(parameters, tcs);
+                }
+                else
+                {
+                    var result = resource.Fetch(parameters);
+                    tcs.SetResult(result);
+                }
             }
             catch (Exception ex)
             {
-                McpLogger.LogError($"Error fetching resource {resource.Name}: {ex.Message}");
+                McpLogger.LogError($"Error fetching resource {resource.Name}: {ex}");
                 tcs.SetResult(CreateErrorResponse(
                     $"Failed to fetch resource {resource.Name}: {ex.Message}",
                     "resource_fetch_error"
                 ));
             }
-            
             yield return null;
         }