diff --git a/.windsurfrules b/.windsurfrules
index 6457e212..6bf8a4bb 100644
--- a/.windsurfrules
+++ b/.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.
\ No newline at end of file
+- 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).
\ No newline at end of file
diff --git a/Editor/Resources/GetTestsResource.cs b/Editor/Resources/GetTestsResource.cs
index d3982ef4..ac099d11 100644
--- a/Editor/Resources/GetTestsResource.cs
+++ b/Editor/Resources/GetTestsResource.cs
@@ -1,11 +1,8 @@
-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;
+using UnityEditor.TestTools.TestRunner.Api;
 
 namespace McpUnity.Resources
 {
@@ -14,63 +11,49 @@ namespace McpUnity.Resources
     /// </summary>
     public class GetTestsResource : McpResourceBase
     {
-        private readonly TestRunnerService _testRunnerService;
+        private readonly ITestRunnerService _testRunnerService;
         
         /// <summary>
         /// Constructor
         /// </summary>
-        public GetTestsResource(TestRunnerService testRunnerService)
+        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();
-            
-            // Apply test mode filter if provided
-            if (!string.IsNullOrEmpty(testModeFilter))
-            {
-                allTests = allTests.Where(t => 
-                    t.TestMode.Equals(testModeFilter, StringComparison.OrdinalIgnoreCase)
-                ).ToList();
-            }
-            
-            // Create the results array
+            List<ITestAdaptor> allTests = await _testRunnerService.GetAllTestsAsync(testModeFilter);
             var results = new JArray();
-            foreach (var test in allTests)
+            
+            foreach (ITestAdaptor test in allTests)
             {
                 results.Add(new JObject
                 {
                     ["name"] = test.Name,
                     ["fullName"] = test.FullName,
-                    ["path"] = test.Path,
-                    ["testMode"] = test.TestMode,
-                    ["runState"] = test.RunState
+                    ["testMode"] = test.TestMode.ToString(),
+                    ["runState"] = test.RunState.ToString()
                 });
             }
             
-            // Return the results
-            return new JObject
+            tcs.SetResult(new JObject
             {
                 ["success"] = true,
                 ["message"] = $"Retrieved {allTests.Count} tests",
-                ["tests"] = results,
-                ["editModeCount"] = allTests.Count(t => t.TestMode.Equals("EditMode", StringComparison.OrdinalIgnoreCase)),
-                ["playModeCount"] = allTests.Count(t => t.TestMode.Equals("PlayMode", StringComparison.OrdinalIgnoreCase))
-            };
+                ["tests"] = results
+            });
         }
     }
 }
diff --git a/Editor/Resources/McpResourceBase.cs b/Editor/Resources/McpResourceBase.cs
index 49a6eadc..08843e36 100644
--- a/Editor/Resources/McpResourceBase.cs
+++ b/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."));
+        }
     }
 }
diff --git a/Editor/Services/ConsoleLogsService.cs b/Editor/Services/ConsoleLogsService.cs
index 418a96fc..e3063c17 100644
--- a/Editor/Services/ConsoleLogsService.cs
+++ b/Editor/Services/ConsoleLogsService.cs
@@ -70,15 +70,18 @@ public void StopListening()
         /// Get all logs as a JSON array
         /// </summary>
         /// <returns>JArray containing all logs</returns>
