mcpforunityserver 8.2.3__py3-none-any.whl → 8.7.0__py3-none-any.whl

services/state/external_changes_scanner.py

@@ -0,0 +1,246 @@
+from __future__ import annotations
+
+import os
+import json
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+
+
+def _now_unix_ms() -> int:
+    return int(time.time() * 1000)
+
+
+def _in_pytest() -> bool:
+    # Keep scanner inert during the Python integration suite unless explicitly invoked.
+    return bool(os.environ.get("PYTEST_CURRENT_TEST"))
+
+
+@dataclass
+class ExternalChangesState:
+    project_root: str | None = None
+    last_scan_unix_ms: int | None = None
+    last_seen_mtime_ns: int | None = None
+    dirty: bool = False
+    dirty_since_unix_ms: int | None = None
+    external_changes_last_seen_unix_ms: int | None = None
+    last_cleared_unix_ms: int | None = None
+    # Cached package roots referenced by Packages/manifest.json "file:" dependencies
+    extra_roots: list[str] | None = None
+    manifest_last_mtime_ns: int | None = None
+
+
+class ExternalChangesScanner:
+    """
+    Lightweight external-changes detector using recursive max-mtime scan.
+
+    This is intentionally conservative:
+    - It only marks dirty when it sees a strictly newer mtime than the baseline.
+    - It scans at most once per scan_interval_ms per instance to keep overhead bounded.
+    """
+
+    def __init__(self, *, scan_interval_ms: int = 1500, max_entries: int = 20000):
+        self._states: dict[str, ExternalChangesState] = {}
+        self._scan_interval_ms = int(scan_interval_ms)
+        self._max_entries = int(max_entries)
+
+    def _get_state(self, instance_id: str) -> ExternalChangesState:
+        return self._states.setdefault(instance_id, ExternalChangesState())
+
+    def set_project_root(self, instance_id: str, project_root: str | None) -> None:
+        st = self._get_state(instance_id)
+        if project_root:
+            st.project_root = project_root
+
+    def clear_dirty(self, instance_id: str) -> None:
+        st = self._get_state(instance_id)
+        st.dirty = False
+        st.dirty_since_unix_ms = None
+        st.last_cleared_unix_ms = _now_unix_ms()
+        # Reset baseline to “now” on next scan.
+        st.last_seen_mtime_ns = None
+
+    def _scan_paths_max_mtime_ns(self, roots: Iterable[Path]) -> int | None:
+        newest: int | None = None
+        entries = 0
+
+        for root in roots:
+            if not root.exists():
+                continue
+
+            # Walk the tree; skip common massive/irrelevant dirs (Library/Temp/Logs).
+            for dirpath, dirnames, filenames in os.walk(str(root)):
+                entries += 1
+                if entries > self._max_entries:
+                    return newest
+
+                dp = Path(dirpath)
+                name = dp.name.lower()
+                if name in {"library", "temp", "logs", "obj", ".git", "node_modules"}:
+                    dirnames[:] = []
+                    continue
+
+                # Allow skipping hidden directories quickly
+                dirnames[:] = [d for d in dirnames if not d.startswith(".")]
+
+                for fn in filenames:
+                    if fn.startswith("."):
+                        continue
+                    entries += 1
+                    if entries > self._max_entries:
+                        return newest
+                    p = dp / fn
+                    try:
+                        stat = p.stat()
+                    except OSError:
+                        continue
+                    m = getattr(stat, "st_mtime_ns", None)
+                    if m is None:
+                        # Fallback when st_mtime_ns is unavailable
+                        m = int(stat.st_mtime * 1_000_000_000)
+                    newest = m if newest is None else max(newest, int(m))
+
+        return newest
+
+    def _resolve_manifest_extra_roots(self, project_root: Path, st: ExternalChangesState) -> list[Path]:
+        """
+        Parse Packages/manifest.json for local file: dependencies and resolve them to absolute paths.
+        Returns a list of Paths that exist and are directories.
+        """
+        manifest_path = project_root / "Packages" / "manifest.json"
+        try:
+            stat = manifest_path.stat()
+        except OSError:
+            st.extra_roots = []
+            st.manifest_last_mtime_ns = None
+            return []
+
+        mtime_ns = getattr(stat, "st_mtime_ns", int(stat.st_mtime * 1_000_000_000))
+        if st.extra_roots is not None and st.manifest_last_mtime_ns == mtime_ns:
+            return [Path(p) for p in st.extra_roots if p]
+
+        try:
+            raw = manifest_path.read_text(encoding="utf-8")
+            doc = json.loads(raw)
+        except Exception:
+            st.extra_roots = []
+            st.manifest_last_mtime_ns = mtime_ns
+            return []
+
+        deps = doc.get("dependencies") if isinstance(doc, dict) else None
+        if not isinstance(deps, dict):
+            st.extra_roots = []
+            st.manifest_last_mtime_ns = mtime_ns
+            return []
+
+        roots: list[str] = []
+        base_dir = manifest_path.parent
+
+        for _, ver in deps.items():
+            if not isinstance(ver, str):
+                continue
+            v = ver.strip()
+            if not v.startswith("file:"):
+                continue
+            suffix = v[len("file:") :].strip()
+            # Handle file:///abs/path or file:/abs/path
+            if suffix.startswith("///"):
+                candidate = Path("/" + suffix.lstrip("/"))
+            elif suffix.startswith("/"):
+                candidate = Path(suffix)
+            else:
+                candidate = (base_dir / suffix).resolve()
+            try:
+                if candidate.exists() and candidate.is_dir():
+                    roots.append(str(candidate))
+            except OSError:
+                continue
+
+        # De-dupe, preserve order
+        deduped: list[str] = []
+        seen = set()
+        for r in roots:
+            if r not in seen:
+                seen.add(r)
+                deduped.append(r)
+
+        st.extra_roots = deduped
+        st.manifest_last_mtime_ns = mtime_ns
+        return [Path(p) for p in deduped if p]
+
+    def update_and_get(self, instance_id: str) -> dict[str, int | bool | None]:
+        """
+        Returns a small dict suitable for embedding in editor_state_v2.assets:
+          - external_changes_dirty
+          - external_changes_last_seen_unix_ms
+          - dirty_since_unix_ms
+          - last_cleared_unix_ms
+        """
+        st = self._get_state(instance_id)
+
+        if _in_pytest():
+            return {
+                "external_changes_dirty": st.dirty,
+                "external_changes_last_seen_unix_ms": st.external_changes_last_seen_unix_ms,
+                "dirty_since_unix_ms": st.dirty_since_unix_ms,
+                "last_cleared_unix_ms": st.last_cleared_unix_ms,
+            }
+
+        now = _now_unix_ms()
+        if st.last_scan_unix_ms is not None and (now - st.last_scan_unix_ms) < self._scan_interval_ms:
+            return {
+                "external_changes_dirty": st.dirty,
+                "external_changes_last_seen_unix_ms": st.external_changes_last_seen_unix_ms,
+                "dirty_since_unix_ms": st.dirty_since_unix_ms,
+                "last_cleared_unix_ms": st.last_cleared_unix_ms,
+            }
+
+        st.last_scan_unix_ms = now
+
+        project_root = st.project_root
+        if not project_root:
+            return {
+                "external_changes_dirty": st.dirty,
+                "external_changes_last_seen_unix_ms": st.external_changes_last_seen_unix_ms,
+                "dirty_since_unix_ms": st.dirty_since_unix_ms,
+                "last_cleared_unix_ms": st.last_cleared_unix_ms,
+            }
+
+        root = Path(project_root)
+        paths = [root / "Assets", root / "ProjectSettings", root / "Packages"]
+        # Include any local package roots referenced by file: deps in Packages/manifest.json
+        try:
+            paths.extend(self._resolve_manifest_extra_roots(root, st))
+        except Exception:
+            pass
+        newest = self._scan_paths_max_mtime_ns(paths)
+        if newest is None:
+            return {
+                "external_changes_dirty": st.dirty,
+                "external_changes_last_seen_unix_ms": st.external_changes_last_seen_unix_ms,
+                "dirty_since_unix_ms": st.dirty_since_unix_ms,
+                "last_cleared_unix_ms": st.last_cleared_unix_ms,
+            }
+
+        if st.last_seen_mtime_ns is None:
+            st.last_seen_mtime_ns = newest
+        elif newest > st.last_seen_mtime_ns:
+            st.last_seen_mtime_ns = newest
+            st.external_changes_last_seen_unix_ms = now
+            if not st.dirty:
+                st.dirty = True
+                st.dirty_since_unix_ms = now
+
+        return {
+            "external_changes_dirty": st.dirty,
+            "external_changes_last_seen_unix_ms": st.external_changes_last_seen_unix_ms,
+            "dirty_since_unix_ms": st.dirty_since_unix_ms,
+            "last_cleared_unix_ms": st.last_cleared_unix_ms,
+        }
+
+
+# Global singleton (simple, process-local)
+external_changes_scanner = ExternalChangesScanner()
+
+

