Fix UnityEvent wiring via manage_components set_property (#757)

* Fix UnityEvent wiring via manage_components set_property (#631)

UnityEventBase-derived fields set via reflection create disconnected
objects that Unity's serialization layer doesn't track, causing
m_PersistentCalls to be empty on save. Route these types through
SerializedObject/SerializedProperty instead.

Adds recursive SerializedProperty setter supporting Generic structs,
arrays, ObjectReference, and leaf types (int, bool, float, string, enum).
Includes fuzzy child property matching to handle batch_execute stripping
underscores from nested JSON keys (tracked in #756).

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* Fix batch_execute mangling nested value keys (#756)

batch_execute NormalizeParameterKeys recursively converted all JSON
keys to camelCase, including nested value data like Unity serialized
property paths (m_PersistentCalls to mPersistentCalls). This broke
UnityEvent wiring and any tool receiving structured nested data through
batch_execute. Stop recursing into values -- only normalize top-level
parameter keys.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Guard against null value in SerializedProperty string setter

Address Sourcery review: check value == null before accessing
value.Type to prevent NullReferenceException in the string case of
SetSerializedPropertyRecursive.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: dsarno

MCPForUnity/Editor/Helpers/ComponentOps.cs

@@ -4,6 +4,7 @@
 using Newtonsoft.Json.Linq;
 using UnityEditor;
 using UnityEngine;
+using UnityEngine.Events;
 
 namespace MCPForUnity.Editor.Helpers
 {
@@ -164,6 +165,15 @@ public static bool SetProperty(Component component, string propertyName, JToken
             BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase;
             string normalizedName = ParamCoercion.NormalizePropertyName(propertyName);
 
+            // UnityEventBase-derived types must be set via SerializedProperty, not reflection.
+            // Reflection creates a disconnected object that Unity's serialization layer doesn't track,
+            // causing m_PersistentCalls to be empty when the scene is saved.
+            Type memberType = ResolveMemberType(type, propertyName, normalizedName);
+            if (memberType != null && typeof(UnityEventBase).IsAssignableFrom(memberType))
+            {
+                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) 
                                  ?? type.GetProperty(normalizedName, flags);
@@ -374,6 +384,314 @@ private static bool AllowsMultiple(GameObject target, Type componentType)
 
             return true;
         }
+
+        // --- UnityEvent SerializedProperty support ---
+
+        private static Type ResolveMemberType(Type componentType, string propertyName, string normalizedName)
+        {
+            BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase;
+
+            PropertyInfo propInfo = componentType.GetProperty(propertyName, flags)
+                                 ?? componentType.GetProperty(normalizedName, flags);
+            if (propInfo != null)
+                return propInfo.PropertyType;
+
+            FieldInfo fieldInfo = componentType.GetField(propertyName, flags)
+                               ?? componentType.GetField(normalizedName, flags);
+            if (fieldInfo != null)
+                return fieldInfo.FieldType;
+
+            fieldInfo = FindSerializedFieldInHierarchy(componentType, propertyName)
+                     ?? FindSerializedFieldInHierarchy(componentType, normalizedName);
+            if (fieldInfo != null)
+                return fieldInfo.FieldType;
+
+            return null;
+        }
+
+        private static bool SetViaSerializedProperty(Component component, string propertyName, string normalizedName, JToken value, out string error)
+        {
+            error = null;
+            var so = new SerializedObject(component);
+
+            SerializedProperty prop = so.FindProperty(propertyName)
+                                   ?? so.FindProperty(normalizedName);
+            if (prop == null)
+            {
+                error = $"SerializedProperty '{propertyName}' not found on component '{component.GetType().Name}'.";
+                return false;
+            }
+
+            if (!SetSerializedPropertyRecursive(prop, value, out error, 0))
+                return false;
+
+            so.ApplyModifiedProperties();
+            return true;
+        }
+
+        private static bool SetSerializedPropertyRecursive(SerializedProperty prop, JToken value, out string error, int depth)
+        {
+            error = null;
+            const int MaxDepth = 20;
+            if (depth > MaxDepth)
+            {
+                error = $"Maximum recursion depth ({MaxDepth}) exceeded.";
+                return false;
+            }
+
+            try
+            {
+                // Array + JArray
+                if (prop.isArray && prop.propertyType != SerializedPropertyType.String && value is JArray jArray)
+                {
+                    prop.arraySize = jArray.Count;
+                    prop.serializedObject.ApplyModifiedProperties();
+                    prop.serializedObject.Update();
+
+                    for (int i = 0; i < jArray.Count; i++)
+                    {
+                        var element = prop.GetArrayElementAtIndex(i);
+                        if (!SetSerializedPropertyRecursive(element, jArray[i], out error, depth + 1))
+                            return false;
+                    }
+                    return true;
+                }
+
+                // Generic (struct/class) + JObject
+                if (prop.propertyType == SerializedPropertyType.Generic && !prop.isArray && value is JObject jObj)
+                {
+                    foreach (var kvp in jObj)
+                    {
+                        var child = FindPropertyRelativeFuzzy(prop, kvp.Key);
+                        if (child == null)
+                        {
+                            error = $"Sub-property '{kvp.Key}' not found under '{prop.propertyPath}'.";
+                            return false;
+                        }
+                        if (!SetSerializedPropertyRecursive(child, kvp.Value, out error, depth + 1))
+                            return false;
+                    }
+                    return true;
+                }
+
+                // ObjectReference
+                if (prop.propertyType == SerializedPropertyType.ObjectReference)
+                    return SetObjectReference(prop, value, out error);
+
+                // Leaf types
+                switch (prop.propertyType)
+                {
+                    case SerializedPropertyType.Integer:
+                        int intVal = ParamCoercion.CoerceInt(value, int.MinValue);
+                        if (intVal == int.MinValue && value?.Type != JTokenType.Integer)
+                        {
+                            if (value == null || value.Type == JTokenType.Null ||
+                                (value.Type == JTokenType.String && !int.TryParse(value.ToString(), out _)))
+                            {
+                                error = "Expected integer value.";
+                                return false;
+                            }
+                        }
+                        prop.intValue = intVal;
+                        return true;
+
+                    case SerializedPropertyType.Boolean:
+                        if (value == null || value.Type == JTokenType.Null)
+                        {
+                            error = "Expected boolean value.";
+                            return false;
+                        }
+                        prop.boolValue = ParamCoercion.CoerceBool(value, false);
+                        return true;
+
+                    case SerializedPropertyType.Float:
+                        float floatVal = ParamCoercion.CoerceFloat(value, float.NaN);
+                        if (float.IsNaN(floatVal))
+                        {
+                            error = "Expected float value.";
+                            return false;
+                        }
+                        prop.floatValue = floatVal;
+                        return true;
+
+                    case SerializedPropertyType.String:
+                        prop.stringValue = value == null || value.Type == JTokenType.Null ? null : value.ToString();
+                        return true;
+
+                    case SerializedPropertyType.Enum:
+                        return SetEnum(prop, value, out error);
+
+                    default:
+                        error = $"Unsupported SerializedPropertyType: {prop.propertyType} at '{prop.propertyPath}'.";
+                        return false;
+                }
+            }
+            catch (Exception ex)
+            {
+                error = $"Error setting '{prop.propertyPath}': {ex.Message}";
+                return false;
+            }
+        }
+
+        private static bool SetObjectReference(SerializedProperty prop, JToken value, out string error)
+        {
+            error = null;
+
+            if (value == null || value.Type == JTokenType.Null)
+            {
+                prop.objectReferenceValue = null;
+                return true;
+            }
+
+            if (value.Type == JTokenType.Integer)
+            {
+                int id = value.Value<int>();
+                var resolved = EditorUtility.InstanceIDToObject(id);
+                if (resolved == null)
+                {
+                    error = $"No object found with instanceID {id}.";
+                    return false;
+                }
+                prop.objectReferenceValue = resolved;
+                return true;
+            }
+
+            if (value is JObject jObj)
+            {
+                var idToken = jObj["instanceID"];
+                if (idToken != null)
+                {
+                    int id = ParamCoercion.CoerceInt(idToken, 0);
+                    var resolved = EditorUtility.InstanceIDToObject(id);
+                    if (resolved == null)
+                    {
+                        error = $"No object found with instanceID {id}.";
+                        return false;
+                    }
+                    prop.objectReferenceValue = resolved;
+                    return true;
+                }
+
+                var guidToken = jObj["guid"];
+                if (guidToken != null)
+                {
+                    string path = AssetDatabase.GUIDToAssetPath(guidToken.ToString());
+                    if (string.IsNullOrEmpty(path))
+                    {
+                        error = $"No asset found for GUID '{guidToken}'.";
+                        return false;
+                    }
+                    prop.objectReferenceValue = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(path);
+                    return true;
+                }
+
+                var pathToken = jObj["path"];
+                if (pathToken != null)
+                {
+                    string sanitized = AssetPathUtility.SanitizeAssetPath(pathToken.ToString());
+                    var resolved = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(sanitized);
+                    if (resolved == null)
+                    {
+                        error = $"No asset found at path '{pathToken}'.";
+                        return false;
+                    }
+                    prop.objectReferenceValue = resolved;
+                    return true;
+                }
+
+                error = "Object reference must contain 'instanceID', 'guid', or 'path'.";
+                return false;
+            }
+
+            if (value.Type == JTokenType.String)
+            {
+                string strVal = value.ToString();
+                if (strVal.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase) || strVal.Contains("/"))
+                {
+                    string sanitized = AssetPathUtility.SanitizeAssetPath(strVal);
+                    var resolved = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(sanitized);
+                    if (resolved == null)
+                    {
+                        error = $"No asset found at path '{strVal}'.";
+                        return false;
+                    }
+                    prop.objectReferenceValue = resolved;
+                    return true;
+                }
+                error = $"Cannot resolve object reference from string '{strVal}'.";
+                return false;
+            }
+
+            error = $"Unsupported object reference format: {value.Type}.";
+            return false;
+        }
+
+        /// <summary>
+        /// Finds a child SerializedProperty by name, falling back to underscore-insensitive matching.
+        /// The batch_execute transport can strip underscores from JSON keys
+        /// (e.g. m_PersistentCalls → mPersistentCalls), so we iterate immediate children
+        /// and compare with underscores removed.
+        /// </summary>
+        private static SerializedProperty FindPropertyRelativeFuzzy(SerializedProperty parent, string key)
+        {
+            var child = parent.FindPropertyRelative(key);
+            if (child != null) return child;
+
+            string normalizedKey = key.Replace("_", "").ToLowerInvariant();
+
+            var end = parent.GetEndProperty();
+            var iter = parent.Copy();
+            if (!iter.Next(true)) return null;
+
+            while (!SerializedProperty.EqualContents(iter, end))
+            {
+                if (iter.depth == parent.depth + 1)
+                {
+                    string normalizedName = iter.name.Replace("_", "").ToLowerInvariant();
+                    if (normalizedName == normalizedKey)
+                        return parent.FindPropertyRelative(iter.name);
+                }
+                if (!iter.Next(false))
+                    break;
+            }
+
+            return null;
+        }
+
+        private static bool SetEnum(SerializedProperty prop, JToken value, out string error)
+        {
+            error = null;
+            var names = prop.enumNames;
+            if (names == null || names.Length == 0)
+            {
+                error = "Enum has no names.";
+                return false;
+            }
+
+            if (value.Type == JTokenType.Integer)
+            {
+                int idx = value.Value<int>();
+                if (idx < 0 || idx >= names.Length)
+                {
+                    error = $"Enum index out of range: {idx}.";
+                    return false;
+                }
+                prop.enumValueIndex = idx;
+                return true;
+            }
+
+            string s = value.ToString();
+            for (int i = 0; i < names.Length; i++)
+            {
+                if (string.Equals(names[i], s, StringComparison.OrdinalIgnoreCase))
+                {
+                    prop.enumValueIndex = i;
+                    return true;
+                }
+            }
+            error = $"Unknown enum name '{s}'.";
+            return false;
+        }
     }
 }
 

MCPForUnity/Editor/Tools/BatchExecute.cs

@@ -225,31 +225,11 @@ private static JObject NormalizeParameterKeys(JObject source)
             foreach (var property in source.Properties())
             {
                 string normalizedName = ToCamelCase(property.Name);
-                normalized[normalizedName] = NormalizeToken(property.Value);
+                normalized[normalizedName] = property.Value;
             }
             return normalized;
         }
 
-        private static JArray NormalizeArray(JArray source)
-        {
-            var normalized = new JArray();
-            foreach (var token in source)
-            {
-                normalized.Add(NormalizeToken(token));
-            }
-            return normalized;
-        }
-
-        private static JToken NormalizeToken(JToken token)
-        {
-            return token switch
-            {
-                JObject obj => NormalizeParameterKeys(obj),
-                JArray arr => NormalizeArray(arr),
-                _ => token.DeepClone()
-            };
-        }
-
         private static string ToCamelCase(string key) => StringCaseUtility.ToCamelCase(key);
     }
 }

TestProjects/UnityMCPTests/Assets/Scripts/TestAsmdef/UnityEventTestComponent.cs

@@ -0,0 +1,14 @@
+using UnityEngine;
+using UnityEngine.Events;
+
+namespace TestNamespace
+{
+    public class UnityEventTestComponent : MonoBehaviour
+    {
+        public UnityEvent onSimpleEvent;
+        public UnityEvent<float> onFloatEvent;
+
+        [SerializeField]
+        private UnityEvent _onPrivateEvent;
+    }
+}