-        public JArray GetAllLogsAsJson()
+        public JArray GetAllLogsAsJson(string logType = "")
         {
-            // Convert log entries to a JSON array
+            // Convert log entries to a JSON array, filtering by logType if provided
             JArray logsArray = new JArray();
+            bool filter = !string.IsNullOrEmpty(logType);
             
             lock (_logEntries)
             {
                 foreach (var entry in _logEntries)
                 {
+                    if (filter && !entry.Type.ToString().Equals(logType, System.StringComparison.OrdinalIgnoreCase))
+                        continue;
                     logsArray.Add(new JObject
                     {
                         ["message"] = entry.Message,
diff --git a/Editor/Services/IConsoleLogsService.cs b/Editor/Services/IConsoleLogsService.cs
index 75127570..ac96d50c 100644
--- a/Editor/Services/IConsoleLogsService.cs
+++ b/Editor/Services/IConsoleLogsService.cs
@@ -11,10 +11,11 @@ namespace McpUnity.Services
     public interface IConsoleLogsService
     {
         /// <summary>
-        /// Get all logs as a JSON array
+        /// Get all logs as a JSON array, optionally filtered by log type
         /// </summary>
-        /// <returns>JArray containing all logs</returns>
-        JArray GetAllLogsAsJson();
+        /// <param name="logType">UnityEngine.LogType as string (e.g. "Error", "Warning", "Log"). Empty string for all logs.</param>
+        /// <returns>JArray containing filtered logs</returns>
+        JArray GetAllLogsAsJson(string logType = "");
         
         /// <summary>
         /// Start listening for logs
diff --git a/Editor/Services/ITestRunnerService.cs b/Editor/Services/ITestRunnerService.cs
index 780ba3f3..b5666099 100644
--- a/Editor/Services/ITestRunnerService.cs
+++ b/Editor/Services/ITestRunnerService.cs
@@ -11,27 +11,19 @@ namespace McpUnity.Services
     public interface ITestRunnerService
     {
         /// <summary>
-        /// Get the TestRunnerApi instance
+        /// Asynchronously retrieves all available tests using the TestRunnerApi.
         /// </summary>
-        TestRunnerApi TestRunnerApi { get; }
-        
-        /// <summary>
-        /// Get a list of all available tests
-        /// </summary>
-        List<TestItemInfo> GetAllTests();
+        /// <param name="testModeFilter">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>
+        Task<List<ITestAdaptor>> GetAllTestsAsync(string testModeFilter = "");
 
         /// <summary>
-        /// Execute tests with the provided parameters
+        /// Executes tests using the TestRunnerApi and returns the results as a JSON object.
         /// </summary>
-        /// <param name="testMode">Test mode to run</param>
-        /// <param name="testFilter">Optional test filter</param>
-        /// <param name="completionSource">TaskCompletionSource to resolve when tests are complete</param>
-        /// <param name="timeoutMinutes">Timeout in minutes, defaults to 10</param>
+        /// <param name="testMode">The test mode to run (EditMode or PlayMode).</param>
+        /// <param name="returnOnlyFailures">If true, only failed test results are included in the output.</param>
+        /// <param name="testFilter">A filter string to select specific tests to run.</param>
         /// <returns>Task that resolves with test results when tests are complete</returns>
-        void ExecuteTests(
-            TestMode testMode,
-            string testFilter,
-            TaskCompletionSource<JObject> completionSource,
-            int timeoutMinutes = 1);
+        Task<JObject> ExecuteTestsAsync(TestMode testMode, bool returnOnlyFailures, string testFilter);
     }
 }
diff --git a/Editor/Services/TestRunnerService.cs b/Editor/Services/TestRunnerService.cs
index 7b7fc87d..a91b9866 100644
--- a/Editor/Services/TestRunnerService.cs
+++ b/Editor/Services/TestRunnerService.cs
@@ -1,9 +1,12 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using McpUnity.Unity;
+using McpUnity.Utils;
 using UnityEngine;
+using UnityEditor;
 using UnityEditor.TestTools.TestRunner.Api;
 using Newtonsoft.Json.Linq;
 
@@ -11,121 +14,211 @@ namespace McpUnity.Services
 {
     /// <summary>
     /// Service for accessing Unity Test Runner functionality
+    /// Implements ICallbacks for TestRunnerApi.
     /// </summary>
-    public class TestRunnerService : ITestRunnerService
+    public class TestRunnerService : ITestRunnerService, ICallbacks
     {
         private readonly TestRunnerApi _testRunnerApi;
-        
-        /// <summary>
-        /// Get the TestRunnerApi instance
-        /// </summary>
-        public TestRunnerApi TestRunnerApi => _testRunnerApi;
-        
+        private TaskCompletionSource<JObject> _tcs;
+        private bool _returnOnlyFailures;
+        private List<ITestResultAdaptor> _results;
+
         /// <summary>
         /// Constructor
         /// </summary>
         public TestRunnerService()
         {
             _testRunnerApi = ScriptableObject.CreateInstance<TestRunnerApi>();
+            
+            _testRunnerApi.RegisterCallbacks(this);
         }
-        
+
+        [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 all available tests
+        /// Async retrieval of all tests using TestRunnerApi callbacks
         /// </summary>
-        public List<TestItemInfo> GetAllTests()
+        /// <param name="testModeFilter">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 async Task<List<ITestAdaptor>> GetAllTestsAsync(string testModeFilter = "")
         {
-            var tests = new List<TestItemInfo>();
-            
-            // Get tests for both edit mode and play mode
-            _testRunnerApi.RetrieveTestList(TestMode.EditMode, adaptor => CollectTestItems(adaptor, tests));
-            _testRunnerApi.RetrieveTestList(TestMode.PlayMode, adaptor => CollectTestItems(adaptor, tests));
-            
+            var tests = new List<ITestAdaptor>();
+            var tasks = new List<Task<List<ITestAdaptor>>>();
+
+            if (string.IsNullOrEmpty(testModeFilter) || testModeFilter.Equals("EditMode", StringComparison.OrdinalIgnoreCase))
+            {
+                tasks.Add(RetrieveTestsAsync(TestMode.EditMode));
+            }
+            if (string.IsNullOrEmpty(testModeFilter) || testModeFilter.Equals("PlayMode", StringComparison.OrdinalIgnoreCase))
+            {
+                tasks.Add(RetrieveTestsAsync(TestMode.PlayMode));
+            }
+
+            var results = await Task.WhenAll(tasks);
+
+            foreach (var result in results)
+            {
+                tests.AddRange(result);
+            }
+
             return tests;
         }
 
         /// <summary>
-        /// Execute tests with the provided parameters
+        /// Executes tests and returns a JSON summary.
         /// </summary>
-        /// <param name="testMode">Test mode to run</param>
-        /// <param name="testFilter">Optional test filter</param>
-        /// <param name="completionSource">TaskCompletionSource to resolve when tests are complete</param>
-        /// <param name="timeoutMinutes">Timeout in minutes, defaults to 10</param>
+        /// <param name="testMode">The test mode to run (EditMode or PlayMode).</param>
+        /// <param name="returnOnlyFailures">If true, only failed test results are included in the output.</param>
+        /// <param name="testFilter">A filter string to select specific tests to run.</param>
         /// <returns>Task that resolves with test results when tests are complete</returns>
-        public async void ExecuteTests(
-            TestMode testMode, 
-            string testFilter, 
-            TaskCompletionSource<JObject> completionSource, 
-            int timeoutMinutes = 1)
+        public async Task<JObject> ExecuteTestsAsync(TestMode testMode, bool returnOnlyFailures, string testFilter = "")
         {
-            // Create filter
-            var filter = new Filter
-            {
-                testMode = testMode
-            };
-                
-            // Apply name filter if provided
+            _tcs = new TaskCompletionSource<JObject>();
+            _results = new List<ITestResultAdaptor>();
+            _returnOnlyFailures = returnOnlyFailures;
+            var filter = new Filter { testMode = testMode };
+
             if (!string.IsNullOrEmpty(testFilter))
             {
                 filter.testNames = new[] { testFilter };
             }
-                
-            // Execute tests
+
             _testRunnerApi.Execute(new ExecutionSettings(filter));
 
-            Task completedTask = await Task.WhenAny(
-                completionSource.Task,
-                Task.Delay(TimeSpan.FromMinutes(timeoutMinutes))
-            );
+            return await WaitForCompletionAsync(
+                McpUnitySettings.Instance.RequestTimeoutSeconds);
+        }
+        
+        /// <summary>
+        /// Asynchronously retrieves all test adaptors for the specified test mode.
+        /// </summary>
+        /// <param name="mode">The test mode to retrieve tests for (EditMode or PlayMode).</param>
+        /// <returns>A task that resolves to a list of ITestAdaptor representing all tests in the given mode.</returns>
+        private Task<List<ITestAdaptor>> RetrieveTestsAsync(TestMode mode)
+        {
+            var tcs = new TaskCompletionSource<List<ITestAdaptor>>();
+            var tests = new List<ITestAdaptor>();
 
-            if (completedTask != completionSource.Task)
+            _testRunnerApi.RetrieveTestList(mode, adaptor =>
             {
-                completionSource.SetResult(McpUnitySocketHandler.CreateErrorResponse(
-                    $"Test run timed out after {timeoutMinutes} minutes",
-                    "test_runner_timeout"
-                ));
-            }
+                CollectTestItems(adaptor, tests);
+                tcs.SetResult(tests);
+            });
+
+            return tcs.Task;
         }
         
         /// <summary>
         /// Recursively collect test items from test adaptors
         /// </summary>
-        private void CollectTestItems(ITestAdaptor testAdaptor, List<TestItemInfo> tests, string parentPath = "")
+        private void CollectTestItems(ITestAdaptor testAdaptor, List<ITestAdaptor> tests)
         {
             if (testAdaptor.IsSuite)
             {
                 // For suites (namespaces, classes), collect all children
                 foreach (var child in testAdaptor.Children)
                 {
-                    string currentPath = string.IsNullOrEmpty(parentPath) ? testAdaptor.Name : $"{parentPath}.{testAdaptor.Name}";
-                    CollectTestItems(child, tests, currentPath);
+                    CollectTestItems(child, tests);
                 }
             }
             else
             {
-                // For individual tests, add to the list
-                string fullPath = string.IsNullOrEmpty(parentPath) ? testAdaptor.Name : $"{parentPath}.{testAdaptor.Name}";
-                
-                tests.Add(new TestItemInfo
-                {
-                    Name = testAdaptor.Name,
-                    FullName = testAdaptor.FullName,
-                    Path = fullPath,
-                    TestMode = testAdaptor.TestMode.ToString(),
-                    RunState = testAdaptor.RunState.ToString()
-                });
+                tests.Add(testAdaptor);
             }
         }
-    }
-    
-    /// <summary>
-    /// Information about a test item
-    /// </summary>
-    public class TestItemInfo
-    {
-        public string Name { get; set; }
-        public string FullName { get; set; }
-        public string Path { get; set; }
-        public string TestMode { get; set; }
-        public string RunState { get; set; }
+
+        #region ICallbacks Implementation
+
+        /// <summary>
+        /// Called when the test run starts.
+        /// </summary>
+        public void RunStarted(ITestAdaptor testsToRun)
+        {
+            McpLogger.LogInfo($"Test run started: {testsToRun?.Name}");
+        }
+
+        /// <summary>
+        /// Called when an individual test starts.
+        /// </summary>
+        public void TestStarted(ITestAdaptor test)
+        {
+            // Optionally implement per-test start logic or logging.
+        }
+
+        /// <summary>
+        /// Called when an individual test finishes.
+        /// </summary>
+        public void TestFinished(ITestResultAdaptor result)
+        {
+            _results.Add(result);
+        }
+
+        /// <summary>
+        /// Called when the test run finishes.
+        /// </summary>
+        public void RunFinished(ITestResultAdaptor result)
+        {
+            var summary = BuildResultJson(_results, result);
+            _tcs?.TrySetResult(summary);
+        }
+
+        #endregion
+
+        #region Helpers
+
+        private async Task<JObject> WaitForCompletionAsync(int timeoutSeconds)
+        {
+            var delayTask = Task.Delay(TimeSpan.FromSeconds(timeoutSeconds));
+            var winner = await Task.WhenAny(_tcs.Task, delayTask);
+            
+            if (winner != _tcs.Task)
+            {
+                _tcs.TrySetResult(
+                    McpUnitySocketHandler.CreateErrorResponse(
+                        $"Test run timed out after {timeoutSeconds} seconds",
+                        "test_runner_timeout"));
+            }
+            return await _tcs.Task;
+        }
+
+        private JObject BuildResultJson(List<ITestResultAdaptor> results, ITestResultAdaptor result)
+        {
+            int pass = results.Count(r => r.ResultState == "Passed");
+            int fail = results.Count(r => r.ResultState == "Failed");
+            int skip = results.Count(r => r.ResultState == "Skipped");
+
+            var arr = new JArray(results
+                .Where(r => !_returnOnlyFailures || r.ResultState == "Failed")
+                .Select(r => new JObject {
+                    ["name"]      = r.Name,
+                    ["fullName"]  = r.FullName,
+                    ["state"]     = r.ResultState,
+                    ["message"]   = r.Message,
+                    ["duration"]  = r.Duration
+                }));
+
+            return new JObject { 
+                ["success"]           = true,
+                ["type"]              = "text",
+                ["message"]           = $"{result.Test.Name} test run completed: {pass}/{results.Count} passed - {fail}/{results.Count} failed - {skip}/{results.Count} skipped",
+                ["resultState"]       = result.ResultState,
+                ["durationSeconds"]   = result.Duration,
+                ["testCount"]         = results.Count,
+                ["passCount"]         = pass,
+                ["failCount"]         = fail,
+                ["skipCount"]         = skip,
+                ["results"]           = arr
+            };
+        }
+
+        #endregion
     }
 }
diff --git a/Editor/Tools/RunTestsTool.cs b/Editor/Tools/RunTestsTool.cs
index 08757ef5..857eb31a 100644
--- a/Editor/Tools/RunTestsTool.cs
+++ b/Editor/Tools/RunTestsTool.cs
@@ -14,35 +14,16 @@ namespace McpUnity.Tools
     /// <summary>
     /// Tool for running Unity Test Runner tests
     /// </summary>
-    public class RunTestsTool : McpToolBase, ICallbacks
+    public class RunTestsTool : McpToolBase
     {
         private readonly ITestRunnerService _testRunnerService;
-        
-        private bool _isRunning = false;
-        private TaskCompletionSource<JObject> _testRunCompletionSource;
-        private List<TestResult> _testResults = new List<TestResult>();
-        
-        // Structure to store test results
-        private class TestResult
-        {
-            public string Name { get; set; }
-            public string FullName { get; set; }
-            public string ResultState { get; set; }
-            public string Message { get; set; }
-            public double Duration { get; set; }
-            public bool Passed => ResultState == "Passed";
-        }
-        
+
         public RunTestsTool(ITestRunnerService testRunnerService)
         {
             Name = "run_tests";
             Description = "Runs tests using Unity's Test Runner";
             IsAsync = true;
-            
             _testRunnerService = testRunnerService;
-            
-            // Register callbacks with the TestRunnerApi
-            _testRunnerService.TestRunnerApi.RegisterCallbacks(this);
         }
         
         /// <summary>
@@ -50,151 +31,25 @@ public RunTestsTool(ITestRunnerService testRunnerService)
         /// </summary>
         /// <param name="parameters">Tool parameters, including optional 'testMode' and 'testFilter'.</param>
         /// <param name="tcs">TaskCompletionSource to set the result or exception.</param>
-        public override void ExecuteAsync(JObject parameters, TaskCompletionSource<JObject> tcs)
+        public override async void ExecuteAsync(JObject parameters, TaskCompletionSource<JObject> tcs)
         {
-            // Check if tests are already running
-            if (_isRunning)
-            {
-                tcs.SetResult(McpUnitySocketHandler.CreateErrorResponse(
-                    "Tests are already running. Please wait for them to complete.",
-                    "test_runner_busy"
-                ));
-                return;
-            }
-            
-            // Extract parameters
-            string testModeStr = parameters["testMode"]?.ToObject<string>() ?? "editmode";
-            string testFilter = parameters["testFilter"]?.ToObject<string>() ?? "";
-            
-            // Parse test mode
-            TestMode testMode;
-            switch (testModeStr.ToLowerInvariant())
-            {
-                case "playmode":
-                    testMode = TestMode.PlayMode;
-                    break;
-                case "editmode":
-                    testMode = TestMode.EditMode;
-                    break;
-                default:
-                    testMode = TestMode.EditMode;
-                    break;
-            }
-            
-            // Log the execution
-            McpLogger.LogInfo($"[MCP Unity] Running tests: Mode={testMode}, Filter={testFilter}");
-            
-            // Reset state
-            _isRunning = true;
-            _testResults.Clear();
-            _testRunCompletionSource = tcs;
-            
-            // Execute tests using the TestRunnerService
-            _testRunnerService.ExecuteTests(
-                testMode, 
-                testFilter, 
-                tcs
-            );
-        }
-        
-        #region ICallbacks Implementation
-        
-        // Called when a test run starts
-        public void RunStarted(ITestAdaptor testsToRun)
-        {
-            McpLogger.LogInfo($"[MCP Unity] Test run started: {testsToRun.Name}");
-        }
-        
-        // Called when a test runs
-        public void TestStarted(ITestAdaptor test)
-        {
-            // Nothing to do here
-        }
-        
-        // Called when a test finishes
-        public void TestFinished(ITestResultAdaptor result)
-        {
-            // Skip test suites (tests with children)
-            if (result.Test.HasChildren)
-            {
-                return;
-            }
-            
-            _testResults.Add(new TestResult
-            {
-                Name = result.Test.Name,
-                FullName = result.FullName,
-                ResultState = result.ResultState,
-                Message = result.Message,
-                Duration = result.Duration
-            });
-            
-            McpLogger.LogInfo($"[MCP Unity] Test finished: {result.Test.Name} - {result.ResultState}");
-        }
-        
-        // Called when a test run completes
-        public void RunFinished(ITestResultAdaptor result)
-        {
-            McpLogger.LogInfo($"[MCP Unity] {_testResults.Count} tests completed in {result.Duration}: {result.Test.Name} - {result.ResultState}");
-            
-            _isRunning = false;
-            
-            // Create test results summary
-            var summary = new JObject
-            {
-                ["testCount"] = result.PassCount + result.FailCount + result.SkipCount + result.InconclusiveCount,
-                ["passCount"] = result.PassCount,
-                ["failCount"] = result.FailCount,
-                ["skipCount"] = result.SkipCount,
-                ["inconclusiveCount"] = result.InconclusiveCount,
-                ["duration"] = result.Duration,
-                ["success"] = result.ResultState == "Passed",
-                ["status"] = "completed",
-                ["message"] = $"Test run completed: {result.Test.Name} - {result.ResultState}"
-            };
-            
-            // Add test results array
-            var resultArray = new JArray();
-            foreach (var testResult in _testResults)
-            {
-                resultArray.Add(new JObject
-                {
-                    ["name"] = testResult.Name,
-                    ["fullName"] = testResult.FullName,
-                    ["result"] = testResult.ResultState,
-                    ["message"] = testResult.Message,
-                    ["duration"] = testResult.Duration
-                });
-            }
-            summary["results"] = resultArray;
+            // Parse parameters
+            string testModeStr = parameters?["testMode"]?.ToObject<string>() ?? "EditMode";
+            string testFilter = parameters?["testFilter"]?.ToObject<string>(); // Optional
+            bool returnOnlyFailures = parameters?["returnOnlyFailures"]?.ToObject<bool>() ?? false; // Optional
+
+            TestMode testMode = TestMode.EditMode;
             
-            // Set the test run completion result
-            try
-            {
-                _testRunCompletionSource?.SetResult(new JObject
-                {
-                    ["success"] = true,
-                    ["type"] = "text",
-                    ["message"] = summary["message"].Value<string>(),
-                    ["testCount"] = summary["testCount"],
-                    ["passCount"] = summary["passCount"],
-                    ["failCount"] = summary["failCount"],
-                    ["skipCount"] = summary["skipCount"],
-                    ["inconclusiveCount"] = summary["inconclusiveCount"],
-                    ["results"] = summary["results"]
-                });
-            }
-            catch (Exception ex)
-            {
-                McpLogger.LogError($"[MCP Unity] Failed to set test results: {ex.Message}");
-                _testRunCompletionSource?.TrySetException(ex);
-            }
-            finally
+            if (Enum.TryParse(testModeStr, true, out TestMode parsedMode))
             {
-                _testRunCompletionSource = null;
+                testMode = parsedMode;
             }
+
+            McpLogger.LogInfo($"Executing RunTestsTool: Mode={testMode}, Filter={testFilter ?? "(none)"}");
+
+            // Call the service to run tests
+            JObject result = await _testRunnerService.ExecuteTestsAsync(testMode, returnOnlyFailures, testFilter);
+            tcs.SetResult(result);
         }
-        
-        #endregion
     }
 }
diff --git a/Editor/Tools/NotifyMessageTool.cs b/Editor/Tools/SendConsoleLogTool.cs
similarity index 93%
rename from Editor/Tools/NotifyMessageTool.cs
rename to Editor/Tools/SendConsoleLogTool.cs
index cd9b93e8..25757fc0 100644
--- a/Editor/Tools/NotifyMessageTool.cs
+++ b/Editor/Tools/SendConsoleLogTool.cs
@@ -8,11 +8,11 @@ namespace McpUnity.Tools
     /// <summary>
     /// Tool for sending notification messages to the Unity console
     /// </summary>
-    public class NotifyMessageTool : McpToolBase
+    public class SendConsoleLogTool : McpToolBase
     {
-        public NotifyMessageTool()
+        public SendConsoleLogTool()
         {
-            Name = "notify_message";
+            Name = "send_console_log";
             Description = "Sends a message to the Unity console";
         }
         
diff --git a/Editor/Tools/NotifyMessageTool.cs.meta b/Editor/Tools/SendConsoleLogTool.cs.meta
similarity index 83%
rename from Editor/Tools/NotifyMessageTool.cs.meta
rename to Editor/Tools/SendConsoleLogTool.cs.meta
index bfeecfaf..59b80e28 100644
--- a/Editor/Tools/NotifyMessageTool.cs.meta
+++ b/Editor/Tools/SendConsoleLogTool.cs.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: a1aaf613f7e9c0341a389b261a93c72e
+guid: 35bb1bb57a358064c9ca8f2c8ba3caf2
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2
diff --git a/Editor/UnityBridge/McpUnityEditorWindow.cs b/Editor/UnityBridge/McpUnityEditorWindow.cs
index 86585300..ded9242f 100644
--- a/Editor/UnityBridge/McpUnityEditorWindow.cs
+++ b/Editor/UnityBridge/McpUnityEditorWindow.cs
@@ -107,6 +107,24 @@ private void DrawServerTab()
             
             EditorGUILayout.Space();
             
+            // Test timeout setting
+            EditorGUILayout.BeginHorizontal();
+            int newTimeout = EditorGUILayout.IntField(new GUIContent("Request Timeout (seconds)", "Timeout in seconds for tool request"), settings.RequestTimeoutSeconds);
+            if (newTimeout < McpUnitySettings.RequestTimeoutMinimum)
+            {
+                newTimeout = McpUnitySettings.RequestTimeoutMinimum;
+                Debug.LogError($"Request timeout must be at least {McpUnitySettings.RequestTimeoutMinimum} seconds.");
+            }
+            
+            if (newTimeout != settings.RequestTimeoutSeconds)
+            {
+                settings.RequestTimeoutSeconds = newTimeout;
+                settings.SaveSettings();
+            }
+            EditorGUILayout.EndHorizontal();
+            
+            EditorGUILayout.Space();
+            
             // Auto start server toggle
             bool autoStartServer = EditorGUILayout.Toggle(new GUIContent("Auto Start Server", "Automatically starts the MCP server when Unity opens"), settings.AutoStartServer);
             if (autoStartServer != settings.AutoStartServer)
diff --git a/Editor/UnityBridge/McpUnityServer.cs b/Editor/UnityBridge/McpUnityServer.cs
index 06c4c7cb..a9274cbb 100644
--- a/Editor/UnityBridge/McpUnityServer.cs
+++ b/Editor/UnityBridge/McpUnityServer.cs
@@ -38,13 +38,10 @@ static McpUnityServer()
             EditorApplication.quitting += Instance.StopServer;
 
             // Auto-restart server after domain reload
-            EditorApplication.delayCall += () =>
+            if (McpUnitySettings.Instance.AutoStartServer)
             {
-                if (McpUnitySettings.Instance.AutoStartServer)
-                {
-                    Instance.StartServer();
-                }
-            };
+                Instance.StartServer();
+            }
         }
         
         /// <summary>
@@ -163,9 +160,9 @@ private void RegisterTools()
             RunTestsTool runTestsTool = new RunTestsTool(_testRunnerService);
             _tools.Add(runTestsTool.Name, runTestsTool);
             
-            // Register NotifyMessageTool
-            NotifyMessageTool notifyMessageTool = new NotifyMessageTool();
-            _tools.Add(notifyMessageTool.Name, notifyMessageTool);
+            // Register SendConsoleLogTool
+            SendConsoleLogTool sendConsoleLogTool = new SendConsoleLogTool();
+            _tools.Add(sendConsoleLogTool.Name, sendConsoleLogTool);
             
             // Register UpdateComponentTool
             UpdateComponentTool updateComponentTool = new UpdateComponentTool();
diff --git a/Editor/UnityBridge/McpUnitySettings.cs b/Editor/UnityBridge/McpUnitySettings.cs
index 821101ab..056cd431 100644
--- a/Editor/UnityBridge/McpUnitySettings.cs
+++ b/Editor/UnityBridge/McpUnitySettings.cs
@@ -15,13 +15,28 @@ public class McpUnitySettings
         // Constants
         public const string ServerVersion = "1.0.0";
         public const string PackageName = "com.gamelovers.mcp-unity";
+        public const int RequestTimeoutMinimum = 10;
+
+#if UNITY_EDITOR_WIN
+        private const string EnvUnityPort = "UNITY_PORT";
+        private const string EnvUnityRequestTimeout = "UNITY_REQUEST_TIMEOUT";
+#endif
         
         private static McpUnitySettings _instance;
         private static readonly string SettingsPath = "ProjectSettings/McpUnitySettings.json";
 
         // Server settings
+#if !UNITY_EDITOR_WIN
+        [field: SerializeField] // Note: On Windows, this property is  persisted in per-user environment variables.
+#endif
         public int Port { get; set; } = 8090;
         
+#if !UNITY_EDITOR_WIN
+        [field: SerializeField] // Note: On Windows, this property is  persisted in per-user environment variables.
+#endif
+        [Tooltip("Timeout in seconds for tool request")]
+        public int RequestTimeoutSeconds { get; set; } = RequestTimeoutMinimum;
+        
         [Tooltip("Whether to automatically start the MCP server when Unity opens")]
         public bool AutoStartServer = true;
         
@@ -66,12 +81,19 @@ public void LoadSettings()
                     JsonUtility.FromJsonOverwrite(json, this);
                 }
                 
+#if UNITY_EDITOR_WIN
                 // Check for environment variable PORT
-                string envPort = System.Environment.GetEnvironmentVariable("UNITY_PORT");
+                string envPort = System.Environment.GetEnvironmentVariable(EnvUnityPort);
                 if (!string.IsNullOrEmpty(envPort) && int.TryParse(envPort, out int port))
                 {
                     Port = port;
                 }
+                string envTimeout = System.Environment.GetEnvironmentVariable(EnvUnityRequestTimeout);
+                if (!string.IsNullOrEmpty(envTimeout) && int.TryParse(envTimeout, out int timeout))
+                {
+                    RequestTimeoutSeconds = timeout;
+                }
+#endif
             }
             catch (Exception ex)
             {
@@ -90,10 +112,15 @@ public void SaveSettings()
                 // Save settings to McpUnitySettings.json
                 string json = JsonUtility.ToJson(this, true);
                 File.WriteAllText(SettingsPath, json);
-                
+
+#if UNITY_EDITOR_WIN
                 // Set environment variable PORT for the Node.js process
                 // Note: This will only affect processes started after this point
-                System.Environment.SetEnvironmentVariable("UNITY_PORT", Port.ToString(), System.EnvironmentVariableTarget.User);
+                // Note: EnvironmentVariableTarget.User should be used on .NET implementations running on Windows systems only.
+                //          see: https://learn.microsoft.com/ja-jp/dotnet/api/system.environmentvariabletarget?view=net-8.0#fields
+                Environment.SetEnvironmentVariable(EnvUnityPort, Port.ToString(), EnvironmentVariableTarget.User);
+                Environment.SetEnvironmentVariable(EnvUnityRequestTimeout, RequestTimeoutSeconds.ToString(), EnvironmentVariableTarget.User);
+#endif
             }
             catch (Exception ex)
             {
diff --git a/Editor/UnityBridge/McpUnitySocketHandler.cs b/Editor/UnityBridge/McpUnitySocketHandler.cs
index ed6a48d1..63c429f0 100644
--- a/Editor/UnityBridge/McpUnitySocketHandler.cs
+++ b/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;
         }
         
diff --git a/README-ja.md b/README-ja.md
index 826bea2c..cc4a75ef 100644
--- a/README-ja.md
+++ b/README-ja.md
@@ -76,8 +76,8 @@ MCP Unityは、Unityの`Library/PackedCache`フォルダーをワークスペー
 - `run_tests`: Unityテストランナーを使用してテストを実行
   > **例:** "プロジェクト内のすべてのEditModeテストを実行"
 
-- `notify_message`: Unityエディターにメッセージを表示
-  > **例:** "タスクが完了したことをUnityに通知"
+- `send_console_log`: Unityにコンソールログを送信
+  > **例:** "Unity Editorにコンソールログを送信"
 
 - `add_asset_to_scene`: AssetDatabaseからアセットをUnityシーンに追加
   > **例:** "プロジェクトからPlayerプレハブを現在のシーンに追加"
@@ -211,6 +211,53 @@ MCP Unityサーバーを起動するには2つの方法があります：
    node Server/build/index.js
    ```
 
+## オプション: タイムアウト設定
+
+デフォルトでは、MCPサーバーとWebSocket間のタイムアウトは 10 秒です。
+お使いのOSに応じて変更できます。
+
+<details>
+<summary><span style="font-size: 1.1em; font-weight: bold;">Option 1: Windows OS</span></summary>
+
+1. Unityエディターを開きます
+2. **Tools > MCP Unity > Server Window** に移動します
+3. **Request Timeout (seconds)** の値を希望のタイムアウト秒数に変更します
+4. Unityはシステム環境変数UNITY_REQUEST_TIMEOUTに新しいタイムアウト値を設定します
+5. Node.jsサーバーを再起動します
+6. **Start Server** をもう一度クリックして、UnityエディターのWebソケットをNode.js MCPサーバーに再接続します
+
+</details>
+
+<details>
+<summary><span style="font-size: 1.1em; font-weight: bold;">Option 2: Windows以外のOS</span></summary>
+
+Windows 以外の OS の場合は、次の 2 か所で設定する必要があります。
+
+### エディター内プロセスのタイムアウト
+
+1. Unityエディターを開きます
+2. **Tools > MCP Unity > Server Window** に移動します
+3. **Request Timeout (seconds)** の値を希望のタイムアウト秒数に変更します
+
+### WebSocketのタイムアウト
+
+1. ターミナルで UNITY_REQUEST_TIMEOUT 環境変数を設定します
+    - Powershell
+   ```powershell
+   $env:UNITY_REQUEST_TIMEOUT = "300"
+   ```
+    - Command Prompt/Terminal
+   ```cmd
+   set UNITY_REQUEST_TIMEOUT=300
+   ```
+2. Node.jsサーバーを再起動します
+3. **Start Server** をもう一度クリックして、UnityエディターのWebソケットをNode.js MCPサーバーに再接続します
+
+</details>
+
+> [!TIP]  
+> AIコーディングIDE（Claude Desktop、Cursor IDE、Windsurf IDE など）とMCPサーバー間のタイムアウト設定は、IDEによって異なります。
+
 ## <a name="debug-server"></a>サーバーのデバッグ
 
 MCP Unityサーバーをデバッグするには、以下の方法を使用できます：
@@ -230,30 +277,61 @@ MCP Unityサーバーをデバッグするには、以下の方法を使用で
 
 ## トラブルシューティング
 
-### <a name="common-issues"></a>よくある問題
-
-#### サーバーが起動しない
+<details>
+<summary><span style="font-size: 1.1em; font-weight: bold;">接続の問題</span></summary>
 
-- Node.js 18以降がインストールされていることを確認
-- npm 9以降がインストールされていることを確認
-- MCP Unityサーバーディレクトリが正しいことを確認
+- WebSocketサーバーが実行中であることを確認してください（UnityのServer Windowを確認）
+- ファイアウォールの制限が接続を妨げていないか確認してください
+- ポート番号が正しいことを確認してください（デフォルトは8080）
+- UnityエディターのMCP Serverウィンドウでポート番号を変更できます（ツール > MCP Unity > Server Window）
+</details>
 
-#### メニュー項目が実行されない
+<details>
+<summary><span style="font-size: 1.1em; font-weight: bold;">サーバーが起動しない</span></summary>
 
-- メニュー項目のパスが正しいことを確認（大文字小文字を区別）
-- メニュー項目が確認を必要とするかどうかを確認
-- メニュー項目が現在のコンテキストで利用可能であることを確認
+- Unityコンソールにエラーメッセージがないか確認してください
+- Node.jsが正しくインストールされ、PATHで利用可能であることを確認してください
+- Serverディレクトリ内の依存関係がすべてインストールされていることを確認してください
+</details>
 
-#### Play Modeテスト実行時に `Connection failed` エラー
+<details>
+<summary><span style="font-size: 1.1em; font-weight: bold;">Play Modeテスト実行時の接続失敗</span></summary>
 
-`run_tests` ツールの実行が次のエラーを返します：
+`run_tests` ツールは以下の応答を返します：
 ```
 Error:
 Connection failed: Unknown error
 ```
 
-このエラーは、Play Modeに切り替わる際にドメインがリロードされるため、ブリッジ接続が失われることで発生します。  
-回避方法は、**Edit > Project Settings > Editor > "Enter Play Mode Settings"** で **Reload Domain** をオフにすることです。
+このエラーは、Play Modeへ切り替える際にドメインリロードが発生し、ブリッジ接続が失われるために発生します。  
+回避策は、**Edit > Project Settings > Editor > "Enter Play Mode Settings"** で **Reload Domain** をオフにすることです。
+</details>
+
+## サポート・フィードバック
+
+ご質問やサポートが必要な場合は、このリポジトリの[issue](https://github.com/CoderGamester/mcp-unity/issues)をご利用ください。
+
+また、以下でも連絡可能です：
+- Linkedin: [![](https://img.shields.io/badge/LinkedIn-0077B5?style=flat&logo=linkedin&logoColor=white 'LinkedIn')](https://www.linkedin.com/in/miguel-tomas/)
+- Discord: gamester7178
+- メール: game.gamester@gmail.com
+
+## コントリビューション
+
+コントリビューションは大歓迎です！Pull Requestの送信やIssueの提出をお待ちしています。
+
+**変更は [Conventional Commits](https://www.conventionalcommits.org/ja/v1.0.0/) フォーマットに従ってください。**
+
+## ライセンス
+
+本プロジェクトは [MIT License](License.md) の下で提供されています。
+
+## 謝辞
+
+- [Model Context Protocol](https://modelcontextprotocol.io)
+- [Unity Technologies](https://unity.com)
+- [Node.js](https://nodejs.org)
+- [WebSocket-Sharp](https://github.com/sta/websocket-sharp)
 
 ## 貢献
 
diff --git a/README.md b/README.md
index 719f0fec..800ec710 100644
--- a/README.md
+++ b/README.md
@@ -76,8 +76,8 @@ MCP Unity provides automatic integration with VSCode-like IDEs (Visual Studio Co
 - `run_tests`: Runs tests using the Unity Test Runner
   > **Example prompt:** "Run all the EditMode tests in my project"
 
-- `notify_message`: Displays messages in the Unity Editor
-  > **Example prompt:** "Send a notification to Unity that the task has been completed"
+- `send_console_log`: Send a console log to Unity
+  > **Example prompt:** "Send a console log to Unity Editor"
 
 - `add_asset_to_scene`: Adds an asset from the AssetDatabase to the Unity scene
   > **Example prompt:** "Add the Player prefab from my project to the current scene"
@@ -236,6 +236,53 @@ By default, the WebSocket server runs on port 8090. You can change this port in
 
 </details>
 
+## Optional: Set Timeout
+
+By default, the timeout between the MCP server and the WebSocket is 10 seconds.
+You can change depending on the OS you are using:
+
+<details>
+<summary><span style="font-size: 1.1em; font-weight: bold;">Option 1: Windows OS</span></summary>
+
+1. Open the Unity Editor
+2. Navigate to Tools > MCP Unity > Server Window
+3. Change the "Request Timeout (seconds)" value to your desired timeout seconds
+4. Unity will setup the system environment variable UNITY_REQUEST_TIMEOUT to the new timeout value
+5. Restart the Node.js server
+6. Click again on "Start Server" to reconnect the Unity Editor web socket to the Node.js MCP Server
+
+</details>
+
+<details>
+<summary><span style="font-size: 1.1em; font-weight: bold;">Option 2: Non-Windows OS</span></summary>
+
+For non-Windows OS, you need to configure two places:
+
+### In Editor Process Timeout
+
+1. Open the Unity Editor
+2. Navigate to Tools > MCP Unity > Server Window
+3. Change the "Request Timeout (seconds)" value to your desired timeout seconds
+
+### WebSocket Timeout
+
+1. Set the UNITY_REQUEST_TIMEOUT environment variable in the terminal
+    - Powershell
+   ```powershell
+   $env:UNITY_REQUEST_TIMEOUT = "300"
+   ```
+    - Command Prompt/Terminal
+   ```cmd
+   set UNITY_REQUEST_TIMEOUT=300
+   ```
+2. Restart the Node.js server
+3. Click again on "Start Server" to reconnect the Unity Editor web socket to the Node.js MCP Server
+
+</details>
+
+> [!TIP]  
+> The timeout between your AI Coding IDE (e.g., Claude Desktop, Cursor IDE, Windsurf IDE) and the MCP Server depends on the IDE.
+
 ## <a name="debug-server"></a>Debugging the Server
 
 <details>
@@ -306,8 +353,7 @@ Don't forget to shutdown the server with `Ctrl + C` before closing the terminal
 <summary><span style="font-size: 1.1em; font-weight: bold;">Connection Issues</span></summary>
 
 - Ensure the WebSocket server is running (check the Server Window in Unity)
-- Check if there are any firewall restrictions blocking the connection
-- Make sure the port number is correct (default is 8080)
+- Send a console log message from MCP client to force a reconnection between MCP client and Unity server
 - Change the port number in the Unity Editor MCP Server window. (Tools > MCP Unity > Server Window)
 </details>
 
@@ -319,14 +365,6 @@ Don't forget to shutdown the server with `Ctrl + C` before closing the terminal
 - Verify that all dependencies are installed in the Server directory
 </details>
 
-<details>
-<summary><span style="font-size: 1.1em; font-weight: bold;">Menu Items Not Executing</span></summary>
-
-- Ensure the menu item path is correct (case-sensitive)
-- Check if the menu item requires confirmation
-- Verify that the menu item is available in the current context
-</details>
-
 <details>
 <summary><span style="font-size: 1.1em; font-weight: bold;">Connection failed when running Play Mode tests</span></summary>
 
diff --git a/README_zh-CN.md b/README_zh-CN.md
index a277a1fd..f1839213 100644
--- a/README_zh-CN.md
+++ b/README_zh-CN.md
@@ -78,8 +78,8 @@ MCP Unity 通过将 Unity `Library/PackedCache` 文件夹添加到您的工作
 - `run_tests`: 使用 Unity 测试运行器运行测试
   > **示例提示:** "运行我项目中所有的 EditMode 测试"
 
-- `notify_message`: 在 Unity 编辑器中显示消息
-  > **示例提示:** "发送通知到 Unity 告知任务已完成"
+- `send_console_log`: 发送控制台日志到 Unity
+  > **示例提示:** "发送控制台日志到 Unity 编辑器"
 
 - `add_asset_to_scene`: 将 AssetDatabase 中的资源添加到 Unity 场景中
   > **示例提示:** "将我的项目中的 Player 预制体添加到当前场景"
@@ -213,6 +213,53 @@ MCP Unity 通过将 Unity `Library/PackedCache` 文件夹添加到您的工作
    node Server/build/index.js
    ```
 
+## 可选：设置超时
+
+默认情况下，MCP 服务器与 WebSocket 之间的超时时间为 10 秒。
+您可以根据所使用的操作系统进行更改：
+
+<details>
+<summary><span style="font-size: 1.1em; font-weight: bold;">Option 1: Windows OS</span></summary>
+
+1. 打开 Unity 编辑器
+2. 导航至 Tools > MCP Unity > Server Window
+3. 将 "Request Timeout (seconds)" 值更改为所需的超时秒数
+4. Unity 会将系统环境变量 UNITY_REQUEST_TIMEOUT 设置为新的超时值
+5. 重启 Node.js 服务器
+6. 再次点击“启动服务器”，将 Unity 编辑器 Web 套接字重新连接到 Node.js MCP 服务器
+
+</details>
+
+<details>
+<summary><span style="font-size: 1.1em; font-weight: bold;">Option 2: 非Windows操作系统</span></summary>
+
+对于非Windows操作系统，需要配置两个地方：
+
+### 编辑器进程超时
+
+1. 打开 Unity 编辑器
+2. 导航至 Tools > MCP Unity > Server Window
+3. 将 "Request Timeout (seconds)" 值更改为所需的超时秒数
+
+### WebSocket 超时
+
+1. 在终端中设置 UNITY_REQUEST_TIMEOUT 环境变量
+    - Powershell
+   ```powershell
+   $env:UNITY_REQUEST_TIMEOUT = "300"
+   ```
+    - Command Prompt/Terminal
+   ```cmd
+   set UNITY_REQUEST_TIMEOUT=300
+   ```
+2. 重启 Node.js 服务器
+3. 再次点击“启动服务器”，将 Unity 编辑器 Web 套接字重新连接到 Node.js MCP 服务器
+
+</details>
+
+> [!TIP]  
+> 您的 AI 编码 IDE（例如，Claude Desktop、Cursor IDE、Windsurf IDE）和 MCP 服务器之间的超时取决于 IDE。
+
 ## <a name="debug-server"></a>调试服务器
 
 要调试 MCP Unity 服务器，您可以使用以下方法：
@@ -232,21 +279,25 @@ MCP Unity 通过将 Unity `Library/PackedCache` 文件夹添加到您的工作
 
 ## 故障排除
 
-### <a name="common-issues"></a>常见问题
-
-#### 服务器无法启动
+<details>
+<summary><span style="font-size: 1.1em; font-weight: bold;">连接问题</span></summary>
 
-- 确保 Node.js 18 或更高版本已安装
-- 验证 npm 9 或更高版本已安装
-- 检查 MCP Unity 服务器目录是否正确
+- 确保 WebSocket 服务器正在运行（检查 Unity 的 Server Window）
+- 检查是否有防火墙限制阻止连接
+- 确认端口号正确（默认是 8080）
+- 可在 Unity 编辑器 MCP Server 窗口更改端口号。(工具 > MCP Unity > Server Window)
+</details>
 
-#### 菜单项无法执行
+<details>
+<summary><span style="font-size: 1.1em; font-weight: bold;">服务器无法启动</span></summary>
 
-- 确保菜单项路径正确（区分大小写）
-- 检查菜单项是否需要确认
-- 验证菜单项在当前上下文中是否可用
+- 检查 Unity 控制台是否有错误消息
+- 确保 Node.js 已正确安装并可在 PATH 中访问
+- 验证 Server 目录下所有依赖均已安装
+</details>
 
-#### 运行播放模式测试时连接失败
+<details>
+<summary><span style="font-size: 1.1em; font-weight: bold;">运行播放模式测试时连接失败</span></summary>
 
 `run_tests` 工具返回以下响应：
 ```
@@ -254,8 +305,35 @@ Error:
 Connection failed: Unknown error
 ```
 
-发生此错误的原因是在切换到播放模式触发域重新加载时，桥接连接会丢失。  
+发生此错误的原因是在切换到播放模式时域重新加载，导致桥接连接丢失。  
 解决方法是在 **Edit > Project Settings > Editor > "Enter Play Mode Settings"** 中关闭 **Reload Domain**。
+</details>
+
+## 支持与反馈
+
+如有任何问题或需要支持，请在本仓库[提交 issue](https://github.com/CoderGamester/mcp-unity/issues)。
+
+你也可以通过以下方式联系：
+- Linkedin: [![](https://img.shields.io/badge/LinkedIn-0077B5?style=flat&logo=linkedin&logoColor=white 'LinkedIn')](https://www.linkedin.com/in/miguel-tomas/)
+- Discord: gamester7178
+- 邮箱: game.gamester@gmail.com
+
+## 贡献
+
+欢迎贡献！请随时提交 Pull Request 或提出 Issue。
+
+**请遵循 [Conventional Commits](https://www.conventionalcommits.org/zh-hans/v1.0.0/) 格式提交更改。**
+
+## 许可证
+
+本项目采用 [MIT License](License.md) 授权。
+
+## 鸣谢
+
+- [Model Context Protocol](https://modelcontextprotocol.io)
+- [Unity Technologies](https://unity.com)
+- [Node.js](https://nodejs.org)
+- [WebSocket-Sharp](https://github.com/sta/websocket-sharp)
 
 ## 贡献
 
diff --git a/Server/build/index.js b/Server/build/index.js
index e0faf2fa..44c35174 100644
--- a/Server/build/index.js
+++ b/Server/build/index.js
@@ -7,7 +7,7 @@ import { createMenuItemTool } from './tools/menuItemTool.js';
 import { createSelectGameObjectTool } from './tools/selectGameObjectTool.js';
 import { createAddPackageTool } from './tools/addPackageTool.js';
 import { createRunTestsTool } from './tools/runTestsTool.js';
-import { createNotifyMessageTool } from './tools/notifyMessageTool.js';
+import { createSendConsoleLogTool } from './tools/sendConsoleLogTool.js';
 import { createUpdateComponentTool } from './tools/updateComponentTool.js';
 import { createAddAssetToSceneTool } from './tools/addAssetToSceneTool.js';
 import { createGetMenuItemsResource } from './resources/getMenuItemResource.js';
@@ -39,7 +39,7 @@ createMenuItemTool(server, mcpUnity, toolLogger);
 createSelectGameObjectTool(server, mcpUnity, toolLogger);
 createAddPackageTool(server, mcpUnity, toolLogger);
 createRunTestsTool(server, mcpUnity, toolLogger);
-createNotifyMessageTool(server, mcpUnity, toolLogger);
+createSendConsoleLogTool(server, mcpUnity, toolLogger);
 createUpdateComponentTool(server, mcpUnity, toolLogger);
 createAddAssetToSceneTool(server, mcpUnity, toolLogger);
 // Create and register all resources with the MCP server
diff --git a/Server/build/resources/getTestsResource.js b/Server/build/resources/getTestsResource.js
index 5c0114e2..74f7a2f6 100644
--- a/Server/build/resources/getTestsResource.js
+++ b/Server/build/resources/getTestsResource.js
@@ -17,14 +17,20 @@ function listTestModes(resourceMimeType) {
         resources: [
             {
                 uri: `unity://tests/EditMode`,
-                name: "EditMode tests",
-                description: "List of all EditMode tests in Unity's test runner",
+                name: "List only 'EditMode' tests",
+                description: "List only 'EditMode' tests from Unity's test runner",
                 mimeType: resourceMimeType
             },
             {
                 uri: `unity://tests/PlayMode`,
-                name: "PlayMode tests",
-                description: "List of all PlayMode tests in Unity's test runner",
+                name: "List only 'PlayMode' tests",
+                description: "List only 'PlayMode' tests from Unity's test runner",
+                mimeType: resourceMimeType
+            },
+            {
+                uri: `unity://tests/`,
+                name: "List all tests",
+                description: "List of all tests in Unity's test runner, this includes PlayMode and EditMode tests",
                 mimeType: resourceMimeType
             }
         ]
@@ -66,7 +72,7 @@ export function createGetTestsResource(server, mcpUnity, logger) {
  */
 async function resourceHandler(mcpUnity, uri, variables) {
     // Convert the new handler signature to work with our existing code
-    const testMode = variables["testMode"] || 'EditMode';
+    const testMode = variables["testMode"];
     const response = await mcpUnity.sendRequest({
         method: resourceName,
         params: {
diff --git a/Server/build/tools/runTestsTool.js b/Server/build/tools/runTestsTool.js
index cd2c00d0..4b461a13 100644
--- a/Server/build/tools/runTestsTool.js
+++ b/Server/build/tools/runTestsTool.js
@@ -4,8 +4,9 @@ import { McpUnityError, ErrorType } from '../utils/errors.js';
 const toolName = 'run_tests';
 const toolDescription = 'Runs Unity\'s Test Runner tests';
 const paramsSchema = z.object({
-    testMode: z.string().optional().describe('The test mode to run (EditMode or PlayMode) - defaults to EditMode (optional)'),
-    testFilter: z.string().optional().describe('The specific test filter to run (e.g. specific test name or namespace) (optional)')
+    testMode: z.string().optional().default('EditMode').describe('The test mode to run (EditMode or PlayMode) - defaults to EditMode (optional)'),
+    testFilter: z.string().optional().default('').describe('The specific test filter to run (e.g. specific test name or namespace) (optional)'),
+    returnOnlyFailures: z.boolean().optional().default(true).describe('Whether to show only failed tests in the results (optional)')
 });
 /**
  * Creates and registers the Run Tests tool with the MCP server
@@ -18,7 +19,7 @@ const paramsSchema = z.object({
 export function createRunTestsTool(server, mcpUnity, logger) {
     logger.info(`Registering tool: ${toolName}`);
     // Register this tool with the MCP server
-    server.tool(toolName, toolDescription, paramsSchema.shape, async (params) => {
+    server.tool(toolName, toolDescription, paramsSchema.shape, async (params = {}) => {
         try {
             logger.info(`Executing tool: ${toolName}`, params);
             const result = await toolHandler(mcpUnity, params);
@@ -39,14 +40,15 @@ export function createRunTestsTool(server, mcpUnity, logger) {
  * @returns A promise that resolves to the tool execution result
  * @throws McpUnityError if the request to Unity fails
  */
-async function toolHandler(mcpUnity, params) {
-    const { testMode = 'EditMode', testFilter } = params;
+async function toolHandler(mcpUnity, params = {}) {
+    const { testMode = 'EditMode', testFilter = '', returnOnlyFailures = true } = params;
     // Create and wait for the test run
     const response = await mcpUnity.sendRequest({
         method: toolName,
         params: {
             testMode,
-            testFilter
+            testFilter,
+            returnOnlyFailures
         }
     });
     // Process the test results
@@ -58,21 +60,12 @@ async function toolHandler(mcpUnity, params) {
     const testCount = response.testCount || 0;
     const passCount = response.passCount || 0;
     const failCount = response.failCount || 0;
-    const inconclusiveCount = response.inconclusiveCount || 0;
     const skipCount = response.skipCount || 0;
-    // Format the result message
-    let resultMessage = `${passCount}/${testCount} tests passed`;
-    if (testCount > 0 && passCount < testCount) {
-        resultMessage += `. Failed tests: ${testResults
-            .filter((r) => r.result !== 'Passed')
-            .map((r) => r.name)
-            .join(', ')}`;
-    }
     return {
         content: [
             {
                 type: 'text',
-                text: resultMessage || response.message
+                text: response.message
             },
             {
                 type: 'text',
@@ -80,7 +73,6 @@ async function toolHandler(mcpUnity, params) {
                     testCount,
                     passCount,
                     failCount,
-                    inconclusiveCount,
                     skipCount,
                     results: testResults
                 }, null, 2)
diff --git a/Server/build/tools/sendConsoleLogTool.d.ts b/Server/build/tools/sendConsoleLogTool.d.ts
new file mode 100644
index 00000000..8eaba712
--- /dev/null
+++ b/Server/build/tools/sendConsoleLogTool.d.ts
@@ -0,0 +1,12 @@
+import { Logger } from '../utils/logger.js';
+import { McpUnity } from '../unity/mcpUnity.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Creates and registers the Send Console Log tool with the MCP server
+ * This tool allows sending messages to the Unity console
+ *
+ * @param server The MCP server instance to register with
+ * @param mcpUnity The McpUnity instance to communicate with Unity
+ * @param logger The logger instance for diagnostic information
+ */
+export declare function createSendConsoleLogTool(server: McpServer, mcpUnity: McpUnity, logger: Logger): void;
diff --git a/Server/src/tools/notifyMessageTool.ts.meta b/Server/build/tools/sendConsoleLogTool.d.ts.meta
similarity index 74%
rename from Server/src/tools/notifyMessageTool.ts.meta
rename to Server/build/tools/sendConsoleLogTool.d.ts.meta
index f98967dd..5c8ced54 100644
--- a/Server/src/tools/notifyMessageTool.ts.meta
+++ b/Server/build/tools/sendConsoleLogTool.d.ts.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 46b2a32d3d3a076479aadb9728235e9c
+guid: 0963564453d22894c9db3e635922fd1c
 DefaultImporter:
   externalObjects: {}
   userData: 
diff --git a/Server/build/tools/sendConsoleLogTool.js b/Server/build/tools/sendConsoleLogTool.js
new file mode 100644
index 00000000..0b152b1a
--- /dev/null
+++ b/Server/build/tools/sendConsoleLogTool.js
@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { McpUnityError, ErrorType } from '../utils/errors.js';
+// Constants for the tool
+const toolName = 'send_console_log';
+const toolDescription = 'Sends console log messages to the Unity console';
+const paramsSchema = z.object({
+    message: z.string().describe('The message to display in the Unity console'),
+    type: z.string().optional().describe('The type of message (info, warning, error) - defaults to info (optional)')
+});
+/**
+ * Creates and registers the Send Console Log tool with the MCP server
+ * This tool allows sending messages to the Unity console
+ *
+ * @param server The MCP server instance to register with
+ * @param mcpUnity The McpUnity instance to communicate with Unity
+ * @param logger The logger instance for diagnostic information
+ */
+export function createSendConsoleLogTool(server, mcpUnity, logger) {
+    logger.info(`Registering tool: ${toolName}`);
+    // Register this tool with the MCP server
+    server.tool(toolName, toolDescription, paramsSchema.shape, async (params) => {
+        try {
+            logger.info(`Executing tool: ${toolName}`, params);
+            const result = await toolHandler(mcpUnity, params);
+            logger.info(`Tool execution successful: ${toolName}`);
+            return result;
+        }
+        catch (error) {
+            logger.error(`Tool execution failed: ${toolName}`, error);
+            throw error;
+        }
+    });
+}
+/**
+ * Handles notification message requests
+ *
+ * @param mcpUnity The McpUnity instance to communicate with Unity
+ * @param params The parameters for the tool
+ * @returns A promise that resolves to the tool execution result
+ * @throws McpUnityError if the request to Unity fails
+ */
+async function toolHandler(mcpUnity, params) {
+    const { message, type = 'info' } = params;
+    // Send to Unity
+    const response = await mcpUnity.sendRequest({
+        method: toolName,
+        params: {
+            message,
+            type
+        }
+    });
+    if (!response.success) {
+        throw new McpUnityError(ErrorType.TOOL_EXECUTION, response.message || `Failed to send message to Unity console`);
+    }
+    return {
+        content: [{
+                type: response.type,
+                text: response.message
+            }]
+    };
+}
diff --git a/Server/build/tools/sendConsoleLogTool.js.meta b/Server/build/tools/sendConsoleLogTool.js.meta
new file mode 100644
index 00000000..3f1a35d9
--- /dev/null
+++ b/Server/build/tools/sendConsoleLogTool.js.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 212342734ce3429469b615bf02b08f08
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Server/build/unity/mcpUnity.js b/Server/build/unity/mcpUnity.js
index 44fd6935..7013a8f8 100644
--- a/Server/build/unity/mcpUnity.js
+++ b/Server/build/unity/mcpUnity.js
@@ -8,7 +8,7 @@ export class McpUnity {
     port;
     ws = null;
     pendingRequests = new Map();
-    REQUEST_TIMEOUT = 10000;
+    REQUEST_TIMEOUT;
     retryDelay = 1000;
     constructor(logger) {
         this.logger = logger;
@@ -19,6 +19,10 @@ export class McpUnity {
         const envPort = process.env.UNITY_PORT || envRegistry;
         this.port = envPort ? parseInt(envPort, 10) : 8090;
         this.logger.info(`Using port: ${this.port} for Unity WebSocket connection`);
+        // Initialize timeout from environment variable (in seconds; it is the same as Cline) or use default (10 seconds)
+        const envTimeout = process.env.UNITY_REQUEST_TIMEOUT;
+        this.REQUEST_TIMEOUT = envTimeout ? parseInt(envTimeout, 10) * 1000 : 10000;
+        this.logger.info(`Using request timeout: ${this.REQUEST_TIMEOUT / 1000} seconds`);
     }
     /**
      * Start the Unity connection
diff --git a/Server/src/index.ts b/Server/src/index.ts
index c8c697a9..6aad3fab 100644
--- a/Server/src/index.ts
+++ b/Server/src/index.ts
@@ -7,7 +7,7 @@ import { createMenuItemTool } from './tools/menuItemTool.js';
 import { createSelectGameObjectTool } from './tools/selectGameObjectTool.js';
 import { createAddPackageTool } from './tools/addPackageTool.js';
 import { createRunTestsTool } from './tools/runTestsTool.js';
-import { createNotifyMessageTool } from './tools/notifyMessageTool.js';
+import { createSendConsoleLogTool } from './tools/sendConsoleLogTool.js';
 import { createUpdateComponentTool } from './tools/updateComponentTool.js';
 import { createAddAssetToSceneTool } from './tools/addAssetToSceneTool.js';
 import { createGetMenuItemsResource } from './resources/getMenuItemResource.js';
@@ -46,7 +46,7 @@ createMenuItemTool(server, mcpUnity, toolLogger);
 createSelectGameObjectTool(server, mcpUnity, toolLogger);
 createAddPackageTool(server, mcpUnity, toolLogger);
 createRunTestsTool(server, mcpUnity, toolLogger);
-createNotifyMessageTool(server, mcpUnity, toolLogger);
+createSendConsoleLogTool(server, mcpUnity, toolLogger);
 createUpdateComponentTool(server, mcpUnity, toolLogger);
 createAddAssetToSceneTool(server, mcpUnity, toolLogger);
 
diff --git a/Server/src/resources/getTestsResource.ts b/Server/src/resources/getTestsResource.ts
index 279cb190..2926bec3 100644
--- a/Server/src/resources/getTestsResource.ts
+++ b/Server/src/resources/getTestsResource.ts
@@ -31,14 +31,20 @@ function listTestModes(resourceMimeType: string) {
     resources: [
       { 
         uri: `unity://tests/EditMode`, 
-        name: "EditMode tests",
-        description: "List of all EditMode tests in Unity's test runner",
+        name: "List only 'EditMode' tests",
+        description: "List only 'EditMode' tests from Unity's test runner",
         mimeType: resourceMimeType
       },
       { 
         uri: `unity://tests/PlayMode`, 
-        name: "PlayMode tests",
-        description: "List of all PlayMode tests in Unity's test runner",
+        name: "List only 'PlayMode' tests",
+        description: "List only 'PlayMode' tests from Unity's test runner",
+        mimeType: resourceMimeType
+      },
+      { 
+        uri: `unity://tests/`, 
+        name: "List all tests",
+        description: "List of all tests in Unity's test runner, this includes PlayMode and EditMode tests",
         mimeType: resourceMimeType
       }
     ]
@@ -75,7 +81,6 @@ export function createGetTestsResource(server: McpServer, mcpUnity: McpUnity, lo
   );
 }
 
-
 /**
  * Handles requests for test information from Unity's Test Runner
  * Retrieves tests filtered by test mode (EditMode or PlayMode)
@@ -88,7 +93,7 @@ export function createGetTestsResource(server: McpServer, mcpUnity: McpUnity, lo
  */
 async function resourceHandler(mcpUnity: McpUnity, uri: URL, variables: Variables): Promise<ReadResourceResult> {
   // Convert the new handler signature to work with our existing code
-  const testMode = variables["testMode"] || 'EditMode';
+  const testMode = variables["testMode"];
   
   const response = await mcpUnity.sendRequest({
     method: resourceName,
diff --git a/Server/src/tools/runTestsTool.ts b/Server/src/tools/runTestsTool.ts
index b8de19a3..90573198 100644
--- a/Server/src/tools/runTestsTool.ts
+++ b/Server/src/tools/runTestsTool.ts
@@ -10,7 +10,8 @@ const toolName = 'run_tests';
 const toolDescription = 'Runs Unity\'s Test Runner tests';
 const paramsSchema = z.object({
   testMode: z.string().optional().describe('The test mode to run (EditMode or PlayMode) - defaults to EditMode (optional)'),
-  testFilter: z.string().optional().describe('The specific test filter to run (e.g. specific test name or namespace) (optional)')
+  testFilter: z.string().optional().describe('The specific test filter to run (e.g. specific test name or namespace) (optional)'),
+  returnOnlyFailures: z.boolean().optional().default(true).describe('Whether to show only failed tests in the results (optional)')
 });
 
 /**
@@ -29,7 +30,7 @@ export function createRunTestsTool(server: McpServer, mcpUnity: McpUnity, logger
     toolName,
     toolDescription,
     paramsSchema.shape,
-    async (params: any) => {
+    async (params: any = {}) => {
       try {
         logger.info(`Executing tool: ${toolName}`, params);
         const result = await toolHandler(mcpUnity, params);
@@ -51,15 +52,20 @@ export function createRunTestsTool(server: McpServer, mcpUnity: McpUnity, logger
  * @returns A promise that resolves to the tool execution result
  * @throws McpUnityError if the request to Unity fails
  */
-async function toolHandler(mcpUnity: McpUnity, params: any): Promise<CallToolResult> {
-  const { testMode = 'EditMode', testFilter } = params;
+async function toolHandler(mcpUnity: McpUnity, params: any = {}): Promise<CallToolResult> {
+  const {
+    testMode = 'EditMode',
+    testFilter = '',
+    returnOnlyFailures = true
+  } = params;
 
   // Create and wait for the test run
   const response = await mcpUnity.sendRequest({
     method: toolName,
     params: { 
       testMode,
-      testFilter
+      testFilter,
+      returnOnlyFailures
     }
   });
   
@@ -76,23 +82,13 @@ async function toolHandler(mcpUnity: McpUnity, params: any): Promise<CallToolRes
   const testCount = response.testCount || 0;
   const passCount = response.passCount || 0;
   const failCount = response.failCount || 0;
-  const inconclusiveCount = response.inconclusiveCount || 0;
   const skipCount = response.skipCount || 0;
   
-  // Format the result message
-  let resultMessage = `${passCount}/${testCount} tests passed`;
-  if (testCount > 0 && passCount < testCount) {
-    resultMessage += `. Failed tests: ${testResults
-      .filter((r: any) => r.result !== 'Passed')
-      .map((r: any) => r.name)
-      .join(', ')}`;
-  }
-  
   return {
     content: [
       {
         type: 'text',
-        text: resultMessage || response.message
+        text: response.message
       },
       {
         type: 'text',
@@ -100,7 +96,6 @@ async function toolHandler(mcpUnity: McpUnity, params: any): Promise<CallToolRes
           testCount,
           passCount,
           failCount,
-          inconclusiveCount,
           skipCount,
           results: testResults
         }, null, 2)
diff --git a/Server/src/tools/notifyMessageTool.ts b/Server/src/tools/sendConsoleLogTool.ts
similarity index 88%
rename from Server/src/tools/notifyMessageTool.ts
rename to Server/src/tools/sendConsoleLogTool.ts
index b53975fc..492e72f9 100644
--- a/Server/src/tools/notifyMessageTool.ts
+++ b/Server/src/tools/sendConsoleLogTool.ts
@@ -6,22 +6,22 @@ import { McpUnityError, ErrorType } from '../utils/errors.js';
 import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 
 // Constants for the tool
-const toolName = 'notify_message';
-const toolDescription = 'Sends a message to the Unity console';
+const toolName = 'send_console_log';
+const toolDescription = 'Sends console log messages to the Unity console';
 const paramsSchema = z.object({
   message: z.string().describe('The message to display in the Unity console'),
   type: z.string().optional().describe('The type of message (info, warning, error) - defaults to info (optional)')
 });
 
 /**
- * Creates and registers the Notify Message tool with the MCP server
+ * Creates and registers the Send Console Log tool with the MCP server
  * This tool allows sending messages to the Unity console
  * 
  * @param server The MCP server instance to register with
  * @param mcpUnity The McpUnity instance to communicate with Unity
  * @param logger The logger instance for diagnostic information
  */
-export function createNotifyMessageTool(server: McpServer, mcpUnity: McpUnity, logger: Logger) {
+export function createSendConsoleLogTool(server: McpServer, mcpUnity: McpUnity, logger: Logger) {
   logger.info(`Registering tool: ${toolName}`);
   
   // Register this tool with the MCP server
diff --git a/Server/src/tools/sendConsoleLogTool.ts.meta b/Server/src/tools/sendConsoleLogTool.ts.meta
new file mode 100644
index 00000000..4a578be9
--- /dev/null
+++ b/Server/src/tools/sendConsoleLogTool.ts.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 55291baeb7210f64888ab4e7668b5fbc
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Server/src/unity/mcpUnity.ts b/Server/src/unity/mcpUnity.ts
index 3b552635..83838c00 100644
--- a/Server/src/unity/mcpUnity.ts
+++ b/Server/src/unity/mcpUnity.ts
@@ -33,7 +33,7 @@ export class McpUnity {
   private port: number;
   private ws: WebSocket | null = null;
   private pendingRequests: Map<string, PendingRequest> = new Map<string, PendingRequest>();
-  private readonly REQUEST_TIMEOUT = 10000;
+  private readonly REQUEST_TIMEOUT: number;
   private retryDelay = 1000;
   
   constructor(logger: Logger) {
@@ -46,8 +46,12 @@ export class McpUnity {
     
     const envPort = process.env.UNITY_PORT || envRegistry;
     this.port = envPort ? parseInt(envPort, 10) : 8090;
-    
     this.logger.info(`Using port: ${this.port} for Unity WebSocket connection`);
+    
+    // Initialize timeout from environment variable (in seconds; it is the same as Cline) or use default (10 seconds)
+    const envTimeout = process.env.UNITY_REQUEST_TIMEOUT;
+    this.REQUEST_TIMEOUT = envTimeout ? parseInt(envTimeout, 10) * 1000 : 10000;
+    this.logger.info(`Using request timeout: ${this.REQUEST_TIMEOUT / 1000} seconds`);
   }
   
   /**
diff --git a/package.json b/package.json
index c4bf5bfb..54230587 100644
--- a/package.json
+++ b/package.json
@@ -2,7 +2,7 @@
   "name": "com.gamelovers.mcp-unity",
   "displayName": "MCP Unity Server",
   "author": "CoderGamester",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "unity": "2022.3",
   "license": "MIT",
   "description": "The purpose of this package is to provide a MCP Unity Server for executing Unity operations and request Editor information from AI MCP enabled hosts",