services/tools/debug_request_context.py

@@ -1,4 +1,8 @@
 from typing import Any
+import os
+import sys
+
+from core.telemetry import get_package_version
 
 from fastmcp import Context
 from services.registry import mcp_for_unity_tool
@@ -50,6 +54,11 @@ def debug_request_context(ctx: Context) -> dict[str, Any]:
     return {
         "success": True,
         "data": {
+            "server": {
+                "version": get_package_version(),
+                "cwd": os.getcwd(),
+                "argv": list(sys.argv),
+            },
             "request_context": {
                 "client_id": rc_client_id,
                 "session_id": rc_session_id,

services/tools/manage_asset.py

@@ -9,38 +9,51 @@ from typing import Annotated, Any, Literal
 from fastmcp import Context
 from services.registry import mcp_for_unity_tool
 from services.tools import get_unity_instance_from_context
-from services.tools.utils import parse_json_payload
+from services.tools.utils import parse_json_payload, coerce_int
 from transport.unity_transport import send_with_unity_instance
 from transport.legacy.unity_connection import async_send_command_with_retry
+from services.tools.preflight import preflight
 
 
 @mcp_for_unity_tool(
-    description="Performs asset operations (import, create, modify, delete, etc.) in Unity."
+    description=(
+        "Performs asset operations (import, create, modify, delete, etc.) in Unity.\n\n"
+        "Tip (payload safety): for `action=\"search\"`, prefer paging (`page_size`, `page_number`) and keep "
+        "`generate_preview=false` (previews can add large base64 blobs)."
+    )
 )
 async def manage_asset(
     ctx: Context,
     action: Annotated[Literal["import", "create", "modify", "delete", "duplicate", "move", "rename", "search", "get_info", "create_folder", "get_components"], "Perform CRUD operations on assets."],
-    path: Annotated[str, "Asset path (e.g., 'Materials/MyMaterial.mat') or search scope."],
+    path: Annotated[str, "Asset path (e.g., 'Materials/MyMaterial.mat') or search scope (e.g., 'Assets')."],
     asset_type: Annotated[str,
-                          "Asset type (e.g., 'Material', 'Folder') - required for 'create'."] | None = None,
+                          "Asset type (e.g., 'Material', 'Folder') - required for 'create'. Note: For ScriptableObjects, use manage_scriptable_object."] | None = None,
     properties: Annotated[dict[str, Any] | str,
                           "Dictionary (or JSON string) of properties for 'create'/'modify'."] | None = None,
     destination: Annotated[str,
                            "Target path for 'duplicate'/'move'."] | None = None,
     generate_preview: Annotated[bool,
-                                "Generate a preview/thumbnail for the asset when supported."] = False,
+                                "Generate a preview/thumbnail for the asset when supported. "
+                                "Warning: previews may include large base64 payloads; keep false unless needed."] = False,
     search_pattern: Annotated[str,
-                              "Search pattern (e.g., '*.prefab')."] | None = None,
+                              "Search pattern (e.g., '*.prefab' or AssetDatabase filters like 't:MonoScript'). "
+                              "Recommended: put queries like 't:MonoScript' here and set path='Assets'."] | None = None,
     filter_type: Annotated[str, "Filter type for search"] | None = None,
     filter_date_after: Annotated[str,
                                  "Date after which to filter"] | None = None,
     page_size: Annotated[int | float | str,
-                         "Page size for pagination"] | None = None,
+                         "Page size for pagination. Recommended: 25 (smaller for LLM-friendly responses)."] | None = None,
     page_number: Annotated[int | float | str,
-                           "Page number for pagination"] | None = None,
+                           "Page number for pagination (1-based)."] | None = None,
 ) -> dict[str, Any]:
     unity_instance = get_unity_instance_from_context(ctx)
 
