Fix misleading 'Property not found' error and add SerializedProperty fallback (#765)

MCPForUnity/Editor/Helpers/ComponentOps.cs

@@ -174,15 +174,37 @@ public static bool SetProperty(Component component, string propertyName, JToken
                 return SetViaSerializedProperty(component, propertyName, normalizedName, value, out error);
             }
 
-            // Try property first - check both original and normalized names for backwards compatibility
-            PropertyInfo propInfo = type.GetProperty(propertyName, flags) 
+            // Try reflection first (property, field, then non-public serialized field)
+            if (TrySetViaReflection(component, type, propertyName, normalizedName, flags, value, out error))
+                return true;
+
+            // Reflection failed — fall back to SerializedProperty which handles arrays,
+            // custom serialization (e.g. UdonSharp), and types reflection can't convert.
+            string reflectionError = error;
+            if (SetViaSerializedProperty(component, propertyName, normalizedName, value, out error))
+                return true;
+
+            // Both paths failed. If reflection found the member but couldn't convert,
+            // report that (more useful than the SerializedProperty error).
+            // If reflection didn't find it at all, report the SerializedProperty error.
+            if (reflectionError != null && !reflectionError.Contains("not found"))
+                error = reflectionError;
+
+            return false;
+        }
+
+        private static bool TrySetViaReflection(object component, Type type, string propertyName, string normalizedName, BindingFlags flags, JToken value, out string error)
+        {
+            error = null;
+
+            // Try property first
+            PropertyInfo propInfo = type.GetProperty(propertyName, flags)
                                  ?? type.GetProperty(normalizedName, flags);
             if (propInfo != null && propInfo.CanWrite)
             {
                 try
                 {
                     object convertedValue = PropertyConversion.ConvertToType(value, propInfo.PropertyType);
-                    // Detect conversion failure: null result when input wasn't null
                     if (convertedValue == null && value.Type != JTokenType.Null)
                     {
                         error = $"Failed to convert value for property '{propertyName}' to type '{propInfo.PropertyType.Name}'.";
@@ -198,15 +220,14 @@ public static bool SetProperty(Component component, string propertyName, JToken
                 }
             }
 
-            // Try field - check both original and normalized names for backwards compatibility
-            FieldInfo fieldInfo = type.GetField(propertyName, flags) 
+            // Try field
+            FieldInfo fieldInfo = type.GetField(propertyName, flags)
                                ?? type.GetField(normalizedName, flags);
             if (fieldInfo != null && !fieldInfo.IsInitOnly)
             {
                 try
                 {
                     object convertedValue = PropertyConversion.ConvertToType(value, fieldInfo.FieldType);
-                    // Detect conversion failure: null result when input wasn't null
                     if (convertedValue == null && value.Type != JTokenType.Null)
                     {
                         error = $"Failed to convert value for field '{propertyName}' to type '{fieldInfo.FieldType.Name}'.";
@@ -222,17 +243,14 @@ public static bool SetProperty(Component component, string propertyName, JToken
                 }
             }
 
-            // Try non-public serialized fields - traverse inheritance hierarchy
-            // Type.GetField() with NonPublic only finds fields declared directly on that type,
-            // so we need to walk up the inheritance chain manually
+            // Try non-public serialized fields — traverse inheritance hierarchy
             fieldInfo = FindSerializedFieldInHierarchy(type, propertyName)
                      ?? FindSerializedFieldInHierarchy(type, normalizedName);
             if (fieldInfo != null)
             {
                 try
                 {
                     object convertedValue = PropertyConversion.ConvertToType(value, fieldInfo.FieldType);
-                    // Detect conversion failure: null result when input wasn't null
                     if (convertedValue == null && value.Type != JTokenType.Null)
                     {
                         error = $"Failed to convert value for serialized field '{propertyName}' to type '{fieldInfo.FieldType.Name}'.";

MCPForUnity/Editor/Tools/GameObjects/GameObjectComponentHelpers.cs

@@ -172,14 +172,26 @@ internal static object SetComponentPropertiesInternal(GameObject targetGo, strin
 
                 try
                 {
-                    bool setResult = SetProperty(targetComponent, propName, propValue);
+                    bool setResult = SetProperty(targetComponent, propName, propValue, out string setError);
                     if (!setResult)
                     {
-                        var availableProperties = ComponentResolver.GetAllComponentProperties(targetComponent.GetType());
-                        var suggestions = ComponentResolver.GetFuzzyPropertySuggestions(propName, availableProperties);
-                        var msg = suggestions.Any()
-                            ? $"Property '{propName}' not found. Did you mean: {string.Join(", ", suggestions)}? Available: [{string.Join(", ", availableProperties)}]"
-                            : $"Property '{propName}' not found. Available: [{string.Join(", ", availableProperties)}]";
+                        // Local reflection failed — fall back to ComponentOps which
+                        // tries SerializedProperty (handles arrays, UdonSharp, etc.)
+                        if (ComponentOps.SetProperty(targetComponent, propName, propValue, out string opsError))
+                        {
+                            continue;
+                        }
+
+                        // Both paths failed. Prefer the more specific error.
+                        string msg = setError ?? opsError;
+                        if (msg == null || msg.Contains("not found"))
+                        {
+                            var availableProperties = ComponentResolver.GetAllComponentProperties(targetComponent.GetType());
+                            var suggestions = ComponentResolver.GetFuzzyPropertySuggestions(propName, availableProperties);
+                            msg = suggestions.Any()
+                                ? $"Property '{propName}' not found. Did you mean: {string.Join(", ", suggestions)}? Available: [{string.Join(", ", availableProperties)}]"
+                                : $"Property '{propName}' not found. Available: [{string.Join(", ", availableProperties)}]";
+                        }
                         McpLog.Warn($"[ManageGameObject] {msg}");
                         failures.Add(msg);
                     }
@@ -199,8 +211,9 @@ internal static object SetComponentPropertiesInternal(GameObject targetGo, strin
 
         private static JsonSerializer InputSerializer => UnityJsonSerializer.Instance;
 
-        private static bool SetProperty(object target, string memberName, JToken value)
+        private static bool SetProperty(object target, string memberName, JToken value, out string error)
         {
+            error = null;
             Type type = target.GetType();
             BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase;
 
@@ -223,39 +236,44 @@ private static bool SetProperty(object target, string memberName, JToken value)
                         propInfo.SetValue(target, convertedValue);
                         return true;
                     }
+                    error = $"Failed to convert value for property '{memberName}' to type '{propInfo.PropertyType.Name}'.";
+                    return false;
                 }
-                else
+
+                FieldInfo fieldInfo = type.GetField(memberName, flags) ?? type.GetField(normalizedName, flags);
+                if (fieldInfo != null)
                 {
-                    FieldInfo fieldInfo = type.GetField(memberName, flags) ?? type.GetField(normalizedName, flags);
-                    if (fieldInfo != null)
+                    object convertedValue = ConvertJTokenToType(value, fieldInfo.FieldType, inputSerializer);
+                    if (convertedValue != null || value.Type == JTokenType.Null)
                     {
-                        object convertedValue = ConvertJTokenToType(value, fieldInfo.FieldType, inputSerializer);
-                        if (convertedValue != null || value.Type == JTokenType.Null)
-                        {
-                            fieldInfo.SetValue(target, convertedValue);
-                            return true;
-                        }
+                        fieldInfo.SetValue(target, convertedValue);
+                        return true;
                     }
-                    else
+                    error = $"Failed to convert value for field '{memberName}' to type '{fieldInfo.FieldType.Name}'.";
+                    return false;
+                }
+
+                var npField = type.GetField(memberName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.IgnoreCase)
+                           ?? type.GetField(normalizedName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.IgnoreCase);
+                if (npField != null && npField.GetCustomAttribute<SerializeField>() != null)
+                {
+                    object convertedValue = ConvertJTokenToType(value, npField.FieldType, inputSerializer);
+                    if (convertedValue != null || value.Type == JTokenType.Null)
                     {
-                        var npField = type.GetField(memberName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.IgnoreCase)
-                                   ?? type.GetField(normalizedName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.IgnoreCase);
-                        if (npField != null && npField.GetCustomAttribute<SerializeField>() != null)
-                        {
-                            object convertedValue = ConvertJTokenToType(value, npField.FieldType, inputSerializer);
-                            if (convertedValue != null || value.Type == JTokenType.Null)
-                            {
-                                npField.SetValue(target, convertedValue);
-                                return true;
-                            }
-                        }
+                        npField.SetValue(target, convertedValue);
+                        return true;
                     }
+                    error = $"Failed to convert value for serialized field '{memberName}' to type '{npField.FieldType.Name}'.";
+                    return false;
                 }
             }
             catch (Exception ex)
             {
-                McpLog.Error($"[SetProperty] Failed to set '{memberName}' on {type.Name}: {ex.Message}\nToken: {value.ToString(Formatting.None)}");
+                error = $"Failed to set '{memberName}' on {type.Name}: {ex.Message}\nToken: {value.ToString(Formatting.None)}";
+                return false;
             }
+
+            // Property/field not found — caller will generate "not found" with suggestions
             return false;
         }
 

TestProjects/UnityMCPTests/Assets/Tests/EditMode/Tools/GameObjectComponentHelpersErrorTests.cs

@@ -0,0 +1,110 @@
+using System.Text.RegularExpressions;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+using Newtonsoft.Json.Linq;
+using MCPForUnity.Editor.Helpers;
+using MCPForUnity.Editor.Tools;
+using MCPForUnity.Editor.Tools.GameObjects;
+
+namespace MCPForUnityTests.Editor.Tools
+{
+    /// <summary>
+    /// Tests for GameObjectComponentHelpers.SetComponentPropertiesInternal error reporting.
+    /// Reproduces issue #765: conversion failures incorrectly reported as "Property not found".
+    /// </summary>
+    public class GameObjectComponentHelpersErrorTests
+    {
+        private GameObject testGo;
+
+        [SetUp]
+        public void SetUp()
+        {
+            testGo = new GameObject("ErrorTestGO");
+            CommandRegistry.Initialize();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            if (testGo != null)
+                Object.DestroyImmediate(testGo);
+        }
+
+        /// <summary>
+        /// When a property exists but conversion fails, the error should say
+        /// "Failed to convert" rather than "Property not found. Did you mean: X?"
+        /// </summary>
+        [Test]
+        public void SetComponentProperties_ConversionFailure_ReportsConversionError_NotPropertyNotFound()
+        {
+            // Expect conversion error logs from PropertyConversion (once from local SetProperty,
+            // once from ComponentOps fallback trying reflection before SerializedProperty)
+            LogAssert.Expect(LogType.Error, new Regex("Error converting token"));
+            LogAssert.Expect(LogType.Error, new Regex("Error converting token"));
+            // Expect the warning log from SetComponentPropertiesInternal
+            LogAssert.Expect(LogType.Warning, new Regex("Failed to set"));
+
+            var audioSource = testGo.AddComponent<AudioSource>();
+
+            // spatialBlend is a float property — passing an array triggers conversion failure
+            var props = new JObject { ["spatialBlend"] = JArray.Parse("[1, 2, 3]") };
+
+            var result = GameObjectComponentHelpers.SetComponentPropertiesInternal(
+                testGo, "AudioSource", props, audioSource);
+
+            Assert.IsNotNull(result, "Should return an error response");
+            Assert.IsInstanceOf<ErrorResponse>(result);
+
+            var errorResponse = (ErrorResponse)result;
+
+            // The error message must NOT say "not found" for a property that exists
+            Assert.IsFalse(
+                errorResponse.Error.Contains("not found"),
+                $"Error should report conversion failure, not 'not found'. Got: {errorResponse.Error}");
+        }
+
+        /// <summary>
+        /// When a property genuinely doesn't exist, the error should still say "not found" with suggestions.
+        /// </summary>
+        [Test]
+        public void SetComponentProperties_NonexistentProperty_ReportsNotFound()
+        {
+            // Expect the "not found" warning
+            LogAssert.Expect(LogType.Warning, new Regex("not found"));
+
+            var audioSource = testGo.AddComponent<AudioSource>();
+
+            var props = new JObject { ["totallyFakeProperty"] = 42 };
+
+            var result = GameObjectComponentHelpers.SetComponentPropertiesInternal(
+                testGo, "AudioSource", props, audioSource);
+
+            Assert.IsNotNull(result);
+            Assert.IsInstanceOf<ErrorResponse>(result);
+
+            var errorResponse = (ErrorResponse)result;
+
+            Assert.IsTrue(
+                errorResponse.Error.Contains("not found") || errorResponse.Error.Contains("failed"),
+                $"Error for nonexistent property should say 'not found'. Got: {errorResponse.Error}");
+        }
+
+        /// <summary>
+        /// Valid property setting should still succeed.
+        /// </summary>
+        [Test]
+        public void SetComponentProperties_ValidProperty_Succeeds()
+        {
+            var audioSource = testGo.AddComponent<AudioSource>();
+
+            var props = new JObject { ["volume"] = 0.42f };
+
+            var result = GameObjectComponentHelpers.SetComponentPropertiesInternal(
+                testGo, "AudioSource", props, audioSource);
+
+            Assert.IsNull(result, "Should return null on success (no errors)");
+            Assert.AreEqual(0.42f, audioSource.volume, 0.001f);
+        }
+    }
+}