Harden MCP tool parameter handling + add material workflow tests (TDD) (#343)

* Add TDD tests for MCP material management issues

- MCPMaterialTests.cs: Tests for material creation, assignment, and data reading
- MCPParameterHandlingTests.cs: Tests for JSON parameter parsing issues
- SphereMaterialWorkflowTests.cs: Tests for complete sphere material workflow

These tests document the current issues with:
- JSON parameter parsing in manage_asset and manage_gameobject tools
- Material creation with properties
- Material assignment to GameObjects
- Material component data reading

All tests currently fail (Red phase of TDD) and serve as specifications
for what needs to be fixed in the MCP system.

* Refine TDD tests to focus on actual MCP tool parameter parsing issues

- Removed redundant tests that verify working functionality (GameObjectSerializer, Unity APIs)
- Kept focused tests that document the real issue: MCP tool parameter validation
- Tests now clearly identify the root cause: JSON string parsing in MCP tools
- Tests specify exactly what needs to be fixed: parameter type flexibility

The issue is NOT in Unity APIs or serialization (which work fine),
but in MCP tool parameter validation being too strict.

* Fix port discovery protocol mismatch

- Update _try_probe_unity_mcp to recognize Unity bridge welcome message
- Unity bridge sends 'WELCOME UNITY-MCP' instead of JSON pong response
- Maintains backward compatibility with JSON pong format
- Fixes MCP server connection to Unity Editor

* Resolve merge: unify manage_gameobject param coercion and schema widening

* Tests: add MaterialParameterToolTests; merge port probe fix; widen tool schemas for JSON-string params

* refactor: extract JSON coercion helper; docs + exception narrowing\nfix: fail fast on bad component_properties JSON\ntest: unify setup, avoid test-to-test calls\nchore: use relative MCP package path

* chore(tests): track MCPToolParameterTests.cs.meta to keep GUID stable

* test: decouple MaterialParameterToolTests with helpers (no inter-test calls)

Author: dsarno

MCPForUnity/Editor/Tools/JsonUtil.cs

@@ -0,0 +1,32 @@
+using Newtonsoft.Json.Linq;
+using UnityEngine;
+
+namespace MCPForUnity.Editor.Tools
+{
+    internal static class JsonUtil
+    {
+        /// <summary>
+        /// If @params[paramName] is a JSON string, parse it to a JObject in-place.
+        /// Logs a warning on parse failure and leaves the original value.
+        /// </summary>
+        internal static void CoerceJsonStringParameter(JObject @params, string paramName)
+        {
+            if (@params == null || string.IsNullOrEmpty(paramName)) return;
+            var token = @params[paramName];
+            if (token != null && token.Type == JTokenType.String)
+            {
+                try
+                {
+                    var parsed = JObject.Parse(token.ToString());
+                    @params[paramName] = parsed;
+                }
+                catch (Newtonsoft.Json.JsonReaderException e)
+                {
+                    Debug.LogWarning($"[MCP] Could not parse '{paramName}' JSON string: {e.Message}");
+                }
+            }
+        }
+    }
+}
+
+

MCPForUnity/Editor/Tools/ManageAsset.cs

@@ -63,6 +63,9 @@ public static object HandleCommand(JObject @params)
             // Common parameters
             string path = @params["path"]?.ToString();
 
+            // Coerce string JSON to JObject for 'properties' if provided as a JSON string
+            JsonUtil.CoerceJsonStringParameter(@params, "properties");
+
             try
             {
                 switch (action)

MCPForUnity/Editor/Tools/ManageGameObject.cs

@@ -66,6 +66,9 @@ public static object HandleCommand(JObject @params)
             bool includeNonPublicSerialized = @params["includeNonPublicSerialized"]?.ToObject<bool>() ?? true; // Default to true
             // --- End add parameter ---
 
+            // Coerce string JSON to JObject for 'componentProperties' if provided as a JSON string
+            JsonUtil.CoerceJsonStringParameter(@params, "componentProperties");
+
             // --- Prefab Redirection Check ---
             string targetPath =
                 targetToken?.Type == JTokenType.String ? targetToken.ToString() : null;

MCPForUnity/UnityMcpServer~/src/tools/manage_asset.py

@@ -2,6 +2,7 @@
 Defines the manage_asset tool for interacting with Unity assets.
 """
 import asyncio
+import json
 from typing import Annotated, Any, Literal
 
 from fastmcp import Context
@@ -33,6 +34,14 @@ async def manage_asset(
     page_number: Annotated[int | float | str, "Page number for pagination"] | None = None
 ) -> dict[str, Any]:
     ctx.info(f"Processing manage_asset: {action}")
+    # Coerce 'properties' from JSON string to dict for client compatibility
+    if isinstance(properties, str):
+        try:
+            properties = json.loads(properties)
+            ctx.info("manage_asset: coerced properties from JSON string to dict")
+        except json.JSONDecodeError as e:
+            ctx.warn(f"manage_asset: failed to parse properties JSON string: {e}")
+            # Leave properties as-is; Unity side may handle defaults
     # Ensure properties is a dict if None
     if properties is None:
         properties = {}

MCPForUnity/UnityMcpServer~/src/tools/manage_gameobject.py

@@ -1,3 +1,4 @@
+import json
 from typing import Annotated, Any, Literal
 
 from fastmcp import Context
@@ -42,8 +43,9 @@ def manage_gameobject(
     layer: Annotated[str, "Layer name"] | None = None,
     components_to_remove: Annotated[list[str],
                                     "List of component names to remove"] | None = None,
-    component_properties: Annotated[dict[str, dict[str, Any]],
+    component_properties: Annotated[dict[str, dict[str, Any]] | str,
                                     """Dictionary of component names to their properties to set. For example:
+                                    Can also be provided as a JSON string representation of the dict.
                                     `{"MyScript": {"otherObject": {"find": "Player", "method": "by_name"}}}` assigns GameObject
                                     `{"MyScript": {"playerHealth": {"find": "Player", "component": "HealthComponent"}}}` assigns Component
                                     Example set nested property:
@@ -65,7 +67,7 @@ def manage_gameobject(
                                           "Controls whether serialization of private [SerializeField] fields is included (accepts true/false or 'true'/'false')"] | None = None,
 ) -> dict[str, Any]:
     ctx.info(f"Processing manage_gameobject: {action}")
-    
+
     # Coercers to tolerate stringified booleans and vectors
     def _coerce_bool(value, default=None):
         if value is None:
@@ -113,6 +115,13 @@ def _to_vec3(parts):
     search_inactive = _coerce_bool(search_inactive)
     includeNonPublicSerialized = _coerce_bool(includeNonPublicSerialized)
 
+    # Coerce 'component_properties' from JSON string to dict for client compatibility
+    if isinstance(component_properties, str):
+        try:
+            component_properties = json.loads(component_properties)
+            ctx.info("manage_gameobject: coerced component_properties from JSON string to dict")
+        except json.JSONDecodeError as e:
+            return {"success": False, "message": f"Invalid JSON in component_properties: {e}"}
     try:
         # Map tag to search_term when search_method is by_tag for backward compatibility
         if action == "find" and search_method == "by_tag" and tag is not None and search_term is None:

MCPForUnity/UnityMcpServer~/src/uv.lock

@@ -134,7 +134,12 @@ public void DoesNotAddEnvOrDisabled_ForTrae()
             var configPath = Path.Combine(_tempRoot, "trae.json");
             WriteInitialConfig(configPath, isVSCode: false, command: _fakeUvPath, directory: "/old/path");
 
-            var client = new McpClient { name = "Trae", mcpType = McpTypes.Trae };
+            if (!Enum.TryParse<McpTypes>("Trae", out var traeValue))
+            {
+                Assert.Ignore("McpTypes.Trae not available in this package version; skipping test.");
+            }
+
+            var client = new McpClient { name = "Trae", mcpType = traeValue };
             InvokeWriteToConfig(configPath, client);
 
             var root = JObject.Parse(File.ReadAllText(configPath));