+    # Best-effort guard: if Unity is compiling/reloading or known external changes are pending,
+    # wait/refresh to avoid stale reads and flaky timeouts.
+    gate = await preflight(ctx, wait_for_no_compile=True, refresh_if_dirty=True)
+    if gate is not None:
+        return gate.model_dump()
+
     def _parse_properties_string(raw: str) -> tuple[dict[str, Any] | None, str | None]:
         try:
             parsed = json.loads(raw)
@@ -83,24 +96,32 @@ async def manage_asset(
         await ctx.error(parse_error)
         return {"success": False, "message": parse_error}
 
-    # Coerce numeric inputs defensively
-    def _coerce_int(value, default=None):
-        if value is None:
-            return default
+    page_size = coerce_int(page_size)
+    page_number = coerce_int(page_number)
+
+    # --- Payload-safe normalization for common LLM mistakes (search) ---
+    # Unity's C# handler treats `path` as a folder scope. If a model mistakenly puts a query like
+    # "t:MonoScript" into `path`, Unity will consider it an invalid folder and fall back to searching
+    # the entire project, which is token-heavy. Normalize such cases into search_pattern + Assets scope.
+    action_l = (action or "").lower()
+    if action_l == "search":
         try:
-            if isinstance(value, bool):
-                return default
-            if isinstance(value, int):
-                return int(value)
-            s = str(value).strip()
-            if s.lower() in ("", "none", "null"):
-                return default
-            return int(float(s))
-        except Exception:
-            return default
-
-    page_size = _coerce_int(page_size)
-    page_number = _coerce_int(page_number)
+            raw_path = (path or "").strip()
+        except (AttributeError, TypeError):
+            # Handle case where path is not a string despite type annotation
+            raw_path = ""
+
+        # If the caller put an AssetDatabase query into `path`, treat it as `search_pattern`.
+        if (not search_pattern) and raw_path.startswith("t:"):
+            search_pattern = raw_path
+            path = "Assets"
+            await ctx.info("manage_asset(search): normalized query from `path` into `search_pattern` and set path='Assets'")
+
+        # If the caller used `asset_type` to mean a search filter, map it to filter_type.
+        # (In Unity, filterType becomes `t:<filterType>`.)
+        if (not filter_type) and asset_type and isinstance(asset_type, str):
+            filter_type = asset_type
+            await ctx.info("manage_asset(search): mapped `asset_type` into `filter_type` for safer server-side filtering")
 
     # Prepare parameters for the C# handler
     params_dict = {

services/tools/manage_gameobject.py

@@ -7,7 +7,8 @@ from services.registry import mcp_for_unity_tool
 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
+from services.tools.utils import coerce_bool, parse_json_payload, coerce_int
+from services.tools.preflight import preflight
 
 
 @mcp_for_unity_tool(
@@ -68,6 +69,11 @@ async def manage_gameobject(
     # Controls whether serialization of private [SerializeField] fields is included
     includeNonPublicSerialized: Annotated[bool | str,
                                           "Controls whether serialization of private [SerializeField] fields is included (accepts true/false or 'true'/'false')"] | None = None,
+    # --- Paging/safety for get_components ---
+    page_size: Annotated[int | str, "Page size for get_components paging."] | None = None,
+    cursor: Annotated[int | str, "Opaque cursor for get_components paging (offset)."] | None = None,
+    max_components: Annotated[int | str, "Hard cap on returned components per request (safety)."] | None = None,
+    include_properties: Annotated[bool | str, "If true, include serialized component properties (bounded)."] | None = None,
     # --- Parameters for 'duplicate' ---
     new_name: Annotated[str,
                         "New name for the duplicated object (default: SourceName_Copy)"] | None = None,
@@ -87,6 +93,10 @@ async def manage_gameobject(
     # Removed session_state import
     unity_instance = get_unity_instance_from_context(ctx)
 
+    gate = await preflight(ctx, wait_for_no_compile=True, refresh_if_dirty=True)
+    if gate is not None:
+        return gate.model_dump()
+
     if action is None:
         return {
             "success": False,
@@ -134,7 +144,12 @@ async def manage_gameobject(
     search_in_children = coerce_bool(search_in_children)
     search_inactive = coerce_bool(search_inactive)
     includeNonPublicSerialized = coerce_bool(includeNonPublicSerialized)
+    include_properties = coerce_bool(include_properties)
     world_space = coerce_bool(world_space, default=True)
+    # If coercion fails, omit these fields (None) rather than preserving invalid input.
+    page_size = coerce_int(page_size, default=None)
+    cursor = coerce_int(cursor, default=None)
+    max_components = coerce_int(max_components, default=None)
 
     # Coerce 'component_properties' from JSON string to dict for client compatibility
     component_properties = parse_json_payload(component_properties)
@@ -194,6 +209,10 @@ async def manage_gameobject(
             "searchInactive": search_inactive,
             "componentName": component_name,
             "includeNonPublicSerialized": includeNonPublicSerialized,
+            "pageSize": page_size,
+            "cursor": cursor,
+            "maxComponents": max_components,
+            "includeProperties": include_properties,
             # Parameters for 'duplicate'
             "new_name": new_name,
             "offset": offset,

services/tools/manage_scene.py

@@ -3,8 +3,10 @@ from typing import Annotated, Literal, Any
 from fastmcp import Context
 from services.registry import mcp_for_unity_tool
 from services.tools import get_unity_instance_from_context
+from services.tools.utils import coerce_int, coerce_bool
 from transport.unity_transport import send_with_unity_instance
 from transport.legacy.unity_connection import async_send_command_with_retry
+from services.tools.preflight import preflight
 
 
 @mcp_for_unity_tool(
@@ -27,29 +29,30 @@ async def manage_scene(
                            "Unity build index (quote as string, e.g., '0')."] | None = None,
     screenshot_file_name: Annotated[str, "Screenshot file name (optional). Defaults to timestamp when omitted."] | None = None,
     screenshot_super_size: Annotated[int | str, "Screenshot supersize multiplier (integer ≥1). Optional." ] | None = None,
+    # --- get_hierarchy paging/safety ---
+    parent: Annotated[str | int, "Optional parent GameObject reference (name/path/instanceID) to list direct children."] | None = None,
+    page_size: Annotated[int | str, "Page size for get_hierarchy paging."] | None = None,
+    cursor: Annotated[int | str, "Opaque cursor for paging (offset)."] | None = None,
+    max_nodes: Annotated[int | str, "Hard cap on returned nodes per request (safety)."] | None = None,
+    max_depth: Annotated[int | str, "Accepted for forward-compatibility; current paging returns a single level."] | None = None,
+    max_children_per_node: Annotated[int | str, "Child paging hint (safety)."] | None = None,
+    include_transform: Annotated[bool | str, "If true, include local transform in node summaries."] | None = None,
 ) -> dict[str, Any]:
     # Get active instance from session state
     # Removed session_state import
     unity_instance = get_unity_instance_from_context(ctx)
+    gate = await preflight(ctx, wait_for_no_compile=True, refresh_if_dirty=True)
+    if gate is not None:
+        return gate.model_dump()
     try:
-        # Coerce numeric inputs defensively
-        def _coerce_int(value, default=None):
-            if value is None:
-                return default
-            try:
-                if isinstance(value, bool):
-                    return default
-                if isinstance(value, int):
-                    return int(value)
-                s = str(value).strip()
-                if s.lower() in ("", "none", "null"):
-                    return default
-                return int(float(s))
-            except Exception:
-                return default
-
-        coerced_build_index = _coerce_int(build_index, default=None)
-        coerced_super_size = _coerce_int(screenshot_super_size, default=None)
+        coerced_build_index = coerce_int(build_index, default=None)
+        coerced_super_size = coerce_int(screenshot_super_size, default=None)
+        coerced_page_size = coerce_int(page_size, default=None)
+        coerced_cursor = coerce_int(cursor, default=None)
+        coerced_max_nodes = coerce_int(max_nodes, default=None)
+        coerced_max_depth = coerce_int(max_depth, default=None)
+        coerced_max_children_per_node = coerce_int(max_children_per_node, default=None)
+        coerced_include_transform = coerce_bool(include_transform, default=None)
 
         params: dict[str, Any] = {"action": action}
         if name:
@@ -62,6 +65,22 @@ async def manage_scene(
             params["fileName"] = screenshot_file_name
         if coerced_super_size is not None:
             params["superSize"] = coerced_super_size
+        
+        # get_hierarchy paging/safety params (optional)
+        if parent is not None:
+            params["parent"] = parent
+        if coerced_page_size is not None:
+            params["pageSize"] = coerced_page_size
+        if coerced_cursor is not None:
+            params["cursor"] = coerced_cursor
+        if coerced_max_nodes is not None:
+            params["maxNodes"] = coerced_max_nodes
+        if coerced_max_depth is not None:
+            params["maxDepth"] = coerced_max_depth
+        if coerced_max_children_per_node is not None:
+            params["maxChildrenPerNode"] = coerced_max_children_per_node
+        if coerced_include_transform is not None:
+            params["includeTransform"] = coerced_include_transform
 
         # Use centralized retry helper with instance routing
         response = await send_with_unity_instance(async_send_command_with_retry, unity_instance, "manage_scene", params)

services/tools/manage_scriptable_object.py

@@ -0,0 +1,75 @@
+"""
+Tool wrapper for managing ScriptableObject assets via Unity MCP.
+
+Unity-side handler: MCPForUnity.Editor.Tools.ManageScriptableObject
+Command name: "manage_scriptable_object"
+Actions:
+  - create: create an SO asset (optionally with patches)
+  - modify: apply serialized property patches to an existing SO asset
+"""
+
+from __future__ import annotations
+
+from typing import Annotated, Any, Literal
+
+from fastmcp import Context
+
+from services.registry import mcp_for_unity_tool
+from services.tools import get_unity_instance_from_context
+from services.tools.utils import coerce_bool, parse_json_payload
+from transport.unity_transport import send_with_unity_instance
+from transport.legacy.unity_connection import async_send_command_with_retry
+
+
+@mcp_for_unity_tool(
+    description="Creates and modifies ScriptableObject assets using Unity SerializedObject property paths."
+)
+async def manage_scriptable_object(
+    ctx: Context,
+    action: Annotated[Literal["create", "modify"], "Action to perform: create or modify."],
+    # --- create params ---
+    type_name: Annotated[str | None, "Namespace-qualified ScriptableObject type name (for create)."] = None,
+    folder_path: Annotated[str | None, "Target folder under Assets/... (for create)."] = None,
+    asset_name: Annotated[str | None, "Asset file name without extension (for create)."] = None,
+    overwrite: Annotated[bool | str | None, "If true, overwrite existing asset at same path (for create)."] = None,
+    # --- modify params ---
+    target: Annotated[dict[str, Any] | str | None, "Target asset reference {guid|path} (for modify)."] = None,
+    # --- shared ---
+    patches: Annotated[list[dict[str, Any]] | str | None, "Patch list (or JSON string) to apply."] = None,
+) -> dict[str, Any]:
+    unity_instance = get_unity_instance_from_context(ctx)
+
+    # Tolerate JSON-string payloads (LLMs sometimes stringify complex objects)
+    parsed_target = parse_json_payload(target)
+    parsed_patches = parse_json_payload(patches)
+
+    if parsed_target is not None and not isinstance(parsed_target, dict):
+        return {"success": False, "message": "manage_scriptable_object: 'target' must be an object {guid|path} (or JSON string of such)."}
+
+    if parsed_patches is not None and not isinstance(parsed_patches, list):
+        return {"success": False, "message": "manage_scriptable_object: 'patches' must be a list (or JSON string of a list)."}
+
+    params: dict[str, Any] = {
+        "action": action,
+        "typeName": type_name,
+        "folderPath": folder_path,
+        "assetName": asset_name,
+        "overwrite": coerce_bool(overwrite, default=None),
+        "target": parsed_target,
+        "patches": parsed_patches,
+    }
+
+    # Remove None values to keep Unity handler simpler
+    params = {k: v for k, v in params.items() if v is not None}
+
+    response = await send_with_unity_instance(
+        async_send_command_with_retry,
+        unity_instance,
+        "manage_scriptable_object",
+        params,
+    )
+    await ctx.info(f"Response {response}")
+    return response if isinstance(response, dict) else {"success": False, "message": "Unexpected response from Unity."}
+
+
+