Merge pull request #731 from whatevertogo/feat/tools-support-json-input

fix: accept JSON strings for list parameters in manage_gameobject and manage_texture

Author: dsarno

Server/src/services/tools/manage_gameobject.py

@@ -7,7 +7,7 @@
 from services.tools import get_unity_instance_from_context
 from transport.unity_transport import send_with_unity_instance
 from transport.legacy.unity_connection import async_send_command_with_retry
-from services.tools.utils import coerce_bool, parse_json_payload, normalize_vector3
+from services.tools.utils import coerce_bool, parse_json_payload, normalize_vector3, normalize_string_list
 from services.tools.preflight import preflight
 
 
@@ -74,7 +74,7 @@ async def manage_gameobject(
                         "Rotation as [x, y, z] euler angles array, {x, y, z} object, or JSON string"] | None = None,
     scale: Annotated[list[float] | dict[str, float] | str,
                      "Scale as [x, y, z] array, {x, y, z} object, or JSON string"] | None = None,
-    components_to_add: Annotated[list[str],
+    components_to_add: Annotated[list[str] | str,
                                  "List of component names to add during 'create' or 'modify'"] | None = None,
     primitive_type: Annotated[str,
                               "Primitive type for 'create' action"] | None = None,
@@ -87,7 +87,7 @@ async def manage_gameobject(
     set_active: Annotated[bool | str,
                           "If True, sets the GameObject active (accepts true/false or 'true'/'false')"] | None = None,
     layer: Annotated[str, "Layer name"] | None = None,
-    components_to_remove: Annotated[list[str],
+    components_to_remove: Annotated[list[str] | str,
                                     "List of component names to remove"] | None = None,
     component_properties: Annotated[dict[str, dict[str, Any]],
                                     """Dictionary of component names to their properties to set. For example:
@@ -149,6 +149,15 @@ async def manage_gameobject(
     if comp_props_error:
         return {"success": False, "message": comp_props_error}
 
+    # --- Normalize components_to_add and components_to_remove ---
+    components_to_add, add_error = normalize_string_list(components_to_add, "components_to_add")
+    if add_error:
+        return {"success": False, "message": add_error}
+
+    components_to_remove, remove_error = normalize_string_list(components_to_remove, "components_to_remove")
+    if remove_error:
+        return {"success": False, "message": remove_error}
+
     try:
         # Prepare parameters, removing None values
         params = {

Server/src/services/tools/manage_texture.py

@@ -53,17 +53,26 @@ def _normalize_palette(value: Any) -> tuple[list[list[int]] | None, str | None]:
     if isinstance(value, str):
         if value in ("[object Object]", "undefined", "null", ""):
             return None, f"palette received invalid value: '{value}'"
-        value = parse_json_payload(value)
+        parsed = parse_json_payload(value)
+        # If parsing succeeded and result is a list, normalize and return
+        if isinstance(parsed, list):
+            value = parsed
+        # If parsing returned the original string (invalid JSON), treat as error
+        elif parsed == value:
+            return None, f"palette must be a list of colors, got invalid string: '{value}'"
+        else:
+            return None, f"palette must be a list of colors (list), got string that parsed to {type(parsed).__name__}"
 
+    # Validate and normalize each color in the palette
     if not isinstance(value, list):
         return None, f"palette must be a list of colors, got {type(value).__name__}"
 
     normalized = []
     for i, color in enumerate(value):
-        parsed, error = _normalize_color_int(color)
+        color_normalized, error = _normalize_color_int(color)
         if error:
             return None, f"palette[{i}]: {error}"
-        normalized.append(parsed)
+        normalized.append(color_normalized)
 
     return normalized, None
 
@@ -405,7 +414,7 @@ async def manage_texture(
         "dots", "grid", "brick"
     ], "Pattern type for apply_pattern action"] | None = None,
 
-    palette: Annotated[list[list[int | float]],
+    palette: Annotated[list[list[int | float]] | str,
                        "Color palette as [[r,g,b,a], ...]. Accepts both 0-255 range or 0.0-1.0 normalized range"] | None = None,
 
     pattern_size: Annotated[int,

Server/src/services/tools/utils.py

@@ -212,6 +212,60 @@ def normalize_vector3(value: Any, param_name: str = "vector") -> tuple[list[floa
     return None, f"{param_name} must be a list, dict, or string, got {type(value).__name__}"
 
 
+def normalize_string_list(value: Any, param_name: str = "list") -> tuple[list[str] | None, str | None]:
+    """
+    Normalize a string list parameter that might be a JSON string or plain string.
+
+    Handles various input formats from MCP clients/LLMs:
+    - None -> (None, None)
+    - list/tuple of strings -> (list, None)
+    - JSON string '["a", "b", "c"]' -> parsed and normalized
+    - Plain non-JSON string "foo" -> treated as ["foo"]
+
+    Returns:
+        Tuple of (parsed_list, error_message). If error_message is set, parsed_list is None.
+    """
+    if value is None:
+        return None, None
+
+    # Already a list/tuple - validate and return
+    if isinstance(value, (list, tuple)):
+        # Ensure all elements are strings
+        if all(isinstance(item, str) for item in value):
+            return list(value), None
+        return None, f"{param_name} must contain only strings, got mixed types"
+
+    # Try parsing as JSON string (immediate parsing for string input)
+    if isinstance(value, str):
+        val_trimmed = value.strip()
+        # Check for obviously invalid values
+        if val_trimmed in ("[object Object]", "undefined", "null", ""):
+            return None, f"{param_name} received invalid value: '{value}'. Expected a JSON array like [\"item1\", \"item2\"]"
+
+        # Check if it looks like a JSON array but will fail to parse
+        looks_like_json_array = (val_trimmed.startswith("[") and val_trimmed.endswith("]"))
+
+        parsed = parse_json_payload(value)
+        # If parsing succeeded and result is a list, validate and return
+        if isinstance(parsed, list):
+            # Validate all elements are strings
+            if all(isinstance(item, str) for item in parsed):
+                return parsed, None
+            return None, f"{param_name} must contain only strings, got: {parsed}"
+        # If parsing returned the original string but it looked like a JSON array,
+        # it's malformed JSON - return error instead of treating as single item
+        if parsed == value and looks_like_json_array:
+            return None, f"{param_name} has invalid JSON syntax: '{value}'. Expected a valid JSON array like [\"item1\", \"item2\"]"
+        # If parsing returned the original string (plain non-JSON), treat as single item
+        if parsed == value:
+            # Treat as single-element list
+            return [value], None
+
+        return None, f"{param_name} must be a JSON array (list), got string that parsed to {type(parsed).__name__}"
+
+    return None, f"{param_name} must be a list or JSON string, got {type(value).__name__}"
+
+
 def normalize_color(value: Any, output_range: str = "float") -> tuple[list[float] | None, str | None]:
     """
     Normalize a color parameter to [r, g, b, a] format.